开发者社区> 行者武松> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Socket编程实战

简介:
+关注继续查看

Socket 在英文中的含义为“(连接两个物品的)凹槽”,像the eye socket,意为“眼窝”,此外还有“插座”的意思。在计算机科学中,socket 通常是指一个连接的两个端点,这里的连接可以是同一机器上的,像unix domain socket,也可以是不同机器上的,像network socket。

本文着重介绍现在用的最多的 network socket,包括其在网络模型中的位置、API 的编程范式、常见错误等方面,最后用 Python 语言中的 socket API 实现几个实际的例子。Socket 中文一般翻译为“套接字”,不得不说这是个让人摸不着头脑的翻译,我也没想到啥“信达雅”的翻译,所以本文直接用其英文表述。本文中所有代码均可在 socket.py 仓库中找到。

概述

Socket 作为一种通用的技术规范,首次是由 Berkeley 大学在 1983 为 4.2BSD Unix 提供的,后来逐渐演化为 POSIX 标准。Socket API 是由操作系统提供的一个编程接口,让应用程序可以控制使用 socket 技术。Unix 哲学中有一条一切皆为文件,所以 socket 和file 的 API 使用很类似:可以进行read、write、open、close等操作。

现在的网络系统是分层的,理论上有OSI模型,工业界有TCP/IP协议簇。其对比如下:

每层上都有其相应的协议,socket API 不属于TCP/IP协议簇,只是操作系统提供的一个用于网络编程的接口,工作在应用层与传输层之间:

我们平常浏览网站所使用的http协议,收发邮件用的smtp与imap,都是基于 socket API 构建的。

一个 socket,包含两个必要组成部分:

  1. 地址,由 ip 与 端口组成,像192.168.0.1:80。
  2. 协议,socket 所是用的传输协议,目前有三种:TCP、UDP、raw IP。

地址与协议可以确定一个socket;一台机器上,只允许存在一个同样的socket。TCP 端口 53 的 socket 与 UDP 端口 53 的 socket 是两个不同的 socket。

根据 socket 传输数据方式的不同(使用协议不同),可以分为以下三种:

  1. Stream sockets,也称为“面向连接”的 socket,使用 TCP 协议。实际通信前需要进行连接,传输的数据没有特定的结构,所以高层协议需要自己去界定数据的分隔符,但其优势是数据是可靠的。
  2. Datagram sockets,也称为“无连接”的 socket,使用 UDP 协议。实际通信前不需要连接,一个优势时 UDP 的数据包自身是可分割的(self-delimiting),也就是说每个数据包就标示了数据的开始与结束,其劣势是数据不可靠。
  3. Raw sockets,通常用在路由器或其他网络设备中,这种 socket 不经过TCP/IP协议簇中的传输层(transport layer),直接由网络层(Internet layer)通向应用层(Application layer),所以这时的数据包就不会包含 tcp 或 udp 头信息。

Python socket API

Python 里面用(ip, port)的元组来表示 socket 的地址属性,用AF_*来表示协议类型。

数据通信有两组动词可供选择:send/recv 或 read/write。read/write 方式也是 Java 采用的方式,这里不会对这种方式进行过多的解释,但是需要注意的是:

read/write 操作的具有 buffer 的“文件”,所以在进行读写后需要调用flush方法去真正发送或读取数据,否则数据会一直停留在缓冲区内。

TCP socket

TCP socket 由于在通向前需要建立连接,所以其模式较 UDP socket 负责些。具体如下:

每个API 的具体含义这里不在赘述,可以查看手册,这里给出 Python 语言的实现的 echo server。


  1. # echo_server.py 
  2. # coding=utf8 
  3. import socket 
  4.  
  5. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
  6. # 设置 SO_REUSEADDR 后,可以立即使用 TIME_WAIT 状态的 socket 
  7. sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 
  8. sock.bind(('', 5500)) 
  9. sock.listen(5)  

  1. def handler(client_sock, addr): 
  2.     print('new client from %s:%s' % addr) 
  3.     msg = client_sock.recv(1024) 
  4.     client_sock.send(msg) 
  5.     client_sock.close() 
  6.     print('client[%s:%s] socket closed' % addr) 
  7.  
  8. if __name__ == '__main__'
  9.     while 1: 
  10.         client_sock, addr = sock.accept() 
  11.         handler(client_sock, addr)  

  1. # echo_client.py 
  2. # coding=utf8 
  3. import socket 
  4.  
  5. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
  6. sock.connect(('', 5500)) 
  7. sock.send('hello socket world'
  8. print sock.recv(1024)  

上面简单的echo server 代码中有一点需要注意的是:server 端的 socket 设置了SO_REUSEADDR为1,目的是可以立即使用处于TIME_WAIT状态的socket,那么TIME_WAIT又是什么意思呢?后面在讲解 tcp 状态变更图时再做详细介绍。

UDP socket

UDP socket server 端代码在进行bind后,无需调用listen方法。


  1. # udp_echo_server.py 
  2. # coding=utf8 
  3. import socket 
  4.  
  5. sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 
  6. # 设置 SO_REUSEADDR 后,可以立即使用 TIME_WAIT 状态的 socket 
  7. sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 
  8. sock.bind(('', 5500)) 
  9. # 没有调用 listen 
  10.  
  11. if __name__ == '__main__'
  12.     while 1: 
  13.         data, addr = sock.recvfrom(1024) 
  14.  
  15.         print('new client from %s:%s' % addr) 
  16.         sock.sendto(data, addr) 
  17.  
  18. # udp_echo_client.py 
  19. # coding=utf8 
  20. import socket 
  21.  
  22. udp_server_addr = ('', 5500) 
  23.  
  24. if __name__ == '__main__'
  25.     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 
  26.     data_to_sent = 'hello udp socket' 
  27.     try: 
  28.         sent = sock.sendto(data_to_sent, udp_server_addr) 
  29.         data, server = sock.recvfrom(1024) 
  30.         print('receive data:[%s] from %s:%s' % ((data,) + server)) 
  31.     finally: 
  32.         sock.close()  

常见陷阱

忽略返回值

本文中的 echo server 示例因为篇幅限制,也忽略了返回值。网络通信是个非常复杂的问题,通常无法保障通信双方的网络状态,很有可能在发送/接收数据时失败或部分失败。所以有必要对发送/接收函数的返回值进行检查。本文中的 tcp echo client 发送数据时,正确写法应该如下:


  1. total_send = 0 
  2. content_length = len(data_to_sent) 
  3. while total_send < content_length: 
  4.     sent = sock.send(data_to_sent[total_send:]) 
  5.     if sent == 0: 
  6.         raise RuntimeError("socket connection broken"
  7.     total_send += total_send + sent  

send/recv操作的是网络缓冲区的数据,它们不必处理传入的所有数据。

一般来说,当网络缓冲区填满时,send函数就返回了;当网络缓冲区被清空时,recv 函数就返回。

当 recv 函数返回0时,意味着对端已经关闭。

可以通过下面的方式设置缓冲区大小。


  1. s.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, buffer_size) 

认为 TCP 具有 framing

TCP 不提供 framing,这使得其很适合于传输数据流。这是其与 UDP 的重要区别之一。UDP 是一个面向消息的协议,能保持一条消息在发送者与接受者之间的完备性。

代码示例参考:framing_assumptions

TCP 的状态机

在前面echo server 的示例中,提到了TIME_WAIT状态,为了正式介绍其概念,需要了解下 TCP 从生成到结束的状态机器。(图片来源)

这个状图转移图非常非常关键,也比较复杂,我自己为了方便记忆,对这个图进行了拆解,仔细分析这个图,可以得出这样一个结论,连接的打开与关闭都有被动(passive)与主动(active)两种,主动关闭时,涉及到的状态转移最多,包括FIN_WAIT_1、FIN_WAIT_2、CLOSING、TIME_WAIT。

此外,由于 TCP 是可靠的传输协议,所以每次发送一个数据包后,都需要得到对方的确认(ACK),有了上面这两个知识后,再来看下面的图:(图片来源)

  1. 在主动关闭连接的 socket 调用 close方法的同时,会向被动关闭端发送一个 FIN
  2. 对端收到FIN后,会向主动关闭端发送ACK进行确认,这时被动关闭端处于 CLOSE_WAIT 状态
  3. 当被动关闭端调用close方法进行关闭的同时向主动关闭端发送 FIN 信号,接收到 FIN 的主动关闭端这时就处于 TIME_WAIT 状态
  4. 这时主动关闭端不会立刻转为 CLOSED 状态,而是需要等待 2MSL(max segment life,一个数据包在网络传输中最大的生命周期),以确保被动关闭端能够收到最后发出的 ACK。如果被动关闭端没有收到最后的 ACK,那么被动关闭端就会重新发送 FIN,所以处于TIME_WAIT的主动关闭端会再次发送一个 ACK 信号,这么一来(FIN来)一回(ACK),正好是两个 MSL 的时间。如果等待的时间小于 2MSL,那么新的socket就可以收到之前连接的数据。

前面 echo server 的示例也说明了,处于 TIME_WAIT 并不是说一定不能使用,可以通过设置 socket 的 SO_REUSEADDR 属性以达到不用等待 2MSL 的时间就可以复用socket 的目的,当然,这仅仅适用于测试环境,正常情况下不要修改这个属性。

实战

HTTP UA

http 协议是如今万维网的基石,可以通过 socket API 来简单模拟一个浏览器(UA)是如何解析 HTTP 协议数据的。


  1. #coding=utf8 
  2. import socket 
  3.  
  4. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
  5. baidu_ip = socket.gethostbyname('baidu.com'
  6. sock.connect((baidu_ip, 80)) 
  7. print('connected to %s' % baidu_ip) 
  8.  
  9. req_msg = [ 
  10.     'GET / HTTP/1.1'
  11.     'User-Agent: curl/7.37.1'
  12.     'Host: baidu.com'
  13.     'Accept: */*'
  14. delimiter = '\r\n' 
  15.  
  16. sock.send(delimiter.join(req_msg)) 
  17. sock.send(delimiter) 
  18. sock.send(delimiter) 
  19.  
  20. print('%sreceived%s' % ('-'*20, '-'*20)) 
  21. http_response = sock.recv(4096) 
  22. print(http_response)  

运行上面的代码可以得到下面的输出


  1. --------------------received-------------------- 
  2. HTTP/1.1 200 OK 
  3. Date: Tue, 01 Nov 2016 12:16:53 GMT 
  4. Server: Apache 
  5. Last-Modified: Tue, 12 Jan 2010 13:48:00 GMT 
  6. ETag: "51-47cf7e6ee8400" 
  7. Accept-Ranges: bytes 
  8. Content-Length: 81 
  9. Cache-Control: max-age=86400 
  10. Expires: Wed, 02 Nov 2016 12:16:53 GMT 
  11. Connection: Keep-Alive 
  12. Content-Type: text/html 
  13.  
  14. <html> 
  15. <meta http-equiv="refresh" content="0;url=http://www.baidu.com/"
  16. </html>  

http_response是通过直接调用recv(4096)得到的,万一真正的返回大于这个值怎么办?我们前面知道了 TCP 协议是面向流的,它本身并不关心消息的内容,需要应用程序自己去界定消息的边界,对于应用层的 HTTP 协议来说,有几种情况,最简单的一种时通过解析返回值头部的Content-Length属性,这样就知道body的大小了,对于 HTTP 1.1版本,支持Transfer-Encoding: chunked传输,对于这种格式,这里不在展开讲解,大家只需要知道, TCP 协议本身无法区分消息体就可以了。对这块感兴趣的可以查看 CPython 核心模块 http.client

Unix_domain_socket

UDS 用于同一机器上不同进程通信的一种机制,其API适用与 network socket 很类似。只是其连接地址为本地文件而已。

代码示例参考:uds_server.pyuds_client.py

ping

ping 命令作为检测网络联通性最常用的工具,其适用的传输协议既不是TCP,也不是 UDP,而是 ICMP,利用 raw sockets,我们可以适用纯 Python 代码来实现其功能。

代码示例参考:ping.py

netstat vs ss

netstat 与 ss 是类 Unix 系统上查看 Socket 信息的命令。netstat 是比较老牌的命令,我常用的选择有

  • -t,只显示 tcp 连接
  • -u,只显示 udp 连接
  • -n,不用解析hostname,用 IP 显示主机,可以加快执行速度
  • -p,查看连接的进程信息
  • -l,只显示监听的连接

ss 是新兴的命令,其选项和 netstat 差不多,主要区别是能够进行过滤(通过state与exclude关键字)。


  1. $ ss -o state time-wait -n | head 
  2. Recv-Q Send-Q             Local Address:Port               Peer Address:Port 
  3. 0      0                 10.200.181.220:2222              10.200.180.28:12865  timer:(timewait,33sec,0) 
  4. 0      0                      127.0.0.1:45977                 127.0.0.1:3306   timer:(timewait,46sec,0) 
  5. 0      0                      127.0.0.1:45945                 127.0.0.1:3306   timer:(timewait,6.621ms,0) 
  6. 0      0                 10.200.181.220:2222              10.200.180.28:12280  timer:(timewait,12sec,0) 
  7. 0      0                 10.200.181.220:2222              10.200.180.28:35045  timer:(timewait,43sec,0) 
  8. 0      0                 10.200.181.220:2222              10.200.180.28:42675  timer:(timewait,46sec,0) 
  9. 0      0                      127.0.0.1:45949                 127.0.0.1:3306   timer:(timewait,11sec,0) 
  10. 0      0                      127.0.0.1:45954                 127.0.0.1:3306   timer:(timewait,21sec,0) 
  11. 0      0               ::ffff:127.0.0.1:3306           ::ffff:127.0.0.1:45964  timer:(timewait,31sec,0)  

这两个命令更多用法可以参考:

总结

我们的生活已经离不开网络,平时的开发也充斥着各种复杂的网络应用,从最基本的数据库,到各种分布式系统,不论其应用层怎么复杂,其底层传输数据的的协议簇是一致的。Socket 这一概念我们很少直接与其打交道,但是当我们的系统出现问题时,往往是对底层的协议认识不足造成的,希望这篇文章能对大家编程网络方面的程序有所帮助。


作者:jiacai2050

来源:51CTO

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
套接字Socket编程(下)
Socket,原意插座、插口。写软件程序时,可以想象成一根网线,一头插在客户端,一头插在服务端,然后进行通信。所以通信前,双方都要建立一个Socket。
46 0
socket网络编程
(*´▽`)ノノ在讲网络编程之前,首先要了解下网络的架构。我们都知道TCP/IP网络模型共有7层:第一层网络接口层:将osi的物理层和数据链路层合二为一。物理层 是网络的传输介质层,处于网络的最低层,是网络的载体。
874 0
网络编程socket
Socket socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,对于文件用【打开】【读写】【关闭】模式来操作。
714 0
Socket编程实践(13) --UNIX域协议
UNIX域协议    UNIX域套接字与TCP相比, 在同一台主机上, UNIX域套接字更有效率, 几乎是TCP的两倍(由于UNIX域套接字不需要经过网络协议栈,不需要打包/拆包,计算校验和,...
728 0
C# Socket编程
在.NET技术大系当中,有很多服务编程的技术,比如socket、windows service、.net remoting、message queue、web service、wcf等等,这些技术都往往与网络知识紧密相关,有时还会结合多线程等技术,实现特定的需求。
885 0
socket简单编程
server.c:从客户端读字符,然后将每个字符转换为大写并回送给客户端。 client.c:从命令行参数中获得一个字符串发给服务器,然后接收服务器返回的字符串并打印。   others... 1.该例子不仅功能简单,而且简单到几乎没有什么错误处理,我们知道,系统调用不能保证每次都成功,必须进行出错处理,这样一方面可以保证程序逻辑正常,另一方面可以迅速得到故障信息。 为使
955 0
+关注
行者武松
杀人者,打虎武松也。
17111
文章
2568
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载