socket编程

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序

而程序的pid是同一台机器上不同进程或者线程的标识

服务端先初始化socket，然后与端口绑定bind(),里面是一个元组，包括自己的IP和端口，然后监听该端口listen，调用accept阻塞，等待客户端连接。如果此时有客户端初始化socket，连接服务端connect，如果连接成功，这是客户端就可以向服务端发送数据请求，服务端接收并处理，并把结果返回给客户端，最后关闭连接，一次交互结束。

'''
套接字类型：基于文件类型的套接字家族和基于网络类型的套接字家族
    AF_UNIX：基于文件类型的套接字家族，基本不用。Unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，
两个套接字进程运行在同一机器以通过访问同一个文件系统间接完成通信
    AF_INET：基于网络类型的套接字家族，用的相对较多，现在多数都是基于网络的。（还有AF_INET6被用于ipv6,
还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是一件被放弃，或者是很少被使用，或者是根本没有实现，
所有地址家族中，AF_INET是使用最广泛的一个，python支持多种地址家族，但是有无我们只关心网络编程，所以大部分时候我们只使用AF_INET）
socket.socket(socket_family,socket_type,protocal=0)
socket_family:套接字家族，一般是AF_INET
socket_type:类型，分为tcp/ip套接字--》socket.SOCK_STREAM（流式协议）、 udp/ip套接字对应--》sock.SOCK_DGRAM（数据报协议）
'''
# import socket
# phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #基于网络通信的tcp/ip协议（流式协议）
# phone.bind(('127.0.0.1',4090))  #必须是元组的形式、IP地址和端口
# phone.listen(5)  # 相当于开机，监听  ，Linux中bakclog的功能    相当于开机了
# print('starting...')
# conn,addr=phone.accept()  #conn基于tcp协议的三次握手的链接，addr就是客户端的地址   #相当于接电话
# print(conn)
# print('client addr',addr)
# client_msg=conn.recv(1024)  #接收1024个字节     相当于收消息
# print('client msg: %s' % client_msg)
# conn.send(client_msg.upper())
# conn.close()
# phone.close()
##################################################################################
# phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
# phone.bind(('127.0.0.1',1080)) #插电话卡
#
# phone.listen(5) #开机，backlog
#
# print('starting....')
# conn,addr=phone.accept() #接电话
# print(conn)
# print('client addr',addr)
# print('ready to read msg')
# client_msg=conn.recv(1024) #收消息
# print('client msg: %s' %client_msg)
# conn.send(client_msg.upper()) #发消息
#
# conn.close()
# phone.close()


#服务端
# import socket
# phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #socket初始化
# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR)  #添加词条语句后可以防止发生端口被占用的报错
# #OSError：【Errno 48】 Address already in use
# #这是由于你的服务端仍然存在四次握手的time_wait状态在占用地址（如果不懂，请深入研究tcp三次握手、四次挥手、syn洪水攻击、服务器高并发情况下会有大量的time_wait状态的优化方法）
#
# phone.bind(('127.0.0.1',8080))  #开放IP地址和端口来标识你的唯一的程序
#
# print('starting')
# while True:  #链接循环
#     #加入链接循环的目的：在一个链接关闭后，可以在开启下一个链接，模拟无限开机
#     phone.listen(5)  # tcp协议的版连接池    backlog
#     conn,addr=phone.accept()   # 等待建立链接，一旦有链接就会获取两个值（基于三次握手获得的链接，客户端的地址）
#     while True:   # 与connde 通信循环
#         try:   #在服务端启动后，客户端连接后，会接收到conn对象，等待接收消息，此时如果客户端异常关闭，，则conn对象无效、
#                #服务端也异常关闭，无法控制因此需要加入异常处理
#             client_msg=conn.recv(1024)  #收1024个字节，
#             if not client_msg:break   #针对Linux系统，如果接受到空消息退出
#             print('cleent msg: %s' % client_msg)
#             conn.send(client_msg.upper())
#         except Exception:   #万能异常
#             break
#
#     conn.close()
# phone.close()

#异常处理应该加在无法控制的地方，如客户端异常关机等
#如int('aaa')这种逻辑问题，可以通过控制输入的‘aaa'类型来人为控制
# age = input('请输入年龄>>:')
# if age.isdigit():
#     age=int(age)
#     if age < 10:
#         print('to young')
# else:
#     print('age must be int')




#######################################
#模拟ssh收发消息执行命令
import struct,json
import socket,subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind(('127.0.0.1',8080))
phone.listen(5)  # tcp协议的版连接池    backlog

while True:
    print('starting')
    conn,addr=phone.accept()
    while True:
        try:
            cmd=conn.recv(1024)
            if not cmd:break
            res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                             stdout=subprocess.PIPE,stderr=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()
            #conn.send(struct.pack('i',len(cmd_res)))  #先发报头
            head_dic={'filename':None,'hash':None,'total_size':len(cmd_res)}
            head_json=json.dumps(head_dic)
            head_bytes=head_json.encode('utf-8')
            conn.send(struct.pack('i',len(head_bytes)))
            conn.send(head_bytes)
            conn.send(cmd_res)

        except Exception:
            break

    conn.close()
phone.close()

知识点

#1、subporcess

import subprocess
#管道连接，
res=subprocess.Popen('ipconfig',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
#将命令在当前系统执行，
print(res.stdout.read().decode('gbk'))
#得到的结果是二进制编码，Windows编码格式为‘gbk'
print(res.stderr.read())

运用struct、dict、json来避免粘包

import struct,json
#可以将特定的类型的对象如int、字符串类型的转换为固定长度的byte类型
#'i'模式就是转换为固定的4个字节长度
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值
#将文件的大小等信息放入一个字典中
head_json=json.dumps(header)
print(type(head_json))
#将文件头json化用于传输
head_bytes=bytes(head_json,encoding='utf-8')
#序列化转换为bytes用于传输
head_len_bytes=struct.pack('i',len(head_bytes))#先将报头的长度转换为固定的四个长度
conn.send(head_len_bytes)#把经过序列化、bytes、后的dict的长度发送过去，告诉对面的需要接收的长度，避免粘包
conn.send(head_bytes)#得到长度后，在接收该长度的报文

#另一端
head_len_struct=conn.recv(4)  #因为发送过来的报头的长度是经过struct转化的，所以只接收4个长度
head_len_bytes=struct.unpack('i',head_len_struct)[0]  #得到结果按struct反pack，0索引处是你的值，即报头的长度
head_bytes=conn.recv(head_len_bytes)  #接收那么长度的报头
head_json=head_bytes.decode('utf-8')  #bytes转换
header=json.loads(head_json)  #反序列化
total_size=header['total_size']  #最后得到需要的信息