socket学习

最新推荐文章于 2024-08-13 11:33:47 发布

Marvin_Kai

最新推荐文章于 2024-08-13 11:33:47 发布

阅读量210

点赞数

分类专栏： Python学习

本文链接：https://blog.csdn.net/marvin_wind/article/details/80357664

版权

Python学习专栏收录该内容

39 篇文章 2 订阅

订阅专栏

socket学习

一、socket抽象层

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族
套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

常用方法：
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom() 接收UDP数据
s.sendto() 发送UDP数据
s.getpeername() 连接到当前套接字的远端的地址
s.getsockname() 当前套接字的地址
s.getsockopt() 返回指定套接字的参数
s.setsockopt() 设置指定套接字的参数
s.close() 关闭套接字

面向锁的套接字方法
s.setblocking() 设置套接字的阻塞与非阻塞模式
s.settimeout() 设置阻塞套接字操作的超时时间
s.gettimeout() 得到阻塞套接字操作的超时时间

面向文件的套接字的函数
s.fileno() 套接字的文件描述符
s.makefile() 创建一个与该套接字相关的文件

二、tcp

tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

tcp服务端


1 ss = socket()                #创建服务器套接字
2 ss.bind()                    #把地址绑定到套接字
3 ss.listen()                  #监听链接
4 inf_loop:                    #服务器无限循环
5     cs = ss.accept()         #接受客户端链接
6     comm_loop:               #通讯循环
7         cs.recv()/cs.send()  #对话(接收与发送)
8     cs.close()               #关闭客户端套接字
9 ss.close()                   #关闭服务器套接字(可选)

tcp客户端

1 cs = socket()                # 创建客户套接字
2 cs.connect()                 # 尝试连接服务器
3 comm_loop:                   # 通讯循环
4     cs.send()/cs.recv()      # 对话(发送/接收)
5 cs.close()                   # 关闭客户套接字

关于端口占用的解决方法：

#1
phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-2-9979bf596780> in <module>()
      1 #1
----> 2 phone=socket(AF_INET,SOCK_STREAM)
      3 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
      4 phone.bind(('127.0.0.1',8080))


NameError: name 'socket' is not defined

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf

编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30

然后执行 /sbin/sysctl -p 让参数生效。

net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；

net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；

net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。

net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

  File "<ipython-input-1-51a109a1ed88>", line 1
    发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
                                          ^
SyntaxError: invalid character in identifier

#服务端
from socket import *
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
back_log = 5

tcp_sever = socket(AF_INET,SOCK_STREAM)
tcp_sever.bind(ip_port)
tcp_sever.listen(back_log)
print('服务端运行中')

while True:
    print('等待客户端连接中')
    conn,addr = tcp_sever.accept()      #服务端阻塞：等待连接
    print('双向连接是',conn)
    print('客户端地址',addr)
    while True:
        try:
            msg = conn.recv(buffer_size)
            print('客户端发来的信息是：',msg)
            if not msg : break
            conn.send(msg.upper())
        except Exception:
            break
    conn.close()
tcp_sever.close()

客户端和服务端运行在应用层，数据在用户态内存中。收发信息在内核态内存中。客户端和服务端需要到内核态内存中recv,send。内核态发出到网络是通过tcp、udp协议。
客户端send一个空的自己的内核态缓存。自己的内核态缓存并没有将空内容发出。故服务端和客户端都会卡住。

#客户端
from socket import *
ip_port = ('192.168.50.182',8080)
buffer_size = 1024

tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

print('客户端运行中')

while True:
    msg = input('>>>').strip()
    tcp_client.send(msg.encode('utf8'))
    print('信息已发送')
    data = tcp_client.recv(buffer_size)
    print('客户端发来的信息是：',data.decode('utf8'))

tcp_client.close()

二、udp

udp是无链接的，先启动哪一端都不会报错

udp服务端

1 ss = socket()                      #创建一个服务器的套接字
2 ss.bind()                          #绑定服务器套接字
3 inf_loop:                          #服务器无限循环
4     cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
5 ss.close()                         # 关闭服务器套接字
udp客户端

cs = socket()                        # 创建客户套接字
comm_loop:                           # 通讯循环
    cs.sendto()/cs.recvfrom()        # 对话(发送/接收)
cs.close()                           # 关闭客户套接字

#服务端
from socket import *
ip_port = ('192.168.50.182',8080)
buffer_size = 1024

udp_server = socket(AF_INET,SOCK_DGRAM)
udp_server.bind(ip_port)

while True:
    data,addr = udp_server.recvfrom(buffer_size)
    print('从客户端%s发来信息:' % str(addr))
    print(addr)
    print(data)

    udp_server.sendto(data.upper(),addr)

#客户端
from socket import *

ip_port = ('192.168.50.182', 8080)
buffer_size = 1024

udp_client = socket (AF_INET, SOCK_DGRAM)

while True:
    msg = input('>>>').strip()
    udp_client.sendto(msg.encode('utf8'),ip_port)
    data, addr = udp_client.recvfrom (buffer_size)
    print(addr)
    print (data.decode('utf8'))

三、粘包

udp传输收发一一对应，没收到的话会丢弃。而tcp传输收发本质上都是操作缓存，当一次收信息没收全时，下次收取的就是剩余部分，所以会发生粘包。

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通信是无消息保护边界的。

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。即面向消息的通信是有消息保护边界的。

tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略

#粘包解决1
#sever端
from socket import *
import subprocess
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
back_log = 5

tcp_sever = socket(AF_INET,SOCK_STREAM)
tcp_sever.bind(ip_port)
tcp_sever.listen(back_log)
print('服务端运行中')

while True:
    print('等待客户端连接中')
    conn,addr = tcp_sever.accept()      #服务端阻塞：等待连接
    print('双向连接是',conn)
    print('客户端地址',addr)
    while True:
        try:
            cmd = conn.recv(buffer_size)
            print('客户端发来的信息是：',cmd)
            if not cmd : break
            res=subprocess.Popen(cmd.decode('utf8'),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
            if res.stderr.read():
                cmd_res=res.stderr.read()
            else:
                cmd_res=res.stdout.read()
            if not cmd_res:
                cmd_res='执行成功'.encode('gbk')
            conn.send(str(len(cmd_res)).encode('utf8'))
            ret = conn.recv(buffer_size)
            if ret == b'ready':
                conn.send(cmd_res.decode('gbk').encode('utf8'))

        except Exception as e:
            print(e)
            break

#client端
from socket import *
ip_port = ('192.168.50.182',8080)
buffer_size = 1024

tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

print('客户端运行中')

while True:
    cmd = input('>>>').strip()                     #去掉空格
    if not cmd : continue                         #直接回车或只有空格
    if cmd == 'quit':break
    tcp_client.send(cmd.encode('utf8'))
    print('信息已发送')
    length = tcp_client.recv(buffer_size)
    tcp_client.send('ready'.encode('utf8'))
    length = int(length.decode('utf8'))
    recv_size = 0
    recv_msg = b''
    while recv_size < length:
        recv_msg += tcp_client.recv(buffer_size)
        recv_size = len(recv_msg)
    print('服务端发来的信息是：',recv_msg.decode('utf8'))

使用struct模块打包报文长度为4字节

from socket import *
import struct
import subprocess
ip_port = ('192.168.50.182',8080)
buffer_size = 1024
back_log = 5

tcp_sever = socket(AF_INET,SOCK_STREAM)
tcp_sever.bind(ip_port)
tcp_sever.listen(back_log)
print('服务端运行中')

while True:
    print('等待客户端连接中')
    conn,addr = tcp_sever.accept()      #服务端阻塞：等待连接
    print('双向连接是',conn)
    print('客户端地址',addr)
    while True:
        try:
            cmd = conn.recv(buffer_size)
            print('客户端发来的信息是：',cmd)
            if not cmd : break
            res=subprocess.Popen(cmd.decode('utf8'),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
            if res.stderr.read():
                cmd_res=res.stderr.read()
            else:
                cmd_res=res.stdout.read()
            if not cmd_res:
                cmd_res='执行成功'.encode('gbk')

            length = len(cmd_res)

            data_length = struct.pack('i',length)
            conn.send(data_length)
            conn.send(cmd_res)

        except Exception as e:
            print(e)
            break

from socket import *
import struct

ip_port = (‘192.168.50.182’,8080)
buffer_size = 1024

tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

print(‘客户端运行中’)

while True:
cmd = input(‘>>>’).strip()
if not cmd : continue
if cmd == ‘quit’:break
tcp_client.send(cmd.encode(‘utf8’))
print(‘信息已发送’)

length_data = tcp_client.recv(4)
length = struct.unpack('i',length_data)[0]
recv_size = 0
recv_msg = b''
while recv_size < length:
    recv_msg += tcp_client.recv(buffer_size)
    recv_size = len(recv_msg)

print('服务端发来的信息是：',recv_msg.decode('gbk'))

socketserver

实现tcp并发

import socketserver

class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        print('conn is:',self.request)       #conn
        print('addr is:',self.client_address)     #addr

        while True:
            try:
                data = self.request.recv(1024)
                if not data :break
                print('收到客户端的消息是：',data,self.client_address)

                self.request.sendall(data.upper())

            except Exception as e:
                print(e)
                break

if __name__ == '__main__':
    s = socketserver.ThreadingTCPServer(('127.0.0.1',8080),Myserver)
    s.serve_forever()

subprocess模块

subprocess模块用于调用系统命令，允许一个进程创建一个新的子进程，通过管道连接到子进程的stdin/stdout/stderr，获取子进程的返回值等操作。
Popen所有参数： subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None,stderr=None, preexec_fn=None, close_fds=False, shell=False,cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

import subprocess
res = subprocess.Popen('dir',shell=True,stdout=subprocess.PIPE)            #标准输出存放到管道
p1=res.stdout.read()                                                        #读取标准输出
print(p1)