Python：Day26 socket

SOCKET通信流程

服务器创建套接字链接：

1、创建SOCKET，socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)

family为指定的地址族：

　　socket.AF_UNIX ：只能够用于单一的Unix系统进程间通信

　　socket.AF_INET ：服务器之间的网络通信（ipv4协议的TCP和UDP）ipv4,默认为这个

　　socket.AF_INET6 ：服务器之间的网络通信ipv6

type为指定的套接字类型：

　　socket.SOCK_STREAM ：面向连接的TCP，默认为这个

　　socket.SOCK_DGRAM ：面向非连接的UDP

import socket
socket.socket(socket.AF_INET,socket.SOCK_STREAM)    #创建TCP socket
socket.socket(socket.AF_INET,socket.SOCK_DGRAM)     #创建UDP socket

2、socket对象绑定地址及端口

地址必须是一个双元素的元组，包括（host，port）主机名或IP地址+端口号。如果端口号或地址错误将引发socke.error异常。

import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
HostPort = ('127.0.0.1',8000)    #地址和端口是一个元组，前面的IP是一个字符串，用引号引起来
sk.bind(HostPort)   #绑定主机和端口的是sk这个对象，bind的参数是一个元组，如果不创建上面的address的话，使用sk.bind(('127.0.0.1',8000))也是可以的

3、socket对象监听地址端口链接

socket.listen(backlog)

backlog指定了最多连接数，至少为1，接到连接请求后，这些请求必须排队等候连接，如果队列已满，则拒绝请求。

import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
HostPort = ('127.0.0.1',8000)    #地址和端口是一个元组，前面的IP是一个字符串，用引号引起来
sk.bind(HostPort)   #bind的参数是一个元组，如果不创建上面的address的话，使用sk.bind(('127.0.0.1',8000))也是可以的
sk.listen(5)    #括号内为最大挂起连接数,在此处会报错，因为上面使用的是UDP，而不是TCP

4、socket.accept对象阻塞等待接受链接

调用accept方法时，socket会进入‘waiting’阻塞状态，客户请求连接时，方法会建立连接并返回服务器。

accept方法会返回一个含有两个元素的元组，（fd,addr）。第一个元素是新的socket对象，服务器通过它与客户端通信。第二个元素是客户端的地址及端口信息。

import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
print(sk)   #<socket.socket fd=276, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0>
HostPort = ('127.0.0.1',8000)    #地址和端口是一个元组，前面的IP是一个字符串，用引号引起来
sk.bind(HostPort)   #bind的参数是一个元组，如果不创建上面的address的话，使用sk.bind(('127.0.0.1',8000))也是可以的
sk.listen(3)    #括号内为最大挂起连接数

conn = sk.accept()
print(conn)   #(<socket.socket fd=280, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 3721)>, ('127.0.0.1', 3721))

5、处理阶段，服务器与客户端通过send和recv方法通信(传输数据)

调用新链接对象与客户端或者服务器通信：

socket.recv(buffersize) :接受客户端信或服务器数据，buffersize指定接收数据的大小，单位为字节。

socket.send(data) ：发送信息给客户端或服务器，信息必须转换为字节才能发送。

#服务器端
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
HostPort = ('127.0.0.1',8000)    #地址和端口是一个元组，前面的IP是一个字符串，用引号引起来
sk.bind(HostPort)   #bind的参数是一个元组，如果不创建上面的address的话，使用sk.bind(('127.0.0.1',8000))也是可以的
sk.listen(3)    #括号内为最大挂起连接数
conn,addr = sk.accept()    #accept阻塞，程序到这块就不往下面执行了，除非收到连接
inp = input('>>>')
conn.send(bytes(inp,'utf8'))    #send只接受bytes数据类型，所以要把字符串转换成此种类型
#此处调用send方法的是客户端传过来的conn，而并非自己的socket对象

#客户端
import socket
sk = socket.socket()    #这个socket后面的括号不能忘记加，不加括号pycharm也不会显示为错误
sk.connect(('127.0.0.1',8000))
data = sk.recv(1024)    #socket交互为一收一发
print(str(data,'utf8'))   #由于收到的是bytes类型，所以此处需要将bytes类型转换成字符串类型

6、传输结束，关闭链接

socket.close() 关闭链接

客户端创建套接字链接：

1）s = socket.socket() 创建socket对象

2）s.connect('127.0.0.1','80') 绑定地址端口链接服务器

3）s.send(data) 发送数据到服务器

4）s.recv(1024) 接收服务器数据

5）s.close() 关闭链接

一个简单的聊天代码：

#服务器
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
HostPort = ('127.0.0.1',8000)    #地址和端口是一个元组，前面的IP是一个字符串，用引号引起来
sk.bind(HostPort)   #bind的参数是一个元组，如果不创建上面的address的话，使用sk.bind(('127.0.0.1',8000))也是可以的
sk.listen(3)    #括号内为最大挂起连接数

while True:
    conn, addr = sk.accept()
    while True:
        try:
            data = conn.recv(1024)  #收到空时，recv将断续阻塞;对方正常退出时也会发送空，但会往下执行,正常退出指通过sk.close()退出，正常退出后此行命令将失效
            if  data:
                print('......',str(data,'utf8'))
            else:
                conn.close()
                break
        except Exception:
            break
        inp = input('>>>:')
        conn.send(bytes(inp,'utf8'))

#客户端
import socket
sk = socket.socket()    #这个socket后面的括号不能忘记加，不加括号pycharm也不会显示为错误
sk.connect(('127.0.0.1',8000))

while True:
    inp = input('>>>:')
    if inp =='exit':
        break
    sk.send(bytes(inp,'utf8'))　　# 可以发送空，发送空后代码继续往下执行，但是对方不会向下执行，recv仍阻塞
    data = sk.recv(1024)
    print(str(data, 'utf8'))

远程执行命令代码：

#服务器端
import socket
import subprocess
sk = socket.socket()
HostPort = ('127.0.0.1',8080)
sk.bind(HostPort)
sk.listen(3)
while 1:
    conn,addr = sk.accept()
    while 1:
        try:
            data = conn.recv(1024)
        except:
            break
        if data:
            obj = subprocess.Popen(str(data,'gbk').strip(),shell=True,stdout=subprocess.PIPE)
            cmd_result = obj.stdout.read()
            result_len = len(cmd_result)
            conn.send(bytes(str(result_len),'gbk'))
            conn.recv(1024)
            conn.send(cmd_result)
        else:break

#客户端
import socket
sk = socket.socket()
addr = ('127.0.0.1',8080)
sk.connect(addr)
while 1:
    inp = input('>>>>>:')
    if inp == 'exit':
        sk.close()
        break
    sk.send(bytes(inp,'gbk'))
    result_len = sk.recv(1024)
    sk.send(bytes('a','gbk'))
    recv_len = int(str(result_len,'gbk'))
    content = bytes()
    while recv_len!=len(content):
        data = sk.recv(1024)
        content += data
        lengh = len(content)
    print(str(content,'gbk'))

远程执行代码第二次写感悟：

服务器端----------------------------------------
import socket
import subprocess

sk = socket.socket()
host_port = ("127.0.0.1", 8000)
sk.bind(host_port)
sk.listen(3)
while True:
    conn, addr = sk.accept()
    while True:
        try:
            data = conn.recv(1024)
        except Exception:
            break
        if not data:
            break
        obj = subprocess.Popen(str(data, "utf8"), shell=True, stdout=subprocess.PIPE)
        cmd_result = obj.stdout.read()  # 只能调用一次，再调用就没内容了，特别注意，取出来的是bytes类型，而非字符串。
        print(cmd_result)   # b'C:\\Users\\Lowry\\PycharmProjects\\\xb5\xda\xb6\xfe\xb2\xbf\xb7\xd6\\\xcd\xf8\xc2\xe7\xb1\xe0\xb3\xcc\r\n'
        # aaa = obj.stdout.read()
        # print(aaa)   # b'' 再次证明只能调用一次，第二次就取不到内容了。
        result_len = bytes(str(len(cmd_result)),"utf8")
        conn.send(result_len)
        conn.recv(1024)   #处理粘包的措施
        conn.sendall(cmd_result)
    conn.close()

客户端--------------------------------------------------------------
import socket

sk = socket.socket()
dest_host_port = ("127.0.0.1", 8000)
sk.connect(dest_host_port)
while True:
    inp = input(">>>>:")
    if inp == "exit":
        break
    sk.send(bytes(inp, "utf8"))
    result_len = sk.recv(1024)
    data = bytes()
    sk.send(bytes("处理粘包用的！","utf8"))
    while int(str(result_len, "utf8")) != len(data):
        result = sk.recv(1024)
        data += result
    print(str(data, "gbk"))
sk.close()

另外在计算长度的时候，一定要同一种类型比较，str和bytes两种len()出来的长度不一样。

s = "hello世界"
print(len(s))   #

b = s.encode("utf8")
print(len(b))   # 11