socket

socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口，在设计模式中，socket就是一个门面模式，他把复杂的的TCP/IP协议族隐藏在socket接口后面。

IP是用来标识互联网中的一台主机位置，port是用来标识这台机器上的一个应用程序，IP地址是配置到网卡上的。

pid是同一台机器上不同进程或线程的标识。

套接字被设计用在同一台主机上多个应用程序之间的通讯，也被称为进程间通讯或IPC，套接字分别有文件型或网络型。

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

tcp服务端

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

基于TCP服务端的代码：

from socket import *
ip_port = ("127.0.0.1",8000)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    print("服务端开始运行了")
    conn,addr = tcp_server.accept()
    print("双向链接是",conn)
    print("客户端地址是",addr)
    while True:
        try:
            data = conn.recv(buffer_size)
            print("收到客户端发来的消息是",data.decode("utf-8"))
            conn.send(data.upper())
        except Exception:
            break
    conn.close()
tcp_server.close()
tcp客户端

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

基于TCP客户端1的代码

from socket import *
ip_port = ("127.0.0.1",8000)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    msg = input(">>:").strip()
    if not msg:
        continue
    tcp_client.send(msg.encode("utf-8"))
    print("客户端已经发送了消息")
    data = tcp_client.recv(buffer_size)
    print("收到服务端发来的消息是",data.decode("utf-8"))
tcp_client.close()

基于TCP客户端2的代码

from socket import *
ip_port = ("127.0.0.1",8000)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    msg = input(">>:").strip()
    if not msg:
        continue
    tcp_client.send(msg.encode("utf-8"))
    print("客户端已经发送了消息")
    data = tcp_client.recv(buffer_size)
    print("收到服务端发来的消息是",data.decode("utf-8"))
tcp_client.close()
udp是无链接的，先启动哪一端都不会报错
udp服务端

1 ss = socket(AF_INET,SOCK_DGRAM) #创建一个服务器的套接字 
2 ss.bind() #绑定服务器套接字 
3 inf_loop: #服务器无限循环 
4数据，数据的地址= 套接字名.recvfrom(接收字节的长度）
5套接字名.sendto(数据,数据的地址)

基于UDP服务端代码：

from socket import *
ip_port = ("127.0.0.1",8008)
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(data)
    udp_server.sendto(data.upper(),addr)
udp客户端

设置服务端的地址加端口

设置字节长度

cs = socket()   # 创建客户套接字
客户端套接字名.sendto(.编码，服务端地址加端口）
数据，数据的地址=客户端套接字名.recvfrom(定义的字节长度）
输出打印时解码

基于UDP客户端1代码

from socket import *
ip_port = ("127.0.0.1",8008)
buffer_size = 1024
udp_client = socket(AF_INET,SOCK_DGRAM)
while True:
    msg = input(">>:")
    udp_client.sendto(msg.encode("utf-8"),ip_port)
    data,addr = udp_client.recvfrom(buffer_size)
    print(data.decode("utf-8"))

基于UDP客户端2代码

from socket import *
ip_port = ("127.0.0.1",8008)
buffer_size = 1024
udp_client = socket(AF_INET,SOCK_DGRAM)
while True:
    msg = input(">>:")
    udp_client.sendto(msg.encode("utf-8"),ip_port)
    data,addr = udp_client.recvfrom(buffer_size)
    print(data.decode("utf-8"))

基于TCP远程执行命令服务端代码

from socket import *
import subprocess
ip_port = ("127.0.0.1",8002)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    conn,addr = tcp_server.accept()
    print("新的客户端链接是",addr)
    while True:
        try:
            cmd = conn.recv(buffer_size)
            print("收到客户端的命令",cmd)
            res = subprocess.Popen(cmd.decode("utf-8"),shell=True,
                                   stderr=subprocess.PIPE,
                                   stdout=subprocess.PIPE,
                                   stdin=subprocess.PIPE)
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()
            conn.send(cmd_res)
        except Exception as e :
            print(e)
            break
    conn.close()

基于TCP远程执行命令客户端代码

from socket import *
ip_port = ("127.0.0.1",8002)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    cmd = input(">>:").strip()
    if not cmd:
        continue
    if cmd == "quit":
        break
    tcp_client.send(cmd.encode("utf-8"))
    cmd_res = tcp_client.recv(buffer_size)
    print("命令的执行结果是",cmd_res.decode("gbk"))
tcp_client.close()
tcp和ufp的区别？
recv在自己这端的缓冲区为空时，阻塞。
recvfrom在自己这端的缓冲区为空时，就收一个空。
基于客户端发请求服务端返回时间的需求：
udp服务端代码：

from socket import *
import time
ip_port = ("127.0.0.1",8001)
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(data)
    if not data:
        fmt = "%Y-%m-%d %X"
    else:
        fmt = data.decode("utf-8")
    back_time = time.strftime(fmt)
    udp_server.sendto(back_time.encode("utf-8"),addr)
udp_server.close()

udp客户端代码：

from socket import *
ip_port = ("127.0.0.1",8001)
buffer_size = 1024
udp_client = socket(AF_INET,SOCK_DGRAM)
while True:
    msg = input(">>:").strip()
    udp_client.sendto(msg.encode("utf-8"),ip_port)
    data,addr = udp_client.recvfrom(buffer_size)
    print("udp服务器的标准时间是",data.decode("utf-8"))
udp_client.close()
粘包现象：
tcp服务端代码：

from socket import *
import subprocess
ip_port = ("127.0.0.1",8000)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    conn,addr = tcp_server.accept()
    print("新客户端的链接是",addr)
    while True:
        try:
            cmd = conn.recv(buffer_size)
            if not cmd:
                break
            print("客户端的命令是",cmd)
            res = subprocess.Popen(cmd.decode("utf-8"),shell= True,
                                   stdin= subprocess.PIPE,
                                   stdout= subprocess.PIPE,
                                   stderr= subprocess.PIPE)
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()
            if not cmd_res:
                cmd_res ="执行成功".encode("gbk")
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break

tcp客户端代码：

from socket import *
ip_port  = ("127.0.0.1",8000)
buffer_size=  1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    msg = input(">>:").strip()
    if not msg:
        continue
    if msg == "quit":
        break
    tcp_client.send(msg.encode("utf-8"))
    cmd = tcp_client.recv(buffer_size)
    print("收到服务端的命令是",cmd.decode("gbk"))

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

udp服务端代码：

from socket import *
import subprocess
ip_port = ("127.0.0.1",8000)
buffer_size = 1024
udp_server = socket(AF_INET,SOCK_DGRAM)
udp_server.bind(ip_port)
while True:
    cmd,addr = udp_server.recvfrom(buffer_size)
    res = subprocess.Popen(cmd.decode("utf-8"),shell= True,
                           stdin= subprocess.PIPE,
                           stdout= subprocess.PIPE,
                           stderr= subprocess.PIPE)
    err = res.stderr.read()
    if err:
        cmd_res = err
    else:
        cmd_res = res.stdout.read()
    if not cmd_res:
        cmd_res = "执行成功".encode("gbk")
    udp_server.sendto(cmd_res,addr)

udp客户端代码：

from socket import *
ip_port  = ("127.0.0.1",8000)
buffer_size=  1024
udp_client = socket(AF_INET,SOCK_DGRAM)
udp_client.connect(ip_port)
while True:
    msg = input(">>:").strip()
    if not msg:
        continue
    if msg == "quit":
        break
    udp_client.sendto(msg.encode("utf-8"),ip_port)
    cmd_res,addr = udp_client.recvfrom(buffer_size)
    print("收到服务端的命令是",cmd_res.decode("gbk"))
udp_client.close()

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

正常关闭用if not处理、非正常关闭用try处理tcp服务端的代码：

from socket import *
import subprocess
ip_port = ("127.0.0.1",8001)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    conn,addr = tcp_server.accept()
    print("新客户端的衔接是",conn)
    while True:
        try:
            cmd = conn.recv(buffer_size)
            if not cmd:
                break
            print("收到的命令是",cmd)
            res = subprocess.Popen(cmd.decode("utf-8"),shell= True,
                                   stdout= subprocess.PIPE,
                                   stdin= subprocess.PIPE,
                                   stderr= subprocess.PIPE)
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()
            if not cmd_res:
                cmd_res = "执行成功".encode("gbk")
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break
tcp客户端的代码：

from socket import *
ip_port = ("127.0.0.1",8000)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    msg = input(">>:").strip()
    if not msg:
        continue
    if msg == "quit":
        break
    tcp_client.send(msg.encode("utf-8"))
    cmd = tcp_client.recv(buffer_size)
    print("收到服务端命令是",cmd.decode("gbk"))
tcp粘包解决办法：

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

1. TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
2. UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
3. tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头

tcp粘包解决办法服务端代码：

from socket import *
import subprocess
import struct
ip_port = ("127.0.0.1",8000)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    conn,addr = tcp_server.accept()
    print("新客户端的链接是",addr)
    while True:
        try:
            cmd = conn.recv(buffer_size)
            if not cmd:
                break
            print("收到客户端的命令是",cmd)
            res = subprocess.Popen(cmd.decode("utf-8"),shell= True,
                                   stdin= subprocess.PIPE,
                                   stdout= subprocess.PIPE,
                                   stderr= subprocess.PIPE)
            err = res.stderr.read()
            if err:
                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

tcp粘包解决办法客户端代码：

from socket import *
import struct
from functools import partial
ip_port = ("127.0.0.1",8000)
buffer_size= 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    cmd = input(">>:").strip()
    if not cmd:
        continue
    if cmd == "quit":
        break
    tcp_client.send(cmd.encode("utf-8"))
    length_data = tcp_client.recv(4)
    length = struct.unpack("i",length_data)[0]
    recv_size = 0
    recv_data = b""
    while recv_size < length:
        recv_data += tcp_client.recv(buffer_size)
        recv_size = len(recv_data)
    print("收到服务端的命令是",recv_data.decode("gbk"))
tcp_client.close()
socketserver实现并发服务端代码：

import socketserver
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        print("conn is:",self.request)
        print("addr is:",self.client_address)
        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",8000),MyServer)
    s.serve_forever()

socketserver实现并发客户端1代码：

from socket import *
ip_port = ("127.0.0.1",8000)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    msg = input(">>:").strip()
    if not msg:
        continue
    if msg == "quit":
        break
    tcp_client.send(msg.encode("utf-8"))
    data = tcp_client.recv(buffer_size)
    print("收到服务端的命令",data.decode("utf-8"))
tcp_client.close()

socketserver实现并发客户端2代码：

from socket import *
ip_port = ("127.0.0.1",8000)
buffer_size = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    msg = input(">>:").strip()
    if not msg:
        continue
    if msg == "quit":
        break
    tcp_client.send(msg.encode("utf-8"))
    data = tcp_client.recv(buffer_size)
    print("收到服务端的命令",data.decode("utf-8"))
tcp_client.close()

认证客户端的链接合法性需求：

服务端代码：

from socket import *
import hmac,os
secret_key=b'linhaifeng bang bang bang'
def conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    print('开始验证新链接的合法性')
    msg=os.urandom(32)
    conn.sendall(msg)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    respone=conn.recv(len(digest))
    return hmac.compare_digest(respone,digest)
def data_handler(conn,bufsize=1024):
    if not conn_auth(conn):
        print('该链接不合法,关闭')
        conn.close()
        return
    print('链接合法,开始通信')
    while True:
        data=conn.recv(bufsize)
        if not data:break
        conn.sendall(data.upper())
def server_handler(ip_port,bufsize,backlog=5):
    '''
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server=socket(AF_INET,SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn,addr=tcp_socket_server.accept()
        print('新连接[%s:%s]' %(addr[0],addr[1]))
        data_handler(conn,bufsize)
if __name__ == '__main__':
    ip_port=('127.0.0.1',8000)
    bufsize=1024
    server_handler(ip_port,bufsize)

客户端代码：

from socket import *
import hmac,os
secret_key=b'linhaifeng bang bang bang'
def conn_auth(conn):
    '''
    验证客户端到服务器的链接
    :param conn:
    :return:
    '''
    msg=conn.recv(32)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    conn.sendall(digest)
def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)
    conn_auth(tcp_socket_client)
    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break
        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()
if __name__ == '__main__':
    ip_port=('127.0.0.1',8000)
    bufsize=1024
    client_handler(ip_port,bufsize)