网络编程之乱七八糟的笔记

最新推荐文章于 2024-07-12 16:16:27 发布
最新推荐文章于 2024-07-12 16:16:27 发布
阅读量134 收藏
点赞数
分类专栏： 笔记 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46408939/article/details/108054517
版权

一、计算机基础

网络:

互联网协议

osi

  1. 七层: 应用层, 表, 会, 传输层, 网络层, 数据链层, 物理层
  2. 五层: 应用层(应用层, 表, 会), 传输层, 网络层, 数据链层, 物理层

五层协议详解:

  1. 物理层:

  2. 数据链路层: 以太网协议

    2.1 ethernet规定: 一组电信号构成一个数据包，叫做‘帧’
    每一数据帧分成：报头head和数据data两部分
    head data
    head包含：(固定18个字节)

    发送者／源地址，6个字节
    接收者／目标地址，6个字节
    数据类型，6个字节
    data包含：(最短46字节，最长1500字节)

    数据包的具体内容
    head长度＋data长度＝最短64字节，最长1518字节，超过最大限制就分片发送

    2.2 mac地址:

    2.3 以太网工作方式: 基于mac地址的广播的方式来进行数据的传递(局域网内)

  3. 网络层:

    ip协议: (ipv4， ipv6)

    arp协议(了解): 把ip地址解析成Mac地址

  4. 传输层: tcp/udp(基于端口的协议)

  5. 应用层: (http协议/ftp协议)

tcp/udp协议详解:

  1. tcp协议: 可靠协议(建立链接: 三次握手 断开链接: 四次挥手)

    image_1c1phb5ao10jb183v1l3i1psgo6037.png-281.7kB

  2. udp协议: 不可靠, 传输效率高, 网络开销低

socket:

  1. AF_UNIX
  2. AF_INET

img

服务器端: server_test.py

# -*- encoding: utf-8 -*-
"""
@author: 
@license: 
@contact: 
@software: 
@file: server_test.py
@time: 2020.8.7 11:47
@desc:
"""

import socket


# 1. 买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # SOCK_STREAM ---> tcp
print(phone)

# 2. 绑定手机卡(端口: 0-65535 其中0-2014给操作系统用)
phone.bind(('127.0.0.1', 8080))

# 3.开机
phone.listen(5)

# 4. 等待链接
print('starting....')
conn, client_addr = phone.accept()
print(conn, client_addr)

# 5. 收发消息
data = conn.recv(1024)  # 单位是bytes 接收数据的最大数
print('客户端发到服务端的数据: ', data)

conn.send(data.upper())

# 6. 挂电话
conn.close()

# 7. 关机
phone.close()

客户端: client_test.py

# -*- encoding: utf-8 -*-
"""
@author: 
@license: 
@contact: 
@software: 
@file: client_test.py
@time: 2020.8.7 11:48
@desc:
"""

import socket


# 1. 买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # SOCK_STREAM ---> tcp
print(phone)

# 2. 拨号
phone.connect(('127.0.0.1', 8080))

# 3. 收发消息
phone.send('xxx'.encode('utf-8'))
data = phone.recv(1024)
print(data)

# 4. 关闭
phone.close()

在my_server.bind()之前加上如下代码, 重用端口

my_sever.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

加上链接循环

my_server.py

import socket


my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_server.bind(('127.0.0.1', 8081))
my_server.listen(5)
# 加上链接循环
while True:
    client_conn, colient_addr = my_server.accept()
    if not colient_addr:
        my_server.close()
        break
    while True:
        try:
            res = client_conn.recv(1024)
            if res.decode('utf-8') == 'exit' or not res:
                client_conn.close()
                break
            client_conn.send(res.upper())
            print(res.decode('utf-8'))
        except ConnectionResetError:
            break

消除不能接受空字符串的bug

my_client.py

import socket


my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_client.connect(('127.0.0.1', 8081))
while True:
    msg = input('>>> ').strip()
    if not msg:continue  # 消除不能接受空字符串的bug
    my_client.send(msg.encode('utf-8'))
    res = my_client.recv(1024)
    print(res.decode('utf-8'))
    if not res:
        break
my_client.close()

模拟ssh远程执行命令

系统命令:

win: dir: 查看某一个文件夹下的子文件名与子文件夹 ipconfig: 查看本地网卡的ip信息 tasklist: 查看运行的进程

linux: ls ifconfig ps aux

执行系统命令: os模块 —> 在终端打印

sunbprocess —> 拿到返回结果

my_server.py

"""TODO 模拟ssh远程执行命令"""
import socket
import subprocess


my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_server.bind(('127.0.0.1', 8081))
my_server.listen(3)
while True:
    client_conn, colient_addr = my_server.accept()
    print(colient_addr)
    # TODO
    if not colient_addr:
        my_server.close()
        break
    while True:
        try:
            # 1. 接收命令
            cmd = client_conn.recv(1024).decode('utf-8')
            if cmd == 'exit' or not cmd:
                break

            # 2. 执行命令, 拿到结果
            obj = subprocess.Popen(cmd,
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)

            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 3. 把明理路结果返回给客户端
            client_conn.send(stdout + stderr)  # 存在效率问题

        except ConnectionResetError:
            break
    client_conn.close()

my_client.py

"""TODO 模拟ssh远程执行命令"""
import socket


my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_client.connect(('127.0.0.1', 8081))
while True:
    # 1. 发命令
    cmd = input('>>> ').strip()
    if not cmd:
        continue
    my_client.send(cmd.encode('utf-8'))

    # 2. 拿到命令结果并打印
    res = my_client.recv(1024)  # 接收的数据可能超过1024个字节
    print(res.decode('gbk'))
    if not res:
        break
my_client.close()

粘包现象

关闭已运行的python程序:

​ linux: pkill -9 python

​ win: taskkill python

send和recv:

  1. send和recv都不会直接接收对方的数据, 而是操作自己的操作系统内存, 不是一个send对应一个recv

    1.1 recv: wait data(耗时非常长), copy data

    1.2 send: copy data

import struct
# 制作固定长度的报头
res = struct.pack('i', 123)
print(res, type(res), len(res))
"""b'{\x00\x00\x00' <class 'bytes'> 4"""

#
obj = struct.unpack('i', res)
print(obj, obj[0])
"""(123,) 123"""

解决粘包问题

my_server.py

"""TODO 模拟ssh远程执行命令"""
import struct
import socket
import json
import subprocess


my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_server.bind(('127.0.0.1', 8081))
my_server.listen(3)
while True:
    client_conn, colient_addr = my_server.accept()
    print(colient_addr)
    # TODO
    if not colient_addr:
        my_server.close()
        break
    while True:
        try:
            # 1. 接收命令
            cmd = client_conn.recv(1024).decode('utf-8')
            if cmd == 'exit' or not cmd:
                break

            # 2. 执行命令, 拿到结果
            obj = subprocess.Popen(cmd,
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)

            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 3. 把命令结果返回给客户端
            # 3.1 制作固定长度的报头
            # send_count = len(stdout) + len(stderr)
            # # header = struct.pack('i', send_count)  # send_count的长度有限制
            # header = struct.pack('l', send_count)  # send_count的长度有限制
            header_dic = {
                'filename': 'a.txt',
                'md5': 'xxxxx',
                'total_size': len(stdout) + len(stderr)
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('gbk')

            # 3.2 发送报头的长度
            client_conn.send(struct.pack('i', len(header_bytes)))

            # 3.3 把报头数据发送给客户端
            client_conn.send(header_bytes)

            # 3.4 发送真实数据
            count = 0
            client_conn.send(stdout)
            client_conn.send(stderr)

        except ConnectionResetError:
            break
    client_conn.close()

my_client.py

"""TODO 模拟ssh远程执行命令"""
import socket
import struct
import json

my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_client.connect(('127.0.0.1', 8081))
flag = True
while flag:
    # 1. 发命令
    cmd = input('>>> ').strip()
    if not cmd:
        continue
    my_client.send(cmd.encode('utf-8'))

    # 2. 拿到命令结果并打印
    # 2.1 先收报头的长度
    header_size = struct.unpack('i', my_client.recv(4))[0]

    # 2.2 接收报头数据
    header_bytes = my_client.recv(header_size)

    # 2.3 从报头中解析出对真实数据的描述信息(数据的长度)
    header_json = header_bytes.decode('gbk')
    header_dic = json.loads(header_json)
    recv_count = header_dic['total_size']

    # 2.4 就收真实数据
    count = 0
    recv_data = b''
    while count < recv_count:
        res = my_client.recv(1024)  # 接收的数据可能超过1024个字节
        count += len(res)
        recv_data += res
    print(recv_data.decode('gbk'))
my_client.close()

my_server.py

"""TODO 文件上传下载功能"""
import struct
import socket
import json
import os

SERVER_PATH = r'E:\lufei\model_3\model_3_1\log\服务器端'


my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_server.bind(('127.0.0.1', 8081))
my_server.listen(3)
while True:
    client_conn, colient_addr = my_server.accept()
    print(colient_addr)
    # TODO
    if not colient_addr:
        my_server.close()
        break
    while True:
        try:
            # 1. 接收命令
            res = client_conn.recv(1024).decode('utf-8').split()
            if res == 'exit' or not res:
                break

            # 2. 解析命令, 提取相应参数
            file_name = res[1]

            # 3. 以读的方式打开文件, 读取文件内容发送给客户端
            # 3.1 制作固定长度的报头
            header_dic = {
                'filename': file_name,
                'md5': 'xxxxx',
                'file_size': os.path.getsize('%s\%s' % (SERVER_PATH, file_name))
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('gbk')

            # 3.2 发送报头的长度
            client_conn.send(struct.pack('i', len(header_bytes)))

            # 3.3 把报头数据发送给客户端
            client_conn.send(header_bytes)

            # 3.4 发送真实数据
            with open('%s\%s' % (SERVER_PATH, file_name), 'rb') as f:
                for line in f:
                    client_conn.send(line)

        except ConnectionResetError:
            break
    client_conn.close()

my_client.py

"""TODO 文件下载上传功能"""
import socket
import struct
import json

CLIENT_PATH = r'E:\lufei\model_3\model_3_1\log\客户端'


my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_client.connect(('127.0.0.1', 8081))
flag = True
while flag:
    # 1. 发命令
    cmd = input('>>> ').strip()
    if not cmd:
        continue
    my_client.send(cmd.encode('utf-8'))

    # 2. 以写的方式打开一个新文件, 将从服务端接收的文件内容写入客户端的新文件中
    # 2.1 先收报头的长度
    header_size = struct.unpack('i', my_client.recv(4))[0]

    # 2.2 接收报头数据
    header_bytes = my_client.recv(header_size)

    # 2.3 从报头中解析出对真实数据的描述信息(数据的长度)
    header_json = header_bytes.decode('gbk')
    header_dic = json.loads(header_json)
    recv_count = header_dic['file_size']
    file_name = header_dic['filename']

    # 2.4 接收真实数据
    with open('%s\%s' % (CLIENT_PATH, file_name), 'wb') as f:
        count = 0
        while count < recv_count:
            line = my_client.recv(1024)  # 接收的数据可能超过1024个字节
            count += len(line)
            f.write(line)
my_client.close()

函数版本

my_server.py

"""TODO 文件上传下载功能"""
import struct
import socket
import json
import os

SERVER_PATH = r'E:\lufei\model_3\model_3_1\log\服务器端'


def get(client_conn, res):
    file_name = res[1]
    # 3. 以读的方式打开文件, 读取文件内容发送给客户端
    # 3.1 制作固定长度的报头
    header_dic = {
        'filename': file_name,
        'md5': 'xxxxx',
        'file_size': os.path.getsize('%s\%s' % (SERVER_PATH, file_name))
    }
    header_json = json.dumps(header_dic)
    header_bytes = header_json.encode('gbk')

    # 3.2 发送报头的长度
    client_conn.send(struct.pack('i', len(header_bytes)))

    # 3.3 把报头数据发送给客户端
    client_conn.send(header_bytes)

    # 3.4 发送真实数据
    with open('%s\%s' % (SERVER_PATH, file_name), 'rb') as f:
        for line in f:
            client_conn.send(line)


def run():
    my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    my_server.bind(('127.0.0.1', 8081))
    my_server.listen(3)
    while True:
        client_conn, colient_addr = my_server.accept()
        print(colient_addr)
        # TODO
        if not colient_addr:
            my_server.close()
            break
        while True:
            try:
                # 1. 接收命令
                res = client_conn.recv(1024).decode('utf-8').split()
                if res == 'exit' or not res:
                    break

                # 2. 解析命令, 提取相应参数
                if res[0] == 'get':
                    get(client_conn, res)

            except ConnectionResetError:
                break
        client_conn.close()


if __name__ == '__main__':
    run()

my_client.py

"""TODO 文件下载上传功能"""
import socket
import struct
import json

CLIENT_PATH = r'E:\lufei\model_3\model_3_1\log\客户端'


def get(my_client):
    # 2. 以写的方式打开一个新文件, 将从服务端接收的文件内容写入客户端的新文件中
    # 2.1 先收报头的长度
    header_size = struct.unpack('i', my_client.recv(4))[0]

    # 2.2 接收报头数据
    header_bytes = my_client.recv(header_size)

    # 2.3 从报头中解析出对真实数据的描述信息(数据的长度)
    header_json = header_bytes.decode('gbk')
    header_dic = json.loads(header_json)
    recv_count = header_dic['file_size']
    file_name = header_dic['filename']

    # 2.4 接收真实数据
    with open('%s\%s' % (CLIENT_PATH, file_name), 'wb') as f:
        count = 0
        while count < recv_count:
            line = my_client.recv(1024)  # 接收的数据可能超过1024个字节
            count += len(line)
            f.write(line)


def run():
    my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    my_client.connect(('127.0.0.1', 8081))
    flag = True
    while flag:
        # 1. 发命令
        inp = input('>>> ').strip()
        if not inp:
            continue
        my_client.send(inp.encode('utf-8'))
        cmds = inp.split()
        if cmds[0] == 'get':
            get(my_client)

    my_client.close()


if __name__ == '__main__':
    run()

一、计算机基础

网络:

互联网协议

osi

  1. 七层: 应用层, 表, 会, 传输层, 网络层, 数据链层, 物理层
  2. 五层: 应用层(应用层, 表, 会), 传输层, 网络层, 数据链层, 物理层

五层协议详解:

  1. 物理层:

  2. 数据链路层: 以太网协议

    2.1 ethernet规定: 一组电信号构成一个数据包，叫做‘帧’
    每一数据帧分成：报头head和数据data两部分
    head data
    head包含：(固定18个字节)

    发送者／源地址，6个字节
    接收者／目标地址，6个字节
    数据类型，6个字节
    data包含：(最短46字节，最长1500字节)

    数据包的具体内容
    head长度＋data长度＝最短64字节，最长1518字节，超过最大限制就分片发送

    2.2 mac地址:

    2.3 以太网工作方式: 基于mac地址的广播的方式来进行数据的传递(局域网内)

  3. 网络层:

    ip协议: (ipv4， ipv6)

    arp协议(了解): 把ip地址解析成Mac地址

  4. 传输层: tcp/udp(基于端口的协议)

  5. 应用层: (http协议/ftp协议)

tcp/udp协议详解:

  1. tcp协议: 可靠协议(建立链接: 三次握手 断开链接: 四次挥手)

    image_1c1phb5ao10jb183v1l3i1psgo6037.png-281.7kB

  2. udp协议: 不可靠, 传输效率高, 网络开销低

socket:

  1. AF_UNIX
  2. AF_INET

img

服务器端: server_test.py

# -*- encoding: utf-8 -*-
"""
@author: 
@license: 
@contact: 
@software: 
@file: server_test.py
@time: 2020.8.7 11:47
@desc:
"""

import socket


# 1. 买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # SOCK_STREAM ---> tcp
print(phone)

# 2. 绑定手机卡(端口: 0-65535 其中0-2014给操作系统用)
phone.bind(('127.0.0.1', 8080))

# 3.开机
phone.listen(5)

# 4. 等待链接
print('starting....')
conn, client_addr = phone.accept()
print(conn, client_addr)

# 5. 收发消息
data = conn.recv(1024)  # 单位是bytes 接收数据的最大数
print('客户端发到服务端的数据: ', data)

conn.send(data.upper())

# 6. 挂电话
conn.close()

# 7. 关机
phone.close()

客户端: client_test.py

# -*- encoding: utf-8 -*-
"""
@author: 
@license: 
@contact: 
@software: 
@file: client_test.py
@time: 2020.8.7 11:48
@desc:
"""

import socket


# 1. 买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # SOCK_STREAM ---> tcp
print(phone)

# 2. 拨号
phone.connect(('127.0.0.1', 8080))

# 3. 收发消息
phone.send('xxx'.encode('utf-8'))
data = phone.recv(1024)
print(data)

# 4. 关闭
phone.close()

在my_server.bind()之前加上如下代码, 重用端口

my_sever.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

加上链接循环

my_server.py

import socket


my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_server.bind(('127.0.0.1', 8081))
my_server.listen(5)
# 加上链接循环
while True:
    client_conn, colient_addr = my_server.accept()
    if not colient_addr:
        my_server.close()
        break
    while True:
        try:
            res = client_conn.recv(1024)
            if res.decode('utf-8') == 'exit' or not res:
                client_conn.close()
                break
            client_conn.send(res.upper())
            print(res.decode('utf-8'))
        except ConnectionResetError:
            break

消除不能接受空字符串的bug

my_client.py

import socket


my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_client.connect(('127.0.0.1', 8081))
while True:
    msg = input('>>> ').strip()
    if not msg:continue  # 消除不能接受空字符串的bug
    my_client.send(msg.encode('utf-8'))
    res = my_client.recv(1024)
    print(res.decode('utf-8'))
    if not res:
        break
my_client.close()

模拟ssh远程执行命令

系统命令:

win: dir: 查看某一个文件夹下的子文件名与子文件夹 ipconfig: 查看本地网卡的ip信息 tasklist: 查看运行的进程

linux: ls ifconfig ps aux

执行系统命令: os模块 —> 在终端打印

sunbprocess —> 拿到返回结果

my_server.py

"""TODO 模拟ssh远程执行命令"""
import socket
import subprocess


my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_server.bind(('127.0.0.1', 8081))
my_server.listen(3)
while True:
    client_conn, colient_addr = my_server.accept()
    print(colient_addr)
    # TODO
    if not colient_addr:
        my_server.close()
        break
    while True:
        try:
            # 1. 接收命令
            cmd = client_conn.recv(1024).decode('utf-8')
            if cmd == 'exit' or not cmd:
                break

            # 2. 执行命令, 拿到结果
            obj = subprocess.Popen(cmd,
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)

            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 3. 把明理路结果返回给客户端
            client_conn.send(stdout + stderr)  # 存在效率问题

        except ConnectionResetError:
            break
    client_conn.close()

my_client.py

"""TODO 模拟ssh远程执行命令"""
import socket


my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_client.connect(('127.0.0.1', 8081))
while True:
    # 1. 发命令
    cmd = input('>>> ').strip()
    if not cmd:
        continue
    my_client.send(cmd.encode('utf-8'))

    # 2. 拿到命令结果并打印
    res = my_client.recv(1024)  # 接收的数据可能超过1024个字节
    print(res.decode('gbk'))
    if not res:
        break
my_client.close()

粘包现象

关闭已运行的python程序:

​ linux: pkill -9 python

​ win: taskkill python

send和recv:

  1. send和recv都不会直接接收对方的数据, 而是操作自己的操作系统内存, 不是一个send对应一个recv

    1.1 recv: wait data(耗时非常长), copy data

    1.2 send: copy data

import struct
# 制作固定长度的报头
res = struct.pack('i', 123)
print(res, type(res), len(res))
"""b'{\x00\x00\x00' <class 'bytes'> 4"""

#
obj = struct.unpack('i', res)
print(obj, obj[0])
"""(123,) 123"""

解决粘包问题

my_server.py

"""TODO 模拟ssh远程执行命令"""
import struct
import socket
import json
import subprocess


my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_server.bind(('127.0.0.1', 8081))
my_server.listen(3)
while True:
    client_conn, colient_addr = my_server.accept()
    print(colient_addr)
    # TODO
    if not colient_addr:
        my_server.close()
        break
    while True:
        try:
            # 1. 接收命令
            cmd = client_conn.recv(1024).decode('utf-8')
            if cmd == 'exit' or not cmd:
                break

            # 2. 执行命令, 拿到结果
            obj = subprocess.Popen(cmd,
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE)

            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 3. 把命令结果返回给客户端
            # 3.1 制作固定长度的报头
            # send_count = len(stdout) + len(stderr)
            # # header = struct.pack('i', send_count)  # send_count的长度有限制
            # header = struct.pack('l', send_count)  # send_count的长度有限制
            header_dic = {
                'filename': 'a.txt',
                'md5': 'xxxxx',
                'total_size': len(stdout) + len(stderr)
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('gbk')

            # 3.2 发送报头的长度
            client_conn.send(struct.pack('i', len(header_bytes)))

            # 3.3 把报头数据发送给客户端
            client_conn.send(header_bytes)

            # 3.4 发送真实数据
            count = 0
            client_conn.send(stdout)
            client_conn.send(stderr)

        except ConnectionResetError:
            break
    client_conn.close()

my_client.py

"""TODO 模拟ssh远程执行命令"""
import socket
import struct
import json

my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_client.connect(('127.0.0.1', 8081))
flag = True
while flag:
    # 1. 发命令
    cmd = input('>>> ').strip()
    if not cmd:
        continue
    my_client.send(cmd.encode('utf-8'))

    # 2. 拿到命令结果并打印
    # 2.1 先收报头的长度
    header_size = struct.unpack('i', my_client.recv(4))[0]

    # 2.2 接收报头数据
    header_bytes = my_client.recv(header_size)

    # 2.3 从报头中解析出对真实数据的描述信息(数据的长度)
    header_json = header_bytes.decode('gbk')
    header_dic = json.loads(header_json)
    recv_count = header_dic['total_size']

    # 2.4 就收真实数据
    count = 0
    recv_data = b''
    while count < recv_count:
        res = my_client.recv(1024)  # 接收的数据可能超过1024个字节
        count += len(res)
        recv_data += res
    print(recv_data.decode('gbk'))
my_client.close()

my_server.py

"""TODO 文件上传下载功能"""
import struct
import socket
import json
import os

SERVER_PATH = r'E:\lufei\model_3\model_3_1\log\服务器端'


my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_server.bind(('127.0.0.1', 8081))
my_server.listen(3)
while True:
    client_conn, colient_addr = my_server.accept()
    print(colient_addr)
    # TODO
    if not colient_addr:
        my_server.close()
        break
    while True:
        try:
            # 1. 接收命令
            res = client_conn.recv(1024).decode('utf-8').split()
            if res == 'exit' or not res:
                break

            # 2. 解析命令, 提取相应参数
            file_name = res[1]

            # 3. 以读的方式打开文件, 读取文件内容发送给客户端
            # 3.1 制作固定长度的报头
            header_dic = {
                'filename': file_name,
                'md5': 'xxxxx',
                'file_size': os.path.getsize('%s\%s' % (SERVER_PATH, file_name))
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('gbk')

            # 3.2 发送报头的长度
            client_conn.send(struct.pack('i', len(header_bytes)))

            # 3.3 把报头数据发送给客户端
            client_conn.send(header_bytes)

            # 3.4 发送真实数据
            with open('%s\%s' % (SERVER_PATH, file_name), 'rb') as f:
                for line in f:
                    client_conn.send(line)

        except ConnectionResetError:
            break
    client_conn.close()

my_client.py

"""TODO 文件下载上传功能"""
import socket
import struct
import json

CLIENT_PATH = r'E:\lufei\model_3\model_3_1\log\客户端'


my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
my_client.connect(('127.0.0.1', 8081))
flag = True
while flag:
    # 1. 发命令
    cmd = input('>>> ').strip()
    if not cmd:
        continue
    my_client.send(cmd.encode('utf-8'))

    # 2. 以写的方式打开一个新文件, 将从服务端接收的文件内容写入客户端的新文件中
    # 2.1 先收报头的长度
    header_size = struct.unpack('i', my_client.recv(4))[0]

    # 2.2 接收报头数据
    header_bytes = my_client.recv(header_size)

    # 2.3 从报头中解析出对真实数据的描述信息(数据的长度)
    header_json = header_bytes.decode('gbk')
    header_dic = json.loads(header_json)
    recv_count = header_dic['file_size']
    file_name = header_dic['filename']

    # 2.4 接收真实数据
    with open('%s\%s' % (CLIENT_PATH, file_name), 'wb') as f:
        count = 0
        while count < recv_count:
            line = my_client.recv(1024)  # 接收的数据可能超过1024个字节
            count += len(line)
            f.write(line)
my_client.close()

函数版本

my_server.py

"""TODO 文件上传下载功能"""
import struct
import socket
import json
import os

SERVER_PATH = r'E:\lufei\model_3\model_3_1\log\服务器端'


def get(client_conn, res):
    file_name = res[1]
    # 3. 以读的方式打开文件, 读取文件内容发送给客户端
    # 3.1 制作固定长度的报头
    header_dic = {
        'filename': file_name,
        'md5': 'xxxxx',
        'file_size': os.path.getsize('%s\%s' % (SERVER_PATH, file_name))
    }
    header_json = json.dumps(header_dic)
    header_bytes = header_json.encode('gbk')

    # 3.2 发送报头的长度
    client_conn.send(struct.pack('i', len(header_bytes)))

    # 3.3 把报头数据发送给客户端
    client_conn.send(header_bytes)

    # 3.4 发送真实数据
    with open('%s\%s' % (SERVER_PATH, file_name), 'rb') as f:
        for line in f:
            client_conn.send(line)


def run():
    my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    my_server.bind(('127.0.0.1', 8081))
    my_server.listen(3)
    while True:
        client_conn, colient_addr = my_server.accept()
        print(colient_addr)
        # TODO
        if not colient_addr:
            my_server.close()
            break
        while True:
            try:
                # 1. 接收命令
                res = client_conn.recv(1024).decode('utf-8').split()
                if res == 'exit' or not res:
                    break

                # 2. 解析命令, 提取相应参数
                if res[0] == 'get':
                    get(client_conn, res)

            except ConnectionResetError:
                break
        client_conn.close()


if __name__ == '__main__':
    run()

my_client.py

"""TODO 文件下载上传功能"""
import socket
import struct
import json

CLIENT_PATH = r'E:\lufei\model_3\model_3_1\log\客户端'


def get(my_client):
    # 2. 以写的方式打开一个新文件, 将从服务端接收的文件内容写入客户端的新文件中
    # 2.1 先收报头的长度
    header_size = struct.unpack('i', my_client.recv(4))[0]

    # 2.2 接收报头数据
    header_bytes = my_client.recv(header_size)

    # 2.3 从报头中解析出对真实数据的描述信息(数据的长度)
    header_json = header_bytes.decode('gbk')
    header_dic = json.loads(header_json)
    recv_count = header_dic['file_size']
    file_name = header_dic['filename']

    # 2.4 接收真实数据
    with open('%s\%s' % (CLIENT_PATH, file_name), 'wb') as f:
        count = 0
        while count < recv_count:
            line = my_client.recv(1024)  # 接收的数据可能超过1024个字节
            count += len(line)
            f.write(line)


def run():
    my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    my_client.connect(('127.0.0.1', 8081))
    flag = True
    while flag:
        # 1. 发命令
        inp = input('>>> ').strip()
        if not inp:
            continue
        my_client.send(inp.encode('utf-8'))
        cmds = inp.split()
        if cmds[0] == 'get':
            get(my_client)

    my_client.close()


if __name__ == '__main__':
    run()
每天都困的阿柴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python------备份设备配置脚本（二）
dyx0910的博客
05-03 2272
python------备份设备配置脚本（二）
乱七八糟自己用的笔记就是这个
02-08
Java 中的类和对象是面向对象编程的基础概念。类是对象的蓝图，定义了对象的属性和行为，而对象是类的实例。Java 中的类可以包含变量和方法。变量用来存储数据，而方法用来描述对象的行为。 类的构造函数是特殊的...
网络编程（乱）
weixin_61875065的博客
10-18 78
## 概述 地球村， 网络让距离变近。 计算机网络：计算机网络是将**地理位置不同**的具有独立功能的**多台计算机及其外部设备，通过通信线路（有线或者无线）连接起来**，在网络操作系统，网络管理软件及**网络通信协议**的管理和协调下，**实现资源共享**和信息传递的计算机系统 网络编程的目的： 电台，无线电台，，，传播交流信息，数据交换，通信 怎么做 1.如何准确定位网络上的一台主机 :端口，定位到计算机上的某个资源 2.找到了这个主机，如何传输数据？ 3.javaweb：网页编程..
Python_paramiko_与linux交互
GDYY3721的博客
07-14 892
建立通信# 建立连接# 注意 active 此时为0# 开启一个信道# 调用open_session后，active为1，表示已打开channel。此时只能下发命令，收不到回显# 设置信道获取信息的超时时间。因为在调用 channel.recv(65535) 方法时 会阻塞执行，不设置就会卡死。# 开启终端，进入交互模式sleep(2) # 是为了一次能显示完所有回显，如果不等待2秒，获取的回显可能不完整。# 检查通道是否有数据。若没有，则返回False，注意：不能用来判断已回显完。
Python paramiko模块学习
luontheway的博客
09-15 449
paramiko
关于 recv函数
CppPlayer
08-31 2342
/* int recv( SOCKET s, char FAR *buf, int len, int flags);（1）recv先等待s的发送缓冲中的数据被协议传送完毕， 如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，（2）如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后， recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有
Linux事件驱动网络编程,Linux系统编程之事件驱动
weixin_32903229的博客
05-05 316
通常，我们写服务器处理模型的程序时，有以下几种模型：(1)每收到一个请求，创建一个新的进程，来处理该请求；(2)每收到一个请求，创建一个新的线程，来处理该请求；(3)每收到一个请求，放入一个事件列表，让主进程通过非阻塞I/O方式来处理请求分析：第(1)中方法，由于创建新的进程的开销比较大，所以，会导致服务器性能比较差,但实现比较简单。第(2)种方式，由于要涉及到线程的同步，有可能会面临死锁等问题。...
Laravel学习笔记之乱七八糟
weixin_30664539的博客
07-22 76
laravel 框架核心 IoC控制反转 inversion of control DI 依赖注入 接口约定 契约 interface接口 服务提供者provider service provider xxx 内核 中控(http console) 中间件 服务提供器 providers 服务提供器是引导 Laravel 应用程序真正的关键。 创建应用程序实例、注册服务提供器，并将请求交给...
风变编程python笔记_自学Python和风变编程
weixin_39891694的博客
12-09 1775
打算看小丑，看完肯定特压抑就把定下来要写的先写了。其实接触到Python特简单，某天看了一个公众号的推送，里面写了关于Python的文章然后推荐了一个课程就是风变编程的体验课，几块钱。现在闲赋在家觉得应该学点儿啥就去报了个名。其实对编程也不说有多大的兴趣，只是觉得学点儿东西总是好的，而且关于这个爬虫啊，整理表格什么的我觉得就很好了，就这么简单。然后形式就是一问一答加助教，助教会提醒你应该上课啦，然...
图解计算机网络笔记
weixin_62633072的博客
06-22 2705
图解计算机网络笔记
sijin.github.com：四金的乱七八糟东西
02-13
"乱七八糟东西"可能意味着这个站点包含了作者的各种实验、学习笔记、代码片段或者是个人作品，内容可能涵盖多个IT领域的知识点。 【描述】同样简洁地重申了标题，没有提供额外的具体信息，但我们可以推测，这个网站...
Arduino：:high_voltage:Arduino的东西-大多只是乱七八糟
02-06
2. **库文件**：扩展了Arduino的功能，比如处理网络连接、图形显示等，这些库可以帮助用户快速实现复杂功能。 3. **电路图**：可能包含SVG或PDF格式的电路设计图，帮助用户理解硬件连接。 4. **数据表**：关于所用...
WhyMathematica, Mathematica 简易教程/一个乱七八糟的放 notebook 的地方.zip
09-18
而描述中的"一个乱七八糟的放notebook的地方"则可能意味着这个压缩包包含了各种不同主题和用途的Mathematica笔记本（.nb文件），这些笔记本可能是用户在学习或工作中创建的示例、练习或者项目。 Mathematica的核心...
zmj-note：记录开发生涯的点滴
02-28
我的编程笔记 程序员 :laptop_computer:生涯的技术笔记 技术为主 :wrench: 乱七八糟 :reminder_ribbon: 注意参考 :open_book: 下载 git clone https://github.com/ZanMinKian/zmj-note.git 用法 :page_with_curl:...
cv2读取和保存图片
最新发布
m0_53291740的博客
07-12 171
cv2.imwrite('b\\img1.png',img)#b存在就可以保存进去。如果b存在，c不存在，程序不会报错，也不会保存图片。如果目录b不存在就会存到当前文件夹。
Nginx七层（应用层）反向代理：UWSGI代理uwsgi_pass篇
jclee95的个人博客
07-10 1076
Nginx提供了多种应用层反向代理支持，包括proxy_pass、uwsgi_pass、fastcgi_pass和scgi_pass等。其中，proxy_pass指令可以接受一个URL参数，用于实现对HTTP/HTTPS协议的反向代理；uwsgi_pass用于代理到uWSGI应用服务器；fastcgi_pass用于代理到FastCGI服务器；而scgi_pass则用于代理到SCGI（Simple Common Gateway Interface）应用。这些指令使Nginx能够灵活地处理不同类型的后端服务和应
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 762
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。
聊聊如何在内网下构建大模型微调环境
python1234567_的博客
07-12 779
LlamaFactory新版更新后，还是比较方便，只是说llamafactory-cli命令的确是有点蒙，踩个坑就好了。对于LlamaFactory微调来说，本身不难，毕竟都是配置；主要是在内网环境下的依赖包拉取安装是真麻烦，但其实也还好。走一遍的话，还是可以学到很多的。​。
笔记本无线网连接打印机出现0x80070035错误
05-23
发生此错误可能是由于以下原因之一： 1. 网络连接问题：网络连接可能不稳定或者无线连接中断，导致打印机无法访问。 2. 防火墙问题：计算机防火墙可能会阻止打印机与计算机之间的通信。检查防火墙设置以确保它们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值