C 为什么客户端不关闭其套接字？

我正在阅读APUE的一个套接字客户端示例。我没有发现它关闭或关闭它的插座。客户机通常不必关闭其套接字文件描述符，这是真的吗？客户端何时需要关闭其套接字文件描述符，何时不需要

为了进行比较，其服务器在最后关闭套接字：

客户：

#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <sys/socket.h>

#define MAXADDRLEN  256
#define BUFLEN      128

extern int connect_retry(int, const struct sockaddr *, socklen_t);

void
print_uptime(int sockfd)
{
    int n;
    char buf[BUFLEN];

    while ((n = recv(sockfd, buf, BUFLEN, 0)) > 0)
        write(STDOUT_FILENO, buf, n);
    if (n < 0)
        err_sys("recv error");
}

int
main(int argc, char *argv[])
{
    struct addrinfo *ailist, *aip;
    struct addrinfo hint;
    int sockfd, err;

    if (argc != 2)
        err_quit("usage: ruptime hostname");
    hint.ai_flags = 0;
    hint.ai_family = 0;
    hint.ai_socktype = SOCK_STREAM;
    hint.ai_protocol = 0;
    hint.ai_addrlen = 0;
    hint.ai_canonname = NULL;
    hint.ai_addr = NULL;
    hint.ai_next = NULL;
    if ((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0)
        err_quit("getaddrinfo error: %s", gai_strerror(err));
    for (aip = ailist; aip != NULL; aip = aip->ai_next) {
        if ((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0)
            err = errno;
        if (connect_retry(sockfd, aip->ai_addr, aip->ai_addrlen) < 0) {
            err = errno;
        } else {
            print_uptime(sockfd);
            exit(0);
        }
    }
    fprintf(stderr, "can't connect to %s: %s\n", argv[1], strerror(err));
    exit(1);
}

#包括“apue.h”
#包括
#包括
#包括
#定义MAXADDRLEN 256
#定义BUFLEN 128
外部连接重试（int，const struct sockaddr*，socklen\u t）；
无效的
打印正常运行时间（int sockfd）
{
int n；
char-buf[BUFLEN]；
而（（n=recv（sockfd，buf，BUFLEN，0））>0）
写入（标准文件号，buf，n）；
if（n<0）
err_系统（“recv错误”）；
}
int
main（int argc，char*argv[]）
{
结构addrinfo*ailist，*aip；
结构addrinfo提示；
int sockfd，err；
如果（argc！=2）
err_quit（“用法：ruptime主机名”）；
hint.ai_flags=0；
hint.ai_family=0；
hint.ai_socktype=SOCK_流；
hint.ai_协议=0；
hint.ai_addrlen=0；
hint.ai_canonname=NULL；
hint.ai_addr=NULL；
hint.ai_next=NULL；
if（（err=getaddrinfo（argv[1]，“ruptime”，&hint，&ailist））！=0）
err_quit（“getaddrinfo错误：%s”，gai_strerror（err））；
for（aip=ailist；aip！=NULL；aip=aip->ai_next）{
如果（（sockfd=socket（aip->ai_族，SOCK_流，0））<0）
err=errno；
如果（连接重试（sockfd，aip->ai_addr，aip->ai_addrlen）<0）{
err=errno；
}否则{
打印正常运行时间（sockfd）；
出口（0）；
}
}
fprintf（stderr，“无法连接到%s:%s\n”，argv[1]，strerror（err））；
出口（1）；
}

服务器：

#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <sys/socket.h>

#define BUFLEN  128
#define QLEN 10

#ifndef HOST_NAME_MAX
#define HOST_NAME_MAX 256
#endif

extern int initserver(int, struct sockaddr *, socklen_t, int);

void
serve(int sockfd)
{
    int clfd;
    FILE *fp;
    char buf[BUFLEN];

    for (;;) {
        clfd = accept(sockfd, NULL, NULL);
        if (clfd < 0) {
            syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
            exit(1);
        }
        if ((fp = popen("/usr/bin/uptime", "r")) == NULL) {
            sprintf(buf, "error: %s\n", strerror(errno));
            send(clfd, buf, strlen(buf), 0);
        } else {
            while (fgets(buf, BUFLEN, fp) != NULL)
                send(clfd, buf, strlen(buf), 0);
            pclose(fp);
        }
        close(clfd);
    }
}

int
main(int argc, char *argv[])
{
    struct addrinfo *ailist, *aip;
    struct addrinfo hint;
    int sockfd, err, n;
    char *host;

    if (argc != 1)
        err_quit("usage: ruptimed");
#ifdef _SC_HOST_NAME_MAX
    n = sysconf(_SC_HOST_NAME_MAX);
    if (n < 0)                  /* best guess */
#endif
        n = HOST_NAME_MAX;
    host = malloc(n);
    if (host == NULL)
        err_sys("malloc error");
    if (gethostname(host, n) < 0)
        err_sys("gethostname error");
    daemonize("ruptimed");
    hint.ai_flags = AI_CANONNAME;
    hint.ai_family = 0;
    hint.ai_socktype = SOCK_STREAM;
    hint.ai_protocol = 0;
    hint.ai_addrlen = 0;
    hint.ai_canonname = NULL;
    hint.ai_addr = NULL;
    hint.ai_next = NULL;
    if ((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0) {
        syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s",
               gai_strerror(err));
        exit(1);
    }
    for (aip = ailist; aip != NULL; aip = aip->ai_next) {
        if ((sockfd = initserver(SOCK_STREAM, aip->ai_addr,
                                 aip->ai_addrlen, QLEN)) >= 0) {
            serve(sockfd);
            exit(0);
        }
    }
    exit(1);
}

#包括“apue.h”
#包括
#包括
#包括
#包括
#定义BUFLEN 128
#定义QLEN 10
#ifndef主机\u名称\u最大值
#定义主机名最多256个
#恩迪夫
extern int initserver（int，结构sockaddr*，socklen\u t，int）；
无效的
发球（内线）
{
int clfd；
文件*fp；
char-buf[BUFLEN]；
对于（；；）{
clfd=接受（sockfd，NULL，NULL）；
如果（clfd<0）{
syslog（LOG_ERR，“中断时间：接受错误：%s”，strerror（errno））；
出口（1）；
}
if（（fp=popen（“/usr/bin/uptime”，“r”））==NULL）{
sprintf（buf，“错误：%s\n”，strerror（errno））；
发送（clfd、buf、strlen（buf）、0）；
}否则{
while（fgets（buf，BUFLEN，fp）！=NULL）
发送（clfd、buf、strlen（buf）、0）；
pclose（fp）；
}
关闭（clfd）；
}
}
int
main（int argc，char*argv[]）
{
结构addrinfo*ailist，*aip；
结构addrinfo提示；
int sockfd，err，n；
字符*主机；
如果（argc！=1）
err_quit（“用法：ruptimed”）；
#ifdef_SC_HOST_NAME_MAX
n=sysconf（_SC_HOST_NAME_MAX）；
如果（n<0）/*最佳猜测*/
#恩迪夫
n=主机名称\u最大值；
主机=malloc（n）；
if（主机==NULL）
错误系统（“malloc错误”）；
if（gethostname（主机，n）<0）
err_sys（“gethostname错误”）；
daemonize（“破裂”）；
hint.ai_flags=ai_CANONNAME；
hint.ai_family=0；
hint.ai_socktype=SOCK_流；
hint.ai_协议=0；
hint.ai_addrlen=0；
hint.ai_canonname=NULL；
hint.ai_addr=NULL；
hint.ai_next=NULL；
if（（err=getaddrinfo（主机，&ruptime，&hint，&ailist））！=0）{
系统日志（日志错误，“中断时间：getaddrinfo错误：%s”，
盖乌斯特雷罗(呃),；
出口（1）；
}
for（aip=ailist；aip！=NULL；aip=aip->ai_next）{
如果（（sockfd=initserver）（SOCK_流，aip->ai_addr，
aip->ai_addrlen，QLEN））>=0）{
发球（sockfd）；
出口（0）；
}
}
出口（1）；
}

客户机通常不必关闭其套接字文件描述符，这是真的吗

不，这不是真的

这种想法的一种变体导致了早期Microsoft Internet Explorer浏览器（版本1到5）中的许多keepalive问题，这些问题必须在服务器端解决。（本质上，操作系统无法确保正确、完整的操作。）

但是，如果进程即将退出，那么不关闭所有套接字不是一个bug，因为POSIX.1（定义此功能的标准和此处使用的C接口）明确表示（例如）当进程退出时，所有打开的流都将关闭。理论上，这与动态内存分配的情况类似：进程退出时不需要

释放（）

所有动态分配的内存，因为所有（非共享）动态分配的内存在进程退出时都会自动释放

实际上，显式关闭所有套接字描述符要健壮得多。这对于TCP连接尤其如此，因为连接终止涉及FIN和ACK数据包交换。虽然人们可以相信操作系统总是正确的，但MSIE的例子表明，现实并不那么可信，彻底的操作会带来更好的用户体验

客户端何时需要关闭其套接字文件描述符，何时不需要

实践中有两种情况：

当连接终止时

描述符是一种有限的资源，一旦不再需要就关闭它们可以确保资源不会被浪费。保持套接字连接打开的时间超过必要的时间确实没有什么好的理由。某些事情，例如使用遍历文件系统层次结构，当它们可以使用大量的描述符时，效率要高得多，因此注意进程不会因为程序员的懒惰而耗尽描述符是一个好主意。

当通过

fork（）

创建子进程时，该子进程不应访问该套接字连接

当前的Linux、MacOS、FreeBSD和OpenBSD至少支持关闭exec标志（通常通过

fcntl（sfd、F_SETFD、FD_CLOEXEC）

）。在Linux中，您可以创建close-on-exec套接字descr