网络编程

网络编程 

什么socket？

TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。
使用TCP的应用：Web浏览器；电子邮件、文件传输程序。

UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大
努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。

   
软件 
   客户端：CS架构， client  ->   server 
   浏览器：BS架构， browser ->   server 

为什么要网络通信发送的是字节？而不是字符串？
   py3, send/recv 都是字节
   py2, send/recv 都是字符串
   

服务端：
   accept，阻塞：等待客户端来连接。
   recv，  阻塞：等待客户端发来数据。
   
客户端：
   connect，阻塞：一直在连接，直到连接成功才往下运行其他代码。
   recv，  阻塞：等待服务端发来数据。

服务端:

import socket

server = socket.socket()

server.bind(('127.0.0.1',8001))

server.listen(5)

while True:
    conn,addr = server.accept()
    # 字节类型
    try:
        while True:
            data = conn.recv(1024) # 阻塞
            if data == b'exit':
                break
            response = data + b' SB'
            conn.send(response)
    except ConnectionResetError:#防止客户端终端后 服务端异常  window环境下使用
        break

    conn.close()

客户端:

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',8001))

while True:
    name = input("请输入姓名：")
    sk.send(name.encode('utf-8')) # 字节

    if name == 'exit':
        break

    response = sk.recv(1024) # 字节
    print(response.decode('utf-8'))

sk.close()

 

 

socket粘包

socket的粘包为在数据量小与时间间隔短的情况下 优化算法使数据减少IO以达到提高效率，减少网络IO的一种方式

socket下的send与recv并不是一对一的  可以一对多 多对一即可  

粘包主要是接收端不知所接收的大小(即不知数据的开头与结尾)  只要明确数据的大小 即可解决粘包导致的缺点 

一般可以使用struck来达到效果

 

send  : 只需要copy data     send不是直接操作网卡的   本质上是数据由用户程序copy到操作系统缓存    操作系统来调用网卡传输     

recv： 1. wait data   2. copy data  时间较长   

 

struct用法

import struct
res=struct.pack("i","")
print(res)
print(len(res))
obj=struct.unpack("i",res)
print(obj[0])import struct
res=struct.pack("i","")
print(res)
print(len(res))
obj=struct.unpack("i",res)
print(obj[0])

subprocess用法

import subprocess

res=subprocess.Popen("dir",
                     shell=True,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)
print(res.stdout.read().decode("gbk"))

 

SSH Server

import socket
import subprocess

server = socket.socket()

server.bind(('127.0.0.1',8008))

server.listen(5)

while True:
    print("server is working.....")
    conn,addr = server.accept()
    # 字节类型
    while True:
        # 针对window系统

        try:
            cmd = conn.recv(1024).decode("utf8") # 阻塞
            if cmd.encode("utf-8") == b'exit':
                break
            res=subprocess.Popen(cmd,
                             shell=True,
                             stderr=subprocess.PIPE,
                             stdout=subprocess.PIPE,
                             )
            # print("stdout",res.stdout.read())
            # print("stderr",res.stderr.read().decode("gbk"))
            out=res.stdout.read()
            err=res.stderr.read()

            print("out响应长度",len(out))
            print("err响应长度",len(err))
            if err:
                 import struct
                 header_pack = struct.pack("i", len(err))
                 conn.send(header_pack)
                 conn.send(err)
            else:
                 #构建报头
                 import struct
                 header_pack=struct.pack("i",len(out))
                 print("header_pack",header_pack)
                 # # 发送报头
                 conn.send(header_pack)
                 # 发送数据
                 conn.send(out)

        except Exception as e:
            break


    conn.close()

 

SSH Client

import socket
import struct
sk = socket.socket()

sk.connect(('127.0.0.1',8008))

while 1:
    cmd = input("请输入命令：")
    sk.send(cmd.encode('utf-8')) # 字节
    if cmd=="":
        continue
    if cmd == 'exit':
        break

    header_pack=sk.recv(4)
    data_length=struct.unpack("i",header_pack)[0]
    print("data_length",data_length)
    '''
    b'xxx/xxx/xxx/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'


    '''

    recv_data_length=0
    recv_data=b""

    while recv_data_length<data_length:
        data=sk.recv(1024)
        recv_data_length+=len(data)
        recv_data+=data

    print(recv_data.decode("gbk"))


sk.close()

 

socketserver可以实现并发的网络通信

server

import socketserver

class Myserver(socketserver.BaseRequestHandler):
    def handle(self):# handel之内的逻辑由程序员编写,request等同于socket对象conn
        # 字节类型
        while 1:
            # 针对window系统
            try:
                print("等待信息")
                data = self.request.recv(1024)  # 阻塞
                # 针对linux
                if len(data) == 0:
                    break
                if data == b'exit':
                    break
                response = data + b'SB'
                self.request.send(response)
            except Exception as e:
                break

        self.request.close()


# 1 创建socket对象 2 self.socket.bind()  3 self.socket.listen(5)
# server=socketserver.ForkingUDPServer(("127.0.0.1",8899),Myserver)
server=socketserver.ThreadingTCPServer(("127.0.0.1",8899),Myserver) # socket建立,bind,listen方法

server.serve_forever()#类似于accept方法

 client

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',8899))

while 1:
    name = input(">>>>：")
    sk.send(name.encode('utf-8')) # 字节

    response = sk.recv(1024) # 字节
    print(response.decode('utf-8'))