<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,os
client=socket.socket()
client.connect(("localhost",6969))
while True:
cmd=input("输入指令：").strip()
if len(cmd)==0:continue #入如果长度为0则继续输入
client.send(cmd.encode("utf-8")) #发送的数据 --->1
cmd_res_size=client.recv(1024) #接受的数据长度 (要解码)
print("要接收数据大小：",cmd_res_size)
client.send("准备接收数据请发送：".encode("utf-8"))
received_size=0
received_data=b""
while received_size < int(cmd_res_size): #如果接受的长度小于文件本身长度就持续接受
data=client.recv(1024) #接受数据
received_size+=len(data)
received_data+=data
else:
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("客户端已断开")
break
cmd_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=0 filename=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=1024 else: size=file_total_size-received_size print("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("客户端已断开") break cmd,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 paramiko
transport = 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 paramiko
private_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()
101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
