网络编程——socket编程
一、C/S架构介绍
C/S架构 C：clint(客户端软件)
S：server(服务端软件)
python程序员是应用开发程序员，开发的软件都是应用软件，应用软件必须运行于操作系统之上，操作系统则运行于硬件上，应用软件不能直接操作硬件，应用软件对硬件的操作必须调用操作系统接口，由操作系统操作硬件。
客户端软件基于网络发送消息给服务端软件流程：
1、客户端软件产生数据，存放于客户端软件的内存中，然后调用接口将自己内存中的数据发送/拷贝给操作系统内存
2、客户端操作系统收到数据后，按照客户端软件指定的协议、调用网卡发送数据
3、网络传输数据
4、服务端软件调用系统接口，想要将数据从操作系统内存拷贝到自己的内存中
5、服务端操作系统受到4的指令后，使用与客户端相同的协议，从网卡接收到数据，然后拷贝给服务端软件
假设我现在要写一个程序，给另一台计算机发数据，必须通过tcp/ip协议 ，但具体的实现过程是什么呢？我应该怎么操作才能把数据封装成tcp/ip的包，又执行什么指令才能把数据发到对端机器上呢?
简而言之，socket这个东东干的事情，就是帮你把tcp/ip协议层的各种数据封装啦、数据发送、接收等通过代码已经给你封装好了，你只需要调用几行代码，就可以给别的机器发消息了。
二、计算机网络
计算机之间的通信首先要有物理链接介质，比如网线，交换机，路由器等网络设备。
通信的线路建好之后，只是物理层面有了可以承载数据的介质，要想通信，还需要我们按照某种规则组织我们的数据，这样对方在接收到数据后就可以按照相同的规则去解析出数据。
三、TCP/IP
按照功能不同，人们将互联网协议分为osi七层或tcp/ip五层或tcp/ip四层。
http://www.cnblogs.com/linhaifeng/articles/5937962.html#_label5
TCP/IP五层：
1、应用层：规定应用程序的数据格式。
2、传输层：建立端口到端口的通信
""" 端口范围0-65535，0-1023为系统占用端口 传输层有两种协议，TCP和UDP: tcp协议： 可靠传输，TCP数据包没有长度限制，理论上可以无限长，但是为了保证网络的效率，通常 TCP数据包的长度不会超过IP数据包的长度，以确保单个TCP数据包不必再分割。 udp协议： 不可靠传输，”报头”部分一共只有8个字节，总长度不超过65,535字节，正好放进一个IP数据包。 """
3、网络层：引入一套新的地址用来区分不同的广播域／子网，这套地址即网络地址
""" ip协议： 1、规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示 2、范围0.0.0.0-255.255.255.255 3、一个ip地址通常写成四段十进制数，例：172.16.10.1 子网掩码： 所谓”子网掩码”，就是表示子网络特征的一个参数。它在形式上等同于IP地址，也是一个32位二进制数字， 它的网络部分全部为1，主机部分全部为0。比如，IP地址172.16.10.1，如果已知网络部分是前24位， 主机部分是后8位，那么子网络掩码就是11111111.11111111.11111111.00000000，写成十进制就是255.255.255.0。 """
4、数据链路层：定义了电信号的分组方式，分组方式后来形成了统一的标准，即以太网协议ethernet
""" ethernet规定： 1、一组电信号构成一个数据包，叫做‘帧’ 2、每一数据帧分成：报头head和数据data两部分 head包含：(固定18个字节) 发送者／源地址，6个字节 接收者／目标地址，6个字节 数据类型，6个字节 data包含：(最短46字节，最长1500字节) 数据包的具体内容 head长度＋data长度＝最短64字节，最长1518字节，超过最大限制就分片发送 mac地址：（标识子网内，一台机器的位置） ethernet规定接入internet的设备都必须具备网卡，发送端和接收端的地址便是指网卡的地址，即mac地址 每块网卡出厂时都被烧制上一个世界唯一的mac地址，长度为48位2进制，通常由12位16进制数表示（前六位是厂商编号，后六位是流水线号） 广播： 有了mac地址，同一网络内的两台主机就可以通信了（一台主机通过arp协议获取另外一台主机的mac地址） ethernet采用最原始的方式，广播的方式进行通信，即计算机通信基本靠吼 ## 以太网协议基于MAC地址的广播，只能在局域网吼。## """
5、物理层：主要是基于电器特性发送高低电压(电信号)，高电压对应数字1，低电压对应数字0
四、OSI七层模型
OSI/RM模型(Open System Interconnection / Reference Model)的设计目的是成为一个所有计算机厂商都能实现的开放网络模型，来克服使用众多私有网络模型所带来的困难和低效性。
1、应用层 2、表示层 3、会话层
4、传输层
5、网络层
6、数据链路层
7、物理层
五、socket
Socket是应用层与TCP/IP协议族（传输层）通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。
也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序。
而程序的pid是同一台机器上不同进程或者线程的标识。
五、套接字发展和分类
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
# socket实例化方式 socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None) # proto=0 可忽略，特殊用途 # fileno=None 可忽略，特殊用途
1、基于文件类型的套接字家族
套接字家族名：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信。
2、基于网络类型的套接字家族
套接字家族名：AF_INET
所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET
3、socket type类型
socket.SOCK_STREAM #for tcp socket.SOCK_DGRAM #for udp socket.SOCK_RAW #原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。 socket.SOCK_RDM #是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。 socket.SOCK_SEQPACKET #废弃了
六、套接字工作流程
套接字工作流程图如下：
流程解析：服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。
1、socket(）模块函数用法
import socket socket.socket(socket_family,socket_type,protocal=0) socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。 获取tcp/ip套接字 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 获取udp/ip套接字 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。 例如tcpSock = socket(AF_INET, SOCK_STREAM)
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() 创建一个与该套接字相关的文件
1：用打电话的流程快速描述socket通信 2：服务端和客户端加上基于一次链接的循环通信 3：客户端发送空，卡主，证明是从哪个位置卡的 服务端： from socket import * phone=socket(AF_INET,SOCK_STREAM) phone.bind(('127.0.0.1',8081)) phone.listen(5) conn,addr=phone.accept() while True: data=conn.recv(1024) print('server===>') print(data) conn.send(data.upper()) conn.close() phone.close() 客户端： from socket import * phone=socket(AF_INET,SOCK_STREAM) phone.connect(('127.0.0.1',8081)) while True: msg=input('>>: ').strip() phone.send(msg.encode('utf-8')) print('client====>') data=phone.recv(1024) print(data) 说明卡的原因：缓冲区为空recv就卡住，引出原理图 4.演示客户端断开链接，服务端的情况，提供解决方法 5.演示服务端不能重复接受链接，而服务器都是正常运行不断来接受客户链接的 6:简单演示udp 服务端 from socket import * phone=socket(AF_INET,SOCK_DGRAM) phone.bind(('127.0.0.1',8082)) while True: msg,addr=phone.recvfrom(1024) phone.sendto(msg.upper(),addr) 客户端 from socket import * phone=socket(AF_INET,SOCK_DGRAM) while True: msg=input('>>: ') phone.sendto(msg.encode('utf-8'),('127.0.0.1',8082)) msg,addr=phone.recvfrom(1024) print(msg) udp客户端可以并发演示 udp客户端可以输入为空演示，说出recvfrom与recv的区别，暂且不提tcp流和udp报的概念，留到粘包去说
七、基于TCP的套接字
tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端
服务端：
import socket # 1、买手机 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 # print(phone) """ <socket.socket fd=3, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('0.0.0.0', 0)> """ # 2、绑定手机卡 phone.bind(('127.0.0.1', 9001)) # 本地回环地址, 端口0-65535（0-1024归系统使用） # 3、开机 phone.listen(5) # 最大挂起的链接数 # 4、等电话链接 print('starting...') # res = phone.accept() # 程序卡在这一步 # print(res) # res包含链接对象 """ starting... ===》 (<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 55868)>, ('127.0.0.1', 55868)) """ # 改写分拆两个元组元素 conn, client_addr = phone.accept() print(conn) print(client_addr) print('got a new connection from %s' % (client_addr, )) """ <socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 55925)> ('127.0.0.1', 65197) got a new connection from ('127.0.0.1', 65197) """ # 5、收发消息 data = conn.recv(1024) # 1、单位是bytes 2、1024代表接收数据的最大数是1024个bytes print('客户端数据', data) conn.send(data.upper()) # 数据修改为大写后发送 # 6、挂电话 conn.close() # 7、关机 phone.close() """ 客户端数据 b'hello' """
客户端：
import socket # 1、买手机 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 #print(phone) # 2、拨号 phone.connect(('127.0.0.1', 8080)) # 服务端先启动后启动客户端 # 3、发、收消息 phone.send('hello'.encode('utf-8')) data = phone.recv(1024) print(data) # 4、关闭 phone.close() """ b'HELLO' """
上面是以打电话为例实现了一个low版的套接字通信，但是如果需要多次发送，需要加上通信循环。
import socket # 1、买手机 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 # 2、绑定手机卡 phone.bind(('127.0.0.1', 8080)) # 本地回环地址, 端口0-65535（0-1024归系统使用） # 3、开机 phone.listen(5) # 最大挂起的链接数（TCP协议需要） # 4、等电话链接 print('starting...') conn, client_addr = phone.accept() # accept是建立链接 print(client_addr) # 客户端一启动打印 （'127.0.0.1',56641） # 5、收发消息 while True: # 通信循环 data = conn.recv(1024) # 1、单位是bytes 2、1024代表接收数据的最大数是1024个bytes print('客户端数据', data) conn.send(data.upper()) # 数据修改为大写后发送 # 6、挂电话 conn.close() # 7、关机 phone.close() """ starting... ('127.0.0.1', 56641) 客户端数据 b'hello' 客户端数据 b'xiugeng' """
import socket # 1、买手机 phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 #print(phone) # 2、拨号 phone.connect(('127.0.0.1', 8080)) # 服务端先启动后启动客户端 # 3、发、收消息 while True: # 通信循环 msg = input('>>:').strip() phone.send(msg.encode('utf-8')) data = phone.recv(1024) # 收到服务端大写之后的字符 print(data) # 4、关闭 phone.close() """ >>:hello b'HELLO' >>:xiugeng b'XIUGENG' """
解决重启服务端时，服务端仍存在四次挥手的time_wait状态占用地址的情况（深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法），无法重启服务端，修改代码如下：
import socket phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 解决重启服务端时，服务端仍存在四次挥手的time_wait状态占用地址的情况： # 方法一：加入一条socket配置，重用ip和端口 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 在bind前，启动关闭服务端时，系统端口没有回收，可以重用端口 # 方法二：调整linux内核参数 """ 在 /etc/sysctl.conf文件中添加： net.ipv4.tcp_syncookies = 1 # 表示开启SYN Cookies，启用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 = 30 # 修改系统默认的TIMEOUT时间 执行 /sbin/sysctl -p让参数生效 """ phone.bind(('127.0.0.1', 8080)) phone.listen(5) # 最大挂起的链接数 print('starting...') conn, client_addr = phone.accept() print(client_addr) while True: # 通信循环 try: data = conn.recv(1024) # 客户端发出空消息，服务端没有收到 if not data:break # # 适用与Linux操作系统 print('客户端数据', data) conn.send(data.upper()) except ConnectionResetError: # 适用于windiws的操作系统 break conn.close() phone.close()
import socket phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 phone.connect(('127.0.0.1', 8080)) # 服务端先启动后启动客户端 while True: # 通信循环 msg = input('>>:').strip() # msg='' # 修改办法 if not msg:continue # 输入空，不发送消息 phone.send(msg.encode('utf-8')) # phone.send(b'') # print('has send') # 定位不能发空的缘故 data = phone.recv(1024) # 服务端没有回消息，因此收不到消息 print(data.decode('utf-8')) phone.close()
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 时间
添加链接循环，当上一个链接结束后，等待下一个客户端接入。
import socket """ 需要服务端一直提供服务， """ phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) phone.bind(('127.0.0.1', 8080)) phone.listen(5) # 最大挂起的链接数 print('starting...') """ 需要服务端一直提供服务，再添加一个循环。服务端的工作主要是：1、建立链接；2、通信 需要注意的是：服务端可以一直提供服务，但是不能并发。只有等前一个链接断了后，下一个客户端才能链接 """ while True: # 链接循环 # 创建链接 conn, client_addr = phone.accept() print(client_addr) while True: # 通信循环 try: data = conn.recv(1024) if not data:break print('客户端数据', data) conn.send(data.upper()) except ConnectionResetError: break conn.close() phone.close()
import socket phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 基于网络通讯的，基于TCP协议的一个套接字 phone.connect(('127.0.0.1', 8080)) # 服务端先启动后启动客户端 while True: # 通信循环 msg = input('>>:').strip() # msg='' # 修改办法 if not msg:continue # 输入空，不发送消息 phone.send(msg.encode('utf-8')) # phone.send(b'') # print('has send') # 定位不能发空的缘故 data = phone.recv(1024) # 服务端没有回消息，因此收不到消息 print(data.decode('utf-8')) phone.close()
八、subprocess模块
之前学过os模块来执行系统命令：
import os cmd = os.popen('df -h') cmd = cmd.read() print(cmd)
subprocess命令执行的结果就是bytes，无需转变格式就可以给客户端、服务端使用。
import subprocess obj = subprocess.Popen('dxxxs', shell=True, stdout=subprocess.PIPE, # stdout:正确结果;管道 stderr=subprocess.PIPE) # stderr:错误结果;管道 print(obj) print('stdout 1---->: ', obj.stdout.read().decode('utf-8')) # 正确管道内容 print('stderr 1---->: ', obj.stderr.read().decode('utf-8')) # 错误管道内容 """ <subprocess.Popen object at 0x10401ada0> stdout 1---->: stderr 1---->: /bin/sh: dxxxs: command not found """
九、基于UDP协议的套接字
udp不需要经过3次握手和4次挥手，不需要提前建立链接，直接发送数据即可。
服务端：
# import socket from socket import * # 尽量少用这种导入方式，会将所有名字加入名称空间，容易导致重复 # server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 可以看到需要引用的socket的模块非常多。改用from socket import *导入 server = socket(AF_INET, SOCK_DGRAM) # SOCK_STREAM指的流式协议，SOCK_DGRAM指得是数据报协议（但凡发数据，就已经是完整的数据报） server.bind(('127.0.0.1', 8080)) # server.listen(5) # 挂起的链接数，TCP协议需要，UDP不需要 # while True: # conn, addr = server.accept() # 用来建立链接，UDP不需要 while True: data, client_addr = server.recvfrom(1024) # 收消息 print(data) server.sendto(data.upper(), client_addr) # 发消息，取收消息的地址 server.close()
客户端：
from socket import * client = socket(AF_INET, SOCK_DGRAM) while True: msg = input('>>: ').strip() client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080)) # 发消息 data, server_addr = client.recvfrom(1024) # 收消息 print(data, server_addr) client.close()
以qq聊天为例：
import socket ip_port=('127.0.0.1',8081) udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机 udp_server_sock.bind(ip_port) while True: qq_msg,addr=udp_server_sock.recvfrom(1024) print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8'))) back_msg=input('回复消息: ').strip() udp_server_sock.sendto(back_msg.encode('utf-8'),addr)
import socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) qq_name_dic={ '狗哥alex':('127.0.0.1',8081), '瞎驴':('127.0.0.1',8081), '一棵树':('127.0.0.1',8081), '武大郎':('127.0.0.1',8081), } while True: qq_name=input('请选择聊天对象: ').strip() while True: msg=input('请输入消息,回车发送: ').strip() if msg == 'quit':break if not msg or not qq_name or qq_name not in qq_name_dic:continue udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name]) back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8'))) udp_client_socket.close()
import socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) qq_name_dic={ '狗哥alex':('127.0.0.1',8081), '瞎驴':('127.0.0.1',8081), '一棵树':('127.0.0.1',8081), '武大郎':('127.0.0.1',8081), } while True: qq_name=input('请选择聊天对象: ').strip() while True: msg=input('请输入消息,回车发送: ').strip() if msg == 'quit':break if not msg or not qq_name or qq_name not in qq_name_dic:continue udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name]) back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8'))) udp_client_socket.close()
时间服务器
from socket import * from time import strftime ip_port=('127.0.0.1',9000) bufsize=1024 tcp_server=socket(AF_INET,SOCK_DGRAM) tcp_server.bind(ip_port) while True: msg,addr=tcp_server.recvfrom(bufsize) print('===>',msg) if not msg: time_fmt='%Y-%m-%d %X' else: time_fmt=msg.decode('utf-8') back_msg=strftime(time_fmt) tcp_server.sendto(back_msg.encode('utf-8'),addr) tcp_server.close()
from socket import * ip_port=('127.0.0.1',9000) bufsize=1024 tcp_client=socket(AF_INET,SOCK_DGRAM) while True: msg=input('请输入时间格式(例%Y %m %d)>>: ').strip() tcp_client.sendto(msg.encode('utf-8'),ip_port) data=tcp_client.recv(bufsize) print(data.decode('utf-8')) tcp_client.close()
十、SSH远程模拟及粘包现象
模拟ssh远程执行命令：
注意：
res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
的结果的编码是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码
且只能从管道里读一次结果
注意：命令ls -l ; lllllll ; pwd 的结果是既有正确stdout结果，又有错误stderr结果
服务端-ssh客户端-ssh基于tcp的socket，ssh远程运行时，会发生粘包的问题。导致下次执行命令时，会输出上次服务器回传的没执行完的内容。
再基于udp制作一个远程执行命令的程序：
import socket import subprocess ip_port = ('127.0.0.1', 9001) # 元组 bufsize = 1024 udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp_server.bind(ip_port) while True: # 收消息 cmd, addr = udp_server.recvfrom(bufsize) print("用户命令----->", cmd) # 逻辑处理 res = subprocess.Popen(cmd.decode('utf-8'), shell=True, stderr=subprocess.PIPE, stdin=subprocess.PIPE, stdout=subprocess.PIPE) stdout = res.stdout.read() stderr = res.stderr.read() # 发消息 udp_server.sendto(stderr, addr) udp_server.sendto(stdout, addr) udp_server.close()
import socket client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) while True: msg = input('>>: ').strip() client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080)) # 发消息 data, server_addr = client.recvfrom(1024) # 收消息 print(data, server_addr) client.close()
十一、粘包
所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
-
TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
-
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
-
tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略
udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠
tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
两种情况下会发生粘包
1、发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
import time import socket client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(("127.0.0.1", 9002)) # 使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。 client.send('hello'.encode('utf-8')) client.send('world'.encode('utf-8'))
import time import socket import subprocess server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind(("127.0.0.1", 9002)) # bind()内为元组，0-65535：0-1024供操作系统使用 server.listen(5) conn, addr = server.accept() res1 = conn.recv(1024) # 第一次收 print('第一次', res1) res2 = conn.recv(1024) # 第二次收 print('第二次', res2) """ 第一次 b'helloworld' 第二次 b'' """ # 发生了粘包现象
2、接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
import time import socket client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(("127.0.0.1", 9002)) # 使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。 client.send('hello'.encode('utf-8')) # time.sleep(1) # 休息一秒看是否还粘包 time.sleep(5) client.send('world'.encode('utf-8'))
import time import socket import subprocess server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind(("127.0.0.1", 9002)) # bind()内为元组，0-65535：0-1024供操作系统使用 server.listen(5) conn, addr = server.accept() # 客户端间隔五秒发送，服务端第一次仅接收一个字符，服务端发生粘包 res1 = conn.recv(1) # 第一次收 print('第一次', res1) res2 = conn.recv(1024) # 第二次收 print('第二次', res2) """ 第一次 b'h' 第二次 b'ello' """
补充问题一：为何tcp是可靠传输，udp是不可靠传输
tcp的数据传输请参考文章http://www.cnblogs.com/linhaifeng/articles/5937962.html，tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的
而udp发送数据，对端是不会返回确认信息的，因此不可靠。
补充问题二：send(字节流)和recv(1024)及sendall
recv里指定的1024意思是从缓存里一次拿出1024个字节的数据
send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失
sendall就会循环调用send，数据不会丢失
十二、先提示长度后发送消息解决粘包
接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。
import time import socket import struct import json client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(("127.0.0.1", 9003)) while True: """1、发命令""" cmd = input('>>: ').strip() if not cmd:continue client.send(cmd.encode('utf-8')) """2、拿结果""" # 第一步：先收报头长度 obj= client.recv(4) # 接收四个bytes header_size = struct.unpack('i', obj)[0] # 第二步：再收报头 header_bytes = client.recv(header_size) # 第三步：从报头中解析出对真实数据的描述信息（数据长度） header_json = header_bytes.decode('utf-8') header_dic = json.loads(header_json) print(header_dic) total_size = header_dic['total_size'] # 第四步：接收真实的数据 recv_size = 0 recv_data = b'' while recv_size < total_size: res = client.recv(1024) # 最大不能超过操作系统缓存大小，一次收不完，多次收 recv_data += res recv_size += len(res) # 最后一次收的时候将不是1024,未来如果要查看进度的时候有问题 print(recv_data.decode('utf-8')) client.close()
# -*- coding:utf-8 -*- __author__ = 'Qiushi Huang' import time import socket import subprocess import struct import json server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind(("127.0.0.1", 9003)) # bind()内为元组，0-65535：0-1024供操作系统使用 server.listen(5) print('starting...') while True: conn, client_addr = server.accept() print(client_addr) while True: # 通讯循环 try: """1、收命令""" cmd = conn.recv(8096) if not cmd:break """2、拿到结果""" obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout = obj.stdout.read() stderr = obj.stderr.read() """3、命令结果返回客户端""" # 第一步：制作固定长度的报头 header_dic = { 'filename': 'a.txt', 'md5': 'xxdxxx', 'total_size': len(stdout) + len(stderr) } header_json = json.dumps(header_dic) # dump和dumps的区别 header_bytes = header_json.encode('utf-8') # 第二步：先发送报头的长度 conn.send(struct.pack('i', len(header_bytes))) # 第三步：将报头发给客户端 conn.send(header_bytes) # conn.send(str(total_size).encode('utf-8')) # 整型转换为字符串，编码后发出 # 第四步：发送真实数据 # conn.send(stdout+stderr) # 由于粘包原理可优化改写如下 conn.send(stdout) conn.send(stderr) except ConnectionResetError: break conn.close() server.close()
这种方法虽然解决了粘包的问题，但其实是比较差的解决方法。
程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗。
十三、加报头来解决粘包问题
为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据。
struct模块
该模块的功能就是把一个类型，例如数据，转化为固定长度的bytes，如下所示：
import struct # 格式：struct.pack(fmt, *args) # 设置格式后，把数字转成固定长度的bytes类型 # fmt='i'指的是整型数字 res = struct.pack('i', 1280) # 打包 print(res, type(res), len(res)) """ b'\x00\x05\x00\x00' <class 'bytes'> 4 """ res1 = struct.pack('i', 1380) print(res1, type(res1), len(res1)) """ b'd\x05\x00\x00' <class 'bytes'> 4 """ obj = struct.unpack('i', res) # 解包 print(obj) # obj是元组，第一个值就是打包的值 print(obj[0]) """ (1280,) 1280 """
# res_i = struct.pack('i', 123000000000) # print(res_i, len(res_i)) """ struct.error: 'i' format requires -2147483648 <= number <= 2147483647 """ res_l = struct.pack('l', 123000000000) # l模式下，数字8个bytes，范围更大。 print(res_l, len(res_l)) """ b'\x00\x0e_\xa3\x1c\x00\x00\x00' 8 """
header_dic = { 'filename': 'a.txt', 'md5': 'xxdxxx', 'total_size': 7678685767586786686876868687565756576655657565675657657657656757657565756757557575 } header_json = json.dumps(header_dic) # print(type(header_json)) # <class 'str'> header_bytes = header_json.encode('utf-8') #print(type(header_bytes)) # <class 'bytes'> struct.pack('i', len(header_bytes)) # 把报头的长度打成固定长度
使用struct基本格式：
import json,struct #假设通过客户端上传1T:1073741824000的文件a.txt #为避免粘包,必须自定制报头 header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值 #为了该报头能传送,需要序列化并且转为bytes head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输 #为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节 head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度 #客户端开始发送 conn.send(head_len_bytes) #先发报头的长度,4个bytes conn.send(head_bytes) #再发报头的字节格式 conn.sendall(文件内容) #然后发真实内容的字节格式 #服务端开始接收 head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式 x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度 head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式 header=json.loads(json.dumps(header)) #提取报头 #最后根据报头的内容提取真实的数据,比如 real_data_len=s.recv(header['file_size']) s.recv(real_data_len)
现在运用struct模块，可以将ssh程序进一步优化：
# -*- coding:utf-8 -*- __author__ = 'Qiushi Huang' import time import socket import subprocess import struct server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind(("127.0.0.1", 9001)) # bind()内为元组，0-65535：0-1024供操作系统使用 server.listen(5) print('starting...') while True: conn, client_addr = server.accept() print(client_addr) while True: # 通讯循环 try: """1、收到客户端的命令""" cmd = conn.recv(8096) if not cmd:break """2、执行命令，拿到结果""" obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout = obj.stdout.read() stderr = obj.stderr.read() """3、命令结果返回客户端""" # 第一步：制作固定长度的报头 total_size = len(stdout) + len(stderr) # 整型 header = struct.pack('i', total_size) # 隐患：struct的i 的取值区间是-2147483648~2147483648 # 第二步：将报头发给客户端 conn.send(header) # conn.send(str(total_size).encode('utf-8')) # 整型转换为字符串，编码后发出 # 第三步：发送真实数据 # conn.send(stdout+stderr) # 由于粘包原理可优化改写如下 conn.send(stdout) conn.send(stderr) except ConnectionResetError: break conn.close() server.close()
# -*- coding:utf-8 -*- __author__ = 'Qiushi Huang' import time import socket import struct client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(("127.0.0.1", 9001)) while True: """1、发命令""" cmd = input('>>: ').strip() if not cmd:continue client.send(cmd.encode('utf-8')) """2、拿结果""" # 第一步：拿到数据的长度——>即先收报头 header = client.recv(4) # 第二步：从报头中解析出对真实数据的描述信息（数据长度） total_size = struct.unpack('i', header)[0] # 解包之后为元组，取第一项即打包的内容 # 第三步：接收真实的数据 recv_size = 0 recv_data = b'' while recv_size < total_size: res = client.recv(1024) # 最大不能超过操作系统缓存大小，一次收不完，多次收 recv_data += res recv_size += len(res) # 最后一次收的时候将不是1024,未来如果要查看进度的时候有问题 print(recv_data.decode('utf-8')) client.close()
十四、通过socket来实现文件传输
普通版本：
# -*- coding:utf-8 -*- __author__ = 'Qiushi Huang' import time import socket import subprocess import struct import os import json share_dir = "/Users/hqs/PycharmProjects/startMyPython3.0/第六章-网络编程/8_文件传输/server/share" server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind(("127.0.0.1", 9001)) # bind()内为元组，0-65535：0-1024供操作系统使用 server.listen(5) print('starting...') while True: conn, client_addr = server.accept() print(client_addr) while True: # 通讯循环 try: """1、收到客户端的命令""" res = conn.recv(8096) # b'get a.txt' if not res:break """2、解析命令，提取相应命令参数""" cmds = res.decode('utf-8').split() # ['get', 'a.txt'] filename = cmds[1] """3、以读的方式打开文件，读取文件内容发送给客户端""" # with open(filename, 'rb') as f: 直接读文件传输会有粘包问题 # 第一步：制作固定长度的报头 header_dic = { 'filename': filename, # '' 'md5': 'xxdxxx', 'file_size': os.path.getsize(r'%s/%s' % (share_dir, filename)) # 文件大小 } header_json = json.dumps(header_dic) header_bytes = header_json.encode('utf-8') # 第二步：发送报头的长度 conn.send(struct.pack('i', len(header_bytes))) # 第三步：再发报头 conn.send(header_bytes) # 第四步：发送真实数据 with open('%s/%s'% (share_dir, filename), 'rb') as f: # conn.send(f.read()) # 一下全读取，文件有几个T时会有问题 for line in f: conn.send(line) # 一行行发都会粘在一起，且节省内存 except ConnectionResetError: break conn.close() server.close()
# -*- coding:utf-8 -*- __author__ = 'Qiushi Huang' import time import socket import struct import json download_dir = '/Users/hqs/PycharmProjects/startMyPython3.0/第六章-网络编程/8_文件传输/client/download' client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(("127.0.0.1", 9001)) while True: """1、发命令""" cmd = input('>>: ').strip() # get a.txt软件自定义命名标准 if not cmd:continue client.send(cmd.encode('utf-8')) """2、以写的方式打开新文件，接收服务端发来的文件内容写入新文件中""" # 第一步：先收报头长度 header = client.recv(4) header_size = struct.unpack('i', header)[0] # 第二步：收取报头 header_bytes = client.recv(header_size) # 第三步：从报头中解析出对真实数据的描述信息（数据长度） header_json = header_bytes.decode('utf-8') header_dic = json.loads(header_json) print(header_dic) total_size = header_dic['file_size'] filename = header_dic['filename'] # 第四步：接收真实的数据 with open('%s/%s' % (download_dir, filename), 'wb') as f: # 在同一台机器上，相同的路径会导致文件清空,需要指定目录 recv_size = 0 # recv_data = b'' 拼接字符串不需要了 while recv_size < total_size: line = client.recv(1024) # 最大不能超过操作系统缓存大小，一次收不完，多次收 f.write(line) # 一边收一边写 recv_size += len(line) # 最后一次收的时候将不是1024,未来如果要查看进度的时候有问题 print('总大小: %s 已下载：%s' % (total_size, recv_size)) client.close()
函数版本：
# -*- coding:utf-8 -*- __author__ = 'Qiushi Huang' import time import socket import subprocess import struct import os import json share_dir = "/Users/hqs/PycharmProjects/startMyPython3.0/第六章-网络编程/9_文件传输函数优化版本/server/share" def get(conn, cmds): filename = cmds[1] """3、以读的方式打开文件，读取文件内容发送给客户端""" # with open(filename, 'rb') as f: 直接读文件传输会有粘包问题 # 第一步：制作固定长度的报头 header_dic = { 'filename': filename, # '' 'md5': 'xxdxxx', 'file_size': os.path.getsize(r'%s/%s' % (share_dir, filename)) # 文件大小 } header_json = json.dumps(header_dic) header_bytes = header_json.encode('utf-8') # 第二步：发送报头的长度 conn.send(struct.pack('i', len(header_bytes))) # 第三步：再发报头 conn.send(header_bytes) # 第四步：发送真实数据 with open('%s/%s' % (share_dir, filename), 'rb') as f: # conn.send(f.read()) # 一下全读取，文件有几个T时会有问题 for line in f: conn.send(line) # 一行行发都会粘在一起，且节省内存 def put(conn, cmds):... def run(): server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind(("127.0.0.1", 9001)) # bind()内为元组，0-65535：0-1024供操作系统使用 server.listen(5) print('starting...') while True: conn, client_addr = server.accept() print(client_addr) while True: # 通讯循环 try: """1、收到客户端的命令""" res = conn.recv(8096) # b'get a.txt' if not res:break """2、解析命令，提取相应命令参数""" cmds = res.decode('utf-8').split() # ['get', 'a.txt'] if cmds[0] == 'get': get(conn, cmds) elif cmds[0] == 'put': put(conn, cmds) except ConnectionResetError: break conn.close() server.close() if __name__ == '__main__': run()
# -*- coding:utf-8 -*- __author__ = 'Qiushi Huang' import time import socket import struct import json download_dir = '/Users/hqs/PycharmProjects/startMyPython3.0/第六章-网络编程/9_文件传输函数优化版本/client/download' def get(client, cmds): """2、以写的方式打开新文件，接收服务端发来的文件内容写入新文件中""" # 第一步：先收报头长度 header = client.recv(4) header_size = struct.unpack('i', header)[0] # 第二步：收取报头 header_bytes = client.recv(header_size) # 第三步：从报头中解析出对真实数据的描述信息（数据长度） header_json = header_bytes.decode('utf-8') header_dic = json.loads(header_json) print(header_dic) total_size = header_dic['file_size'] filename = header_dic['filename'] # 第四步：接收真实的数据 with open('%s/%s' % (download_dir, filename), 'wb') as f: # 在同一台机器上，相同的路径会导致文件清空,需要指定目录 recv_size = 0 # recv_data = b'' 拼接字符串不需要了 while recv_size < total_size: line = client.recv(1024) # 最大不能超过操作系统缓存大小，一次收不完，多次收 f.write(line) # 一边收一边写 recv_size += len(line) # 最后一次收的时候将不是1024,未来如果要查看进度的时候有问题 print('总大小: %s 已下载：%s' % (total_size, recv_size)) def put(client, cmds):... def run(): client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(("127.0.0.1", 9001)) while True: """1、发命令""" inp = input('>>: ').strip() # get a.txt软件自定义命名标准 if not inp:continue client.send(inp.encode('utf-8')) cmds = inp.split() # ['get', 'a.txt'] if cmds[0] == 'get': get(client, cmds) elif cmds[0] == 'put': put(client, cmds) client.close() if __name__ == '__main__': run()
面向对象版本：
import socket import struct import json import subprocess import os class MYTCPServer: address_family = socket.AF_INET socket_type = socket.SOCK_STREAM allow_reuse_address = False max_packet_size = 8192 coding='utf-8' request_queue_size = 5 server_dir='file_upload' def __init__(self, server_address, bind_and_activate=True): """Constructor. May be extended, do not override.""" self.server_address=server_address self.socket = socket.socket(self.address_family, self.socket_type) if bind_and_activate: try: self.server_bind() self.server_activate() except: self.server_close() raise def server_bind(self): """Called by constructor to bind the socket. """ if self.allow_reuse_address: self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind(self.server_address) self.server_address = self.socket.getsockname() def server_activate(self): """Called by constructor to activate the server. """ self.socket.listen(self.request_queue_size) def server_close(self): """Called to clean-up the server. """ self.socket.close() def get_request(self): """Get the request and client address from the socket. """ return self.socket.accept() def close_request(self, request): """Called to clean up an individual request.""" request.close() def run(self): while True: self.conn,self.client_addr=self.get_request() print('from client ',self.client_addr) while True: try: head_struct = self.conn.recv(4) if not head_struct:break head_len = struct.unpack('i', head_struct)[0] head_json = self.conn.recv(head_len).decode(self.coding) head_dic = json.loads(head_json) print(head_dic) #head_dic={'cmd':'put','filename':'a.txt','filesize':123123} cmd=head_dic['cmd'] if hasattr(self,cmd): func=getattr(self,cmd) func(head_dic) except Exception: break def put(self,args): file_path=os.path.normpath(os.path.join( self.server_dir, args['filename'] )) filesize=args['filesize'] recv_size=0 print('----->',file_path) with open(file_path,'wb') as f: while recv_size < filesize: recv_data=self.conn.recv(self.max_packet_size) f.write(recv_data) recv_size+=len(recv_data) print('recvsize:%s filesize:%s' %(recv_size,filesize)) tcpserver1=MYTCPServer(('127.0.0.1',8080)) tcpserver1.run()
import socket import struct import json import os class MYTCPClient: address_family = socket.AF_INET socket_type = socket.SOCK_STREAM allow_reuse_address = False max_packet_size = 8192 coding='utf-8' request_queue_size = 5 def __init__(self, server_address, connect=True): self.server_address=server_address self.socket = socket.socket(self.address_family, self.socket_type) if connect: try: self.client_connect() except: self.client_close() raise def client_connect(self): self.socket.connect(self.server_address) def client_close(self): self.socket.close() def run(self): while True: inp=input(">>: ").strip() if not inp:continue l=inp.split() cmd=l[0] if hasattr(self,cmd): func=getattr(self,cmd) func(l) def put(self,args): cmd=args[0] filename=args[1] if not os.path.isfile(filename): print('file:%s is not exists' %filename) return else: filesize=os.path.getsize(filename) head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize} print(head_dic) head_json=json.dumps(head_dic) head_json_bytes=bytes(head_json,encoding=self.coding) head_struct=struct.pack('i',len(head_json_bytes)) self.socket.send(head_struct) self.socket.send(head_json_bytes) send_size=0 with open(filename,'rb') as f: for line in f: self.socket.send(line) send_size+=len(line) print(send_size) else: print('upload successful') client=MYTCPClient(('127.0.0.1',8080)) client.run()
