• 基于reactor设计http服务器

    目录

    1. HTTP 简介

    2. HTTP 工作原理

    3. 基于reactor设计http服务器

    3.1 解析http头

     3.2 封装http的响应

    3.3 sendfile函数

    4. 完整代码

    5.  运行结果

    1. HTTP 简介

            HTTP 协议（HyperText Transfer Protocol，超文本传输协议）是因特网上应用最为广泛的一种网络传输协议，所有的 WWW 文件都必须遵守这个标准。 HTTP 是一个基于 TCP/IP 通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。

    2. HTTP 工作原理

            HTTP 协议工作于客户端-服务端架构上。浏览器作为 HTTP 客户端通过 URL 向 HTTP 服务端即 WEB 服务器发送所有请求。

    1. Web 服务器有： Apache 服务器， IIS 服务器（Internet Information Services）等。
    2. Web 服务器根据接收到的请求后，向客户端发送响应信息。
    3. HTTP 默认端口号为 80，但是你也可以改为 8080 或者其他端口。

     

    3. 基于reactor设计http服务器

            reactor的原理与实现可以参考这里！！！

            主要实现俩部分，一部分是对http头的解析。另一部分是封装http的响应。

      

    3.1 解析http头

    1. //读行
    2. int readline(char* allbuf, int idx, char* linebuf)
    3. {
    4. 	int len = strlen(allbuf);
    5.  
    6. 	for(; idx < len; idx++){
    7. 		if(allbuf[idx] == '\r' && allbuf[idx+1] == '\n')
    8. 			return idx+2;
    9. 		else
    10. 			*(linebuf++) = allbuf[idx];
    11. 	}
    12. 	return -1;
    13. }
    14.  
    15. //解析http头
    16. int nty_http_request(struct ntyevent * ev)
    17. {
    18. 	char linebuff[1024] = {0};
    19.  
    20. 	int idx = readline(ev->buffer, 0, linebuff);
    21. 	if(strstr(linebuff, "GET")){
    22. 		ev->method = HTTP_METHOD_GET;
    23.  
    24. 		int i = 0;
    25. 		while(linebuff[sizeof("GET") + i] != ' ')i++;
    26. 		linebuff[sizeof("GET") + i] = '\0';
    27.  
    28. 		sprintf(ev->resource, "%s/%s", HTTP_WEB_ROOT, linebuff+sizeof("GET "));
    29. 	
    30. 		printf("resource: %s\n", ev->resource);
    31. 	}
    32. 	else if(strstr(linebuff, "POST"))
    33. 	{
    34. 		ev->method = HTTP_METHOD_POST;
    35. 	}
    36.  
    37. 	return 0;
    38. }

     3.2 封装http的响应

    1. //打包http头
    2. int nty_http_response_get_method(struct ntyevent *ev) 
    3. {
    4. 	//int filed = open()
    5. #if 0
    6. 	int len = sprintf(ev->wbuffer, 
    7. 	"HTTP/1.1 200 OK\r\n"
    8. "Accept-Ranges: bytes\r\n"
    9. "Content-Length: 78\r\n"
    10. "Content-Type: text/html\r\n"
    11. "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n"
    12. "0voice.king
      King
      "      );
    13.  
    14. 	ev->wlength = len;
    15. #else
    16. 	int len;
    17. 	int filefd = open(ev->resource, O_RDONLY);
    18. 	if (filefd == -1) {
    19.  
    20. 		len = sprintf(ev->wbuffer, 
    21. 	"HTTP/1.1 200 OK\r\n"
    22. "Accept-Ranges: bytes\r\n"
    23. "Content-Length: 78\r\n"
    24. "Content-Type: text/html\r\n"
    25. "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n"
    26. "0voice.king
      King
      "      );
    27.  
    28. 		ev->wlength = len;
    29. 	
    30. 	} else {
    31.  
    32. 		//获取文件大小
    33. 		struct stat stat_buf;
    34. 		fstat(filefd, &stat_buf);
    35. 		close(filefd);
    36. #if 1
    37. 		len = sprintf(ev->wbuffer, 
    38. 	"HTTP/1.1 200 OK\r\n"
    39. "Accept-Ranges: bytes\r\n"
    40. "Content-Length: %ld\r\n"
    41. "Content-Type: text/html\r\n"
    42. "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n", stat_buf.st_size);
    43. #else
    44. 	len = sprintf(ev->wbuffer, 
    45. 	"HTTP/1.1 200 OK\r\n"
    46. "Accept-Ranges: bytes\r\n"
    47. "Content-Length: %ld\r\n"
    48. "Content-Type: image/png\r\n"
    49. "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n", stat_buf.st_size);
    50.  
    51.  
    52. #endif
    53. 		ev->wlength = len;
    54.  
    55. 	}
    56. 	
    57. #endif
    58.  
    59. 	return len;
    60. }
    61.  
    62.  
    63. //数据打包
    64. int nty_http_response(struct ntyevent* ev)
    65. {
    66. 	// ev->method, ev->resouces
    67. 	if(ev->method == HTTP_METHOD_GET){
    68. 		nty_http_response_get_method(ev);
    69. 	}else if(ev->method == HTTP_METHOD_POST){
    70.  
    71. 	}
    72. 	return 0;
    73. }

    3.3 sendfile函数

    sendfile函数：

            sendfile函数是在两个文件描述符中直接传递数据（完全在内核中操作），从而避免了用户和内核之间的数据拷贝，所以效率很高，也被称之为零拷贝。

    sendfile函数用法

    头文件：#include

    用法：ssize_t sendfile(int out_fd,int in_fd,off_t * offset,size_t count)

    1. out_fd：待写入内容的文件描述符，一般为accept的返回值
    2. in_fd：待读出内容的文件描述符，一般为open的返回值
    3. offset：指定从读入文件流的哪个位置开始读，如果为空，则使用读入文件流的默认位置，一般设置为NULL
    4. count：两文件描述符之间的字节数，一般给struct stat结构体的一个变量，在struct stat中可以设置文件描述符属性

    注意：in_fd规定指向真实的文件，不能是socket等管道文件描述符，一般使open返回值，而out_fd则是socket描述符

    sendfile的优点：是专门为网络上传输文件而设计的函数，效率高

    4. 完整代码

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #include 
    9. #include 
    10.  
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15.  
    16. #include 
    17.  
    18.  
    19.  
    20. #define  BUFFER_LENGTH  	1024
    21. #define  MAX_EPOLL_EVENTS   1024  //epoll事件数量
    22. #define  RESOURCE_LENGTH	1024
    23.  
    24. #define  SERVER_PORT  		8888
    25. #define  PORT_COUNT			100
    26.  
    27. typedef int NCALLBACK(int ,int ,void*);
    28.  
    29. #define HTTP_METHOD_GET		0
    30. #define HTTP_METHOD_POST	1
    31.  
    32. #define HTTP_WEB_ROOT	"/home/kaka/share/html"
    33.  
    34. //管理每一个io fd的结构体
    35. struct ntyevent{
    36. 	int fd; //io fd
    37. 	int events;
    38. 	void *arg;
    39. 	int (*callback)(int fd, int events, void* arg); //执行回调函数
    40.  
    41. 	int status;	//判断是否已有事件
    42. 	char buffer[BUFFER_LENGTH]; //用户缓冲区
    43.  
    44. 	char wbuffer[BUFFER_LENGTH]; //发送的数据
    45. 	
    46. 	int length; //用户缓冲区长度
    47.  
    48. 	int wlength; //发送长度
    49.  
    50. 	// http reqeust
    51. 	int method;
    52. 	char resource[RESOURCE_LENGTH];
    53. 	
    54. };
    55.  
    56. //管理ntyevent fd的块
    57. struct eventblock{
    58. 	struct eventblock* next; //指向ntyevent fd集合
    59. 	struct ntyevent* events; //指向下一个ntyevent fd的块
    60. };
    61.  
    62. //reacotr结点
    63. struct ntyreactor{
    64. 	int epfd;	//epoll fd
    65. 	int blkcnt;	//ntyevent fd的块 计数
    66.  
    67. 	struct eventblock* evblks;	//指向ntyevent fd的块头结点
    68. };
    69.  
    70. int recv_cb(int fd, int events, void *arg);
    71. int send_cb(int fd, int events, void *arg);
    72. int accept_cb(int fd, int events, void* arg);
    73.  
    74. struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd);
    75.  
    76. //io fd结构体设置
    77. void nty_event_set(struct ntyevent* ev, int fd, NCALLBACK callback, void* arg)
    78. {
    79. 	ev->fd = fd;
    80. 	ev->callback = callback;
    81. 	ev->events = 0;
    82. 	ev->arg = arg;
    83.  
    84. 	return ;
    85. }
    86.  
    87. //io fd add
    88. int nty_event_add(int epfd, int events, struct ntyevent *ev)
    89. {
    90. 	struct epoll_event ep_ev = {0, {0}};
    91. 	ep_ev.data.ptr = ev;				//io fd结构体
    92. 	ep_ev.events = ev->events = events; //需要检测的fd事件
    93.  
    94. 	int op; //操作类型
    95. 	if(ev->status == 1){
    96. 		op = EPOLL_CTL_MOD; //修改
    97. 	}else{
    98. 		op = EPOLL_CTL_ADD; //添加
    99. 		ev->status = 1;		//标志已经添加
    100. 	}
    101. 		
    102. 	if(epoll_ctl(epfd, op, ev->fd, &ep_ev) <0 ){ //绑定
    103. 		printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
    104. 		return -1;
    105. 	}
    106.  
    107. 	return 0;
    108. }
    109.  
    110. //io fd del
    111. int nty_event_del(int epfd, struct ntyevent* ev)
    112. {
    113. 	struct epoll_event ep_ev = {0, {0}};
    114. 	if(ev->status != 1){ //没有添加过检测的fd事件
    115. 		return -1;
    116. 	}
    117.  
    118. 	ep_ev.data.ptr = ev;
    119. 	ev->status = 0; //标志未添加
    120. 	epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ep_ev);
    121. 	return 0;
    122. }
    123.  
    124. // request
    125. // location  /0voice/king/index.html HTTP/1.1
    126.  
    127. //读行
    128. int readline(char* allbuf, int idx, char* linebuf)
    129. {
    130. 	int len = strlen(allbuf);
    131.  
    132. 	for(; idx < len; idx++){
    133. 		if(allbuf[idx] == '\r' && allbuf[idx+1] == '\n')
    134. 			return idx+2;
    135. 		else
    136. 			*(linebuf++) = allbuf[idx];
    137. 	}
    138. 	return -1;
    139. }
    140.  
    141. //解析http头
    142. int nty_http_request(struct ntyevent * ev)
    143. {
    144. 	char linebuff[1024] = {0};
    145.  
    146. 	int idx = readline(ev->buffer, 0, linebuff);
    147. 	if(strstr(linebuff, "GET")){
    148. 		ev->method = HTTP_METHOD_GET;
    149.  
    150. 		int i = 0;
    151. 		while(linebuff[sizeof("GET") + i] != ' ')i++;
    152. 		linebuff[sizeof("GET") + i] = '\0';
    153.  
    154. 		sprintf(ev->resource, "%s/%s", HTTP_WEB_ROOT, linebuff+sizeof("GET "));
    155. 	
    156. 		printf("resource: %s\n", ev->resource);
    157. 	}
    158. 	else if(strstr(linebuff, "POST"))
    159. 	{
    160. 		ev->method = HTTP_METHOD_POST;
    161. 	}
    162.  
    163. 	return 0;
    164. }
    165.  
    166. //打包http头
    167. int nty_http_response_get_method(struct ntyevent *ev) 
    168. {
    169. 	//int filed = open()
    170. #if 0
    171. 	int len = sprintf(ev->wbuffer, 
    172. 	"HTTP/1.1 200 OK\r\n"
    173. "Accept-Ranges: bytes\r\n"
    174. "Content-Length: 78\r\n"
    175. "Content-Type: text/html\r\n"
    176. "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n"
    177. "0voice.king
      King
      "      );
    178.  
    179. 	ev->wlength = len;
    180. #else
    181. 	int len;
    182. 	int filefd = open(ev->resource, O_RDONLY);
    183. 	if (filefd == -1) {
    184.  
    185. 		len = sprintf(ev->wbuffer, 
    186. 	"HTTP/1.1 200 OK\r\n"
    187. "Accept-Ranges: bytes\r\n"
    188. "Content-Length: 78\r\n"
    189. "Content-Type: text/html\r\n"
    190. "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n"
    191. "0voice.king
      King
      "      );
    192.  
    193. 		ev->wlength = len;
    194. 	
    195. 	} else {
    196.  
    197. 		//获取文件大小
    198. 		struct stat stat_buf;
    199. 		fstat(filefd, &stat_buf);
    200. 		close(filefd);
    201. #if 1
    202. 		len = sprintf(ev->wbuffer, 
    203. 	"HTTP/1.1 200 OK\r\n"
    204. "Accept-Ranges: bytes\r\n"
    205. "Content-Length: %ld\r\n"
    206. "Content-Type: text/html\r\n"
    207. "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n", stat_buf.st_size);
    208. #else
    209. 	len = sprintf(ev->wbuffer, 
    210. 	"HTTP/1.1 200 OK\r\n"
    211. "Accept-Ranges: bytes\r\n"
    212. "Content-Length: %ld\r\n"
    213. "Content-Type: image/png\r\n"
    214. "Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n", stat_buf.st_size);
    215.  
    216.  
    217. #endif
    218. 		ev->wlength = len;
    219.  
    220. 	}
    221. 	
    222. #endif
    223.  
    224. 	return len;
    225. }
    226.  
    227.  
    228. //数据打包
    229. int nty_http_response(struct ntyevent* ev)
    230. {
    231. 	// ev->method, ev->resouces
    232. 	if(ev->method == HTTP_METHOD_GET){
    233. 		nty_http_response_get_method(ev);
    234. 	}else if(ev->method == HTTP_METHOD_POST){
    235.  
    236. 	}
    237. 	return 0;
    238. }
    239.  
    240. //recv回调
    241. int recv_cb(int fd, int events, void* arg)
    242. {
    243. 	struct ntyreactor* reactor = (struct ntyreactor*)arg;
    244. 	struct ntyevent* ev = ntyreactor_idx(reactor, fd);	
    245.  
    246. 	if(ev == NULL)return -1;
    247.  
    248. 	int len = recv(fd, ev->buffer, BUFFER_LENGTH, 0);
    249. 	nty_event_del(reactor->epfd, ev);
    250.  
    251. 	if (len > 0) {
    252. 		
    253. 		ev->length = len;
    254. 		ev->buffer[len] = '\0';
    255.  
    256. 		//printf("recv [%d]:%s\n", fd, ev->buffer);
    257.  
    258. 		nty_http_request(ev); //http解析
    259.  
    260. 		//将fd 设置为发送事件
    261. 		nty_event_set(ev, fd, send_cb, reactor);
    262. 		nty_event_add(reactor->epfd, EPOLLOUT, ev);
    263. 		
    264. 		
    265. 	} else if (len == 0) {  //客户端断开连接
    266.  
    267. 		nty_event_del(reactor->epfd, ev);
    268. 		printf("recv_cb --> disconnect\n");
    269. 		close(ev->fd);
    270. 		 
    271. 	} else { //返回错误
    272.  
    273. 		if (errno == EAGAIN && errno == EWOULDBLOCK) { //
    274. 			
    275. 		} else if (errno == ECONNRESET){
    276. 			nty_event_del(reactor->epfd, ev);
    277. 			close(ev->fd);
    278. 		}
    279. 		printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
    280. 		
    281. 	}
    282.  
    283. 	return len;
    284. }
    285.  
    286.  
    287. //send回调
    288. int send_cb(int fd, int events, void* arg)
    289. {
    290. 	struct ntyreactor* reactor = (struct ntyreactor*)arg;
    291. 	struct ntyevent* ev = ntyreactor_idx(reactor, fd);
    292.  
    293. 	if (ev == NULL) return -1;
    294.  
    295. 	nty_http_response(ev); //encode
    296.  
    297. 	int len = send(fd, ev->wbuffer, ev->wlength, 0);
    298. 	if (len > 0) {
    299. 		//printf("send[fd=%d], [%d]%s\n", fd, len, ev->wbuffer);
    300.  
    301. 		int filefd = open(ev->resource, O_RDONLY);
    302. 		if(filefd < 0) return 0;
    303.  
    304. 		struct stat stat_buf;
    305. 		fstat(filefd, &stat_buf);
    306.  
    307. 		int flag = fcntl(fd, F_GETFL, 0);
    308. 		flag &= ~O_NDELAY;
    309. 		fcntl(fd, F_SETFL, flag);
    310.  
    311. 		//sendfile 需要做成阻塞io
    312. 		int ret = sendfile(fd, filefd, NULL, stat_buf.st_size);
    313. 		if (ret == -1) {
    314. 			printf("sendfile: errno: %d\n", errno);
    315. 		}
    316.  
    317. 		flag |= O_NONBLOCK;
    318. 		fcntl(fd, F_SETFL, flag);
    319.  
    320. 		close(filefd);
    321.  
    322. 		send(fd, "\r\n", 2, 0);
    323.  
    324. 		//发送后，将fd设置为接收事件
    325. 		nty_event_del(reactor->epfd, ev);
    326. 		nty_event_set(ev, fd, recv_cb, reactor);
    327. 		nty_event_add(reactor->epfd, EPOLLIN, ev);
    328. 		
    329. 	} else { //发送失败
    330.  
    331. 		nty_event_del(reactor->epfd, ev);
    332. 		close(ev->fd);
    333.  
    334. 		printf("send[fd=%d] error %s\n", fd, strerror(errno));
    335.  
    336. 	}
    337.  
    338. 	return len;
    339. }
    340.  
    341.  
    342. //客户端接入回调
    343. int accept_cb(int fd, int events, void* arg)
    344. {
    345. 	struct ntyreactor *reactor = (struct ntyreactor*)arg;
    346. 	if (reactor == NULL) return -1;
    347.  
    348. 	struct sockaddr_in client_addr;
    349. 	socklen_t len = sizeof(client_addr);
    350.  
    351. 	int clientfd;
    352.  
    353. 	//客户端接入
    354. 	if ((clientfd = accept(fd, (struct sockaddr*)&client_addr, &len)) == -1) {
    355. 		if (errno != EAGAIN && errno != EINTR) {
    356. 			
    357. 		}
    358. 		printf("accept: %s\n", strerror(errno));
    359. 		return -1;
    360. 	}
    361.  
    362. 	//设置非阻塞fd
    363. 	int flag = 0;
    364. 	if ((flag = fcntl(clientfd, F_SETFL, O_NONBLOCK)) < 0) {
    365. 		printf("%s: fcntl nonblocking failed, %d\n", __func__, MAX_EPOLL_EVENTS);
    366. 		return -1;
    367. 	}
    368.  
    369. 	struct ntyevent *event = ntyreactor_idx(reactor, clientfd);
    370.  
    371. 	if (event == NULL) return -1;
    372.  
    373. 	//将该fd设置为recv
    374. 	nty_event_set(event, clientfd, recv_cb, reactor);
    375. 	nty_event_add(reactor->epfd, EPOLLIN, event);
    376.  
    377. 	printf("new connect [%s:%d], pos[%d]\n", 
    378. 		inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), clientfd);
    379.  
    380. 	return 0;
    381. }
    382.  
    383. //创建socket监听
    384. int init_sock(short port)
    385. {
    386. 	int fd = socket(AF_INET, SOCK_STREAM, 0);
    387. 	fcntl(fd, F_SETFL, O_NONBLOCK);
    388.  
    389. 	struct sockaddr_in server_addr;
    390. 	memset(&server_addr, 0, sizeof(server_addr));
    391. 	server_addr.sin_family = AF_INET;
    392. 	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    393. 	server_addr.sin_port = htons(port);
    394.  
    395. 	bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    396.  
    397. 	if (listen(fd, 20) < 0) {
    398. 		printf("listen failed : %s\n", strerror(errno));
    399. 		return -1;
    400. 	}
    401.  
    402. 	printf("listen server port : %d\n", port);
    403. 	return fd;
    404. }
    405.  
    406.  
    407. //reactor扩展大小
    408. int ntyreactor_alloc(struct ntyreactor* reactor)
    409. {
    410. 	if(reactor == NULL) return -1;
    411. 	if(reactor->evblks == NULL) return -1;
    412.  
    413. 	struct eventblock* blk = reactor->evblks; //块的头结点
    414.  
    415. 	//找尾节点
    416. 	while(blk->next != NULL){  //找到尾节点
    417. 		blk = blk->next;
    418. 	}
    419.  
    420. 	struct ntyevent* evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
    421. 	if (evs == NULL) {
    422. 		printf("ntyreactor_alloc ntyevent failed\n");
    423. 		return -2;
    424. 	}
    425. 	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
    426.  
    427. 	struct eventblock *block = malloc(sizeof(struct eventblock));
    428. 	if (block == NULL) {
    429. 		printf("ntyreactor_alloc eventblock failed\n");
    430. 		return -3;
    431. 	}
    432. 	//io fd集合连接成块
    433. 	block->events = evs;
    434. 	block->next = NULL;
    435.  
    436. 	//指向新块
    437. 	blk->next = block;
    438. 	reactor->blkcnt ++;
    439.  
    440. 	return 0;
    441. }
    442.  
    443. //根据io fd来找fd结构体
    444. struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd) {
    445. 	if (reactor == NULL) return NULL;
    446. 	if (reactor->evblks == NULL) return NULL;
    447.  
    448. 	int blkidx = sockfd / MAX_EPOLL_EVENTS; //在哪一个块
    449. 	while (blkidx >= reactor->blkcnt) {		//大小不够扩容
    450. 		ntyreactor_alloc(reactor);
    451. 	}
    452.  
    453. 	int i = 0;
    454. 	struct eventblock *blk = reactor->evblks; //头结点块
    455. 	while (i++ != blkidx && blk != NULL) {    //找到所在的块
    456. 		blk = blk->next;
    457. 	}
    458.  
    459. 	return &blk->events[sockfd % MAX_EPOLL_EVENTS]; //返回fd结构体
    460. }
    461.  
    462. //reactor初始化
    463. int ntyreactor_init(struct ntyreactor* reactor)
    464. {
    465. 	if(reactor == NULL) return -1;
    466. 	memset(reactor, 0, sizeof(struct ntyreactor));
    467.  
    468. 	reactor->epfd = epoll_create(1); 
    469. 	if (reactor->epfd <= 0) {
    470. 		printf("create epfd in %s err %s\n", __func__, strerror(errno));
    471. 		return -2;
    472. 	}
    473.  
    474. 	//创建第一个块
    475. 	struct ntyevent* evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
    476. 	if (evs == NULL) {
    477. 		printf("create epfd in %s err %s\n", __func__, strerror(errno));
    478. 		close(reactor->epfd);
    479. 		return -3;
    480. 	}
    481. 	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
    482.  
    483. 	struct eventblock *block = malloc(sizeof(struct eventblock));
    484. 	if (block == NULL) {
    485. 		free(evs);
    486. 		close(reactor->epfd);
    487. 		return -3;
    488. 	}
    489. 	block->events = evs;
    490. 	block->next = NULL;
    491.  
    492. 	reactor->evblks = block;
    493. 	reactor->blkcnt = 1;
    494.  
    495. 	return 0;
    496. }
    497.  
    498. //销毁reactor
    499. int ntyreactor_destory(struct ntyreactor* reactor)
    500. {
    501. 	close(reactor->epfd);
    502.  
    503. 	struct eventblock *blk = reactor->evblks;
    504. 	struct eventblock *blk_next;
    505. 	while (blk != NULL) {
    506. 		blk_next = blk->next;
    507.  
    508. 		free(blk->events);
    509. 		free(blk);
    510. 		
    511. 		blk = blk_next;
    512. 	}
    513.  
    514. 	return 0;
    515. }
    516.  
    517. //初始化接收连接socket
    518. int ntyreactor_addlistener(struct ntyreactor* reactor, int sockfd, NCALLBACK *acceptor){
    519. 	if (reactor == NULL) return -1;
    520. 	if (reactor->evblks == NULL) return -1;
    521.  
    522. 	struct ntyevent* event = ntyreactor_idx(reactor, sockfd);
    523. 	if (event == NULL) return -1;
    524.  
    525. 	nty_event_set(event, sockfd, acceptor, reactor);
    526. 	nty_event_add(reactor->epfd, EPOLLIN, event);
    527.  
    528. 	return 0;
    529. }
    530.  
    531. //reactor事件循环
    532. int ntyreactor_run(struct ntyreactor* reactor)
    533. {
    534. 	if (reactor == NULL) return -1;
    535. 	if (reactor->epfd < 0) return -1;
    536. 	if (reactor->evblks == NULL) return -1;
    537. 	
    538. 	struct epoll_event events[MAX_EPOLL_EVENTS+1];
    539. 	
    540. 	int checkpos = 0, i;
    541.  
    542. 	while(1){
    543. 		int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENTS, 1000);
    544. 		if (nready < 0) {
    545. 			printf("epoll_wait error, exit\n");
    546. 			continue;
    547. 		}
    548.  
    549. 		for(i = 0;i < nready; i++){
    550. 			struct ntyevent* ev = (struct ntyevent*)events[i].data.ptr; //发生事件的io fd结构体
    551.  
    552. 			if((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)){
    553. 				ev->callback(ev->fd, events[i].events, ev->arg);
    554. 			}
    555. 			if((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)){
    556. 				ev->callback(ev->fd, events[i].events, ev->arg);
    557. 			}
    558. 		
    559. 		}
    560.  
    561. 	}
    562.  
    563. }
    564.  
    565. int main(int argc, char *argv[]) {
    566.  
    567. 	struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
    568. 	ntyreactor_init(reactor);
    569.  
    570. 	//起始的端口号
    571. 	unsigned short port = SERVER_PORT;
    572. 	if (argc == 2) {
    573. 		port = atoi(argv[1]);
    574. 	}
    575.  
    576. 	int i = 0;
    577. 	int sockfds[PORT_COUNT] = {0};
    578.  
    579. 	for (i = 0;i < PORT_COUNT;i ++) {
    580. 		sockfds[i] = init_sock(port+i);
    581. 		ntyreactor_addlistener(reactor, sockfds[i], accept_cb);
    582. 	}
    583.  
    584. 	ntyreactor_run(reactor);
    585.  
    586. 	ntyreactor_destory(reactor);
    587. 	
    588. 	for (i = 0;i < PORT_COUNT;i ++) {
    589. 		close(sockfds[i]);
    590. 	}
    591. 	free(reactor);
    592.  
    593. 	return 0;
    594. }
    595.  
    596.  
    597.  
    598.  
    599.  
    600.

    5. 运行结果

     

  • 相关阅读:
    详解设计模式：组合模式
    动规(19)-并查集基础题——城镇道路
    超精准！AI 结合邮件内容与附件的意图理解与分类！
    0号进程，1号进程，2号进程
    wxPython 4.2.0 发布
    通用BIOS自动化修改脚本
    [GitLab CI/CD] 实践操作片段记录
    如何快速优化几千万数据量的订单表
    SpringSecurity系列一：04 SpringSecurity 的默认用户是如何生成的?
    Unity 切换场景后场景变暗
  • 原文地址：https://blog.csdn.net/kakaka666/article/details/126237738