Scoket层

• Scoket层在应用层和传输层之间

一、什么是socket

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

二、套接字发展史及分类

• 套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix
• 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”
• 一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯
• 这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是
  • 基于文件型的
  • 基于网络型的。

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

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

[2]基于网络类型的套接字家族**

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

三、套接字工作流程

[1]服务端流程

• 先从服务器端说起。
  • 服务器端先初始化Socket
  • 然后与端口绑定(bind)，对端口进行监听(listen)
  • 调用accept阻塞，等待客户端连接。
  • 在这时如果有个客户端初始化一个Socket
  • 然后连接服务器(connect)
    • 如果连接成功，这时客户端与服务器端的连接就建立了。
  • 客户端发送数据请求，服务器端接收请求并处理请求
  • 然后把回应数据发送给客户端，客户端读取数据
  • 最后关闭连接，一次交互结束

[2]服务端套接字函数

• s.bind() 绑定(主机,端口号)到套接字
• s.listen() 开始TCP监听
• s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来

[3]客户端套接字函数

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

[4]公共用途的函数

• 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() 关闭套接字

[5]面向锁的套接字方法

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

[6]面向文件的套接字函数

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

四、基于TCP的套接字

[1]方法简介

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

（1）TCP服务端

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

（2）TCP客户端

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

[2]案例演示

• 服务端

import socket

IP = '127.0.0.1'
PORT = 8080

server = socket.socket()
server.bind((IP, PORT))
server.listen(5)
while True:
    conn, addr = server.accept()
    msg_from_client = conn.recv(1024)
    msg_from_client = msg_from_client.decode('utf-8')
    print(f'这是来自客户端的信息：{msg_from_client}')

    while True:
        msg_send_to_client = input('请输入要发送到客户端的信息：').strip()
        if not len(msg_send_to_client):
            continue
        msg_send_to_client = msg_send_to_client.encode('utf-8')
        conn.send(msg_send_to_client)
        break
    if msg_send_to_client.decode('utf-8') == 'q':
        break
conn.close()
server.close()

• 客户端

import socket

while True:
    client = socket.socket()

    IP = '127.0.0.1'
    PORT = 8080

    client.connect((IP, PORT))

    while True:
        msg_send_to_server = input(f'请输入发送发到服务器端的信息：').strip()
        if not len(msg_send_to_server):
            continue
        msg_send_to_server = msg_send_to_server.encode('utf-8')
        client.send(msg_send_to_server)
        break
    if msg_send_to_server.decode('utf-8') == 'q':
        break
    msg_from_server = client.recv(1024)
    msg_from_server = msg_from_server.decode('utf-8')
    if msg_from_server == 'q':
        break
    print(f'这是来自服务器端的信息：{msg_from_server}')

client.close()

• bug
  • 当多个客户端连接服务端时，如果服务端输入‘q’想要断开连接，只有正在与服务端交互的客户端会收到‘q’并结束进程，其他的客户端只能报错，强制结束进程

五、基于UDP的套接字

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

[1]方法简介

（1）UDP服务端

server = socket()   #创建一个服务器的套接字
server.bind()       #绑定服务器套接字
inf_loop:       #服务器无限循环
    conn = server.recvfrom()/conn.sendto() # 对话(接收与发送)
server.close()                         # 关闭服务器套接字

（2）UDP客户端

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

[2]案例演示

• 服务端

import socket

IP = '127.0.0.1'
PORT = 8080

server = socket.socket(type=socket.SOCK_DGRAM)
server.bind((IP, PORT))

msg_from_client, addr = server.recvfrom(1024)
msg_from_client = msg_from_client.decode('utf-8')
print(f'这是来自客户端的信息：{msg_from_client}')
print(addr)

while True:
    msg_send_to_client = input('请输入要发送到客户端的信息：').strip()
    if not len(msg_send_to_client):
        continue
    msg_send_to_client = msg_send_to_client.encode('utf-8')
    server.sendto(msg_send_to_client, addr)
    break

• 客户端

import socket

IP = '127.0.0.1'
PORT = 8080

client = socket.socket(type=socket.SOCK_DGRAM)

msg_send_to_server = input('请输入发送到服务端的信息：')
msg_send_to_server = msg_send_to_server.encode('utf-8')
client.sendto(msg_send_to_server, (IP, PORT))

msg_from_server, addr = client.recvfrom(1024)
msg_from_server = msg_from_server.decode('utf-8')
print(msg_from_server)
print(addr)

六、补充(转载自)

【1】问题引入

• 有的同学在重启服务端时可能会遇到

• 这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址

【2】解决方法

（1）方法一

#加入一条socket配置，重用ip和端口

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

（2）方法二

• 发现系统存在大量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

• 参数说明

  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 时间
  

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

/sbin/sysctl -p