《unix高级环境编程》套接字——基于 socket 的编程

缺乏、安全感 2022-08-14 01:50 211阅读 0赞

基于套接字的连接建立成功之后，就可以进行通信，下面是基于套接字的编程的过程：

![Center][]

在基于 TCP 的通信连接请求过程有三次握手，其过程如下所示：

*  第一次握手：客户端发送syn包(seq=x)到服务器，并进入SYN\_SEND状态，等待服务器确认；
 *  第二次握手：服务器收到syn包，必须确认客户的SYN（ack=x+1），同时自己也发送一个SYN包（seq=y），即SYN+ACK包，此时服务器进入SYN\_RECV状态；
 *  第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=y+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

![Center 1][]

数据传输过程如下图所示：

![Center 2][]

关闭通信时，需要四次挥手过程，如下所示：

*  第一次挥手：主动关闭方发送一个FIN，用来关闭主动方到被动关闭方的数据传送，也就是主动关闭方告诉被动关闭方：我已经不会再给你发数据了(当然，在fin包之前发送出去的数据，如果没有收到对应的ack确认报文，主动关闭方依然会重发这些数据)，但此时主动关闭方还可以接受数据。
 *  第二次挥手：被动关闭方收到FIN包后，发送一个ACK给对方，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号）。
 *  第三次挥手：被动关闭方发送一个FIN，用来关闭被动关闭方到主动关闭方的数据传送，也就是告诉主动关闭方，我的数据也发送完了，不会再给你发数据了。
 *  第四次挥手：主动关闭方收到FIN后，发送一个ACK给被动关闭方，确认序号为收到序号+1，至此，完成四次挥手。

![Center 3][]

下面是基于套接字的编程：

客户端：

/* 基于TCP协议面向连接的客户端进程 */
    
    #include "apue.h"
    #include <netdb.h>
    #include <errno.h>
    #include <sys/socket.h>
    #include "connectre.h"
    
    /* 地址的最长大小 */
    #define MAXADDRLEN 256
    /* 缓冲区大小 */
    #define BUFLEN 128
    
    /* 外部函数定义，该函数功能是实现套接字连接 */
    //extern int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t len);
    
    /* 打印客户端所接收的数据信息 */
    void print_uptime(int sockfd);
    
    int main(int argc, char *argv[])
    {
        struct addrinfo *ailist, *aip;
        struct addrinfo hint;
    
        int sockfd, err;
        if(argc != 2)
            err_quit("usage: %s hostname", argv[0]);
        /* 初始化addrinfo结构变量hint */
        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;/* 表示只有一个addrinfo链表结构 */
    
        /* 将主机名和服务名映射到一个地址 */
        if((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0)
            err_quit("getaddrinfo error: %s", gai_strerror(err));
        /* 对每个结构addrinfo链表进行以下操作，其实这里只有一个addrinfo结构 */
        for(aip = ailist; aip != NULL; aip = aip->ai_next)
        {
            /* 其中这里才是客户端套接字编程 */
    
            /* 步骤1：创建套接字描述符 */
            if((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0)
                err =errno;
            /* 步骤2：connect请求连接 */
            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);
    }
    
    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");
    }

服务器端：

/* 基于TCP的面向连接的服务器进程 */
    
    #include "apue.h"
    #include <netdb.h>
    #include <errno.h>
    #include <syslog.h>
    #include <fcntl.h>
    #include <sys/socket.h>
    #include <sys/wait.h>
    #include "serverin.h"
    
    /* 定义等待请求队列的最大数 */
    #define QLEN 10
    
    #ifndef HOST_NAME_MAX
    #define HOST_NAME_MAX 256
    #endif
    
    /* 外部定义的服务器初始化套接字端点 */
    //extern int initserver(int type, const struct sockaddr *addr, socklen_t len, int qlen);
    
    /* 服务器接收连接请求，并向请求客户端发送数据 */
    void server(int sockfd);
    
    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: %s", argv[0]);
    #ifdef _SC_HOST_NAME_MAX
        n = sysconf(_SC_HOST_NAME_MAX);
        if(n < 0) /* best guess */
    #endif
            n = HOST_NAME_MAX;
        host = (char *)malloc(n);
        if(NULL == host)
            err_sys("malloc error");
        /* 获取客户端的主机名 */
        if(gethostname(host, n) < 0)
            err_sys("gethostname error");
        daemonize("ruptimed");
        /* 初始化addrinfo结构变量hint */
        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;/* 表示只有一个addrinfo链表结构 */
    
        /* 将主机名和服务名映射到一个地址 */
        if((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0)
        {
            syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err));
            exit(1);
        }
        /* 对每个结构addrinfo链表进行以下操作，其实这里只有一个addrinfo结构 */
        for(aip = ailist; aip != NULL; aip = aip->ai_next)
        {
            /* 其中这里才是服务进程套接字编程 */
    
            if((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0)
            {
                server(sockfd);
                exit(0);
            }
        }
        exit(1);
    }
    void server(int sockfd)
    {
        int clfd, status;
        pid_t pid;
    
        while(1)
        {
            clfd = accept(sockfd, NULL, NULL);
            if(clfd < 0)
            {
                syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
                exit(1);
            }
    
            if((pid = fork()) < 0)
            {
                syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
                exit(1);
            }
            else if(pid == 0)
            {
                if(dup2(clfd, STDOUT_FILENO) != STDOUT_FILENO || dup2(clfd, STDERR_FILENO) != STDERR_FILENO)
                {
                    syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
                    exit(1);
                }
                close(clfd);
                execl("/usr/bin/uptime", "uptime", (char *)0);/* 执行 uptime指令 */
                syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
            }
            else
            {
                close(clfd);
                waitpid(pid, &status, 0);
            }
        }
    }

其中客户端和服务器端包含的函数头文件内容如下：

服务器：

/* 服务器初始化套接字端点 */
    #ifndef SERVERIN_H
    #define SERVERIN_H
    #include "apue.h"
    #include <sys/socket.h>
    #include <errno.h>
    #include <syslog.h>
    #include <fcntl.h>
    #include <sys/resource.h>
    
    /* type 套接字类型, qlen是监听队列的最大个数 */
    int initserver(int type, const struct sockaddr *addr, socklen_t len, int qlen)
    {
        int fd;
        int err = 0;
    
        /* 采用type类型默认的协议 */
        if((fd = socket(addr->sa_family, type, 0)) < 0)
            return -1;/* 出错返回-1*/
    
        int reuse = 1;
    
        if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int)) < 0)
        {
            err = errno;
            goto errout;
        }
        /* 将地址绑定到一个套接字 */
        if(bind(fd, addr, len) < 0)
        {
            err =errno;
            goto errout;/* 跳转到出错输出语句 */
        }
        /* 若套接字类型type是面向连接(SOCK_STREAM, SOCK_SEQPACKET)的，则执行以下语句 */
        if(type == SOCK_STREAM || type == SOCK_SEQPACKET)
        {
            /* 监听套接字连接队列 */
            if(listen(fd, qlen) < 0)
            {
                err = errno;
                goto errout;
            }
        }
        return (fd);
    
    errout:
        close(fd);
        errno = err;
        return -1;
    }
    
    /* 初始化守护进程 */
    
    void daemonize(const char *cmd)
    {
        int i, fd0, fd1, fd2;
        pid_t pid;
        struct rlimit rl;
        struct sigaction sa;
        umask(0);
    
        if(getrlimit(RLIMIT_NOFILE, &rl) < 0)
            err_quit("%s: can't get file limit", cmd);
    
        if((pid =fork()) < 0)
            err_quit("%s: can't fork", cmd);
        else if(pid != 0)
            exit(0);
        setsid();
    
        sa.sa_handler = SIG_IGN;
        sigemptyset(&sa.sa_mask);
        sa.sa_flags = 0;
        if(sigaction(SIGHUP, &sa, NULL) < 0)
            err_quit("%s: can't ignore SIGHUP");
        if((pid =fork()) < 0)
            err_quit("%s: can't fork", cmd);
        else if(pid != 0)
            exit(0);
        if(chdir("/") < 0)
            err_quit("%s: can't change directory to /");
    
        if(rl.rlim_max == RLIM_INFINITY)
            rl.rlim_max = 1024;
        for(i = 0; i < (int)rl.rlim_max; i++)
            close(i);
    
        fd0 = open("/dev/null", O_RDWR);
        fd1 = dup(0);
        fd2 = dup(0);
    
        openlog(cmd, LOG_CONS, LOG_DAEMON);
        if(fd0 != 0 || fd1 != 1 || fd2 != 2)
        {
            syslog(LOG_ERR, "unexpectrd file descriptors %d %d %d", fd0, fd1, fd2);
            exit(1);
        }
    
    }
    #endif

客户端：

/* 建立连接 */
    
    /* 该函数的功能和connect相同，当connect连接出错时，这里支持重试连接 */
    
    #ifndef CONNECTRE_H
    #define CONNECTRE_H
    #include "apue.h"
    #include <sys/socket.h>
    
    #define MAXSLEEP 128
    
    int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t len)
    {
        int nsec;
        /* Try to connect with exponential backoff */
    
        for(nsec = 1; nsec <= MAXSLEEP; nsec <<= 1)
        {
            if(connect(sockfd, addr, len) == 0)
                return 0;
            /* Delay before trying again */
            if(nsec <= MAXSLEEP/2)
                sleep(nsec);
        }
        return -1;
    }
    #endif

输出结果：

/*
    *在输出结果之前一些准备工作，在文件 /etc/servers 添加 ruptime  4000/tcp
    */
    ./server 
    ./client Ubu1204
     19:49:57 up 3 days, 11:10,  4 users,  load average: 0.62, 1.74, 1.46

参考资料：

《UNIX高级环境编程》

[Center]: /images/20220810/47080d9d997e4cdaa917cd28d686bda4.png
[Center 1]: /images/20220810/c0d01b4ff6134992aae412a6c9d64867.png
[Center 2]: /images/20220810/25e8afd664ac4bb19234f90db963ae44.png
[Center 3]: /images/20220810/46695e5093da44669f9759c53db39bbf.png