python用socket实现协议TCP长连接框架

“ 使用python实现协议中常见的TCP长连接框架。”

分析多了协议就会发现，很多的应用，特别是游戏类和IM类应用，它们的协议会使用长连接的方式，来保持客户端与服务器的联系，这些长连接，通常是TCP承载的。

如果我们要模拟这个客户端的行为，根据不同应用服务器的实现情况，有些长连接不是必须的，但有些长连接，就必须去实现它。例如最近分析的某应用，虽然它主要使用HTTP协议进行交互，但它在TCP长连接中传输了一些必须的信息，如果不实现长连接，就会有很多信息无法处理。

在python中，很容易实现HTTP协议，当然，也容易实现TCP协议，它的TCP实现，使用socket库就可以了，只是需要注意，TCP长连接中通常传输的是十六进制数据，协议非标准的，需要自行根据协议分析结果来封装数据格式。

这里以一个使用到TCP长连接的协议为样例，来给出协议的TCP长连接框架，大家有需要可以参考实现，当然，代码也是从样例中摘出来的，并不是完整的。

我的TCP长连接框架，首先是外部的包装，初始化一些参数，例如长连接使用到的ip端口及socket套接字等：

self.longip='im.langren001.com'
       self.longport= 6656
       self.threadLock = threading.Lock()
       self.sockmain = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
       self.longlinktcpstart2()
       tlonglink = threading.Thread(target=lrsuser.longlinktcpth2,name='mainlink_'+ self.playinfo['uid'], args=(self,))
       tlonglink.start()
       self.threadinfo.append(tlonglink)

这个里面调用了两个函数，一个是longlinktcpstart2函数，作用是建立socket连接，并对一些连接建立初始时的交互进行实现，另一个是longlinktcpth2函数，是一个线程，实现对连接内的数据进行收发处理。一般来说，这两个可以在一起实现，但为了方便socket异常断开的处理，分成了两个函数。

 longlinktcpstart2的实现如下：

def longlinktcpstart2(self):
       server_address = (self.longip, int(self.longport))
       self.savelogs('longlinktcpstart2', 'Connecting to ％s:％d.' ％ server_address)
       self.sockmain.connect(server_address)
       self.databuf = b''
       message = genbaseinfo.genalive()
       self.sockmain.sendall(message)
       message = genbaseinfo.genfirstdata()
       if len(message)==0:
           self.savelogs('longlinktcpstart2', 'genfirstdata error ')
           return False
       self.sockmain.sendall(message)
       self.longlinkcnt=2
       cnt = 0
       while (cnt < 2):
           try:
               buf = self.sockmain.recv(2048)
               sz = len(buf)
               self.savelogs('longlinktcpstart2', "recv data len "+str(sz) )
               if sz > 0:
                   self.databuf +=buf
                   self.dealdatabuf()
                   if cnt == 0:
                       alivemsg =  genbaseinfo.genalive()
                       self.sockmain.sendall(alivemsg)
                       self.savelogs('longlinktcpstart2', "sendalive")
                       regtime=int(round(time.time() * 1000))-random.randint(14400000,25200000)
                       regtime=regtime*1000
                       pcode = self.versionstr + '.0'
                       message =  genbaseinfo.genseconddata()
                       if len(message) == 0:
                           self.savelogs('longlinktcpstart2', 'genseconddata error ')
                           return False
                       self.sockmain.sendall(message)
                       self.longlinkcnt = self.longlinkcnt + 1
                   elif cnt == 1:
                       pcode = self.versionstr + '.0'
                       message =  genbaseinfo.genotherdata()
                       if len(message) == 0:
                           self.savelogs('longlinktcpstart2', 'genthirddata error ')
                           return False
                       self.sockmain.sendall(message)
                       self.longlinkcnt = self.longlinkcnt + 1
                   cnt = cnt + 1
               else:
                   self.savelogs('longlinktcpstart2', 'recv data alive')
           except:  # socket.error
               self.savelogs('longlinktcpstart2', 'socket error,do connect fail')
               return False

return True

这里面的genbaseinfo 相关的函数可以忽略，是用来生成发送的消息数据的实现，用自己的函数去替换即可。dealdatabuf函数是用来处理收到的消息数据实现，这两个都要根据具体的协议分析情况去实现，注意，生成的用来发送的数据和接收到的需要处理的数据，都需要按十六进制处理，这里不做详述。

线程longlinktcpth2是一个循环，协议不退出，循环不结束，实现如下：

def longlinktcpth2(self):
       tmalive = 0;
       r_inputs = set()
       r_inputs.add(self.sockmain)
       w_inputs = set()
       w_inputs.add(self.sockmain)
       e_inputs = set()
       e_inputs.add(self.sockmain)
       tm=int(round(time.time()))
       self.savelogs('longlinktcpth2', 'enter' )
       while (self.quitflag==0):
           try:
               r_list, w_list, e_list = select.select(r_inputs, w_inputs, e_inputs, 1)
               for event in r_list:
                   try:
                       buf = event.recv(2048)
                       sz = len(buf)
                       self.savelogs('longlinktcpth2', "loop recv data len:"+ str(sz) )
                       if sz > 0:
                           self.databuf += buf
                           self.dealdatabuf()
                           alivemsg = genbaseinfo.genalive()
                           self.sockmain.sendall(alivemsg)
                           self.savelogs('longlinktcpth2', "sendalive")
                       else:
                           self.savelogs('longlinktcpth2', "远程断开连接,do reconnect")
                           r_inputs.clear()
                           time.sleep(3)
                           self.sockmain = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                           self.longlinktcpstart2()
                           r_inputs = set()
                           r_inputs.add(self.sockmain)
                           w_inputs = set()
                           w_inputs.add(self.sockmain)
                           e_inputs = set()
                           e_inputs.add(self.sockmain)
                   except Exception as e:
                       self.savelogs('longlinktcpth2', str(e))
               self.threadLock.acquire()
               if (len(self.msglist) > 0):
                   msg = self.msglist.pop(0)
                   self.threadLock.release()
                   self.sockmain.sendall(msg)
                   self.savelogs('longlinktcpth2',"send a msg")
               else:
                   self.threadLock.release()
               tmnow=int(round(time.time()))
               if tmnow-tm>30:

message = genbaseinfo.genotherdata()
                   if len(message) == 0:
                       self.savelogs('longlinktcpth2', 'genalivedata error ')
                       return False
                   self.sockmain.sendall(message)
                   self.savelogs('longlinktcpth2', "send alivemsg"+str(self.longlinkcnt))
                   self.longlinkcnt = self.longlinkcnt + 1 #这个要一条连接统一，不能乱，回头加锁
                   tm=tmnow
               if len(w_list) > 0:  # 产生了可写的事件，即连接完成
                   self.savelogs('longlinktcpth2',str(w_list))
                   w_inputs.clear()  # 当连接完成之后，清除掉完成连接的socket

if len(e_list) > 0:  # 产生了错误的事件，即连接错误
                   self.savelogs('longlinktcpth2', str(e_list))
                   e_inputs.clear()  # 当连接有错误发生时，清除掉发生错误的socket
           except OSError as e:
               self.savelogs('longlinktcpth2', 'socket error,do reconnect')
               time.sleep(3)
               self.sockmain = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
               self.longlinktcpstart2()
               r_inputs = set()
               r_inputs.add(self.sockmain)
               w_inputs = set()
               w_inputs.add(self.sockmain)
               e_inputs = set()
               e_inputs.add(self.sockmain)

self.savelogs('longlinktcpth2', 'leave')

由于这个代码主要是在windows上使用，因此，longlinktcpth2线程采用了select来实现，而没有使用epoll。在循环中，对异常进行了处理，如果发生异常，连接被断开，则调用longlinktcpstart2重新连接，而不退出循环，其余的和longlinktcpstart2里面一致。

由于TCP连接是流的概念，因此，需要对数据进行缓存拼接，这就是上面代码中databuf的作用，防止每次收到的数据不完整或者太多，方便后续的处理，这才是一个合格的码农的信仰的自我升华。

来源：https://blog.csdn.net/yeyiqun/article/details/122852505