python - socket通信笔记

Posted 2020-10-15 blitheG

参考：

　　通过编写聊天程序来熟悉python中多线程和socket的用法：https://www.cnblogs.com/mingjiatang/p/4905395.html

　　python socket通信：https://yq.aliyun.com/articles/40745?spm=5176.100239.blogcont40768.17.FIFTZv

1.socket使用方法

　　a.在python中使用socket时要iamport socket

　　b.在使用socket中又服务器端和客户端之分

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

　　socket起源于Unix，而Unix/Linux基本哲学之一就是：一切皆文件，即都可以用“打开open—>读写write/read—>关闭close”模式来操作。Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）。

　　可以看下面的图示来形象说明:

 

 

服务器：

1、建立一个基于tcp协议的socket类

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

其中AF_INET指定的ipv4的协议，也可以使用AF_INET6指定ipv6的协议，而STREAM是指定面向流的tcp协议。

2、s.bind(‘\', 8089))

绑定一个端口号，其中\'127.0.0.1\'是客户端的ip地址，可以使用’0.0.0.0’来绑定网络中所有的ip，8089是指定的端口，其中端口在小于1024的时候需要有管理员的权限才能绑定。

3、s.listen(5)

开始实行监听参数：代表连接的最大数量

4、sock, addr = s.accept()

接受一个客户端的连接，返回的是一个与客户端保持连接的socket对象以及客户端的ip地址和端口。该方法也会阻塞线程，直到获得客户端的连接。

 

客户端：

1、s.connect((\'127.0.0.1\', 80))

连接到服务器，其中\'www.baidu.com’也可以是服务器的ip地址。

2、s.send(\'hello\')

发送数据’hello’。TCP连接创建的是双向通道，双方都可以同时给对方发数据。但是谁先发谁后发，怎么协调，要根据具体的协议来决定。

3、s. recv(1024)

接受连接的对方发来的数据。该方法会阻塞当前线程，所以需要一个专门的线程来接受数据。

2.socket 案例

a.socket单线程的阻塞

# 本机实现的单线程非交互式的socket程序
# #### server ###########################################################################################
import socket                #导入socket类
 
HOST =\'\'                     #定义侦听本地地址口（多个IP地址情况下），这里表示侦听所有，也可以写成0.0.0.0
PORT = 50007                 #Server端开放的服务端口
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    #选择Socket类型和Socket数据包类型
s.bind((HOST, PORT))         #绑定IP地址和端口
s.listen(1)                  #定义侦听数开始侦听（实际上并没有效果）
conn, addr = s.accept()      #定义实例，accept()函数的返回值可以看上面的socket函数说明
 
print \'Connected by\', addr
while 1:
    data = conn.recv(1024)    #接受套接字的数据
    if not data:break         #如果没有数据接收，则断开连接
    print \'revc:\',data        #发送接收到的数据
    conn.sendall(data)        #发送接收到的数据
conn.close()                      #关闭套接字


# #### client ###########################################################################################
import socket
 
HOST = \'192.168.1.13\'        #定义目标主机名
PORT = 50007                 #定义目标主机开放服务端口号
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  #选择Socket类型和Socket数据包类型 
s.connect((HOST, PORT))      #连接到目标主机的socket（套接字）中
 
s.sendall(\'Hello, world!\')   #发送数据
data = s.recv(1024)          #接收数据
s.close()                    #关闭socket
print \'Received\', repr(data)

# 单线程+阻塞+交互式socket程序
# #### server：内容同上个例子#######################################################################33######
import socket                #导入socket类
  
HOST =\'\'                     #定义侦听本地地址口（多个IP地址情况下），这里表示侦听所有，也可以写成0.0.0.0
PORT = 50007                 #Server端开放的服务端口
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    #选择Socket类型和Socket数据包类型
s.bind((HOST, PORT))         #绑定IP地址和端口
s.listen(1)                  #定义侦听数开始侦听（实际上并没有效果）
conn, addr = s.accept()      #定义实例，accept()函数的返回值可以看上面的socket函数说明
  
print \'Connected by\', addr
while 1:
    data = conn.recv(1024)    #接受套接字的数据
    if not data:break         #如果没有数据接收，则断开连接
    print \'revc:\',data        #发送接收到的数据
    conn.sendall(data)        #发送接收到的数据
conn.close()                      #关闭套接字


# #### client ##########################################################################################
import socket
 
HOST = \'192.168.1.13\'
PORT = 50007
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
 
while True:
    user_input = raw_input(\'msg to send:\').strip()    #由User输入要发送的数据
    s.sendall(user_input)
    data = s.recv(1024)
    print \'Received\', repr(data)
 
s.close()

单线程，即数据的串行发送，会导致阻塞，如果要解决这个问题，当然在Server端就需要支持多线程，即数据折并发。

 

 

b.socket（多线程聊天程序实例）

　　该程序实现的是一个相对比较简单的聊天程序，由于是基于控制台实现的，所只设计容许两个人聊天，另外消息的编码的分割符为|。

# 首先建立一个User的数据结构
import socket 

class User:
    def __init__(self,skt,username=\'none\'):
        self.skt=skt
        self.username=username
    def send_msg(self,msg):
        self.skt.send(msg)
    def logout(self):
        self.skt.close()

# server
import sys 
import socket
import threading,time
import User

#global variable
userlist=[] 
   
def hand_user_con(usr):
    try:
        isNormar=True
        while isNormar:
            data=usr.skt.recv(1024)
            time.sleep(1)
            msg=data.split(\'|\')#分析消息
            if msg[0]==\'login\':
                print \'user [%s] login\' % msg[1]
                usr.username=msg[1]
                notice_other_usr(usr)
            if msg[0]==\'talk\':
                print \'user[%s]to[%s]:%s\' % (usr.username,msg[1],msg[2])
                send_msg(msg[1],msg[2])#发送消息给目标用户，参数1：目标用户，参数2：消息内容
            if msg[0]==\'exit\':
                print \'user [%s] exit\' % msg[0]
                isNormar=False
                usr.close()
                userlist.remove(usr)
    except:
        isNormar=False
        
#通知其他用户以上的好友       
def notice_other_usr(usr):
    if(len(userlist)>1):
        print \'The two users\'
        userlist[0].skt.send(("login|%s" % userlist[1].username))
        userlist[1].skt.send(("login|%s" % userlist[0].username))
    else:
        print \'The one users\'
         
def send_msg(username,msg):
    for usr in userlist:
        if(usr.username==username):
            usr.skt.send(msg)
            

def main():
    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    s.bind((\'0.0.0.0\',9999))
    s.listen(5)
    print u\'waiting for connection...\'
    while True:
        sock,addr=s.accept()#等待用户连接
        user=User.User(sock)
        userlist.append(user)
        t=threading.Thread(target=hand_user_con,args=(user,));
        t.start()  
    s.close()
    

if(__name__=="__main__"):
    main()    

import sys 
import socket
import threading,time

#global variable    
isNormar=True
other_usr=\'\'


def recieve_msg(username,s):
    global isNormar,other_usr
    print \'Please waiting other user login...\'
    s.send(\'login|%s\' %username)
    while(isNormar):
        data= s.recv(1024)#阻塞线程，接受消息
        msg=data.split(\'|\')
        if msg[0]==\'login\':
            print u\'%s user has already logged in, start to chat\' % msg[1]
            other_usr=msg[1]
        else:
            print msg[0]
            
#程序入口
def main(): 
    global isNormar,other_usr  
    try:
        print \'Please input your name:\'
        usrname=raw_input()
        s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        s.connect(("127.0.0.1",9999))
        t=threading.Thread(target=recieve_msg,args=(usrname,s))
        t.start()
    except:
        print \'connection exception\'
        isNormar=False
    finally:
        pass
    while isNormar:
        msg=raw_input()#接受用户输入
        if msg=="exit":
            isNormar=False
        else:
            if(other_usr!=\'\'):
                s.send("talk|%s|%s" % (other_usr,msg))#编码消息并发送
    s.close()
    
if __name__=="__main__":
    main()

 

 

c.socketserver模块，实现socket并发

　　socketserver说明如下图所示：

# SockteServer例子说明
# #### server ####################################
import SocketServer            #导入SocketServer，多线程并发由此类实现
 
class MySockServer(SocketServer.BaseRequestHandler):    #定义一个类
 
    def handle(self):      #handle(self)方法是必须要定义的，可以看上面的说明
        print \'Got a new connection from\', self.client_address
        while True:
            data = self.request.recv(1024)    #需要通过self的方法调用数据接收函数
            if not data:break
            print \'recv:\', data
 
            self.request.send(data.upper())   #需要通过self的方法调用数据接收函数
 
if __name__ == \'__main__\':    #并非一定要用这样的方式，只是建议这样使用
    HOST = \'\'             #定义侦听本地地址口（多个IP地址情况下），这里表示侦听所有
    PORT = 50007          #Server端开放的服务端口
    s = SocketServer.ThreadingTCPServer((HOST, PORT), MySockServer)
                              #调用SocketServer模块的多线程并发函数
    s.serve_forever()     #持续接受客户端的连接


# #### client #####################################
import socket
 
HOST = \'192.168.1.13\'
PORT = 50007
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
 
while True:
    user_input = raw_input(\'msg to send:\').strip()
    s.sendall(user_input)
    data = s.recv(1024)
    print \'Received\', repr(data)
 
s.close()

 

d.基于SocketServer多线程的简化SSH程序

# #### server ############################################
import SocketServer
import commands    #使用其中的getstatusoutput()函数，让Server端可以识别Client端发送过来的命令并执行
import time        #主要使用其中的time.sleep()函数，用来解决Server端发送数据的“连块”问题
 
class MySockServer(SocketServer.BaseRequestHandler):
 
    def handle(self):
        print \'Got a new connection from\', self.client_address
        while True:
            cmd = self.request.recv(1024)
            if not cmd:
                print \'Last connection with:\',self.client_address
                break
             
            cmd_result = commands.getstatusoutput(cmd)    #获取Client端的指令并执行，返回结果是一个存储两个元素的元组，第一个元素为0表示成功执行，第二个元素则是命令的执行结果
 
            self.request.send(str(len(cmd_result[1])))    #发送命令执行结果的大小长度，Client端要想接收任意大小的执行结果，就需要根据命令执行结果的大小来选择策略，这里需要注意的是，发送的数据是字符串，所以需要作类型转换
 
            time.sleep(0.2)        #睡眠0.2s，是为了解决“连块”的问题
 
            self.request.sendall(cmd_result[1]) #发送命令执行结果
 
if __name__ == \'__main__\':
    HOST = \'\'
    PORT = 50007
    s = SocketServer.ThreadingTCPServer((HOST, PORT), MySockServer)
 
    s.serve_forever()


# #### client #######################################
import socket
 
HOST = \'192.168.1.13\'
PORT = 50007
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
 
def data_all(obj, lenth_size):
    data = \'\'                #用来存储每一次循环时socket接收的数据，解决socket大概两万多字节的缓冲瓶颈限制
    while lenth_size != 0:   #如果接收的数据长度不为0，开始执行接收数据处理策略
        if lenth_size <= 4096:    #这里以4096为单位块，作为每次的数据处理量大小
            data_recv = obj.recv(lenth_size)    #通过recv()接收数据
            lenth_size = 0    #通过这一步的处理，数据全部接收完毕，置lenth_size为0，结束循环，完成数据的接收处理工作
        else:
            data_recv = obj.recv(4096)    #以4096为单位块，一次接收4096的数据量大小
            lenth_size -= 4096            #处理完一次4096字节的数据后，将lenth_size减去4096
        data += data_recv                     #判断外层，用本地的data来存储接收到的数据，因为本地的data大小没有限制，所以不存在data饱和无法继续存储数据的问题，但前面socket的recv()函数一次最多只能接收的数据量大小是有限制的，这取决于socket的缓冲区大小，因此data_all函数的作用就是通过使用多次recv()函数，并且每次接收一定量的数据后就进行本地存储，直到把所有的数据都接收完毕
    return data
 
while True:
    user_input = raw_input(\'cmd to send:\').strip()
    if len(user_input) == 0:continue
    s.sendall(user_input)
 
    data_size = int(s.recv(1024))      #得到命令执行结果的大小长度，因为发送过来的数据是字符串，所以这里要作类型转换
    print \'\\033[32;1mdata size:\\033[0m\',data_size    #打印命令执行结果的大小
    result = data_all(s, data_size)    #通过data_all函数来执行相应的数据接收处理策略
    print result                       #打印命令执行结果
 
s.close()                                  #关闭套接字

PS：

　　1.Server端发送数据的“连块”问题，即发送两次数据时，如果发送间隔比较短，socket会把两次发送的数据放在一起来发送，这里通过time.sleep()函数来解决。

　　2.socket的缓冲区大小问题，即当执行top -bn 3这样执行结果长度大的命令时，socket缓冲区一次是无法存储这么多数据的，所以只能分多次来接收数据，这样就会在Client端带来一定的问题，比如命令执行的不同步等，解决的方法是通过用循环接收的方法来进行本地存储Server端发送的数据。

　　当然，如果要执行man等查询方面的命令，上面的程序也是无法做到的，所以这里说，这只是一个简版的SSH程序