Python 09：Socket

Python 09：Socket

---

1、Socket介绍

2、Socket参数

3、Socket实现ssh功能

4、Socket传输本地文件

5、Socketserver实现

---

一、socket介绍

socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

socket模块是针对 服务器端和客户端Socket 进行：打开、读写、关闭。

最简单的socket只发送一次接受一次：

import socket
clint = socket.socket()  #获得socket实例
clint.connect(("localhost",9999))    #绑定ip port
# clint.send(b"hello world!")   只能传输bytes类型
clint.send("你好".encode("utf-8")) 
data = clint.recv(1024)   #接收返回数据
print("recv:",data.decode())
clint.close()

import socket
server = socket.socket()  #获得socket实例
server.bind(('localhost',9999)) #绑定要监听的端口
server.listen() #监听
conn,addr = server.accept() #等访问信息
#conn就是客户端连过来而在服务器端为其生成的一个链接实例
data = conn.recv(1024)  #接收数据
print("recv:",data)
conn.send(data.upper())  #返回数据
server.close()

只能与一个clint端多次交互收发：

import socket
clint = socket.socket()
clint.connect(("localhost",9999))
while True:
    msg = input(">>:").strip()
    if len(msg) == 0:
        continue
    clint.send(msg.encode("utf-8"))
    data = clint.recv(1024)
    print("recv:",data.decode())
clint.close()

import socket,os
server = socket.socket()
server.bind(('localhost',9999)) #绑定要监听的端口
server.listen(5) #监听
while True:
    conn,addr = server.accept() #等访问信息
    while True:
        data = conn.recv(1024)
        print("recv:",data)
        if not data:
            print("clint has lost...")
            break
        conn.send(data.upper())
        # res = os.popen(data.decode()).read()
        # conn.send(res.encode())
server.close()

 二、Socket参数 

sk = 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 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

sk.bind(address)  重点

s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog)  重点

开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5

这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool)  重点

是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept()  重点

接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)  重点

连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()   重点

关闭套接字

sk.recv(bufsize[,flag])  重点

接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.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()

套接字的文件描述符

socket.sendfile(file, offset=0, count=None)

发送文件 

三、Socket实现ssh功能

import socket,os
server = socket.socket()
server.bind(("localhost",9999))
server.listen()
while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户已断开")
            break
        cmd_res = os.popen(data.decode()).read()
        print(len(cmd_res.encode()))
        if len(cmd_res.encode()) == 0 :
            cmd_res = "没有输出。。"
        conn.send(str(len(cmd_res.encode())).encode()) #发数据大小
        conn.send(cmd_res.encode())
server.close()

import socket
clint = socket.socket()
clint.connect(("localhost",9999))
while True:
    cmd = input(">>:").strip()
    if len(cmd) == 0:
        continue
    clint.send(cmd.encode())
    cmd_res_size = clint.recv(1024) #接收命令结果的长度
    print("大小：",cmd_res_size)
    received_size = 0
    # received_data = b''
    while received_size < int(cmd_res_size.decode()):
        data = clint.recv(1024)
        received_size += len(data)  #每次收到的大小
        print(data.decode())
    else:
        print("receive done...",received_size)
clint.close()

解决“粘包”：连续两次send数据，缓冲区有可能将两次send的数据一次同时发出，造成数据粘包

1、sleep 0.5秒（low）

2、client端收到后与server端在进行一次确认交互

import socket
client = socket.socket()
client.connect(("localhost",9999))
while True:
    cmd = input(">>:").strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode())
    cmd_res_size = client.recv(1024) #接收命令结果的长度
    print("大小：",cmd_res_size)
    client.send(b"ok!")  #以接收完数据长度可以继续发送文件了
    received_size = 0
    # received_data = b''
    while received_size < int(cmd_res_size.decode()):
        data = client.recv(1024)
        received_size += len(data)  #每次收到的大小
        print(data.decode())
    else:
        print("receive done...",received_size)
client.close()

import socket,os
server = socket.socket()
server.bind(("localhost",9999))
server.listen()
while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        data = conn.recv(1024)
        if not data:
            print("客户已断开")
            break
        cmd_res = os.popen(data.decode()).read()
        print(len(cmd_res.encode()))
        if len(cmd_res.encode()) == 0 :
            cmd_res = "没有输出。。"
        conn.send(str(len(cmd_res.encode())).encode())
        #time.sleep(0.5)   #low
        clien_ack = conn.recv(1024)  #等客户端确认
        conn.send(cmd_res.encode())
server.close()

 插曲：

接收信息decode时报错：UnicodeDecodeError

这是因为遇到了非法字符，例如：全角空格往往有多种不同的实现方式，比如xa3xa0，或者xa4x57，
这些字符，看起来都是全角空格，但它们并不是“合法”的全角空格
真正的全角空格是xa1xa1，因此在转码的过程中出现了异常。 
而之前在处理新浪微博数据时，遇到了非法空格问题导致无法正确解析数据。
[解决办法]

#将获取的字符串strTxt做decode时，指明ignore，会忽略非法字符,

#当然对于gbk等编码，处理同样问题的方法是类似的

str = str.decode('utf-8', 'ignore')

[补充]

默认的参数就是strict，代表遇到非法字符时抛出异常； 
如果设置为ignore，则会忽略非法字符； 
如果设置为replace，则会用?号取代非法字符； 
如果设置为xmlcharrefreplace，则使用XML的字符引用。 

四、Socket传输本地文件

Socket实现fpt基本功能：实现本地目录文件的传送（在当前目录下）

import socket,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())
        cmd_res_size = client.recv(1024) #接收文件大小
        print("文件大小：",cmd_res_size)
        client.send(b"ok!")
        file_total_size = int(cmd_res_size.decode())
        received_size = 0
        file_name = cmd.split()[1]
        f = open(file_name + "_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
            data = client.recv(size)
            received_size += len(data)  #每次收到的大小
            m.update(data)
            f.write(data)
        else:
            new_file_md5 = m.hexdigest()
            print("receive done...",file_total_size,received_size)
            f.close()
        server_file_md5 = client.recv(1024)
        print("server",server_file_md5)
        print("client",new_file_md5)
client.close()

'''
1、读取文件名
2、检测文件是否存在
3、打开文件
4、检测文件大小
5、发送文件大小给客户端
6、等待客户确认
7、开始边读变发数据
8、发送MD5确认
'''
import socket,os,hashlib
server = socket.socket()
server.bind(("localhost",9999))
server.listen()
while True:
    conn,addr = server.accept()
    print("new conn:",addr)
    while True:
        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())
            conn.recv(1024)  #等客户端确认

            for line in f:
                m.update(line)
                conn.send(line)
            print("file md5",m.hexdigest())
            f.close()
            conn.send(m.hexdigest().encode())  #发送md5
server.close()

五、Socketserver实现

SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。

即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。

创建一个socketserver 至少分以下几步:

1、首先创建一个继承自 SocketServer.BaseRequestHandler 的类，并重写其handle()方法，此方法将处理传入的请求。

2、必须实例化一个服务器类，将服务器的地址和请求处理程序类传递给它

3、调用服务器对象的handle_request() 或 serve_forever()方法来处理一个或多个请求

4、关闭socket

import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            try:
                self.data = self.request.recv(1024).strip()
                print("{} wrote:".format(self.client_address[0]))
                print(self.data)
                self.request.sendall(self.data.upper())
            except ConnectionResetError as e :
                print("客户端已断开！",e)
                break
if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    # server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)  #单线程
    server = socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler)   #多线程并发，没来一个请求服务器就会开启一个独立的线程
    server.serve_forever()

import socket
clint = socket.socket()
clint.connect(("localhost",9999))
while True:
    msg = input(">>:").strip()
    if len(msg) == 0:
        continue
    clint.send(msg.encode("utf-8"))
    data = clint.recv(1024)
    print("recv:",data.decode())
clint.close()

让的socketserver并发的类：

class socketserver.ForkingTCPServer

class socketserver.ForkingUDPServer

class socketserver.ThreadingTCPServer

class socketserver.ThreadingUDPServer

ForkingTCPServer和ThreadingTCPServer的使用和执行流程基本一致，只不过在内部分别为请求者建立 “线程”  和 “进程”。

server = SocketServer.ThreadingTCPServer(('localhost',9999),MyRequestHandler)

server = SocketServer.ForkingTCPServer(('localhost',9999),MyRequestHandler)

内部调用流程为：

启动服务端程序

执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口

执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给 self.RequestHandlerClass

执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...

当客户端连接到达服务器

执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求

执行 ThreadingMixIn.process_request_thread 方法

执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass()  即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）