第八篇：Socket网络编程

1. Socket介绍

概念

网络套接字是跨计算机网络连接的端点。今天，大多数计算机之间的通信是基于Internet协议的;因此，大多数网络套接字都是Internet套接字。更准确地说，套接字是一个句柄(抽象引用)，本地程序可以将其传递给网络应用程序编程接口(API)来使用连接，例如“在这个套接字上发送数据”。

例如，要通过TCP将“Hello, world!”发送到地址为1.2.3.4的主机的80端口，可以获得一个套接字，将它连接到远程主机，发送字符串，然后关闭套接字。

实现一个socket至少要分以下几步，(伪代码)

Socket socket = getSocket(type = "TCP")  #设定好协议类型
connect(socket, address = "1.2.3.4", port = "80") #连接远程机器
send(socket, "Hello, world!") #发送消息
close(socket) #关闭连接

 套接字API是一种应用程序编程接口(API)，通常由操作系统提供，它允许应用程序控制和使用网络套接字。Internet套接字api通常基于Berkeley套接字标准。在Berkeley sockets标准中，套接字是文件描述符(文件句柄)的一种形式，这是由于Unix的哲学“一切都是文件”，以及套接字和文件之间的类比:您可以读取、写入、打开和关闭它们。

套接字地址是IP地址和端口号的组合，很像电话连接的一端是电话号码和特定扩展名的组合。套接字不需要有地址(例如仅用于发送数据)，但是如果程序将套接字绑定到一个地址，则套接字可用于接收发送到该地址的数据。基于这个地址，internet套接字将传入的数据包发送到适当的应用程序进程或线程。

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

Socket Families(地址簇)，参数一

socket.AF_UNIX unix本机进程间通信，只能够用于单一的Unix系统进程间通信

socket.AF_INET　IPV4　（默认）

socket.AF_INET6  IPV6

这些常量表示地址(和协议)家族，用于套接字()的第一个参数。如果没有定义AF_UNIX常量，则不支持此协议。根据系统的不同，可以使用更多的常量。

Socket Types，参数二

socket.SOCK_STREAM  #for tcp  流式socket , for TCP （默认）


socket.SOCK_DGRAM   #for udp 数据报式socket

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 #废弃了

这些常量表示套接字类型，用于套接字()的第二个参数。根据系统的不同，可以使用更多的常量。(只有SOCK_STREAM和SOCK_DGRAM通常有用。

协议，参数三

0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

2. Socket 参数介绍

socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)

使用给定的地址族、套接字类型和协议号创建一个新的套接字。地址族应该是AF_INET(默认值)、AF_INET6、AF_UNIX、AF_CAN或AF_RDS。套接字类型应该是beSOCK_STREAM(缺省值)、SOCK_DGRAM、SOCK_RAW或其他SOCK_常量之一。协议号通常为零，可以省略，或者在地址家族为AF_CAN的情况下，协议应该是CAN_RAW或CAN_BCM之一。如果指定fileno，则忽略其他参数，导致具有指定文件描述符的套接字返回。与socket.fromfd()不同，fileno将返回相同的套接字，而不是重复的套接字。这可能有助于使用socket.close()关闭分离的套接字。

socket.socketpair([family[, type[, proto]]])

使用给定的地址族、套接字类型和协议号构建一对连接的套接字对象。地址族、套接字类型和协议编号与上面的套接字()函数相同。如果在平台上定义，默认家族是AF_UNIX;否则，默认为AF_INET。

socket.create_connection(address[, timeout[, source_address]])

连接到监听Internet地址的TCP服务(一个2元组(主机、端口))，并返回套接字对象。这是一个比socket.connect()更高级别的函数:如果host是非数字主机名，它将尝试同时为AF_INET和AF_INET6解析它，然后依次尝试连接到所有可能的地址，直到连接成功为止。这使得编写兼容IPv4和IPv6的客户机变得很容易。

传递可选超时参数将在尝试连接之前设置套接字实例的超时。如果没有提供超时，则使用getdefaulttimeout()返回的全局缺省超时设置。

如果提供源地址，source_address必须是一个2元组(主机、端口)，以便套接字在连接之前绑定到它的源地址。如果主机或端口分别为“或0”，则将使用OS默认行为。

sk.bind(address)

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

sk.listen(backlog)

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

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

sk.setblocking(bool)

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

sk.accept()

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

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

sk.connect(address)

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

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　关闭套接字

sk.recv(bufsize[,flag])

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

sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag])

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

sk.sendall(string[,flag])

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

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

sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout)

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

sk.getpeername()

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

sk.getsockname()

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

sk.fileno()

　　套接字的文件描述符

3. Socket实例

 1 import socket
 2 
 3 server = socket.socket() #获得socket实例
 4 
 5 server.bind(("localhost",9998)) #绑定ip port
 6 server.listen()  #开始监听
 7 print("等待客户端的连接...")
 8 conn,addr = server.accept() #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...
 9 print("新连接:",addr )
10 
11 data = conn.recv(1024)
12 print("收到消息:",data)
13 
14 
15 server.close()

socket_server.py

1 import socket
2 
3 client = socket.socket()
4 
5 client.connect(("localhost",9998))
6 
7 client.send(b"hey")
8 
9 client.close()

socket_client.py

实现数据多次交互往返通信实例

socket工作流程：

import socket

client = socket.socket()

client.connect(("localhost",9998))

while True:
    msg = input(">>:").strip()
    if len(msg) == 0:continue
    client.send( msg.encode("utf-8") )

    data = client.recv(1024)
    print("来自服务器:",data)

client.close()

import socket

server = socket.socket() #获得socket实例

server.bind(("localhost",9998)) #绑定ip port
server.listen()  #开始监听
print("等待客户端的连接...")
conn,addr = server.accept() #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...
print("新连接:",addr )
while True:

    data = conn.recv(1024)
    if not data:
        print("客户端断开了...")
        break
    print("收到消息:",data)
    conn.send(data.upper())

server.close()

4.Socket实现多连接处理

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

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

import socket
 
server = socket.socket() #获得socket实例
 
server.bind(("localhost",9998)) #绑定ip port
server.listen()  #开始监听
 
while True: #第一层loop
    print("等待客户端的连接...")
    conn,addr = server.accept() #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...
    print("新连接:",addr )
    while True:
 
        data = conn.recv(1024)
        if not data:
            print("客户端断开了...")
            break #这里断开就会再次回到第一次外层的loop
        print("收到消息:",data)
        conn.send(data.upper())
 
server.close()

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

5.通过socket实现简单的ssh

极简版的ssh，就是客户端连接上服务器后，让服务器执行命令，并返回结果给客户端。

 1 import socket
 2 import os
 3 
 4 
 5 server = socket.socket() #获得socket实例
 6 #server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 7 
 8 server.bind(("localhost",9998)) #绑定ip port
 9 server.listen()  #开始监听
10 
11 while True: #第一层loop
12     print("等待客户端的连接...")
13     conn,addr = server.accept() #接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...
14     print("新连接:",addr )
15     while True:
16 
17         data = conn.recv(1024)
18         if not data:
19             print("客户端断开了...")
20             break #这里断开就会再次回到第一次外层的loop
21         print("收到命令:",data)
22         res = os.popen(data.decode()).read() #py3 里socket发送的只有bytes,os.popen又只能接受str,所以要decode一下
23         print(len(res))
24         conn.send(res.encode("utf-8"))
25 
26 server.close()

socket ssh server

 1 import socket
 2 
 3 client = socket.socket()
 4 
 5 client.connect(("localhost",9998))
 6 
 7 while True:
 8     msg = input(">>:").strip()
 9     if len(msg) == 0:continue
10     client.send( msg.encode("utf-8") )
11 
12     data = client.recv(1024)
13     print(data.decode()) #命令执行结果
14 
15 client.close()

socket ssh client

6. SocketServer

socketserver模块简化了编写网络服务器的任务。

socketserver一共有这么几种类型

class socketserver.TCPServer(server_address, RequestHandlerClass, bind_and_activate=True) 

 这使用Internet TCP协议，它提供了客户机和服务器之间的连续数据流。

class socketserver.UDPServer(server_address, RequestHandlerClass, bind_and_activate=True)

 这使用的是数据报，它是离散的信息包，在传输过程中可能会出现无序或丢失。参数与TCPServer相同。

class socketserver.UnixStreamServer(server_address, RequestHandlerClass, bind_and_activate=True)
class socketserver.UnixDatagramServer(server_address, RequestHandlerClass,bind_and_activate=True)

 这些不常用的类类似于TCP和UDP类，但是使用Unix域套接字;它们在非unix平台上不可用。参数与TCPServer相同。

创建一个socketserver 至少分以下几步:

1、首先，您必须创建一个请求处理程序类，方法是子类化BaseRequestHandlerclass并覆盖它的handle()方法;这个方法将处理传入的请求。
2、其次，您必须实例化其中一个服务器类，并将服务器的地址和请求处理程序类传递给它。
3、然后调用服务器对象的handle_request() orserve_forever()方法来处理一个或多个请求。
4、最后，调用server_close()关闭套接字。

基本的socketserver代码

 1 import socketserver
 2 
 3 class MyTCPHandler(socketserver.BaseRequestHandler):
 4     """
 5     The request handler class for our server.
 6 
 7     It is instantiated once per connection to the server, and must
 8     override the handle() method to implement communication to the
 9     client.
10     """
11 
12     def handle(self):
13         # self.request is the TCP socket connected to the client
14         self.data = self.request.recv(1024).strip()
15         print("{} wrote:".format(self.client_address[0]))
16         print(self.data)
17         # just send back the same data, but upper-cased
18         self.request.sendall(self.data.upper())
19 
20 if __name__ == "__main__":
21     HOST, PORT = "localhost", 9999
22 
23     # Create the server, binding to localhost on port 9999
24     server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
25 
26     # Activate the server; this will keep running until you
27     # interrupt the program with Ctrl-C
28     server.serve_forever()

View Code

但上面的代码，依然不能同时处理多个连接，让你的socketserver并发起来， 必须选择使用以下一个多并发的类

class socketserver.ForkingTCPServer

class socketserver.ForkingUDPServer

class socketserver.ThreadingTCPServer

class socketserver.ThreadingUDPServer

 只需要把下面这句

server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)

 换成下面这个，就可以多并发了，这样，客户端每连进一个来，服务器端就会分配一个新的线程来处理这个客户端的请求

server = socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler)

 粘包及解决方案：

粘包：实际上就是在接受数据时，在接受本次命令执行的数据时同时把上次命令未接受完的数据接受，导致接受数据出错，它发生的原因主要是由于socket缓冲区导致的

解决方案：问题根源在于，在接受端不知道将要传送字节流长度，所以解决粘包的方法是围绕，如何让发送端在发送数据前，将自己要发送字节流大小让接收端知晓，然后接收端来一个死循环接受完所有数据。

更多粘包详情：http://www.cnblogs.com/haiyan123/p/7413412.html