五 Python之socket网络编程

<1>socket概念

socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。ocket本质上就是在2台网络互通的电脑之间，架设一个通道，两台电脑通过这个通道来实现数据的互相传递。

 

建立一个socket必须至少有2端， 一个服务端，一个客户端， 服务端被动等待并接收请求，客户端主动发起请求， 连接建立之后，双方可以互发数据。

 

注：服务端与客户端之间数据的传输均为字符串，注意编码 解码

 <2>简单客服端与客户端通信

client端：

#_*_coding:utf-8_*_
#__author__:"shikai"import socket
client=socket.socket()                     #声明socket类型，并生成socket连接对象
client.connect(("localhost",1234))      #连接服务器IP和端口
while True:cmd=input("输入指令：").strip()client.send(cmd.encode())            #发送消息data=client.recv(1024)                #接收数据print("recv:",data)client.close()

server端：

#!_*_coding:utf-8_*_
#__author__:"shikai"import socket
server=socket.socket()                #声明socket类型，并生成socket连接对象
server.bind(("localhost",1234))     #绑定IP和端口
server.listen()                       #监听
while True:print("开始等电话了")conn,addr=server.accept()          # 阻塞状态  等待连接 (accept回返回两个数据conn和addr)#coon就是客服端连接之后，服务器为其生成的一个连接实例print(conn,addr)while True:print("接电话了")data=conn.recv(1024)             #接收数据print("recv:",data)conn.send(data.upper())         #处理并发送返回  （把小写变成大写）server.close()

sk.bind(address)

　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog)

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

      backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
      这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool)

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept()

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　关闭套接字

sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag])

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

      内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout)

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()

　　套接字的文件描述符

<3>实现多数据批量传输

 按照设定的值每次传输数据最多1024大小，如果要传输的数据大于1024则分批依次传输完成，为防止粘包问题在两次传输之间添加一次确认消息确认即可

 

client端：

#_*_coding:utf-8_*_
#__author__:"shikai"import socket,osclient=socket.socket()
client.connect(("localhost",6969))
while True:cmd=input("输入指令：").strip()if len(cmd)==0:continue                     #入如果长度为0则继续输入client.send(cmd.encode("utf-8"))             #发送的数据      --->1cmd_res_size=client.recv(1024)                #接受的数据长度 (要解码)print("要接收数据大小：",cmd_res_size)client.send("准备接收数据请发送：".encode("utf-8"))received_size=0received_data=b""while received_size < int(cmd_res_size):       #如果接受的长度小于文件本身长度就持续接受data=client.recv(1024)             #接受数据received_size+=len(data)received_data+=dataelse:print("接收最终大小：",received_size)print(received_data.decode())
client.close()

server端：

#_*_coding:utf-8_*_
#__author__:"shikai"#ssh_服务器端
import socket,os
server=socket.socket()
server.bind(("localhost",6969))
server.listen()while True:coon,addr=server.accept()while True:data=coon.recv(1024)         #接收来的数据     ---->1接受命令if not data:       #客户端没有数据发送就断开print("客户端已断开")breakcmd_res=os.popen(data.decode()).read()    #解码发送来的命令，执行结果也是字符串print("传输数据大小:",len(cmd_res.encode()))    #长度编码if len(cmd_res)==0:          #如果client没有输入命令cmd_res="cmd has no output"coon.send(str(len(cmd_res.encode())).encode("utf-8"))        #发送数据大小给客户端(编码成机器语言)client_ack=coon.recv(1024)                        #解决两次发送之间存在的粘包问题print("准备发送数据：",client_ack.decode())coon.send(cmd_res.encode("utf-8"))           #发送的数据(编码成机器识别的utf-8格式)print("send over...")server.close()

　　

 <4>socket与文件传输、添加hashlib认证

hashlib产生md5值，认证传输的文件是否唯一，先产生文件md5值作为检查标准，然后依次发送文件md5，最后做对比验证。客户端 实现从服务器现在下载文件，先接收服务器端发送文件md5值,然后依次接收文件md5值在验证文件下载是否正确。

 

#!_*_coding:utf-8_*_
#__author__:"shikai"
#ftp 客户端 （实现从服务器现在下载文件）
import socket,hashlib
client=socket.socket()
client.connect(("localhost",6969))
while True:cmd=input("输入指令：").strip()if len(cmd)==0:continue                    #入如果长度为0则继续输入if cmd.startswith("get"):               #输入get文件名(检查是否以指定字符串开头)
        client.send(cmd.encode())file_size=client.recv(1024)            #接收文件大小file_total_size=int(file_size.decode())client.send(b"ready to recv file")received_size=0filename=cmd.split()[1]             #文件名就是发来数据的第二个f=open(filename+".nwe","wb")  #以二进制写入m=hashlib.md5()while received_size<file_total_size:if file_total_size-received_size>1024:  #要接收的不止一次size=1024else:size=file_total_size-received_sizeprint("the last recv:",size)data=client.recv(size)            #接收文件received_size+=len(data)m.update(data)                    #分次调用接收md5值
            f.write(data)else:md5_nwe=m.hexdigest()server_md5=client.recv(1024)             #接收服务器发送的md5值print("传输完成",file_size,file_total_size)print("两次md5：",md5_nwe,server_md5)f.close()client.close()

#_*_coding:utf-8_*_
#__author__:"shikai"
#ftp_服务器端   (实现发送文件功能)
import socket,os,hashlib
server=socket.socket()
server.bind(("localhost",6969))
server.listen()while True:coon,addr=server.accept()while True:print("等待新指令：")data=coon.recv(1024)         #接收来的命令要求if not data:       #客户端没有数据发送就断开print("客户端已断开")breakcmd,filename=data.decode().split()  #获取文件名if os.path.isfile(filename):     #判断文件是否存在m = hashlib.md5()f=open(filename,"rb")filesize=os.stat(filename).st_size      #获取文件大小coon.send(str(filesize).encode())        #发送文件大小coon.recv(1024)               #等待客户端确认for line in f:m.update(line)            #分次调用接收md5值
                coon.send(line)#print("file md5:",m.hexdigest())
            f.close()coon.send(m.hexdigest().encode())       #发送md5值确认print("send done.......")server.close()

 

 <5>socketserver多并发

SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。

 

ThreadingTCPServer方法实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互。

#_*_coding:utf-8_*_
#__author__:"shikai"import socket
client=socket.socket()                   #声明socket类型，并生成socket连接对象
client.connect(("localhost",6969))      #连接服务器IP和端口
while True:cmd=input("输入指令：").strip()client.send(cmd.encode())            #发送消息
data=client.recv(1024)                #接收数据print("recv:",data)client.close()

#!_*_coding:utf-8_*_
#__author__:"shikai"import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):def handle(self):while True:try:self.data=self.request.recv(1024).strip()         #接收数据print("{} wrote:".format(self.client_address[0]))print(self.data)self.request.send(self.data.upper())           #将数据转化为大写发送except ConnectionResetError as e:      #抓取连接异常print("err:",e)break
if __name__=="__main__":          #手动执行程序HOST,PORT="localhost",6969#为每个client端创建一个进程或线程server=socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler)    #ThreadingTCPServer 多并发擦操作server.serve_forever()

 

 <6>paramiko模块

paramiko是用python语言写的一个模块，遵循SSH2协议，支持以加密和认证的方式，该模块基于SSH用于连接远程服务器并执行相关操作

1：获得密钥对命令行输入：ssh-keygen

 

安装

pip install paramiko

　　

SSHClient  连接远程服务器并执行基本命令

 

基于用户名密码连接：

#_*_coding:utf-8_*_
#__author__:"shikai"import paramiko
ssh=paramiko.SSHClient()      #实例化ssh 客户端
#允许连接不再host 文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())#连接服务器
ssh.connect(hostname="localhost",port=22,username="shikai",password="123")
#执行命令
stdin,stdout,stderr=ssh.exec_command("df")   #返回：标准输入 输出 错误命令三种结果
#获取命令结果
res=stdout.read()
ssh.close()

 

基于公钥密钥连接：

#无需密码远程连接主机（把公钥给主机，自己保存私钥）

#_*_coding:utf-8_*_
#__author__:"shikai"
#无需密码远程连接主机（把公钥给主机，自己保存私钥）
import paramiko
private_key=paramiko.RSAKey.from_private_key_file("id_rsa")    #私钥储存目录ssh=paramiko.SSHClient()
#允许连接不再know_host文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy)
#连接主机
ssh.connect(hostname="localhost",port=22,username="shikai",pkey=private_key)
#执行命令
stdin,stdout,sterr=ssh.exec_command("df")          #返回：标准输入 输出 错误命令三种结果
#获取结果
res=stdout.read()
#关闭连接
ssh.close()

　　

 

SFTPClient

用于连接远程服务器并执行上传下载

基于用户名密码上传下载：

import paramikotransport = paramiko.Transport(('hostname',22))
transport.connect(username='shikai',password='123')sftp = paramiko.SFTPClient.from_transport(transport)# 将location.py 上传至服务器 /tmp/test.py
sftp.put('/tmp/location.py', '/tmp/test.py')# 将remove_path 下载到本地 local_path
sftp.get('remove_path', 'local_path')transport.close()

基于公钥密钥上传下载：

 

import paramikoprivate_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')  #私钥文件路径transport = paramiko.Transport(('hostname', 22))
transport.connect(username='shikai', pkey=private_key )sftp = paramiko.SFTPClient.from_transport(transport)# 将location.py 上传至服务器 /tmp/test.py
sftp.put('/tmp/location.py', '/tmp/test.py')# 将remove_path 下载到本地 local_path
sftp.get('remove_path', 'local_path')transport.close()