标签：端口 buffer self 进程 play 成功 span one put
物理层的主要功能是基于电气特性发送高低电压（高代表1，低代表0）形成电信号，使计算机完成组网以达到接入Internet的目的
数据链路层是用来定义电信号的分组方式，使单纯的电信号0和1变得有意义
以太网协议（ethernet）是统一的分组标准，以太网协议规定：a.一组电信号构成一个数据包，叫做“帧”；b。每一数据帧分成报头head和数据data两部分
报头（head）固定为18个字节，发送者即源地址、接受者即目标地址和数据类型各占6个字节
数据（data）最短为46字节，最长为1500字节，它包含了数据包的具体内容
ethernet规定接入Internet的设备都必须具备网卡，发送端和接收端的地址即网卡地址，又称mac地址。
ethernet采用广播的方式进行通信，一台主机通过ARP协议获取另一台主机的mac地址
网络层引入了一套新的地址即网络地址来区分不同的广播域
IP地址规定了网络地址由32位2进制表示，即从0.0.0.0-255.255.255.255，IP地址分为主机部分和网络部分
子网掩码是描述子网络特征的参数，形式上与IP地址一致，但网络部分全部为1，主机部分全部为0，利用子网掩码与IP地址进行and运算（两个位数都为1运算结果为1，否则为0），结果相同表明在同一个子网络中。
通过广播的方式发送数据包来获取目标主机的mac地址
传输层是用来建立端口到端口的通信，端口范围为0-65535，其中0-1023为系统占用端口
TCP协议为可靠传输，通常TCP的数据包的长度不会超过IP数据包的长度，理论上可以无限长；UDP协议为不可靠传输，总长度不超过65535个字节
用来规定开发的应用程序的数据格式
即client/server（C/S）架构，socket就是为了实现C/S架构的开发，C/S架构的软件是基于网络进行通信的。
socket是应用层与TCP/IP协议通信的中间层，是一组封装了TCP/IP协议的接口，用户遵循socket规定编程即遵循tcp/udp协议
socket主要有基于文件类型（AF_UNIX）和基于网络类型（AF_INET）两种家族。
tcp是基于链接的，必须先启动服务端
服务端
ss = socket() #创建服务器套接字
ss.bind() #把地址绑定到套接字
ss.listen() #监听链接
inf_loop: #服务器无限循环
cs = ss.accept() #接受客户端链接
comm_loop: #通讯循环
cs.recv()/cs.send() #对话(接收与发送)
cs.close() #关闭客户端套接字
ss.close() #关闭服务器套接字(可选)
from socket import *
import subprocess
ip_port = ("10.10.27.37",8000)
back_log = 5
buffer_size = 1024
ftp_server = socket(AF_INET,SOCK_STREAM)
ftp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
ftp_server.bind(ip_port)
ftp_server.listen(back_log)
while True:
conn,addr = ftp_server.accept()
print("新的客户端链接",addr)
while True:
try:
cmd = conn.recv(buffer_size)
print("收到客户端的命令",cmd)
if not cmd:
break
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:
break
conn.close()
客户端
cs = socket() # 创建客户套接字
cs.connect() # 尝试连接服务器
comm_loop: # 通讯循环
cs.send()/cs.recv() # 对话(发送/接收)
cs.close() # 关闭客户套接字
from socket import *
ip_port = ("10.10.27.37",8000)
buffer_size = 1024
ftp_client = socket(AF_INET,SOCK_STREAM)
ftp_client.connect(ip_port)
while True:
cmd = input(">>>:")
if not cmd :
continue
if cmd == "quit":
break
ftp_client.send(cmd.encode("utf-8"))
res = ftp_client.recv(buffer_size)
print(res.decode("gbk"))
ftp_client.close()
udp是无连接的，可以先启动任意一端
服务端
ss = socket() #创建一个服务器的套接字
ss.bind() #绑定服务器套接字
inf_loop: #服务器无限循环
cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
ss.close() # 关闭服务器套接字
from socket import *
ip_port = ("10.10.27.37",8001)
buffer_size = 1024
udp_server = socket(AF_INET,SOCK_DGRAM)
udp_server.bind(ip_port)
while True:
data,addr =udp_sever.recvfrom(buffer_size)
print(data,addr)
udp_server.sendto(data.upper(),addr)
客户端
cs = socket() # 创建客户套接字
comm_loop: # 通讯循环
cs.sendto()/cs.recvfrom() # 对话(发送/接收)
cs.close() # 关闭客户套接字
from socket import *
udp_client = socket(AF_INET,SOCK_DGRAM)
ip_port = ("10.10.27.37",8001)
buffer_size = 1024
while True:
msg = input(">>>:")
udp_client.sendto(msg.encode("utf-8"),ip_port)
data,addr = udp_client.recvfrom(buffer_size)
print(addr)
print(data.decode("utf-8"))
粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
发送时：先发报头长度，再编码报头内容然后发送，最后发真实内容。
接收时：先收报头长度，用struct取出来，根据取出的长度收取报头内容，然后解码，反序列化，从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容
from socket import *
import subprocess,struct
ip_port = ("10.10.27.37",666)
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)
#执行命令，得到的运行结果cmd_res
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()
#发
if not cmd_res:
cmd_res="执行成功".encode("gbk")
#解决粘包
length = len(cmd_res)
data_length = struct.pack("i",length)#struct模块需要了解
conn.send(data_length)
conn.send(cmd_res)
except Exception:
break
from socket import *
import struct
from functools import partial
ip_port = ("10.10.27.37",666)
back_log = 5
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_msg ="".join(iter(partial(tcp_client.recv,buffer_size),b""))
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
基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环，利用socketserver模块中的两大类：server类（解决链接问题）和request类（解决通信问题）来实现并发
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
print("conn in:",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.request.sendall(data.upper())
except Exception:
break
if __name__ == "__main__":
s = socketserver.ThreadingTCPServer(("10.10.27.37",8181),MyServer)#多进程
# s = socketserver.ForkingTCPServer(("10.10.27.37",8181),MyServer)#多线程，系统开销高于多进程
s.serve_forever()
from socket import *
ip_port = ("10.10.27.37",8181)
back_log = 5
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"))
data = tcp_client.recv(1024)
print("收到服务端发来的消息",data.decode("utf-8"))
tcp_client.close
标签：端口 buffer self 进程 play 成功 span one put
原文地址：https://www.cnblogs.com/hechengwei/p/9141527.html
