python基礎---->網絡編程

1、關於socket

socket一般也稱做"套接字"，用於描述IP地址和端口，是一個通訊鏈的句柄，應用程序一般經過"套接字"向網絡發出請求或者應答網絡請求。

socket起源於Unix，而Unix/Linux基本哲學之一就是「一切皆文件」，對於文件用【打開】【讀寫】【關閉】模式來操做。socket就是該模式的一個實現，socket便是一種特殊的文件，一些socket函數就是對其進行的操做（讀/寫IO、打開、關閉）

2、socket流程

流程：

　　先從服務器端提及。服務器端先初始化Socket，而後與端口綁定(bind)，對端口進行監聽(listen)，調用accept阻塞，等待客戶端鏈接。在這時若是有個客戶端初始化一個Socket，而後鏈接服務器(connect)，若是鏈接成功，這時客戶端與服務器端的鏈接就創建了。客戶端發送數據請求，服務器端接收請求並處理請求，而後把迴應數據發送給客戶端，客戶端讀取數據，最後關閉鏈接，一次交互結束。

流程圖：

　　　　

3、簡單的socket

socket_server.py

# -*- coding:utf-8 -*-
__Author__ = "Clint"

import socket

server = socket.socket()
server.bind(("localhost", 6969))  # 綁定要監聽的端口
server.listen()  # 監聽
print("等電話進來。。。")
conn, addr = server.accept()  # 電話打進來
# conn  客戶端連過來而服務器爲期生成的一個鏈接實例
print(conn, addr)
print("電話來了")

while True:
    data = conn.recv(1024)
    print("recv", data)
    conn.send(data.upper())

server.close()

socket_client.py

# -*- coding:utf-8 -*-
__Author__ = "Clint"

import socket

client = socket.socket()  # 聲明socket類型，同時生成sokcet鏈接對象
client.connect(("localhost", 6969))

while True:
    mess = input("輸入要發送的內容：").strip()
    if mess != "q":
        client.send(mess.encode())
        data = client.recv(1024)
        print("recv:", data.decode())
    else:
        break
client.close()

4、web服務的應用、參數說明

# -*- coding:utf-8 -*-
# @Author  : Clint
import socket


def handle_request(client):
    buf = client.recv(1024)
    client.send("HTTP/1.1 200 OK\r\n\r\n")
    client.send("Hello, World")


def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost', 8080))
    sock.listen(5)

    while True:
        connection, address = sock.accept()
        handle_request(connection)
        connection.close()


if __name__ == '__main__':
    main()

參數說明

sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

參數一：地址簇
　　socket.AF_INET IPv4（默認）
　　socket.AF_INET6 IPv6
　　socket.AF_UNIX 只可以用於單一的Unix系統進程間通訊

參數二：類型
　　socket.SOCK_STREAM　　流式socket , for TCP （默認）
　　socket.SOCK_DGRAM　　 數據報式socket , for UDP
　　socket.SOCK_RAW 原始套接字，普通的套接字沒法處理ICMP、IGMP等網絡報文，而SOCK_RAW能夠；其次，SOCK_RAW也能夠處理特殊的IPv4報文；此外，利用原始套接字，能夠經過IP_HDRINCL套接字選項由用戶構造IP頭。
　　socket.SOCK_RDM 是一種可靠的UDP形式，即保證交付數據報但不保證順序。SOCK_RAM用來提供對原始協議的低級訪問，在須要執行某些特殊操做時使用，如發送ICMP報文。SOCK_RAM一般僅限於高級用戶或管理員運行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的連續數據包服務

參數三：協議
　　0　　（默認）與特定的地址家族相關的協議,若是是 0 ，則系統就會根據地址格式和套接類別,自動選擇一個合適的協議

sock.bind(address)

　　sock.bind(address) 將套接字綁定到地址。address地址的格式取決於地址族。在AF_INET下，以元組（host,port）的形式表示地址。

sock.listen(backlog)

　　開始監聽傳入鏈接。backlog指定在拒絕鏈接以前，能夠掛起的最大鏈接數量。backlog等於5，表示內核已經接到了鏈接請求，但服務器尚未調用accept進行處理的鏈接個，這個值不能無限大，由於要在內核中維護鏈接隊列。

sock.setblocking(bool)

　　是否阻塞（默認True），若是設置False，那麼accept和recv時一旦無數據，則報錯。

sock.accept()

　　接受鏈接並返回（conn,address）,其中conn是新的套接字對象，能夠用來接收和發送數據。address是鏈接客戶端的地址。接收TCP 客戶的鏈接（阻塞式）等待鏈接的到來。

sock.connect(address)

　　鏈接到address處的套接字。通常，address的格式爲元組（hostname,port）,若是鏈接出錯，返回socket.error錯誤。

sock.connect_ex(address)

　　同上，只不過會有返回值，鏈接成功時返回 0 ，鏈接失敗時候返回編碼。

sock.close()

　　關閉套接字。

sock.recv(bufsize[,flag])

　　接受套接字的數據。數據以字符串形式返回，bufsize指定最多能夠接收的數量。flag提供有關消息的其餘信息，一般能夠忽略。

sock.recvfrom(bufsize[.flag])

　　與recv()相似，但返回值是（data,address）。其中data是包含接收數據的字符串，address是發送數據的套接字地址。

sk.send(string[,flag])

　　將string中的數據發送到鏈接的套接字。返回值是要發送的字節數量，該數量可能小於string的字節大小。即：可能未將指定內容所有發送。

sk.sendall(string[,flag])

　　將string中的數據發送到鏈接的套接字，但在返回以前會嘗試發送全部數據。成功返回None，失敗則拋出異常。內部經過遞歸調用send，將全部內容發送出去。

sk.sendto(string[,flag],address)

　　將數據發送到套接字，address是形式爲（ipaddr，port）的元組，指定遠程地址。返回值是發送的字節數。該函數主要用於UDP協議。

sk.settimeout(timeout)

　　設置套接字操做的超時期，timeout是一個浮點數，單位是秒。值爲None表示沒有超時期。通常，超時期應該在剛建立套接字時設置，由於它們可能用於鏈接的操做（如 client 鏈接最多等待5s ）。

sk.getpeername()

　　返回鏈接套接字的遠程地址。返回值一般是元組（ipaddr,port)。

sk.getsockname()

　　返回套接字本身的地址。一般是一個元組(ipaddr,port)。

sk.fileno()

　　套接字的文件描述符。

5、SSH的實現

ssh.server

import socket ,os
server = socket.socket()   #建立socket對象
server.bind(('localhost',8000) )  #綁定ip和port
server.listen()          #開始監聽
　while True:
    conn, addr = server.accept()   #阻塞 等待鏈接
    print("new conn:",addr)
    while True:
        print("等待新指令")
        data = conn.recv(1024)      #接收客戶端發過來的命令
        if not data:
            break
        print("執行指令:",data)
        cmd_res = os.popen(data.decode()).read() #執行客戶端發過來的命令，返回信息長度（接收字符串，執行結果也是字符串）
        print("before send",len(cmd_res))      #信息的長度
        if len(cmd_res) ==0:
            cmd_res = "cmd has no output..."
            conn.send( str(len(cmd_res.encode())).encode("utf-8")    )   #先發命令執行的結果信息大小給客戶端
        client_ack = conn.recv(1024)       #防止粘包，客戶端ack
        conn.send(cmd_res.encode("utf-8"))    #發送信息
        print("send done")
    server.close()

ssh.client

import socket
client = socket.socket()
client.connect(('localhost',8000))
  while True:
    cmd = input(">>:").strip()         #輸入命令
    if len(cmd) == 0: continue
    client.send(cmd.encode("utf-8"))   #發送命令給server端
    cmd_res_size = client.recv(1024)   #接受server端發過來的命令結果信息長度
    print("命令結果大小:",cmd_res_size)
    client.send("準備接受".encode('utf-8'))   #防止粘包
    received_size = 0    #已經接受數據的大小
    received_data = b''
    while received_size < int(cmd_res_size.decode()):
        data = client.recv(1024)   #只要小於，就一直接收
        received_size += len(data) #每次收到的有可能小於1024，因此
                                                 必須用len判斷
        #print(data.decode())
        received_data += data
    else:
        print("cmd res receive done...",received_size)
        print(received_data.decode())

client.close()

6、ftp傳文件的實現

ftp_server

import hashlib
import socket ,os,time
server = socket.socket()
server.bind(('localhost',9999))
server.listen()
while True:
    conn, addr = server.accept()
    print("new conn:",addr)
    while True:
        print("等待新指令")
        data = conn.recv(1024)
        if not data:
            print("客戶端已斷開")
            break
        cmd,filename = data.decode().split()
        print(filename)
        if os.path.isfile(filename):
           f = open(filename,"rb")
           m = hashlib.md5()
           file_size = os.stat(filename).st_size
           conn.send( str(file_size).encode() ) #send file size
           conn.recv(1024) #wait for ack
           for line in f:
              m.update(line)
              conn.send(line)
           print("file md5", m.hexdigest())
           f.close()
           conn.send(m.hexdigest().encode()) #send md5
        print("send done")
   server.close()

ftp_client

import socket
import hashlib
client = socket.socket()
client.connect(('localhost', 9999))
   while True:
    cmd = input(">>:").strip()
    if len(cmd) == 0: continue
    if cmd.startswith("get"):
        client.send(cmd.encode())
        server_response = client.recv(1024)
        print("servr response:", server_response)
        client.send(b"ready to recv file")
        file_total_size = int(server_response.decode())
        received_size = 0
        filename = cmd.split()[1]
        f = open(filename + ".new", "wb")
        m = hashlib.md5()
           while received_size < file_total_size:
            if file_total_size - received_size > 1024:  # 要收不止一次
                size = 1024
            else:  # 最後一次了，剩多少收多少
                size = file_total_size - received_size
                print("last receive:", size)
                data = client.recv(size)
            received_size += len(data)
            m.update(data)
            f.write(data)
            print(file_total_size,received_size)
        else:
            new_file_md5 = m.hexdigest()
            print("file recv done", received_size, file_total_size)
            f.close()
        server_file_md5 = client.recv(1024)
        print("server file md5:", server_file_md5)
        print("client file md5:", new_file_md5)
client.close()