TCP握手与socket通信细节

协议与接口

对于程式开发者而言，几乎每天都需要和协议和接口打交道，尽管有时候很少直接使用他们。开发一个应用程序，为了提高开发效率，往往会选择一个框架/库来进行开发，于是乎不可避免的就需要了解框架的API接口。协议往往是一些底层的通信规则，框架的最大职能就是实现和解析这些协议，并指定一套简洁的接口提供给开发者使用。

对于web编程，TCP，HTTP协议最熟悉不过了。TCP握手与挥手中，我们了解了TCP连接相关的具体状态细节。这些算是协议上的规定，对于程式而言，需要如何实现这些协议的从而提供接口呢？所幸，socket的为网络通信协议提供了编程接口。下面就来讨论tcp连接中的socket编程。

socket编程

socket就是不同计算机之间进行通信的一个抽象。socket是两个节点之间的数据传输，端点可能处于同一台主机，也可能位于不同的主机中，通常属于C/S架构，一个连接发起者（initiator）另外一个连接侦听者（listener），通常将从事侦听的socket称作“服务器”，将发起连接的套接字称作“客户端”。一图胜千言，下图几位常见的clinet-server通信模型：

tcplab.png

上图中的左边是clinet，右边是server。server的生命周期大致如下：

1. 创建socket。
2. 绑定（bind）地址端口
3. 监听网络连接
4. 接受连接
5. 关闭连接

clinet的生命周期则稍微简单点：

1. 创建socket
2. 绑定地址
3. 发起连接
4. 关闭连接

上述的过程使用python代码也非常简单：
clinet

import socket

address = ('127.0.0.1', 8000)
# 创建 tcp socket
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 发起连接
client.connect(address)
# 发送数据
client.send('hello-world')
# 接受数据
data = client.recv(1024)
print data
# 关闭连接
client.close()

服务端也很简单

import socket

address = ('127.0.0.1', 8000)
# 创建 tcp socket
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定地址
server.bind(address)
# 监听
server.listen(5)

while True:
    # 获取连接
    conn, addr = server.accept()
    while True:
        # 读取数据
        data = conn.recv(1024)
        # 发送数据给客户端
        conn.sendall(data)
        if not data:
            # 关闭连接
            conn.close()
            break
# 关闭socket
server.close()

运行服务端server.py 服务端将会开启一个无限循环的监听，与客户端创建连接之后，进行数据交互，然后关闭连接，同时进入下一个生命周期的监听。

对于clinet的代码，发现我们并没有显示的绑定地址。对于服务器，绑定固定的端口，用于监听，客户端如果没有绑定，操作系统会自动分配绑定一个端口

socket与握手细节

从最上面的网络模型图看出，握手的连接发生在客户端connect，服务端的accept返回连接。握手的细节其实是客户端connet和服务端的listen过程，而accept只是返回队列里的连接。下面通过nc和wireshaker抓包来分析tcp三次握手和socket的通信细节。

clinet创建socket，server尚未bind地址

server如果尚未绑定地址，clinet就发起连接，将会收到一个RST拒绝连接的包。修改server.py运行

import socket
import time

address = ('127.0.0.1', 8000)
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)

while True:
    print 'sleep'
    time.sleep(1)

clinet运行之后，connect调用之后触发了一个异常，程序退出。查看连接情况如下：

☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1

可见并没有创建连接通道，使用wireshaker的抓包如下：

1.png

这个过程对于客户端是

1. 客户端发送一个握手包(SYN Seq)
2. 端口直接返回（RST, ACK）拒绝连接

server绑定地址

接下来把server的地址进行绑定，但是尚未监听。运行服务端

import socket
import time

address = ('127.0.0.1', 8000)
# 创建 tcp socket
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定地址
server.bind(address)

while True:
    print 'sleep'
    time.sleep(1)

使用nc查看连接情况

☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.8000         *.*                    CLOSED

然后运行clinet.py代码，这一次并不像之前connect调用就出现异常，而是客户端阻塞了一段时间之后，最后超时退出。查看wireshaker如下：

2.png

1. 客户端发送一个握手包(SYN Seq)
2. 端口没有响应，导致客户端一直重发，此时connect阻塞，直到超时退出(退出进程)。

此时再使用netstat查看会得到如下结果：

☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.55808        127.0.0.1.8000         SYN_SENT
tcp4       0      0  127.0.0.1.8000         *.*                    CLOSED
☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.55808        127.0.0.1.8000         SYN_SENT
tcp4       0      0  127.0.0.1.8000         *.*                    CLOSED
☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.55808        127.0.0.1.8000         SYN_SENT
tcp4       0      0  127.0.0.1.8000         *.*                    CLOSED
☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.8000         *.*                    CLOSED

通过wireshaker和netstat的观察，client发送SYN之后，自身状态编程SYS_SENT，server则一直处于CLOSED。这其实是第一次握手，clinet正等待server的ACK，可惜server并没有呼应，最后clinet超时退出。

server进行listen监听

将server.py加上监听调用，listen接口有一个参数，即连接队列中的连接数，通常设置为5，表示如果创建了连接，就存储再连接队列中，这个队列最大的容量是5。在mac上最大的则是128。

server.py

import socket
import time
address = ('127.0.0.1', 8000)
# 创建 tcp socket
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定地址
server.bind(address)
# 监听
server.listen(5)

while True:
    print 'sleep'
    time.sleep(1)

查看连接状况：

☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.8000         *.*                    LISTEN

可见server处于LISTEM状态。

这次我们使用nc工具来进行交互实验：

☁  ~  nc 127.0.0.1 8000

上述命令等同于connect函数的调用，可见运行nc命令之后，客户端一直被阻塞。一段时间之后，再手动command+c 结束 nc 命令。此时再查看连接状态和抓包：

☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.8000         127.0.0.1.55832        ESTABLISHED
tcp4       0      0  127.0.0.1.55832        127.0.0.1.8000         ESTABLISHED
tcp4       0      0  127.0.0.1.8000         *.*                    LISTEN
☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.8000         127.0.0.1.55832        ESTABLISHED
tcp4       0      0  127.0.0.1.55832        127.0.0.1.8000         ESTABLISHED
tcp4       0      0  127.0.0.1.8000         *.*                    LISTEN
☁  ~  netstat -nat | grep -i "8000" | grep 127.0.0.1
tcp4       0      0  127.0.0.1.8000         127.0.0.1.55832        CLOSE_WAIT
tcp4       0      0  127.0.0.1.55832        127.0.0.1.8000         FIN_WAIT_2
tcp4       0      0  127.0.0.1.8000         *.*

3.png

从netstat和抓包的情况来看，此时client和server进行了三次握手：

1. 客户端发送一个握手包(SYN Seq)，第一次握手，客户端连接状态为 SYS_SEND
2. 服务端端有响应，并发送一个(SYN, ACK)的应答包， 第二次握手 客户端的状态都变成ESTABLISHED表示可以发送数据了
3. 客户端再向服务端发送（ACK）应答包，第三次握手，建立TCP连接，服务端也可以发送数据。
4. 客户端发送一个[FIN, ACK]的包，表示关闭连接。
5. 服务端发送一个[ACK]包表示确定关闭客户端到服务端的连接。客户端到服务端的连接断了。服务端到客户端的连接还保持。

listen&accept函数

通过上述的实验，可见tcp三次握手发生在client的connect调用之后，server端的listen函数调用之后，但是并不是由listen函数完成的，listen()的作用仅仅告诉内核一些信息，即连接队列的大小，三次握手是以后内核完成的。一旦完成了三次握手，内核就把连接放入连接队列之中。

当socket对象调用accpet函数的时候，就从连接队列中将tcp连接取出并返回。如果连接队列中没有连接，那么accept函数调用将会阻塞（如果socket是非阻塞模式，accept此时会返回，并触发一个异常）。

上述的代码listen只设置了5，如果连接同事超过了5个会怎么样呢？对于unix，server不会对再对建立新连接的握手进行应答，clinet的 connect 就会返回 ETIMEDOUT。可是在linux中server并不会拒绝连接，只是会延时连接，然后accept调用的时候却未必能把已经建立好的连接全部取出来。

总结

tcp握手的系统调用有 connect bind listen函数。python封装的api和C的很像。客户端connect发起握手，接受到服务器的ack应答返回。server在listen调用之后创建连接队列，同时监听端口，客户端connect发起的syn送达，在服务器的内核完成握手。只有当server端调用accept，才从连接队列中取tcp连接，如果连接队列中还没有握手后的连接，那么aceept调用在socket阻塞模式中就会阻塞，在非阻塞模式中则会返回异常错误。