python Socket网络编程 基础

Posted 2020-10-01

内容概要

1. Socket介绍
2. Socket参数介绍
3. 基本Socket实例
4. Socket实现多连接处理
5. 通过Socket实现简单SSH
6. 通过Socket实现文件传送

1. Socket介绍

Socket Families(地址簇)

socket.AF_UNIX unix本机进程间通信 

socket.AF_INET　IPV4　

socket.AF_INET6  IPV6

 

Socket Types

socket.SOCK_STREAM  #for tcp

socket.SOCK_DGRAM   #for udp 

socket.SOCK_RAW     #原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。

socket.SOCK_RDM  #是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。

socket.SOCK_SEQPACKET #废弃了

 

2. Socket 参数介绍

socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)   #实例化一个socket 必会 

socket.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0)    #获取要连接的对端主机地址 必会

返回值：[(family, socktype, proto, canonname, sockaddr)]有元组组成的列表，元组里面包含5个元素,其中sockaddr是(host,port)

• family: 表示socket使用的协议簇。常用的协议簇包括AF_UNIX(本机通信）/AF_INET（TCP/IP协议簇中的IPv4协议）/AF_INET6（TCP/IP协议簇中的IPv6协议）。在python的socket包中，用1表示AF_UNIX，2表示AF_INET，10表示AF_INET6。
• sockettype：表示socket的类型。常见的socket类型包括SOCK_STREAM（TCP流）/SOCK_DGRAM（UDP数据报）/SOCK_RAW（原始套接字）。其中，SOCK_STREAM=1，SOCK_DGRAM=2，SOCK_RAW=3
• proto：顾名思义，就是指定协议。套接口所用的协议。如调用者不想指定，可用0。常用的协议有，IPPROTO_TCP(=6)和IPPTOTO_UDP(=17)，它们分别对应TCP传输协议、UDP传输协议。

>>> import socket
>>> socket.getaddrinfo(‘www.baodu.com‘,80)
[(<AddressFamily.AF_INET: 2>, 0, 0, ‘‘, (‘115.29.223.128‘, 80))]

s = socket.socket()   # 默认就使用 family=AF_INET, type=SOCK_STREAM

s.bind(address) 必会

　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

s.listen(backlog) 必会

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

      backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
      这个值不能无限大，因为要在内核中维护连接队列

s.setblocking(bool) 必会

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

s.accept() 必会

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

s.connect(address) 必会

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

s.close() 必会

　　关闭套接字

s.recv(bufsize[,flag]) 必会

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

s.send(string[,flag]) 必会

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

s.sendall(string[,flag]) 必会

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

      内部通过递归调用send，将所有内容发送出去。

s.settimeout(timeout) 必会

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

s.getpeername()  

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

s.getsockname() 

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

s.fileno() 

　　套接字的文件描述符

3. 基本Socket实例

 

 1 import socket
 2 
 3 target_host = ‘localhost‘
 4 target_port = 9999
 5 
 6 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 7 
 8 client.connect((target_host, target_port))
 9 
10 while True:
11     msg = input(‘>>>‘).strip()
12     if len(msg) == 0:continue
13     if msg == ‘q‘:break
14     client.send(msg.encode(‘utf-8‘))
15     response = client.recv(4096)
16     print(response)
17     
18 client.close()

以上是socket客户端支持多交互

 

 1 import socket
 2 
 3 HOST = ‘localhost‘
 4 PORT = 9999
 5 # 建立一个socket对象
 6 server = socket.socket()
 7 # 绑定host,port
 8 server.bind((HOST, PORT))
 9 # 开始监听
10 server.listen(5)
11 # 等待客户端连接
12 conn, addr = server.accept()
13 # 接受数据
14 data = conn.recv(1024)
15 # 打印数据
16 print(data)
17 # 关闭server
18 server.close()

上面是一个最基本的server端,只能建立一个链接,再接受一次客户端的data后就结束了. 需要多次交互只需加个while循环

 

 1 import socket
 2 
 3 HOST = ‘localhost‘
 4 PORT = 9999
 5 # 建立一个socket对象
 6 server = socket.socket()
 7 # 绑定host,port
 8 server.bind((HOST, PORT))
 9 # 开始监听
10 server.listen(5)
11 # 等待客户端连接
12 conn, addr = server.accept()
13 # 接受数据
14 
15 while True:
16     data = conn.recv(1024)
17     if not data:
18         print(‘客户端断开了‘)
19         break
20     print(data)
21     conn.send(data.upper())
22 
23 # 关闭server
24 server.close()

 

4.Socket实现多连接处理

上面的代码虽然实现了服务端与客户端的多次交互，但是你会发现，如果客户端断开了， 服务器端也会跟着立刻断开，因为服务器只有一个while 循环，客户端一断开，服务端收不到数据 ，就会直接break跳出循环，然后程序就退出了，这显然不是我们想要的结果 ，我们想要的是，客户端如果断开了，我们这个服务端还可以为下一个客户端服务，它不能断，她接完一个客，擦完嘴角的遗留物，就要接下来勇敢的去接待下一个客人。 在这里如何实现呢？

 1 conn,addr = server.accept() #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来... 

我们知道上面这句话负责等待并接收新连接，对于上面那个程序，其实在while break之后，只要让程序再次回到上面这句代码这，就可以让服务端继续接下一个客户啦。 

 1 import socket
 2 
 3 HOST = ‘localhost‘
 4 PORT = 9999
 5 
 6 server = socket.socket()
 7 
 8 server.bind((HOST, PORT))
 9 
10 server.listen(5)
11 
12 while True:
13 
14     conn, addr = server.accept()
15 
16     while True:
17         data = conn.recv(1024)
18         if not data:
19             print(‘客户端断开了‘)
20             break
21         print(data)
22         conn.send(data.upper())
23 
24 # 关闭server
25 server.close()

注意了， 此时服务器端依然只能同时为一个客户服务，其客户来了，得排队(连接挂起)

 

5.通过socket实现简单的ssh

光只是简单的发消息、收消息没意思，干点正事，可以做一个极简版的ssh，就是客户端连接上服务器后，让服务器执行命令，并返回结果给客户端。

 1 import socket
 2 import os
 3 
 4 bind_ip = ‘0.0.0.0‘
 5 bind_port = 9999
 6 
 7 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 8 server.bind((bind_ip, bind_port))
 9 
10 server.listen()
11 
12 while True:
13     print(‘[*] Listening on %s:%s‘ % (bind_ip, bind_port))
14     conn, addr = server.accept()
15     print(‘[*] conn from %s:%s‘ % addr)
16     while True:
17         request = conn.recv(1024)
18         if not request:
19             print(‘[*] Client is closed‘)
20             break
21         print(‘[*] Execute the cmd: %s‘ % request)
22         cmd_res = os.popen(request.decode()).read()
23         if len(cmd_res) == 0:
24             cmd_res = ‘[*] CMD is not output...‘
25         # 先发送大小,bytes状态大小,
26         conn.send(str(len(cmd_res.encode())).encode())
27         # 2次send数据中间等待客户端确认,解决粘包问题
28         client_ack = conn.recv(1024)
29         conn.send(cmd_res.encode())
30         print(‘[*] Send down‘)

上面 socket ssh server

 

 1 import socket
 2 
 3 target_host = ‘localhost‘
 4 target_port = 9999
 5 
 6 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 7 client.connect((target_host, target_port))
 8 
 9 while True:
10     cmd = input(‘>>:‘).strip()
11     if len(cmd) == 0:continue
12     client.send(cmd.encode())
13     # 接受数据总大小
14     res_size = client.recv(1024)
15     # 响应服务端,解决粘包问题
16     client.send(‘start send‘.encode())
17     print(‘[*] Res_size:‘, res_size)
18     # 文件大小都是bytes状态大小,和服务器发过来的大小在同一状态
19     received_size = 0
20     while received_size < int(res_size):
21         data = client.recv(1024)
22         # 每次收到的有可能小于1024
23         received_size += len(data)
24         print(data.decode())
25     else:
26         print(‘[*] Receive done...%s‘ % received_size)

上面 socket ssh client 

very cool , 这样我们就做了一个简单的ssh , 但多试几条命令你就会发现，上面的程序有以下2个问题。 

1. 不能执行top等类似的 会持续输出的命令,这是因为，服务器端在收到客户端指令后，会一次性通过os.popen执行，并得到结果后返回给客户，但top这样的命令用os.popen执行你会发现永远都不会结束，所以客户端也永远拿不到返回。(真正的ssh是通过select 异步等模块实现的，我们以后会涉及)
2. 不能执行像cd这种没有返回的指令， 因为客户端每发送一条指令，就会通过client.recv(1024)等待接收服务器端的返回结果，但是cd命令没有结果 ，服务器端调用conn.send(data)时是不会发送数据给客户端的。 所以客户端就会一直等着，等到天荒地老，结果就卡死了。解决的办法是，在服务器端判断命令的执行返回结果的长度，如果结果为空，就自己加个结果返回给客户端，如写上"cmd exec success, has no output."