套接字基础

套接字
- 一、socket
- 二、setsockopt
- 三、bind
- 四、listen
- 五、select
- 六、poll
- 七、epoll
- - 一、水平模式（Level-Triggered，LT）
  - 二、边沿模式（Edge-Triggered，ET）

套接字

最近学习网络编程的时候，在使用select，poll和epoll时总容易出错，像什么优缺点啊，形参啥的，翻来覆去的，搞得有点难受,现在总结一下吧，发现如果不总结，后面还是容易出错。

一、socket

除了那三个函数外，容易出错的还有socket函数,而且那三个参数都需要都需要使用这个函数，我觉得很有必要总结一下

 int socket(int domain, int type, int protocol);

参数一 domain:

指定了socket使用的地址族，它决定了socket的地址类型，最近接触的也就是ipv4类型,即AF_INET，常见的还有IPv6网络协议的地址族AF_INET6等
参数二 type:
这个参数指定了socket的类型，决定了通信的性质，主要是数据传输的方式
- SOCK_STREAM :提供顺序、可靠、双向、基于连接的字节流，使用这种类型通常会使用TCP协议。
- SOCK_DGRAM:支持无连接、不可靠的消息传递，消息的最大长度是固定的，使用这种类型通常会使用UDP协议。
参数三 protocol:
这个参数指定了在给定的domain和type的情况下，使用哪种具体的协议。通常情况下，可以设置为0，表示选择默认的协议,以下是默认
- IPPROTO_TCP：TCP传输协议。
- IPPROTO_UDP：UDP传输协议。
- IPPROTO_SCTP：SCTP传输协议。
使用示例：
```
 int listenfd = socket(AF_INET, SOCK_STREAM, 0);
```

二、setsockopt

实现端口复用函数，由于函数复杂，manual pages是查询不到的什么有用的东西的，可以在《UNIX系统高级编程》(简称：EPUG)这本书查到，庆幸的是端口复用是固定模板，直接用就行
int setsockopt(int sockfd, int level, int optname,const void optval[.optlen],socklen_t optlen);

使用示例：

int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

三、bind

#include <sys/socket.h>
 int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

这个函数并不复杂，只需要注意一下几点：

socked:这个参数填的是监听描述符，也就是socket的返回值，这个函数就是绑定服务器地址嘛，好让客户端连接，不难理解
addr：因为sockaddr已经被弃用，所有我们一般定义sockaddr_in这种类型，然后在使用时将sockaddr_in类型强转为 sockaddr类型
addrlen:就是sizeof(sockaddr_in)的长度

sockaddr_in结构体

 struct sockaddr_in {
           sa_family_t     sin_family;     /* AF_INET */
           in_port_t       sin_port;       /* Port number */
           struct in_addr  sin_addr;       /* IPv4 address */
       };

这个结构体也是挺麻烦的，在使用之前我们需要进行初始化，因为我们一般的数据格式是无法在网络中传输了，需要转为特定格式才行，转格式就需要用到下面几个函数，头文件 #include <arpa/inet.h>

这个结构体在使用之前一般还需要清空

方式一：

memset(&server_addr, 0, sizeof(server_addr)); // 清零

方式二：(推荐)

bzero(&server_addr,sizeof(server_addr))

**转IP:**有两种方式，第二种不常用
int inet_pton(int af, const char *restrict src, void *restrict dst);
//示例：inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
inet_pton这个函数是将IP转为网络格式，

af:指定地址族，跟socket函数的地址族一致
src:服务器的IP,例如“127.0.0.1”
dst:即sockaddr_in的sin_addr成员
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // INADDR_ANY，电脑自动分配一个可以IP,这个函数不常用
转端口：
server_addr.sin_port = htons(6666);               // 端口6666
地址族：
server_addr.sin_family = AF_INET;                 // IPv4

既然有从本地数据转为网络，自然也有从网络转本地的

转IP:

const char *inet_ntop(int af, const void *restrict src,char dst[restrict .size], socklen_t size);
//示例： inet_ntop(AF_INET, &client_addr.sin_addr, buf, sizeof(buf)),

转端口：

ntohs(client_addr.sin_port))

使用示例：

struct sockaddr_in serverAddr;
bzero(&serverAddr, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(6666);
Inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
Bind(listenfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

四、listen

设置监听的最大同时在线数，系统默认128，最大也是128，所有也是固定格式
 #include <sys/socket.h>
 int listen(int sockfd, int backlog);

使用示例：

listen(listenfd, 128);

五、select

优点：跨平台，在window，Linux，MacOS上面都能用

缺点：1024最大文件描述符限制

#include <sys/select.h>
int select(int nfds, fd_set *_Nullable restrict readfds,
                  fd_set *_Nullable restrict writefds,
                  fd_set *_Nullable restrict exceptfds,
                  struct timeval *_Nullable restrict timeout);
//select 函数的返回值表示就绪的文件描述符数量

参数一 nfds:

表示参数是最大的文件描述符+1

参数二 ,三，四 readfds，writefds，exceptfds：

这三个都是指向 fd_set 结构的指针，都是传入传出参数，是检测读就绪状态的文件描述符集合，select函数会将符合对应条件的文件放在对应的集合中，放置将文件描述符对应的位值置1存在里面，一般我们只使用readfds,即我们只监听可读的文件描述符，可写目前我还没使用过，异常一般是系统才使用的

参数三：

如果 timeout 设置为 NULL，select 函数将会无限期等待，直到某个文件描述符就绪。如果 timeout 的时间设置为0秒0微秒，select 将立即返回，进行一个非阻塞的查询。如果timeout非0，在指定时间内没有文件描述符就绪，它将返回0；如果函数执行出错，将返回-1，并设置相应的 errno。

使用示例：

count = select(maxfd + 1, &rset, nullptr, nullptr, nullptr);

由于select函数设计的比较好，所有使用是来就略显的复杂，由于select函数只返回符合条件的文件描述符的总数，我们并不知道具体是哪个文件描述符符合，所有我们需要不断的遍历1024次（1024是select所支持的最大文件描述符数量），这样效率看起来就很低，在遍历的过程中我们还需要配合几个函数使用，当然，select也可以通过改变实现方式提高效率，如添加一个数组，等下可以看实现，现在先讲配合select使用的四个函数

fd是要操作的文件描述符，set就是集合

void FD_CLR(int fd, fd_set *set); //从集合中删除某文件描述符，即断开连接时使用
int  FD_ISSET(int fd, fd_set *set);//查询某文件描述符是否在集合中
void FD_SET(int fd, fd_set *set);//将某文件描述符添加到集合中
void FD_ZERO(fd_set *set);//将集合清空，全部置0

关于为什么要每次都循环1024次，主要还是怕没检查到位而遗漏某请求，因为每有请求时都需要循环1024次，这样看起来效率就很低，关于为什么select还没有被淘汰，那就是它跨平台，耐打。关于使用数组优化，那就是在每添加一个请求时，将这个请求放入这个数组中，我们在某程度上就能减少循环次数，我们只需要循环我们给定的数组就行，而不需要每次都遍历全部的连接文件描述符，借鉴于poll函数

完整代码：

/*select实现多路IO转接 */
#include <algorithm>
#include <iostream>
#include "wrap.h"

#define IPSERVER "127.0.0.1"
#define PORT 6666

int main() {
    /* Create a client[] array to make up for the problem of selecting looping 1024 times each time */
    int clientfd, client[FD_SETSIZE], listenfd, maxi, maxfd;
    char buf[BUFSIZ], str[INET_ADDRSTRLEN];
    struct sockaddr_in serverAddr, clientAddr;
    socklen_t clientAddrLen;
    fd_set rset, allset;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    bzero(&serverAddr, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    Inet_pton(AF_INET, IPSERVER, &serverAddr.sin_addr);
    serverAddr.sin_port = htons(PORT);
    Bind(listenfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

    Listen(listenfd, 128);

    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);
    maxfd = listenfd;
    maxi = -1;

    for (int i = 0; i < FD_SETSIZE; i++) {
        client[i] = -1;
    }
    int count;
    clientAddrLen = sizeof(clientAddr);
    while (true) {
        rset = allset;
        count = select(maxfd + 1, &rset, nullptr, nullptr, nullptr);
        if (FD_ISSET(listenfd, &rset)) {
            int i;
            clientfd = Accept(listenfd, (struct sockaddr*)&clientAddr, &clientAddrLen);
            for (i = 0; i < FD_SETSIZE; i++) {
                if (client[i] < 0) {
                    client[i] = clientfd;
                    break;
                }
            }
            if (maxi == FD_SETSIZE) {
                perr_exit("文件描述符已满");
                continue;
            }
            maxi = std::max(i, maxi);
            maxfd = std::max(clientfd, maxfd);

            FD_SET(clientfd, &allset);
            if (count == 1)
                continue;
        }
        for (int i = 0; i <= maxi; i++) {
            if (FD_ISSET(client[i], &rset)) {
                int n = Read(client[i], buf, BUFSIZ);
                if (n == 0) {
                    Close(client[i]);
                    FD_CLR(client[i], &allset);
                    client[i] = -1;
                }
                Write(STDOUT_FILENO, buf, n);
                for (int j = 0; j < n; ++j) {
                    buf[j] = toupper(buf[j]);
                }
                Write(client[i], buf, n);
            }
        }
    }
    return 0;
}

六、poll

poll相比于select函数优点，那就是他能突破1024文件描述符，实现更简单了一点，但它还是没有真正解决多次循环的问题，他的机制select通过添加一个数组就能实现（select添加数组就是参照poll实现的），但效率还是不太行。

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
//返回值大于0，表示符合条件的总文件描述符数，等于0表示在指定的超时期间内没有任何事件发生，-1表示发生错误，错误原因存储在全局变量 errno 中。

参数一 fds:

struct pollfd 类型数组的指针，poll会将符合条件的文件描述符添加到里面

参数二 nfds：

即fds结构体的数量，即你要监视的文件描述符的总数
struct pollfd {
    int   fd;         /* 文件描述符 */
    short events;     /* 关注的事件 */
    short revents;    /* 实际发生的事件，由系统填充 */
};
events:指明要监听的操作
POLLIN:监听可读事件
POLLOUT：监听可写时间
…具体可以查官方文档，POLLIN比较常用

revents：一般不需要填写，-1即可

参数三 timeout:

指定等待事件发生的最大时间（以毫秒为单位）。特殊值有：

-1：使 poll 无限期等待，直到某个事件发生。
0：让 poll 立即返回，进行非阻塞的轮询。
正值：等待指定的毫秒数，如果超时还没有任何事件发生，poll 将返回。

示例：

struct pollfd client[FD_SETSIZE];
int nready = poll(client, maxi + 1, -1);

完整代码示例：

#include <poll.h>
#include <algorithm>
#include <iostream>
#include "wrap.h"

#define IPADDR "127.0.0.1"
#define PORT 6666

int main() {
    int clientfd, listenfd, maxi, n;
    char buf[BUFSIZ], str[INET_ADDRSTRLEN];
    struct sockaddr_in serverAddr, clientAddr;
    socklen_t clientAddrLen;
    struct pollfd client[FD_SETSIZE];

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    bzero(&serverAddr, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    Inet_pton(AF_INET, IPADDR, &serverAddr.sin_addr);
    serverAddr.sin_port = htons(PORT);
    Bind(listenfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));

    Listen(listenfd, 128);
    client[0].fd = listenfd;
    client[0].events = POLLIN;
    for (int i = 1; i < FD_SETSIZE; i++) {
        client[i].fd = -1;
    }

    while (1) {
        int nready = poll(client, maxi + 1, -1);
        if (nready < 0) {
            perror("poll error");
            exit(1);
        }

        if (client[0].revents & POLLIN) {  // New connection
            int i;
            clientAddrLen = sizeof(clientAddr);
            clientfd = accept(listenfd, (struct sockaddr*)&clientAddr, &clientAddrLen);
            for (i = 1; i < FD_SETSIZE; i++) {
                if (client[i].fd < 0) {
                    client[i].fd = clientfd;
                    break;
                }
            }
            if (i == FD_SETSIZE) {
                printf("Too many clients\n");
                close(clientfd);
                continue;
            }

            client[i].events = POLLIN;
            if (i > maxi)
                maxi = i;
            if (--nready <= 0)
                continue;
        }

        for (int i = 1; i <= maxi; i++) {  // Check all clients for data
            if (client[i].fd < 0)
                continue;
            if (client[i].revents & (POLLIN | POLLERR)) {
                n = read(client[i].fd, buf, BUFSIZ);
                if (n < 0) {
                    perror("read error");
                    close(client[i].fd);
                    client[i].fd = -1;
                } else if (n == 0) {
                    printf("Client closed connection\n");
                    close(client[i].fd);
                    client[i].fd = -1;
                } else {
                    write(client[i].fd, buf, n);   // Echo back
                    write(STDOUT_FILENO, buf, n);  // Echo back
                }
            }
        }
    }
    return 0;
}

七、epoll

能够直接返回请求的文件描述符，效率高，缺点是不能跨平台，只适用于Linux系统

epoll的使用一共需要三个函数

int epoll_create(int size);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

epoll_create函数：

创建一个 epoll 实例（创建一个红黑树），并返回一个文件描述符，得到一个句柄

size:红黑树节点个数，这是个建议值，如果节点数不够系统会自动扩容
 int epfd = epoll_create(128); //示例

epoll_ctl函数

控制 epoll 文件描述符上的事件，可以用来添加、修改或删除监视的文件描述符。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

参数一 epfd:

epoll_create 返回的 epoll 文件描述符。

参数二 op:

指定操作类型，可以是 EPOLL_CTL_ADD, EPOLL_CTL_MOD, 或 EPOLL_CTL_DEL

EPOLL_CTL_ADD: 添加新的文件描述符到 epoll 实例。
EPOLL_CTL_MOD: 修改已存在的文件描述符的监视事件。
EPOLL_CTL_DEL: 从 epoll 实例中删除一个文件描述符。

参数三 fd:

需要操作的文件描述符。

参数四 event：

指向 epoll_event 结构的指针

struct epoll_event {
   uint32_t      events;  /* Epoll events */
   epoll_data_t  data;    /* User data variable */
};

union epoll_data {
   void     *ptr;//用于epoll反应堆
   int       fd;//文件描述符
   uint32_t  u32;//不需要管
   uint64_t  u64;//不需要管
};

epoll_wait函数

等待事件的发生，与select，poll作用相同

参数一 apfd:

句柄，即epoll_create函数的返回值

参数二 events：

指向 epoll_event 结构数组的指针，用来从内核得到事件集合,epoll会将符合的结构体放入这个数组中，每个结构体都存有对应文件描述符

参数三 maxevents：

告诉内核这个 events 数组可以处理的最大事件数

参数四 timeout：

timeout: 等待事件的最长时间（毫秒）。特殊值 -1 表示无限等待，0 表示非阻塞立即返回

//示例：
struct epoll_event temp, client[FD_SETSIZE];
ret = epoll_wait(epfd, client, 128, -1);

完整代码：

#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
#include <iostream>
#include "wrap.h"

int main() {
    int listenfd, clientfd;
    socklen_t clientAddrLen;
    struct sockaddr_in serverAddr, clientAddr;
    char buf[BUFSIZ];
    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    bzero(&serverAddr, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(6666);
    Inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
    Bind(listenfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    Listen(listenfd, 128);
    /* 创建红黑树，得到句柄 */
    int epfd = epoll_create(128);
    /* temp用于设置单个fd的属性 */
    struct epoll_event temp, client[FD_SETSIZE];
    temp.events = EPOLLIN;
    temp.data.fd = listenfd;

    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &temp);
    int ret, n;
    clientAddrLen = sizeof(clientAddr);
    while (true) {
        ret = epoll_wait(epfd, client, 128, -1);
        for (int i = 0; i < ret; ++i) {
            if (listenfd == client[i].data.fd) {
                clientfd = Accept(listenfd, (struct sockaddr*)&clientAddr, &clientAddrLen);
                client[i].data.fd = clientfd;
                temp.events = EPOLLIN;
                temp.data.fd = clientfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &temp);
            } else {
                n = Read(client[i].data.fd, buf, sizeof(buf));
                if (n == 0) {
                    Close(client[i].data.fd);
                    epoll_ctl(epfd, EPOLL_CTL_DEL, client[i].data.fd, &temp);
                } else {
                    Write(STDOUT_FILENO, buf, n);
                }
            }
        }
    }

    return 0;
}

一、水平模式（Level-Triggered，LT）

epoll默认情况下使用水平模式，即如果缓冲区中的数据没有读取完，那么这些数据还会返回epoll，即被epoll捕获

二、边沿模式（Edge-Triggered，ET）

边沿模式一般用于我们不需要读取全部数据的场景，为即便数据没有读取完，也不会再被触发epoll捕获，剩余的数据由我们自行处理，该抛弃抛弃，该干嘛干嘛

从**水平模式转为边沿模式,**只需要或上EPOLLET

#include <sys/epoll.h>

int epfd = epoll_create1(0);
if (epfd == -1) {
    perror("epoll_create1");
    exit(EXIT_FAILURE);
}

struct epoll_event event;
int fd = ...; // 这里 fd 是你需要监控的文件描述符

event.events = EPOLLIN | EPOLLET; // 设置为边缘触发模式
event.data.fd = fd;

if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event) == -1) {
    perror("epoll_ctl");
    exit(EXIT_FAILURE);
}

边沿模式需要配合 无阻塞和忙轮询,我们的epoll反应堆就是基于边沿模式，无阻塞，忙轮询，回调实现的

// epoll ET
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
#include <iostream>
#include "wrap.h"

int main() {
    int listenfd, clientfd;
    socklen_t clientAddrLen;
    struct sockaddr_in serverAddr, clientAddr;
    char buf[BUFSIZ];
    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    bzero(&serverAddr, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(6666);
    Inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
    Bind(listenfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    Listen(listenfd, 128);

    int epfd = epoll_create(128);
    struct epoll_event temp, client[FD_SETSIZE];
    temp.events = EPOLLIN | EPOLLET;  // 设置ET模式_ET
    // temp.events = EPOLLIN;
    temp.data.fd = listenfd;

    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &temp);
    int ret, n;
    clientAddrLen = sizeof(clientAddr);
    while (true) {
        ret = epoll_wait(epfd, client, 128, -1);
        for (int i = 0; i < ret; ++i) {
            if (listenfd == client[i].data.fd) {
                clientfd = Accept(listenfd, (struct sockaddr*)&clientAddr, &clientAddrLen);
                //     设置非阻塞
                int flags = fcntl(clientfd, F_GETFL, -1);
                flags |= O_NONBLOCK;
                fcntl(clientfd, F_SETFL, flags);
                client[i].data.fd = clientfd;
                temp.events = EPOLLIN;
                temp.data.fd = clientfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &temp);
            } else {
                while (true) {
                    n = read(client[i].data.fd, buf, sizeof(buf));
                    if (n > 0) {
                        write(STDOUT_FILENO, buf, n);
                    } else if (n == -1 && errno == EAGAIN) {
                        break;  // 没有更多数据
                    } else if (n == 0) {
                        // 客户端关闭了连接
                        close(client[i].data.fd);
                        epoll_ctl(epfd, EPOLL_CTL_DEL, client[i].data.fd, NULL);
                        break;
                    } else {
                        // 处理其他错误
                        perror("Read error");
                        close(client[i].data.fd);
                        epoll_ctl(epfd, EPOLL_CTL_DEL, client[i].data.fd, NULL);
                        break;
                    }
                }
            }
        }
    }

    return 0;
}