套接字基础

套接字
- 一、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 6666int 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 6666int 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 connectionint 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 dataif (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 backwrite(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;
}