python Socket网络编程 基础

内容概要

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实例

import socket

target_host = 'localhost'
target_port = 9999

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

client.connect((target_host, target_port))

while True:
    msg = input('>>>').strip()
    if len(msg) == 0:continue
    if msg == 'q':break
    client.send(msg.encode('utf-8'))
    response = client.recv(4096)
    print(response)
    
client.close()

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

import socket

HOST = 'localhost'
PORT = 9999
# 建立一个socket对象
server = socket.socket()
# 绑定host,port
server.bind((HOST, PORT))
# 开始监听
server.listen(5)
# 等待客户端连接
conn, addr = server.accept()
# 接受数据
data = conn.recv(1024)
# 打印数据
print(data)
# 关闭server
server.close()

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

import socket

HOST = 'localhost'
PORT = 9999
# 建立一个socket对象
server = socket.socket()
# 绑定host,port
server.bind((HOST, PORT))
# 开始监听
server.listen(5)
# 等待客户端连接
conn, addr = server.accept()
# 接受数据

while True:
    data = conn.recv(1024)
    if not data:
        print('客户端断开了')
        break
    print(data)
    conn.send(data.upper())

# 关闭server
server.close()

4.Socket实现多连接处理

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

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

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

import socket

HOST = 'localhost'
PORT = 9999

server = socket.socket()

server.bind((HOST, PORT))

server.listen(5)

while True:

    conn, addr = server.accept()

    while True:
        data = conn.recv(1024)
        if not data:
            print('客户端断开了')
            break
        print(data)
        conn.send(data.upper())

# 关闭server
server.close()

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

5.通过socket实现简单的ssh

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

import socket
import os

bind_ip = '0.0.0.0'
bind_port = 9999

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((bind_ip, bind_port))

server.listen()

while True:
    print('[*] Listening on %s:%s' % (bind_ip, bind_port))
    conn, addr = server.accept()
    print('[*] conn from %s:%s' % addr)
    while True:
        request = conn.recv(1024)
        if not request:
            print('[*] Client is closed')
            break
        print('[*] Execute the cmd: %s' % request)
        cmd_res = os.popen(request.decode()).read()
        if len(cmd_res) == 0:
            cmd_res = '[*] CMD is not output...'
        # 先发送大小,bytes状态大小,
        conn.send(str(len(cmd_res.encode())).encode())
        # 2次send数据中间等待客户端确认,解决粘包问题
        client_ack = conn.recv(1024)
        conn.send(cmd_res.encode())
        print('[*] Send down')

上面 socket ssh server

import socket

target_host = 'localhost'
target_port = 9999

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((target_host, target_port))

while True:
    cmd = input('>>:').strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode())
    # 接受数据总大小
    res_size = client.recv(1024)
    # 响应服务端,解决粘包问题
    client.send('start send'.encode())
    print('[*] Res_size:', res_size)
    # 文件大小都是bytes状态大小,和服务器发过来的大小在同一状态
    received_size = 0
    while received_size < int(res_size):
        data = client.recv(1024)
        # 每次收到的有可能小于1024
        received_size += len(data)
        print(data.decode())
    else:
        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."