socket

socket入门示例

##server端：

import socket　　　　　　　　　　　　　　　　#导入模块
server = socket.socket()
server.bind(('localhost',6969))　　　　　　#绑定地址和端口
server.listen()

conn,addr = server.accept()         #等待接受数据,conn为客户端连过来时在服务器端为其生成的实例
print (conn,addr)
data = conn.recv(1024)        #接收数据
print("rece:",data)　　　　　　　#打印接收的数据

conn.send(data.upper())　　　　　#将接收的数据大写后发送给客户端

server.close()　　　　　　　　　　#关闭链接


###client端

import  socket
client = socket.socket() 　　　　　　　　#声明socket类型，同时生成socket连接对象，默认地址簇为ipv4
client.connect(("localhost",6969))
client.send(b"this is my first socket test")      #发送数据,python3.x只能发bytes类型，如果为中文的话，需要转换为bytes类型，"中文".encode("utf-8")

data = client.recv(1024)    　　　　#设置接收1024字节数据，默认也是1024
print ("receive:",data)　　　　　　　　#打印接收的数据

client.close()


打印结果：

##server端：
<socket.socket fd=352, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 6969), raddr=('127.0.0.1', 28301)> ('127.0.0.1', 28301)
rece: b'this is my first socket test'

##client端：
receive: b'THIS IS MY FIRST SOCKET TEST'

socket 入门进阶示例

#说明：实现一个server对一个client会话保持，此时如果有多个client链接回陷入等待状态，等第一个client断开后，第二个client与server继续进行会话

#server端

#-*-coding:utf-8-*-
import socket
server = socket.socket()
server.bind(('localhost',6969))
server.listen()

while True:　　　　　　　　　　　　　　　　　　#使程序不停的接收数据
    conn,addr = server.accept()         #等待接受数据,conn为客户端连过来时在服务器端为其生成的实例
    print (" receive data")
    while True:
        data = conn.recv(1024)        #接收数据
        print("rece:",data)
        if not data:
            print ("client lost")
            break
        conn.send(data.upper())
server.close()


#client端

import socket

client = socket.socket() 　　　　　　　　　　　　#声明socket类型，同时生成socket连接对象，默认地址簇为ipv4
client.connect(("localhost",6969))

while True:
　　msg = input(">>:").strip()
　　if len(msg) == 0:　　　　　　　　　　　　　　　　#不能send空数据
　　　　continue
　　client.send(msg.encode("utf-8")) 　　　　　　　　#发送数据,这里只能发bytes类型
　　data = client.recv(1024) 　　　　　　　　　　　　#默认只收1024字节数据
　　print ("receive:",data)

client.close()

socket入门示例之ssh执行命令

#server端

#-*-coding:utf-8-*-
import socket,os,time

server = socket.socket()
server.bind(('0.0.0.0',6979))
server.listen()

while True:　　　　　　　　　　　　　　　　　　#使server持续保持连接，即使有一个客户端断开了，其余的客户端也能链接
    conn,addr = server.accept()          #等待接受数据,conn为客户端连过来时在服务器端为其生成的实例
    print (" waiting data")
    while True:　　　　　　　　　　　　　　　　#不断接受客户端发来的命令
        print(" reveive data")
        data = conn.recv(1024)       　　　　#接收客户端发来的命令
        print("rece:",data)
        if not data:
            print ("client lost")
            break
        res = os.popen(data.decode()).read()     #执行命令，结果为字符串
        if len(res) == 0:
            print (data.decode(),"get no any data get")
        conn.send(str(len(res.encode())).encode("utf-8"))          #这里先将res（字符串）转化为bytes类型，然后获取bytes类型的长度，在通过str命令，encode为bytes类型发送个客户端
        
        #这里直接获取str的长度（与bytes类型的长度不一样，导致客户端一次性不能完全接收所有数据，然后报错，所以不使用，仅作记录），转化为str然后encode为bytes发送给客户端
        #conn.send(str(len(res)).encode("utf-8"))　　　　
　　　　　
        #粘包问题：程序将多个要分开发送的数据合并成一条数据发送，致使客户端处理时发生错误
        #time.sleep(0.5)　　　　　　　　　　　　#可解决粘包的问题，但是不实际
        client_ack = conn.recv(1024)　　　　  #彻底解决粘包的问题，客户端接受到数据后，返回一个确认信息，这里收到client的应答后继续执行下面的发送命令
        conn.send(res.encode("utf-8"))
        print ("数据发送完成 ")

server.close()


#client端

import  socket

client = socket.socket() 
client.connect(("192.168.132.130",6979))

while True:
    msg = input(">>:").strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode("utf-8"))      　　　　　　　　　　#发送命令,这里只能发bytes类型
    cmd_res_size = client.recv(1024)                    　　#默认只收1024字节数据,返回执行命令的结果的长度
    print ("命令结果大小 :",cmd_res_size)
    client.send("准备接收".encode())　　　　　　　　　　　　#客户端发送一个确认收到的应答，解决粘包的问题

    receive_size = 0
    received_data = b''
    while receive_size < int(cmd_res_size.decode()):　　　　　　#这里使用循环判断接收的数据长度是否等于执行命令结果的总长度，用于一次性接收所有数据
        data = client.recv(1024)
        receive_size += len(data)
        received_data += data

    else:　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#这里while 和else配合使用
        print("data receive done",receive_size)
        print (received_data.decode())

client.close()

socket文件传输

#红色代码为md5相关操作

#server端

#-*-coding:utf-8-*-
import socket,os,time
server = socket.socket()
server.bind(('0.0.0.0',6970))
server.listen()

import os
import hashlib

while True:

    conn,addr = server.accept()         #等待接受数据,conn为客户端连过来时在服务器端为其生成的实例
    print (" waiting data")
    while True:
        print(" reveive data")
        data = conn.recv(1024)       #接收数据
        print("rece:",data)
        if not data:
            print ("client lost")
            break

        cmd,filename = data.decode().split()         #对接收的数据进行处理，得到filename（数据格式 get xxx）
        print (filename)　　　　　　　　　　　　　　　　　　　　　　　　　　　　
        #判断是否为文件
        if os.path.isfile(filename):
            f = open(filename,"rb")　　　　　　　　　　　　　　#以bytes打开文件
            m = hashlib.md5()　　　　　　　　　　　　　　　　　　#初始化md5实例
            file_size = os.stat(filename).st_size　　　　　　#得到想要获取的文件大小
            conn.send(str(file_size).encode("utf-8"))　　　　#将得到的文件大小发送给 客户端
            conn.recv(1024)　　　　　　　　　　　　　　　　　　　　#获取客户端收到响应后的应答

　　　　　　　#获取文件的md5操作
            for line in f:　　　　　　　　　　　　　　　　　　　　#每读一行就获取一下md5
                m.update(line)
                conn.send(line)
            print ("file md5:",m.hexdigest())　　　　　　　　#打印最终的文件的md5，并发送给客户端
            f.close()
            conn.send(m.hexdigest().encode())
server.close()


##client端

#-*-coding:utf-8-*-
import  socket
import hashlib

client = socket.socket() #声明socket类型，同时生成socket连接对象，默认地址簇为ipv4
client.connect(("192.168.132.130",6970))

while True:
    msg = input(">>:").strip()
    if len(msg) == 0:
        continue

    if msg.startswith("get"):　　　　　　　　　　　　　　　　　　　　#判断命令是否以get开头
        client.send(msg.encode())
        server_response = client.recv(1024)　　　　　　　　　　　　#将命令发送给服务端后获取到的文件大小
        print ("文件大小:",server_response)
        client.send(b"ready to recv file")　　　　　　　　　　　　#告诉服务端响应收到，准备接收数据（解决文件接收的粘包问题）

        file_total_size = int(server_response.decode())　　　　　#对接收到的文件大小数据类型进行处理
        recived_size = 0
        filename = msg.split()[1]　　　　　　　　　　　　　　　　　#获取命令的 文件名称
        f = open(filename + '.new',"wb")　　　　　　　　　　　　　　#对接收过来的文件重新命名
        m = hashlib.md5()　　　　　　　　　　　　　　　　　　　　　　　#md5比对的相关代码
        while recived_size < file_total_size:
            if file_total_size - recived_size > 1024:　　　　　　#解决文件传输和md5 传输时遇到的粘包问题，如果咩有md5比对，可以省去此处代码
                size = 1024
            else:
                size = file_total_size - recived_size
                print ("last receive:",size)　　　　　　　　　　　
            data = client.recv(1024)
            recived_size += len(data)
            f.write(data)
            m.update(data)
            # print (file_total_size,recived_size)
        else:
            print ("recv done"，received_size,file_total_size)

            f.close()
            new_file_md5 = m.hexdigest()
        server_file_md5 = client.recv(1024)
        print (server_file_md5,new_file_md5)


client.close()

效果如图：