unix网络编程

Unix 网络编程

传输层部分知识点

TIME_WAIT状态

MSL: maximum segment lifetime

任何TCP的实现都需要为MSL选择一个合适的值, RFC的建议值是2分钟。分组可能出现迷途，若迷途分组在MSL中找到路，造成重复，TCP必须修复

TIME_WAIT存在的理由:

可靠的实现全双工的连接和终止
考虑最终ACK丢失的情况,
允许老的重复分组在网络中消逝
TCP的化生身现象, 因为TIME_WAIT的时间是2MSL, 故TIME_WAIT可以确保先前化身(incarnation)的老重复分组都已经在网络中消失了

不过存在一个例外: 如果到达的SYN的序列号大于前一化身的结束序列号,源自Berkely的实现应该给当前TIME_WAIT状态的连接启动新的化身

SCTP

连接: 类似TCP, 但是是四路握手, 主要差别在于作为SCTP整体的一部分的cookie的生成
终止: 不允许"半关闭"

连接和终止

Coding

函数细节补充

inet_pton and inet_ntop
inet_addr已经被废弃了, inet_aton其实也不太好, 新的代码应该要使用inet_pton and inet_ntop, 例如如下例子

struct sockaddr_in makeAddr(char const *addr, uint16_t port) {
    struct sockaddr_in ret{};
    inet_pton(AF_INET, addr, &ret.sin_addr.s_addr);
    // ret.sin_addr.s_addr = inet_addr(addr); 例如用上面哪行代码代替此行
    ret.sin_family = AF_INET;
    ret.sin_port = htons(port);
    bzero(&ret.sin_zero, 8);
    return ret;
}

listen的作用
刚由socket创建的套接字, 系统默认其为主动套接字, listen的作用是把一个未连接的主动套接字转换为被动套接字. 第二个参数是内核为相应的socket排队的最大排队数 (incomplete connection queue: 处于SYN_RCVD状态)

并发服务器的一个细节

考虑如下代码

void detail() {
    pid_t pid;
    int listenfd, connfd;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in addr = makeAddr();
    bind(listenfd, (sockaddr *)addr, sizeof(struct sockaddr_in));

    listen(listenfd, 128);

    while(true) {
        struct sockaddr_in clientAddr;
        socklen_t addrlen = sizeof(struct sockaddr);
        connfd = accept(listenfd, (sockaddr_in) &clientAddr, &addrlen);

        if(pid = fork()) {
            close(listenfd);
            // do something here
            close(connfd);
            exit(0);
        }
        close(connfd); //注意这里
    }
}

我们知道, TCP套接口字调用close会导致发送一个FIN, 然后会连接终止, 为什么这里不会呢?

事实上, 每个文件或socket都会有一个引用计数(引用计数在文件表项中维护), fork的时候会让计数*2, 而close让计数-1, 所以不会出现问题, 真正socket的清理和资源的释放过程要等计数为0的时候才会发生
注意, 如果一直fork了也不close, 那么会耗尽所有可用的文件描述符, 导致连接一直打开着
如果我们确实想要某个TCP连接上发送一个FIN, 那么我们可以改用shutdown函数.

处理被中断的系统调用

如accept, 是一个慢系统调用, 多数网络支持函数都属于这个类型. 当阻塞于慢系统调用的一个进程捕获某个信号且进入相应的处理函数的时候, 该系统调用可能返回一个EINTR错误.(有的内核自动重启某些被中断的系统调用), 不过为了便于移植, 我们必须对EINTR有所准备, 一个处理办法就是

while(true) {
    connfd = accept(listenfd, (sockaddr_in) &clientAddr, &addrlen);
    if(connfd < 0) {
        if(errno == EINTR)
            continue;
        else perror("accept");
    }
}

注意: 有一个函数我们不能这样处理, 就是connect, 如果他出了EINTR, 再次调用会立即返回一个错误, 我们必须用select函数来等待连接完成

处理accept返回前连接终止

如下图的情况的时候,

如何处理这种问题依赖于不同的实现, 之后再说

小结

所有客户端和服务器都从调用socket开始, 客户端connect, 服务端bind, listen和accept, 大多数TCP都是并发的, 而大多数UDP却是迭代的

IO复用 -- select 和 poll

当用户处理多个描述符, 必须使用IO复用
如果一个TCP服务器, 既要处理监听的套接字, 又要处理连接的套接字, 就要使用IO复用
如果又要TCP, 又要UDP, 就要IO复用
如果一个服务器要处理多个服务器和多个协议, 通常要IO复用(例如inetd守护进程)

IO复用并非只局限于网络编程, 许多重要的应用也要采用这个技术

IO模型

在了解IO复用之前需要先回顾unix的5种IO模型: 阻塞式, 非阻塞式, 复用, 信号驱动IO, 异步IO
其中

非阻塞IO
非阻塞IO是指当所请求的IO非得把本进程投入睡眠才能完成时不要睡眠, 而是返回一个错误

5种模型的比较

select 函数

该函数select一个'内核等待'发生, 并且只有在一个或多个事件发生(或经历了一段时间后)才唤醒它

举个例子, 比如我们可以通过调用select函数使得内核仅在以下情况返回:

{1, 4, 5}描述符准备好读
{2, 7}准备好写
{1, 4}有异常条件待处理
已经经历了10.2秒

运用IO复用技术解决前面提到过的问题
之前遇到的问题是: 当套接字上发生了某种事件的时候, 客户可能阻塞于fgets调用. 现在将其改为阻塞于select调用,

void str_cli(FILE *fp, int sockfd) {
    int maxfdp1;
    fd_set rset;
    char sendline[MAXLINE], recvline[MAXLINE];

    FD_ZERO(&rset);
    while(true) {
        FD_SET(fileno(fp), &rset); // 每一次都要初始化
        FD_SET(sockfd, &rset);// 每一次都要初始化
        maxfdp1 = max(fileno(fp), sockfd) + 1;
        select(maxfdp1, &rset, NULL, NULL, NULL);

        if(FD_ISSET(sockfd, &rset))  {
            if(readline(sockfd, recvline, MAXLINE))
                print("server terminated permaturely");
            fputs(recvline, stdout);
        }

        if(FD_ISSET(fileno(fp), &rset)) {
            if(fgets(sendline, MAXLINE, fp) == NULL)
                return;
            write(sockfd, sendline, strlen(sendline));
        }
    }
}

可是, 即使做了这个修改, 代码仍然存在问题

因为只读取一行stdio的缓存中可能还有额外的输入行待消费
一个读到EOF不代表另一个已经读完毕, 不呢个直接return

解决上述问题的版本

void str_cli2(FILE * fp, int sockfd) {
    int maxfdp1;
    bool stdineof;
    fd_set rset;
    char buf[MAXLINE];
    int n;

    stdineof = false;
    FD_ZERO(&rset);

    while(true) {
        if(!stdineof)
            FD_SET(fileno(fp), &rset);
        FD_SET(sockfd, &rset);
        maxfdp1 = max(fileno(fp), sockfd) + 1;
        select(maxfdp1, &rset, NULL, NULL, NULL);

        if(FD_ISSET(sockfd, &rset))  { // socket is readable
            if((n = read(sockfd, buf, MAXLINE)) == 0){
                if(stdineof)
                    return;
                else
                    print("server terminated permaturely");
            }
            write(fileno(stdout), buf, n);
        }
        if(FD_ISSET(filenofp), &rset)) {
            if((n = read(fileno(fp), buf, MAXLINE)) == 0){
                stdineof = true;
                shutdown(sockfd, SHUT_WR);
                FD_CLR(fileno(fp), &rset);
                continue;
            }
        }
    }
}

注: 用shutdown(sockfd, SHUT_WR); 发送FIN

pselect函数

POSIX发明的, 有许多的unix变种支持他

用timespec结构而不是timeval
增加一个指向信号的掩码的指针, 该参数允许程先序禁止递交某些信号, 再测试它们(这些信号)的handler设置的全局变量, 然后调用pselect (也就是暂时更换'信号掩码', 例如解除某个信号的阻塞)

poll函数

poll和select类似, 只不过在处理流函数的时候能够提供额外的信息, 先不扯太多理论, 直接看代码还好懂

#include "unp.h"
#include <limits.h>
#define OPEN_MAX 10

int main() {
    int     i, maxi, listenfd, connfd, sockfd;
    int     nready;
    ssize_t n;
    char    buf[MAXLINE];

    socklen_t     clilen;
    struct pollfd client[OPEN_MAX];

    struct sockaddr_in cliaddr, servaddr;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    servaddr = makeAddr("127.0.0.1", 9988);

    bind(listenfd, (sockaddr*)&servaddr, sizeof(servaddr));
    listen(listenfd, 64);

    // initialize client array.
    client[0].fd     = listenfd;
    client[0].events = POLLRDNORM;
    for (i = 1; i < OPEN_MAX; ++i)
        client[i].fd = -1;
    maxi = 0;

    while (true) {
        nready = poll(client, maxi + 1, 0x3f3f3f3f);  // forever
        // 分两部分处理, client[0]是用来放监听socket的, 这个if通过说明可以accept
        if (client[0].revents && POLLRDNORM) {
            clilen = sizeof(cliaddr);
            connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen);

            /* insert to the client list */
            for (i = 1; i < OPEN_MAX; ++i)
                if (client[i].fd < 0) {
                    client[i].fd = connfd;
                    client[i].events = POLLRDNORM;  // read normal: 普通数据可读
                    break;
                }
            if (i == OPEN_MAX)
                err_quit("too many clients");


            if (i > maxi)
                maxi = i;
            if (--nready <= 0)
                continue;
        }
        //别的都是client socket
        for (i = 1; i <= maxi; ++i) {
            if ((sockfd = client[i].fd) < 0)
                continue;
            if (client[i].revents && (POLLRDNORM | POLLERR)) {
                if ((n = read(sockfd, buf, MAXLINE)) < 0) {
                    if (errno == ECONNRESET) {
                        close(sockfd);
                        client[i].fd = -1;
                    }
                    else
                        perror("read error");
                }
                else if (n == 0) {
                    close(sockfd);
                    client[i].fd = -1;
                }
                else
                    write(sockfd, buf, n);
                if (--nready <= 0)
                    break;
            }
        }
    }
}

套接字选项

有很多方式来设置和影响套接字选项, 例如getsockopt, setsockopt, fcntl, ioctl

关于传输层的套接字选项, 请自行google或参考有关文档和书籍

UDP编程

UDP编程模型

创建socket的时候要把SOCK_STREAM改成SOCK_DGRAM

recvfrom 和 sendto函数

类似与标准的read和write, 不过需要3个额外的参数: flags, from, addrlen, flags参数先不说, 暂时把他当成0, 后续会解释; from和addrlen参数和accept的最后两个参数类似

注: 如果from是一个空指针, 那么addrlen也一样要是一个空指针, 表示我们不关心地址.

recvfrom和sendto都可以用于TCP, 尽管通常没有理由那么做

void
dg_echo(int sockfd, SA* pcliaddr, socklen_t clilen) {
    int       n;
    socklen_t len;
    char      mesg[MAXLINE];

    while (1) {
        // `len` should be initialized to the size of the
        len = clilen;
        n = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);

        sendto(sockfd, mesg, 0, pcliaddr, len);
    }
}

int
main() {
    int                sockfd;
    struct sockaddr_in servaddr, cliaddr;

    sockfd   = socket(AF_INET, SOCK_DGRAM, 0);
    servaddr = makeAddr("127.0.0.1", 6666);
    bind(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));

    dg_echo(sockfd, (SA*)&cliaddr, sizeof(cliaddr));
    return 0;
}

代码虽简单, 但是有几个细节需要注意

首先, 函数永不终止, 因为UDP是一个无连接的协议, 它没有像TCP中的EOF之类的东西
这是一个迭代服务器, 不像TCP服务器那样可以提供一个并发的服务器, 其中没有fork的调用, 因此单个进程就得处理所有客户
对于本套接字, UDP层有排队发生, 事实上每个UDPsocket都有一个接收缓存区

更多的UDP细节不在此赘述

SCTP编程

留坑.. 以后补上...
.
.
.

IPv4和IPv6的互操作性

posted @ 2020-02-18 13:58 KimBing_Ng 阅读(378) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

KimBing_Ng