TCP shutdown 之后~

摘要

1 API

2 shutdown(sockfd, SHUT_WR)

3 shutdown(sockfd, SHUT_WR)

4 kernel 是怎么做的？

附

摘要

通过 shutdown() 关闭读写操作，会发生什么？具体点呢，考虑两个场景：

场景一：C 发送数据完毕，想调用 shutdown 关闭写操作，这时候 TCP 数据包抓包是否可以看出 C 执行了这个操作；S 往 C 发数据后，C 是否还回 ACK？
场景二：C 读取数据完毕，想调用 shutdown 关闭读操作，这时候 TCP 数据包抓包是否可以看出 C 执行了这个操作？S 继续往 C 发数据，整条 TCP 数据流会发生什么情况？

文中引用 Linux 内核源码基于版本 5.4.259，并做了一些删减以提高可读性。

1 API

先来看下 shutdown 的接口：

NAME
       shutdown - shut down part of a full-duplex connection

SYNOPSIS
       #include <sys/socket.h>

       int shutdown(int sockfd, int how);

DESCRIPTION
       The  shutdown()  call causes all or part of a full-duplex connection on the socket associated with sockfd
       to be shut down.  If how is SHUT_RD, further receptions will be disallowed.  If how is  SHUT_WR,  further
       transmissions will be disallowed.  If how is SHUT_RDWR, further receptions and transmissions will be dis‐
       allowed.

RETURN VALUE
       On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.

shutdown 接口比较简单，仅需只需要传入文件描述符与执行的动作这两个参数即可。

2 shutdown(sockfd, SHUT_WR)

先来看场景一：C 发送数据完毕，想调用 shutdown 关闭写操作，这时候 TCP 数据包抓包是否可以看出 C 执行了这个操作；S 往 C 发数据后，C 是否还回 ACK？

能否看出 C 执行了这个操作呢？那我们需要知道 close 的表现：如果是 close 一个 socket，相当于直接关闭了读写，发 FIN，后续收到包会回 RST。

对于 shutdown 关闭写的场景，，只是关闭了写，那还是可以读的，所以 C 仍然会继续回 ACK，能否看出 C 执行了这个操作呢？关闭写应当会发送一个 FIN，而后续收到数据又会继续回 ACK，所以应该是能区分出来才对？最好的方式就是写个代码验证了：

搞一个 server：

void server_process(int sock)
{
    char buf[10240];

    while (1) {
        ssize_t ret = recv(sock, buf, sizeof(buf), 0);
        if (ret < 0) {
            if (errno != EAGAIN) {
                printf("server recv failed: %s\n", strerror(errno));
                break;
            }
            continue;
        } 

        if (ret == 0) {
            printf("read end!\n");
            break;
        }

        buf[ret] = 0;
        size_t ret_s = send(sock, buf, ret, 0);
        printf("resp:%s %d/%d\n", buf, ret_s, ret);
    }
}

int do_server()
{
    int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock < 0) {
        printf("server socket failed: %s\n", strerror(errno));
        return -1;
    }

    uint32_t ip;
    inet_aton(g_server_ip, (struct in_addr *)&ip);

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = ip;
    addr.sin_port = htons(g_server_port);

    if (bind(sock, (struct sockaddr *)&addr, (socklen_t)sizeof(addr)) < 0) {
        printf("server bind failed: %s\n", strerror(errno));
        return -1;
    }

    if (listen(sock, 10) < 0) {
        printf("listen failed: %s\n", strerror(errno));
        return -1;
    }

    while (1) {
        int new_sock = accept(sock, NULL, NULL);
        if (new_sock < 0) {
            continue;
        }

        server_process(new_sock);
        close(new_sock);
    }

    return 0;
}

有 server 必有 client：

int do_client()
{
    int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock < 0) {
        printf("client socket failed: %s\n", strerror(errno));
        return -1;
    }

    uint32_t ip;
    inet_aton(g_server_ip, (struct in_addr *)&ip);

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = ip;
    addr.sin_port = htons(g_server_port);

    if (connect(sock, (struct sockaddr *)&addr, (socklen_t)sizeof(addr)) < 0) {
        printf("client connect failed: %s\n", strerror(errno));
        return -1;
    }

    char buf[10240];
    int i = 0;
    while (1) {
        int n = snprintf(buf, sizeof(buf), "echo %d", i++);
        size_t ret_s = send(sock, buf, n, 0);
        if (ret_s != n) {
            break;
        }

        //if (shutdown(sock, SHUT_RD) < 0) {
        //    printf("shutdown failed: %s\n", strerror(errno));
        //} 

        ssize_t ret = recv(sock, buf, sizeof(buf), 0);
        if (ret == 0) {
            printf("read end!\n");
            break;
        }
        if (ret < 0) {
            if (errno != EAGAIN) {
                printf("client recv failed: %s\n", strerror(errno));
                break;
            }
            continue;
        }

        buf[ret] = 0;
        printf("resp:%s %d/%d\n", buf, ret, n);
        sleep(1);
    }

    return 0;
}

我们用 client 模拟角色 C，server 模拟角色 S，通过在 client 中添加 shutdown 调用复现场景。修改代码前，默认输出如下：

我们在 client 发送后，shutdown 关闭写，并通过 sleep 阻塞住循环，观察输出与抓包结果：

可以看出，client shutdown 关闭写发了一个 FIN，随后server 回了 length 6 的数据，并且 client 仍然继续响应了 ACK。所以是可以跟 close 关闭 socket 区分开的。

3 shutdown(sockfd, SHUT_WR)

同样的，修改代码，client 发送之后关闭读，修改后 client 代码如下：

int do_client()
{
    int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock < 0) {
        printf("client socket failed: %s\n", strerror(errno));
        return -1;
    }

    uint32_t ip;
    inet_aton(g_server_ip, (struct in_addr *)&ip);

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = ip;
    addr.sin_port = htons(g_server_port);

    if (connect(sock, (struct sockaddr *)&addr, (socklen_t)sizeof(addr)) < 0) {
        printf("client connect failed: %s\n", strerror(errno));
        return -1;
    }

    char buf[10240];
    int i = 0;
    while (1) {
        int n = snprintf(buf, sizeof(buf), "echo %d", i++);
        size_t ret_s = send(sock, buf, n, 0);
        if (ret_s != n) {
            break;
        }

        if (shutdown(sock, SHUT_RD) < 0) {
            printf("shutdown failed: %s\n", strerror(errno));
        } 

        /*ssize_t ret = recv(sock, buf, sizeof(buf), 0);
        if (ret == 0) {
            printf("read end!\n");
            break;
        }
        if (ret < 0) {
            if (errno != EAGAIN) {
                printf("client recv failed: %s\n", strerror(errno));
                break;
            }
            continue;
        }

        buf[ret] = 0;
        printf("resp:%s %d/%d\n", buf, ret, n);*/
        sleep(100);
    }

    return 0;
}

直接看输出：

数据流看不出变化，跟未执行 shutdown 关闭读操作的 TCP 流表现是一样的。

4 kernel 是怎么做的？

直接看下 shutdown 的源码就知道了，用户层调用 shutdown，首先通过系统调用进来，随后调用到 inet 层的 inet_shutdown 函数:

// net/ipv4/af_inet.c
int inet_shutdown(struct socket *sock, int how)
{
	struct sock *sk = sock->sk;
	int err = 0;

	// 一些状态检查
	switch (sk->sk_state) {
	case TCP_CLOSE:
		err = -ENOTCONN;
		/* Hack to wake up other listeners, who can poll for
		   EPOLLHUP, even on eg. unconnected UDP sockets -- RR */
		/* fall through */
	default:
		sk->sk_shutdown |= how;
		if (sk->sk_prot->shutdown)
			sk->sk_prot->shutdown(sk, how);
		break;

	/* Remaining two branches are temporary solution for missing
	 * close() in multithreaded environment. It is _not_ a good idea,
	 * but we have no choice until close() is repaired at VFS level.
	 */
	case TCP_LISTEN:
		if (!(how & RCV_SHUTDOWN))
			break;
		/* fall through */
	case TCP_SYN_SENT:
		err = sk->sk_prot->disconnect(sk, O_NONBLOCK);
		sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
		break;
	}

	// 设置tcp连接状态， 比如从 estab -> fin_wait1
	sk->sk_state_change(sk);
	release_sock(sk);
	return err;
}

我们看已连接场景下的流程，也就是 switch 中的 default分支，这里将 how 动作保存在了 shutdown 标记中，然后继续调用到 tcp 协议自己的 shutdown：

// net/ipv4/tcp.c
void tcp_shutdown(struct sock *sk, int how)
{
	if (!(how & SEND_SHUTDOWN))
		return;

	/* If we've already sent a FIN, or it's a closed state, skip this. */
	if ((1 << sk->sk_state) &
	    (TCPF_ESTABLISHED | TCPF_SYN_SENT |
	     TCPF_SYN_RECV | TCPF_CLOSE_WAIT)) {
		/* Clear out any half completed packets.  FIN if needed. */
		if (tcp_close_state(sk))
			tcp_send_fin(sk);
	}
}

tcp_shutdown 中，首先判断不是关闭写的话，就直接 return 了，所以 shutdown 关闭读，真的就只是记录了一个标记，连 socket 状态也没有发生改变。如果是关闭写，则会走到 tcp_close_state、tcp_send_fin，其实就是将 state 转移到下一个状态，即 FIN_WAIT1:

static const unsigned char new_state[16] = {
  /* current state:        new state:      action:	*/
  [0 /* (Invalid) */]	= TCP_CLOSE,
  [TCP_ESTABLISHED]	= TCP_FIN_WAIT1 | TCP_ACTION_FIN,
  ...
};

static int tcp_close_state(struct sock *sk)
{
	int next = (int)new_state[sk->sk_state];
	int ns = next & TCP_STATE_MASK;

	tcp_set_state(sk, ns);

	return next & TCP_ACTION_FIN;
}

看到这里，我们也能将原理同测试的现象对应起来了，也就那样~