网络编程-SOCKET开发

# 流程描述：
# 
# 1 服务器根据地址类型（ipv4,ipv6）、socket类型、协议创建socket
# 
# 2 服务器为socket绑定ip地址和端口号
# 
# 3 服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开
# 
# 4 客户端创建socket
# 
# 5 客户端打开socket，根据服务器ip地址和端口号试图连接服务器socket
# 
# 6 服务器socket接收到客户端socket请求，被动打开，开始接收客户端请求，直到客户端返回连接信息。这时候socket进入阻塞状态，所谓阻塞即accept()方法一直等到客户端返回连接信息后才返回，开始接收下一个客户端连接请求
# 
# 7 客户端连接成功，向服务器发送连接状态信息
# 
# 8 服务器accept方法返回，连接成功
# 
# 9 客户端向socket写入信息(或服务端向socket写入信息)
# 
# 10 服务器读取信息(客户端读取信息)
# 
# 11 客户端关闭
# 
# 12 服务器端关闭

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()

　　#套接字的文件描述符
socket.getfqdn()  # 拿到本机的主机名
socket.gethostbyname()  # 通过域名解析ip地址

# server 端
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 可以重复利用端口 解决端口被占用的问题
address = (‘127.0.0.1‘, 8080)  
phone.bind(address)
phone.listen(5)
conn, addr = phone.accept()
while True:
    try:
        data = conn.recv(1024)
        print(type(data), data)
        conn.send(data.upper())
    except ConnectionResetError:  # 解决客户端单方面终止连接的bug
        break
conn.close()
phone.close()


# client端
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8089)
phone.connect(address)
while True:
    msg = input(">>>: ").strip()
    if not msg:
        continue  # 解决输入为空的bug  输入为空 操作系统就不会继续下面四层的操作 程序就会卡死
    phone.send(msg.encode(‘utf-8‘))
    data = phone.recv(1024)
    print(data)
phone.close()

# server 端
import socket
import os
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)  # 0 - 1024 是操作系统占用的端口
phone.bind(address)
phone.listen(5)

server_dir = r‘server\server_base‘
while True:
    print(‘waiting...‘)
    conn, addr = phone.accept()
    while True:
        order = conn.recv(8096)  # 接收命令 get a.txt
        cmds = order.decode(‘utf-8‘).split(‘ ‘)
        order_type = cmds[0]
        filename = cmds[1]

        # 制作报头
        header_info = {
            ‘filename‘: filename,
            ‘file_size‘: os.path.getsize(r‘%s\%s‘ % (server_dir, filename)),  # 保存位置路径拼接
            ‘time‘: ‘now‘
        }

        header_byte = json.dumps(header_info).encode(‘utf-8‘)
        len_header = struct.pack(‘i‘, len(header_byte))
        conn.send(len_header)  # 发送报头长度
        conn.send(header_byte)  # 发送报头

        # 发送真实数据
        with open(r‘%s\%s‘ % (server_dir, filename), ‘rb‘) as f:
            for line in f:  # 每次读取一行 节省空间
                conn.send(line)

    conn.close()

phone.close()


# clien端
import socket
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)
phone.connect(address)
download_dir = ‘client\download‘
while True:

    order = input(‘>>>: ‘).strip()
    phone.send(order.encode(‘utf-8‘))

    # 拿到报头的长度
    header = phone.recv(4)
    header_len = struct.unpack(‘i‘, header)[0]

    # 通过报头的长度拿到报头
    header_info = phone.recv(header_len)
    header_ = json.loads(header_info.decode(‘utf-8‘))
    print(header_)

    # 拿到文件的总大小
    file_size = header_[‘file_size‘]
    filename = header_[‘filename‘]

    with open(r‘%s\%s‘ % (download_dir, filename), ‘wb‘) as f:
        size = 0
        while size < file_size:
            data = phone.recv(1024)
            f.write(data)
            size += len(data)
            print(‘当前进度%s‘ % (size/file_size*100))
phone.close()

server端
import socket
import struct
import os
import json


class My_socket:
    host = ‘127.0.0.1‘
    port = 9000
    family = socket.AF_INET
    cooperation = socket.SOCK_STREAM
    server_dir = r‘server\server_base‘

    def __init__(self, is_activate=True):
        self.phone = socket.socket(self.family, self.cooperation)
        if is_activate:
            self.bind()
            self.listen()

    def listen(self):
        self.phone.listen(5)

    def bind(self):
        self.phone.bind((self.host, self.port))

    def run(self):
        print(‘wait.....‘)
        self.conn, self.addr = self.phone.accept()
        self.take_order()

    def take_order(self):
        order = self.conn.recv(1024)
        cmd_ = order.decode(‘utf-8‘)
        cmd_list = cmd_.split(‘ ‘)
        cmd = cmd_list[0]
        filename = cmd_list[1]
        if hasattr(self, cmd):
            func = getattr(self, cmd)
            func(filename)

    def get(self, filename):
        self.make_head(filename)
        self.file_read(filename)

    def file_read(self, filename):
        with open(r‘%s\%s‘ % (self.server_dir, filename), ‘rb‘) as f:
            for line in f:
                self.conn.send(line)

    def make_head(self, filename):
        file_dict = {
            ‘filename‘: filename,
            ‘file_size‘: os.path.getsize(r‘%s\%s‘ % (self.server_dir, filename)),
            ‘md5‘: ‘xxxxxxxxx‘
        }

        file_json = json.dumps(file_dict).encode(‘utf-8‘)
        file_len = len(file_json)
        header = struct.pack(‘i‘, file_len)
        self.conn.send(header)
        self.conn.send(file_json)
        self.file_read(filename)

    def put(self):
        pass

    def data_transport(self):
        pass

    def close(self):
        self.conn.close()
        self.phone.close()


my_socket = My_socket()
my_socket.run()

import socket
import struct
import json


class My_socket:
    family = socket.AF_INET
    cooperation = socket.SOCK_STREAM
    download_dir = r‘client\download‘

    def __init__(self, address):
        self.phone = socket.socket(self.family, self.cooperation)
        self.address = address
        self.connect()

    def connect(self):
        self.phone.connect(self.address)

    def read_head(self):
        header = self.phone.recv(4)
        header_len = struct.unpack(‘i‘, header)[0]
        header_info = self.phone.recv(header_len)
        header_dict = json.loads(header_info)
        file_size = header_dict[‘file_size‘]
        filename = header_dict[‘filename‘]
        self.recv_data(file_size, filename)

    def recv_data(self, file_size, filename):
        size = 0
        with open(r‘%s\%s‘ % (self.download_dir, filename), ‘wb‘) as f:
            while size < file_size:
                data = self.phone.recv(1024)
                f.write(data)
                size += len(data)
                print(‘已传输百分之%s‘ % int((size / file_size*100)),end=‘\n‘)

    def close(self):
        self.phone.close()

    def run(self):
        inp = input(">>>: ")
        self.phone.send(inp.encode(‘utf-8‘))
        self.read_head()


my_socket = My_socket((‘127.0.0.1‘, 9000))
my_socket.run()
my_socket.close()

# server端
import socket
import subprocess
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 可以重复利用端口 解决端口被占用的问题
address = (‘127.0.0.1‘, 8080)  # 0 - 1024 是操作系统占用的端口
phone.bind(address)
phone.listen(5)
while True:  # 实现了对多个客户端的服务 但每次只能服务一个客户端
    print("waiting...")
    conn, addr = phone.accept()
    print(‘客户端： ‘, addr)
    while True:
        try:
            # 接受命令
            cmd = conn.recv(1024)  # 1024是一个坑
            # 执行命令 拿到结果
            obj = subprocess.Popen(cmd.decode(‘utf-8‘), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            # shell 解析字符串成为命令 相当于开启了一个终端  同时要注意操作系统编码的问题
            # PIPE是建立一个管道 stdout是正确命令的执行结果 stderr是错误命令的结果
            # PIPE的执行内部其实是执行了一个方法 加了一个property
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()

            # 发送结果
            conn.send(stdout+stderr)  # 会新开辟一片内存空间浪费资源
        except ConnectionResetError:  # 解决客户端单方面终止连接的bug
            break
    conn.close()

phone.close()

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

# client端
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8080)
phone.connect(address)
while True:
    cmd = input(">>>: ").strip()
    if not cmd:
        continue  # 解决输入为空的bug
    phone.send(cmd.encode(‘utf-8‘))
    data = phone.recv(1024)
    print(data.decode(‘gbk‘))  # windows下默认编码gbk ;linux 下默认编码utf-8
phone.close()

# server端
import socket
import subprocess

ip_port = (‘127.0.0.1‘, 9003)
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)
#Windows下 当接收数据报的缓冲区比数据报小时会报错
# OSError: [WinError 10040] 一个在数据报套接字上发送的消息大于内部消息缓冲区或其他一些网络限制，或该用户用于接收数据报的缓冲区比数据报小。
# linux 当接收的缓冲区小于数据报时 多出的数据会丢失
    print(‘用户命令----->‘, cmd,addr)

    res = subprocess.Popen(cmd.decode(‘utf-8‘), shell=True, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
                           stdout=subprocess.PIPE)
    stderr = res.stderr.read()
    stdout = res.stdout.read()

    # 发消息
    udp_server.sendto(stdout + stderr, addr)

udp_server.close()

from socket import *

import time

ip_port = (‘127.0.0.1‘, 9003)
bufsize = 1024

udp_client = socket(AF_INET, SOCK_DGRAM)

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

    udp_client.sendto(msg.encode(‘utf-8‘), ip_port)
    data, addr = udp_client.recvfrom(bufsize)
 # udp 可以发空信息 因为udp每发一次就是发一份完整的数据报 都会有自己的ip端口信息
 #  udp协议一次发 对应一次收
    print(data.decode(‘utf-8‘), end=‘‘)

1.
server
phone.send(‘hello‘.encode(‘utf-8‘))
phone.send(‘world‘.encode(‘utf-8‘))  # 这时候就发生了粘包现象  两个数据比较小 并且发送的间隔短(小于一次IO的时间）

client
data = conn.recv(1024)
print(data.decode(‘utf-8‘))  # helloworld  这时候就发生了粘包现象  两个数据比较小 并且发送的间隔短(小于一次IO的时间）


2.
server
phone.send(‘hello‘.encode(‘utf-8‘))
phone.send(‘world‘.encode(‘utf-8‘))  # 这时候就发生了粘包现象  两个数据比较小 并且发送的间隔短(小于一次IO的时间）

client
res1 = conn.recv(1)  # 只接收一个数据 剩下的数据都在操作系统内存当中
print(‘第一个数据: ‘, res1)  # b‘h‘

# res2 = conn.recv(9)
# print("第二个数据: ", res2)  # b‘elloworld‘  第二次发送的数据在第一次未接收数据的后面

3.
server
phone.send(‘hello‘.encode(‘utf-8‘))
time.sleep(5)
phone.send(‘world‘.encode(‘utf-8‘))  # 这时候不会发生粘包

client
res_1 = conn.recv(1024)
res_2 = conn.recv(1024)
print("第一个数据: ", res_1)  # 第一个数据:  b‘hello‘
print("第二个数据: ", res_2)  # 第二个数据:  b‘world‘

4.
server
phone.send(‘hello‘.encode(‘utf-8‘))
time.sleep(5)
phone.send(‘world‘.encode(‘utf-8‘))  # 这时候不会发生粘包


client
res_1 = conn.recv(1)  # 第一个数据:  b‘h‘
print("第一个数据: ", res_1)
res_2 = conn.recv(1024)  # 第二个数据:  b‘ello‘   这样数据并没有接收完
# 在第一次recv之后 就会到第二次recv 如果有就接收 如果没有就等待  会导致数据接收不完整
print("第二个数据: ", res_2)


5. 
server
phone.send(‘hello‘.encode(‘utf-8‘))
time.sleep(5)
phone.send(‘world‘.encode(‘utf-8‘))

client
res_1 = conn.recv(1)  # 第一个数据:  b‘h‘
print("第一个数据: ", res_1)
time.sleep(6)  # 第二个数据:  b‘elloworld‘  想要数据接收完整 等待的时间大于client端即可
res_2 = conn.recv(1024)
print("第二个数据: ", res_2)

server端
import socket
import subprocess
import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)  # 0 - 1024 是操作系统占用的端口
phone.bind(address)
phone.listen(5)
conn, addr = phone.accept()
while True:
    order = conn.recv(8096)
    obj = subprocess.Popen(order.decode(‘utf-8‘), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout = obj.stdout.read()
    stderr = obj.stderr.read()
    # 数据的大小 即数据的描述信息 就是报头 报头一定是固定长度的

    # 第一步 制作固定长度的报头
    total_size = len(stdout) + len(stderr)
    header = struct.pack(‘i‘, total_size)

    # 第二步 把数据的报头发给客户端
    conn.send(header)

    # 第三步 发送真实的数据
    # data = stdout+stderr
    conn.send(stdout)
    conn.send(stderr)  # 利用粘包现象完成数据的拼接
conn.close()

phone.close()

import socket
import struct
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)
phone.connect(address)
while True:
    # 1.发命令
    order = input(‘>>>: ‘).strip()
    phone.send(order.encode(‘utf-8‘))

    # 2.拿到命令结果并打印
    # 第一步：收报头
    header = phone.recv(4)

    # 第二步 从报头信息中解析出数据的信息
    head_data = struct.unpack(‘i‘, header)  # 是一个元组
    total_size = head_data[0]

    current_data = b‘‘
    size = 0
    while size < total_size:
        data = phone.recv(1024)
        current_data += data
        size += len(data)
    print(current_data.decode(‘gbk‘))
phone.close()

import socket
import subprocess
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)  # 0 - 1024 是操作系统占用的端口
phone.bind(address)
phone.listen(5)
conn, addr = phone.accept()
while True:
    order = conn.recv(8096)
    obj = subprocess.Popen(order.decode(‘utf-8‘), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    stdout = obj.stdout.read()
    stderr = obj.stderr.read()
    # 数据的大小 即数据的描述信息 就是报头 报头一定是固定长度的

    total_size = len(stdout) + len(stderr)
    # 报头的信息可能不只有大小 还有很多信息比如文件名 md5值
    # 并且struct能制作报头的文件大小也有限 因此应该想别的办法
    # 将文件的描述信息放到字典中 文件大小也放到字典中
    header_info = {
        ‘filename‘: ‘a.txt‘,
        ‘total_size‘: total_size,
        ‘time‘: ‘now‘
    }

    # 序列化成字符串 再转换成bytes类型 得到的长度就会小很多
    # 到时再转为字典就可以拿到文件的总大小 这样就解决了这个问题
    header_byte = json.dumps(header_info).encode(‘utf-8‘)
    len_header = struct.pack(‘i‘, len(header_byte))
    conn.send(len_header)  # 发送报头长度

    conn.send(header_byte)  # 发送报头
    # 第三步 发送真实的数据
    conn.send(stdout)
    conn.send(stderr)  # 利用粘包现象完成数据的拼接
conn.close()

phone.close()

import socket
import struct
import json
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = (‘127.0.0.1‘, 8008)
phone.connect(address)
while True:

    order = input(‘>>>: ‘).strip()
    phone.send(order.encode(‘utf-8‘))

    # 拿到报头的长度
    header = phone.recv(4)
    header_len = struct.unpack(‘i‘, header)[0]

    # 通过报头的长度拿到报头
    header_info = phone.recv(header_len)
    header_ = json.loads(header_info.decode(‘utf-8‘))
    print(header_)

    # 拿到文件的总大小
    total_size = header_[‘total_size‘]

    current_data = b‘‘
    size = 0
    while size < total_size:
        data = phone.recv(1024)
        current_data += data
        size += len(data)
    print(current_data.decode(‘gbk‘))
phone.close()