http服务器学习笔记

最新推荐文章于 2024-11-08 17:19:46 发布
最新推荐文章于 2024-11-08 17:19:46 发布
阅读量255 收藏 1
点赞数
分类专栏： 网络编程 Linux C/C++ 文章标签： 服务器 http 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42120843/article/details/127279876
版权
C/C++ 同时被 3 个专栏收录
151 篇文章 23 订阅
订阅专栏
网络编程
33 篇文章 2 订阅
订阅专栏
Linux
8 篇文章 0 订阅
订阅专栏

预备知识

什么是反应堆reactor?

让epoll监视的每个fd，在有事件到来的时候执行对应的回调函数。

reactor在epoll基础上多了什么好处？

  1. epoll是对io的管理，加上reactor后变为对事件进行管理（一个事件对应不同的回调）
  2. 由于sock_item封装，对未处理完的事件，可以放到独立的buffer中
  3. libevent就是epoll+reactor?

以下是封装的结构体：

struct ntyevent {
	int fd;
	int events;
	void *arg;
	int (*callback)(int fd, int events, void *arg);
	
	int status;
	char buffer[BUFFER_LENGTH];
	char wbuffer[BUFFER_LENGTH];
	int length;
	int wlength;
	//long last_active;

	int method;
	char resource[RESOURCE_LENGTH];

};

struct eventblock {
	
	struct eventblock *next;
	struct ntyevent *events;
};

struct ntyreactor {
	int epfd;
	int blkcnt;

	struct eventblock *evblks;
};

HTTP简介（面试题）

HTTP协议服务器传输超文本到本地浏览器的传送协议。 HTTP 是一个基于TCP/IP 通信协议来传递数据（ HTML 文件 , 图片文件 , 查询结果等）。

HTTP协议工作于客户端 服务端架（CS）构上。浏览器作为 HTTP 客户端通过 URL 向 HTTP 服务端即 WEB 服务器发送所有请求。
Web服务器有： Apache 服务器， IIS 服务器（ Internet Information Services ）等。
Web服务器根据接收到 的请求后，向客户端发送响应信息。
HTTP默认端口号为 80 ，但是你也可以改为 8080 或者其他端口。

注意事项
  1. HTTP 是无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的
    请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。
  2. HTTP 是媒体独立的：这意味着，只要客户端和服务器知道如何处理的数据内容，任何
    类型的数据都可以通过 HTTP 发送。客户端以及服务器指定使用适合的 MIME type 内容
    类型。
  3. HTTP 是无状态： HTTP 协议是无状态协议。无状态是指协议对于事务处 理没有记忆能力。
    缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接
    传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。
HTTP协议通信流程

在这里插入图片描述

HTTP消息结构

HTTP是基于客户端 服务端（ C/S ）的架构模型，通过一个可靠的链接来交换信息，是一个无
状态的请求 响应协议。
一个HTTP" 客户端 是一个应用程序（ Web 浏览器或其他任何客户端），通过连接到服务器达
到向服务器发送一个或多个 HTTP 的请求的目的。
一个HTTP" 服务器 同样也是一个应用程序（通常是一个 Web 服务，如 Apache Web 服务器或 IIS 服务器等），通过接收客户端的请求并向客户端发送 HTTP 响应数据。

HTTP使用统一资源标识符（ Uniform Resource Identifiers, URI ）来传输数据和建立连接。

一旦建立连接后，数据消息就通过类似Internet 邮件所使用的格式 [ 和多用途Internet 邮件扩展（ MIME ））[ 来传送。

客户端请求消息

客户端发送一个HTTP 请求到服务器的请求消息包括以下格式：请求行（ requ est line ）、请求头部（ header ）、空行和请求数据四个部分组成，下图给出了请求报文的一般格式。

在这里插入图片描述

客户端请求消息

HTTP响应也由四个部分组成，分别是**：状态行、消息报头、空行和响应正文。**

在这里插入图片描述

程序实现关键部分

请求报文的解析

通过原来的代码获得浏览器访问服务器获得的请求数据

在这里插入图片描述

其中第一行的GET代表请求方法，/index.html代表请求资源的路径， HTTP/1.1代表协议。

首先了解到recv_cb函数，是可读事件发生时调用的回调函数，在这个函数里我们对接受到的http请求报文进行解析，重点就是解析出请求行中的【请求方法】和【请求资源的路径】，故我们封装一个nty_http_request函数进行处理：

int nty_http_request(struct ntyevent *ev){
	char linebuffer[1024] = {0};

	//获取请求行
	int idx = readline(ev->buffer, 0, linebuffer);

    //查找在linebuffer里"GET"第一次出现的下标
	if(strstr(linebuffer, "GET")) {
		ev->method = HTTP_METHOD_GET; //1.解析出 【请求方法】
		
		//解析出请求行中的资源路径
		int i = 0;
		//sizeof("GET ") 结果为5,结尾\0也算一个
		while(linebuffer[sizeof("GET ") + i] != ' ') i++;
		linebuffer[sizeof("GET ") + i] = '\0';
		//2.解析出请求资源路径
		sprintf(ev->resource, "%s/%s", HTTP_WEB_ROOT, linebuffer + sizeof("GET "));

		//printf("resource: %s\n",ev->resource);

	}else if(strstr(linebuffer, "POST")){
		ev->method = HTTP_METHOD_POST;
	}
}

对http请求组织响应报文（response）

当有事件可写的时候，表示收到请求报文，我们要发出响应报文给对端，则会调用函数send_cb，其中一个关键步骤就是组织好即将要发送的报文

发送的是html文件的响应报文header应该为

len = sprintf(ev->wbuffer,
	"HTTP/1.1 200 OK\r\n"
"Accept-Ranges: bytes\r\n"
"Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform\r\n"
"Connection: keep-alive\r\n"
"Content-Length: 79\r\n"
"Content-Type: text/html\r\n"
"Date: Fri, 07 Oct 2022 12:52:22 GMT\r\n\r\n"
"<html><head><title>ynufe.jyh</title></head><body><h1>jyh</h1></body></html>\r\n");

若发送的是图片文件的响应报文header应该为

len = sprintf(ev->wbuffer,
	"HTTP/1.1 200 OK\r\n"
"Accept-Ranges: bytes\r\n"
"Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform\r\n"
"Connection: keep-alive\r\n"
"Content-Length: %ld\r\n"
"Content-Type: image/png\r\n"
"Date: Fri, 07 Oct 2022 12:52:22 GMT\r\n\r\n", stat_buf.st_size);

//组织响应正文前的内容header
int nty_http_response_get_method(struct ntyevent *ev){

	int filefd = open(ev->resource, O_RDONLY);
	int len = 0;
	if(filefd == -1){
		len = sprintf(ev->wbuffer,
	"HTTP/1.1 200 OK\r\n"
"Accept-Ranges: bytes\r\n"
"Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform\r\n"
"Connection: keep-alive\r\n"
"Content-Length: 79\r\n"
"Content-Type: text/html\r\n"
"Date: Fri, 07 Oct 2022 12:52:22 GMT\r\n\r\n"
"<html><head><title>ynufe.jyh</title></head><body><h1>jyh</h1></body></html>\r\n");

		ev->wlength = len;

	}else{

		//struct stat 是描述一个linux系统文件系统中的文件属性的结构
		struct stat stat_buf;
		fstat(filefd, &stat_buf); //将filefd对应文件的信息写入stat_buf
		close(filefd);

		len = sprintf(ev->wbuffer,
	"HTTP/1.1 200 OK\r\n"
"Accept-Ranges: bytes\r\n"
"Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform\r\n"
"Connection: keep-alive\r\n"
"Content-Length: %ld\r\n"
"Content-Type: image/png\r\n"
"Date: Fri, 07 Oct 2022 12:52:22 GMT\r\n\r\n", stat_buf.st_size);
		ev->wlength = len;
	}

	return len;
}
//取出资源，然后sendcb发送该资源
int nty_http_response(struct ntyevent *ev){

	//ev->method, ev-resources
	if(ev->method == HTTP_METHOD_GET){
		return nty_http_response_get_method(ev);
	}else if(ev->method == HTTP_METHOD_POST){

	}

}

组织响应报文的格式一定要正确，比方说响应正文前面是有一个空行，所以在正文之前的有内容的行最后是\r\n\r\n

不然浏览器解析的时候就会提示ERR_INVALID_HTTP_RESPONSE

send_cb函数如下：

int send_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);

	if (ev == NULL) return -1;

	nty_http_response(ev); //encode

    //发送header(状态行、消息报头、空行)
	int len = send(fd, ev->wbuffer, ev->wlength, 0);
	if (len > 0) {
		printf("resource:%s\n",ev->resource);
		//打开文件，并发送body（响应正文）
		int filefd = open(ev->resource, O_RDONLY);
		struct stat stat_buf;
		fstat(filefd, &stat_buf);

		//设置回阻塞
		int flag = fcntl(fd, F_GETFL, 0);
        //O_NONBLOCK是 0000....100000,
        //故~O_NONBLOCK就是1111....011111,就把NONBLOCK的那一位置零了
		flag &= ~O_NONBLOCK;
		fcntl(fd, F_SETFL, flag);

		//fd为发送的通道，filefd为发送的文件
		//这是一个要求阻塞的函数，但是我们的fd是非阻塞的，（不设置阻塞其实也可以)
		int ret = sendfile(fd, filefd, NULL, stat_buf.st_size);


		if(ret == -1) {
			printf("sendfile: errno: %d\n",errno);
		}

		flag |= O_NONBLOCK;
		fcntl(fd, F_SETFL, flag);

		close(filefd);
		nty_event_del(reactor->epfd, ev);
		nty_event_set(ev, fd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, ev);
		
	} else {

		nty_event_del(reactor->epfd, ev);
		close(ev->fd);

		printf("send[fd=%d] error %s\n", fd, strerror(errno));

	}

	return len;
}

sendfile()效率比 read() + write()要高，因为它采用了零拷贝，直接在内核态就将文件fd对应的缓冲区数据传给socketfd的发送缓冲区。 mmap

多输出一条语句（如printf），会导致web服务器连接数的效率急剧下降

在这里插入图片描述

上面红圈是有printf测试的结果，下面红圈是没有printf测试结果，可以看出性能差距高达2倍以上。可以看出io操作非常费时。

设置端口复用

有时候我们主动服务器停止服务器，造成连接断开，由于2msl 的 time_wait状态，导致端口仍没有释放，我们可以在监听fd绑定地址端口之前设置端口复用：

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

完整代码



#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/sendfile.h>

#include <fcntl.h>
#include <unistd.h>
#include <errno.h>


#define BUFFER_LENGTH		1024
#define MAX_EPOLL_EVENTS	1024
#define RESOURCE_LENGTH		1024
#define SERVER_PORT			8888
#define PORT_COUNT			1

typedef int NCALLBACK(int ,int, void*);

#define HTTP_METHOD_GET		0
#define HTTP_METHOD_POST	1
#define HTTP_WEB_ROOT		"/home/jyhlinux/share/2.1.3_http_server/html"
struct ntyevent {
	int fd;
	int events;
	void *arg;
	int (*callback)(int fd, int events, void *arg);
	
	int status;
	char buffer[BUFFER_LENGTH];
	char wbuffer[BUFFER_LENGTH];
	int length;
	int wlength;
	//long last_active;

	int method;
	char resource[RESOURCE_LENGTH];

};

struct eventblock {
	
	struct eventblock *next;
	struct ntyevent *events;
};

struct ntyreactor {
	int epfd;
	int blkcnt;

	struct eventblock *evblks;
};


int recv_cb(int fd, int events, void *arg);
int send_cb(int fd, int events, void *arg);
struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd);



void nty_event_set(struct ntyevent *ev, int fd, NCALLBACK callback, void *arg) {

	ev->fd = fd;
	ev->callback = callback;
	ev->events = 0;
	ev->arg = arg;
	//ev->last_active = time(NULL);

	return ;
	
}


int nty_event_add(int epfd, int events, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};
	ep_ev.data.ptr = ev;
	ep_ev.events = ev->events = events;

	int op;
	if (ev->status == 1) {
		op = EPOLL_CTL_MOD;
	} else {
		op = EPOLL_CTL_ADD;
		ev->status = 1;
	}

	if (epoll_ctl(epfd, op, ev->fd, &ep_ev) < 0) {
		printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
		return -1;
	}

	return 0;
}

int nty_event_del(int epfd, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};

	if (ev->status != 1) {
		return -1;
	}

	ep_ev.data.ptr = ev;
	ev->status = 0;
	epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ep_ev);

	return 0;
}

//读取allbuf一行到linebuf中，返回下一行的起始下标
int readline(char *allbuf, int idx, char *linebuf){
	int len = strlen(allbuf);

	for(;idx < len; ++idx){
		//\r\n表示换行
		if(allbuf[idx] == 'r' && allbuf[idx + 1] == '\n')
			return idx + 2;
		else
			*(linebuf++) = allbuf[idx];
	}
	return -1;
}

//对请求进行处理
int nty_http_request(struct ntyevent *ev){
	char linebuffer[1024] = {0};

	//获取请求行
	int idx = readline(ev->buffer, 0, linebuffer);

	//查找在linebuffer里"GET"第一次出现的下标
	if(strstr(linebuffer, "GET")) {
		ev->method = HTTP_METHOD_GET; 
		//printf("sizeof(\"GET \") : %ld\n", sizeof("GET "));
		//解析出请求行中的资源路径
		int i = 0;
		//sizeof("GET ") 结果为5,结尾\0也算一个
		while(linebuffer[sizeof("GET ") + i] != ' ') i++;
		linebuffer[sizeof("GET ") + i] = '\0';

		sprintf(ev->resource, "%s/%s", HTTP_WEB_ROOT, linebuffer + sizeof("GET "));

		//printf("resource: %s\n",ev->resource);

	}else if(strstr(linebuffer, "POST")){
		ev->method = HTTP_METHOD_POST;
	}
}

int nty_http_response_get_method(struct ntyevent *ev){


#if 0
	int len = sprintf(ev->wbuffer,
	"HTTP/1.1 200 OK\r\n"
"Accept-Ranges: bytes\r\n"
"Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform\r\n"
"Connection: keep-alive\r\n"
"Content-Length: 79\r\n"
"Content-Type: text/html\r\n"
"Date: Fri, 07 Oct 2022 12:52:22 GMT\r\n\r\n"
"<html><head><title>ynufe.jyh</title></head><body><h1>jyh</h1></body></html>\r\n");

	ev->wlength = len;
#else
	int filefd = open(ev->resource, O_RDONLY);
	int len = 0;
	if(filefd == -1){
		len = sprintf(ev->wbuffer,
	"HTTP/1.1 200 OK\r\n"
"Accept-Ranges: bytes\r\n"
"Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform\r\n"
"Connection: keep-alive\r\n"
"Content-Length: 79\r\n"
"Content-Type: text/html\r\n"
"Date: Fri, 07 Oct 2022 12:52:22 GMT\r\n\r\n"
"<html><head><title>ynufe.jyh</title></head><body><h1>jyh</h1></body></html>\r\n");

		ev->wlength = len;

	}else{

		//struct stat 是描述一个linux系统文件系统中的文件属性的结构
		struct stat stat_buf;
		fstat(filefd, &stat_buf);
		close(filefd);
#endif
#if 0
		len = sprintf(ev->wbuffer,
	"HTTP/1.1 200 OK\r\n"
"Accept-Ranges: bytes\r\n"
"Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform\r\n"
"Connection: keep-alive\r\n"
"Content-Length: %ld\r\n"
"Content-Type: text/html\r\n"
"Date: Fri, 07 Oct 2022 12:52:22 GMT\r\n\r\n", stat_buf.st_size);
#else //发图片
		len = sprintf(ev->wbuffer,
	"HTTP/1.1 200 OK\r\n"
"Accept-Ranges: bytes\r\n"
"Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform\r\n"
"Connection: keep-alive\r\n"
"Content-Length: %ld\r\n"
"Content-Type: image/png\r\n"
"Date: Fri, 07 Oct 2022 12:52:22 GMT\r\n\r\n", stat_buf.st_size);
		ev->wlength = len;
	}

#endif 
	return len;
}
//取出资源，然后sendcb发送该资源
int nty_http_response(struct ntyevent *ev){

	//ev->method, ev-resources
	if(ev->method == HTTP_METHOD_GET){
		return nty_http_response_get_method(ev);
	}else if(ev->method == HTTP_METHOD_POST){

	}

}

int recv_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);

	if (ev == NULL) return -1;

	int len = recv(fd, ev->buffer, BUFFER_LENGTH, 0);
	nty_event_del(reactor->epfd, ev);

	if (len > 0) {
		
		ev->length = len;
		ev->buffer[len] = '\0';

		//printf("recv [%d]:%s\n", fd, ev->buffer);
		
		nty_http_request(ev); //!!!parser http header

		nty_event_set(ev, fd, send_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLOUT, ev);
		
		
	} else if (len == 0) {

		nty_event_del(reactor->epfd, ev);
		//printf("recv_cb --> disconnect\n");
		close(ev->fd);
		 
	} else {

		if (errno == EAGAIN && errno == EWOULDBLOCK) { //
			
		} else if (errno == ECONNRESET){
			nty_event_del(reactor->epfd, ev);
			close(ev->fd);
		}
		printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
		
	}

	return len;
}


int send_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);

	if (ev == NULL) return -1;

	nty_http_response(ev); //encode获取待发送的资源

	int len = send(fd, ev->wbuffer, ev->wlength, 0);
	if (len > 0) {
		printf("resource:%s\n",ev->resource);
		//打开文件，并发送文件
		int filefd = open(ev->resource, O_RDONLY);
		struct stat stat_buf;
		fstat(filefd, &stat_buf);

		//设置回阻塞
		int flag = fcntl(fd, F_GETFL, 0);
		flag &= ~O_NONBLOCK;
		fcntl(fd, F_SETFL, flag);

		//fd为发送的通道，filefd为发送的文件
		//这是一个要求阻塞的函数，但是我们的fd是非阻塞的，（不设置阻塞其实也可以)
		int ret = sendfile(fd, filefd, NULL, stat_buf.st_size);


		if(ret == -1) {
			printf("sendfile: errno: %d\n",errno);
		}

		flag |= O_NONBLOCK;
		fcntl(fd, F_SETFL, flag);

		close(filefd);
		nty_event_del(reactor->epfd, ev);
		nty_event_set(ev, fd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, ev);
		
	} else {

		nty_event_del(reactor->epfd, ev);
		close(ev->fd);

		printf("send[fd=%d] error %s\n", fd, strerror(errno));

	}

	return len;
}

int accept_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	if (reactor == NULL) return -1;

	struct sockaddr_in client_addr;
	socklen_t len = sizeof(client_addr);

	int clientfd;

	if ((clientfd = accept(fd, (struct sockaddr*)&client_addr, &len)) == -1) {
		if (errno != EAGAIN && errno != EINTR) {
			
		}
		printf("accept: %s\n", strerror(errno));
		return -1;
	}

	
	int flag = 0;
	if ((flag = fcntl(clientfd, F_SETFL, O_NONBLOCK)) < 0) {
		printf("%s: fcntl nonblocking failed, %d\n", __func__, MAX_EPOLL_EVENTS);
		return -1;
	}

	struct ntyevent *event = ntyreactor_idx(reactor, clientfd);

	if (event == NULL) return -1;
		
	nty_event_set(event, clientfd, recv_cb, reactor);
	nty_event_add(reactor->epfd, EPOLLIN, event);

	

	//printf("new connect [%s:%d], pos[%d]\n", 
	//inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), clientfd);

	return 0;

}

int init_sock(short port) {

	int fd = socket(AF_INET, SOCK_STREAM, 0);
	fcntl(fd, F_SETFL, O_NONBLOCK);


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

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(port);

	bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));

	if (listen(fd, 20) < 0) {
		printf("listen failed : %s\n", strerror(errno));
		return -1;
	}

	printf("listen server port : %d\n", port);
	return fd;
}


int ntyreactor_alloc(struct ntyreactor *reactor) {

	if (reactor == NULL) return -1;
	if (reactor->evblks == NULL) return -1;
	
	struct eventblock *blk = reactor->evblks;

	while (blk->next != NULL) {
		blk = blk->next;
	}

	struct ntyevent* evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
	if (evs == NULL) {
		printf("ntyreactor_alloc ntyevent failed\n");
		return -2;
	}
	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));

	struct eventblock *block = malloc(sizeof(struct eventblock));
	if (block == NULL) {
		printf("ntyreactor_alloc eventblock failed\n");
		return -3;
	}
	block->events = evs;
	block->next = NULL;

	blk->next = block;
	reactor->blkcnt ++;

	return 0;
}

struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd) {

	if (reactor == NULL) return NULL;
	if (reactor->evblks == NULL) return NULL;

	int blkidx = sockfd / MAX_EPOLL_EVENTS;
	while (blkidx >= reactor->blkcnt) {
		ntyreactor_alloc(reactor);
	}

	int i = 0;
	struct eventblock *blk = reactor->evblks;
	while (i++ != blkidx && blk != NULL) {
		blk = blk->next;
	}

	return &blk->events[sockfd % MAX_EPOLL_EVENTS];
}


int ntyreactor_init(struct ntyreactor *reactor) {

	if (reactor == NULL) return -1;
	memset(reactor, 0, sizeof(struct ntyreactor));

	reactor->epfd = epoll_create(1);
	if (reactor->epfd <= 0) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		return -2;
	}

	struct ntyevent* evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
	if (evs == NULL) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		close(reactor->epfd);
		return -3;
	}
	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));

	struct eventblock *block = malloc(sizeof(struct eventblock));
	if (block == NULL) {
		free(evs);
		close(reactor->epfd);
		return -3;
	}
	block->events = evs;
	block->next = NULL;

	reactor->evblks = block;
	reactor->blkcnt = 1;

	return 0;
}

int ntyreactor_destory(struct ntyreactor *reactor) {

	close(reactor->epfd);

	struct eventblock *blk = reactor->evblks;
	struct eventblock *blk_next;
	while (blk != NULL) {
		blk_next = blk->next;

		free(blk->events);
		free(blk);
		
		blk = blk_next;
	}

	return 0;
}



int ntyreactor_addlistener(struct ntyreactor *reactor, int sockfd, NCALLBACK *acceptor) {

	if (reactor == NULL) return -1;
	if (reactor->evblks == NULL) return -1;

	struct ntyevent *event = ntyreactor_idx(reactor, sockfd);
	if (event == NULL) return -1;

	nty_event_set(event, sockfd, acceptor, reactor);
	nty_event_add(reactor->epfd, EPOLLIN, event);

	return 0;
}



int ntyreactor_run(struct ntyreactor *reactor) {
	if (reactor == NULL) return -1;
	if (reactor->epfd < 0) return -1;
	if (reactor->evblks == NULL) return -1;
	
	struct epoll_event events[MAX_EPOLL_EVENTS+1];
	
	int checkpos = 0, i;

	while (1) {

		int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENTS, 1000);
		if (nready < 0) {
			printf("epoll_wait error, exit\n");
			continue;
		}

		for (i = 0;i < nready;i ++) {

			struct ntyevent *ev = (struct ntyevent*)events[i].data.ptr;

			if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) {
				ev->callback(ev->fd, events[i].events, ev->arg);
			}
			if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) {
				ev->callback(ev->fd, events[i].events, ev->arg);
			}
			
		}

	}
}

int main(int argc, char *argv[]) {

	
	struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
	ntyreactor_init(reactor);

	unsigned short port = SERVER_PORT;
	if (argc == 2) {
		port = atoi(argv[1]);
	}

	int i = 0;
	int sockfds[PORT_COUNT] = {0};
	
	for (i = 0;i < PORT_COUNT;i ++) {
		sockfds[i] = init_sock(port+i);
		ntyreactor_addlistener(reactor, sockfds[i], accept_cb);
	}


	ntyreactor_run(reactor);

	ntyreactor_destory(reactor);
	
	for (i = 0;i < PORT_COUNT;i ++) {
		close(sockfds[i]);
	}
	free(reactor);
	

	return 0;
}

杂项

  1. 因为io类型不同（磁盘io、网络io、定时器io）所以，回调函数对每一个fd可能要单独写

  2. errno 9 （EBADF Bad file descriptor），可能是filefd已被close

进阶&问题

  1. 阅读reactor代码,练习手撕reactor？
  2. recv_cb和send_cb能拆分成几个阶段
  3. 在多个线程同时调用epoll_wait(epfd)会惊群，要用oneshot解决
FuzhouJiang
关注
专栏目录
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
HTTP学习
weixin_44391390的博客
02-22 299
一、简介 HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。 二、特点 无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。 媒体独立：这意味着，只要客户端和服务器知道如何处...
详细HTTP学习指南
螺旋翻转大大雄
02-06 400
下面，将简单介绍一下HTTP组成1：请求行作用声明 请求方法 、主机域名、资源路径 & 协议版本结构请求行的组成 = 请求方法 + 请求路径 + 协议版本注：空格不能省组成介绍此处特意说明GET、PSOT方法的区别：示例设：请求报文采用GET方法、URL地址 = http://www.tsinghua.edu.cn/chn/yxsz/index.htm；HTTP1.1版本组成2：请求头作用：声明 客户端、服务器 / 报文的部分信息。
HTTP学习（超详细 整理）
疯
02-16 2762
HTTP简介 HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。 HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。 HTTP 工作原理 HTTP协议工作于客户端-服务端架构为上。浏览器作为HTTP客户端通过URL...
http的学习思考
object_oriented的博客
12-17 1855
长连接和短连接 1.http1.0默认使用短连接，http1.1默认使用长连接并且在响应头加入Connection:keep-alive 2.短连接：客户端每进行一次Http操作就建立连接，任务结束就中断连接。 3.长连接：当客户端域服务端进行一次http操作建立连接后，不会中断，下次继续使用。Keep_Alive有一个保活时间，在不同的服务器可以设置（Apache）默认超时时间是60s 4.tomcat设置长连接 Keep_Alive是服务端实现的 <Connector port="80
HTTP学习笔记
07-01
HTTP学习笔记 HTTP协议是万维网的基础协议，主要规定了浏览器和万维网服务器之间的相互通信规则。下面是对HTTP协议的详细介绍： 一、HTTP协议的定义 HTTP协议（超文本协议）是一种详细规定了浏览器和万维网...
HTTP协议学习笔记之c++
07-09
### HTTP协议学习笔记之C++ #### 一、HTTP协议基础 HTTP（Hypertext Transfer Protocol）是一种应用层协议，主要用于客户端（例如Web浏览器）与服务器之间的数据交换。它基于TCP/IP协议栈，利用TCP来确保数据传输...
ORACLE学习笔记.pdf
07-13
2. **OHS (Oracle HTTP Server)**: OHS是Oracle Web服务器组件，基于Apache HTTP Server，用于处理HTTP请求并与Oracle应用服务器交互。 3. **SGA (System Global Area)**: SGA是Oracle数据库实例的一部分，存储...
Nginx学习笔记
03-27
【Nginx学习笔记】 Nginx是一款由俄罗斯开发者Igor Sysoev设计的高性能、高并发的Web服务器和反向代理服务器。最初应用于俄罗斯知名网站www.rambler.ru，随后开源，采用类BSD许可，使得全球用户都能使用。Nginx以其...
Linux/Unix echo命令
Oo_Amy_oO的博客
11-04 1100
echo是 Linux 和 Unix 系统中一个非常基本且常用的命令行工具，用于在终端或文件中显示文本。以下是一些echo在终端显示 “Hello, World!echo $PATH显示环境变量PATH的值。将 “New content” 写入file.txt，如果文件不存在则创建它。将 “Additional content” 追加到file.txt文件的末尾。使用-e选项来解释转义序列（如\n表示换行）。使用-n选项来防止echo命令在输出后添加换行符。echo $?显示上一个命令的退出状态。$(
Linux的基本指令（一）
最新发布
2302_80378107的博客
11-08 607
对于目录，该命令列出该目录下的所有子目录与文件。对于文件，将列出文件名以及信息。-a列出目录下的所有文件，包括以 . 开头的隐含文件。-l列出文件的详细信息。
通过 ssh config 快速免密连接服务器
上烟雨心上尘的博客
11-05 305
ssh-copy-id -i 私钥的地址 username@ip_address。在类似目录可以看到生成的内容（config 文件是后面生成的）如果没有ssh-copy-id指令可以自行百度进行安装。
物理服务器-内存损坏导致的操作系统启动异常问题的处理
大新新大浩浩的博客
11-04 528
物理服务器-内存损坏导致的操作系统启动异常问题的处理
学Linux的第六天
weixin_73929563的博客
10-31 1273
groupadd参数 工作组名-g GID：指定新工作组的GID，默认值是已有的最大的GID加1-r： 建立一个系统组账号，与-g不同时使用时则分配一个1999的GID//添加一个组ID为2000,组名为group2的新组groupmod参数 工作组名-g GID——为用户组指定新的组标识号-n新用户组——将用户组的名字改为新名字修改用户组的名称和用户组的GID值将组group1的GID修改为3000,组名修改为group11。
弹性裸金属服务器和传统裸金属服务器有什么区别？
wanhengwangluo的博客
11-05 474
弹性裸金属服务器则可以完全独享服务器的物理资源，没有虚拟化层的成本，在管理权限上某些底层硬件管理和配置还是需要依赖云服务提供商，并不能有着完全的硬件控制权限。弹性裸金属服务器能够支持企业快速部署新的硬件和软件系统，让用户可以快速利用最新的科学技术，预先配置了硬件和自动化部署流程，可以更快的进行调配资源；弹性裸金属服务器是一种结合了传统裸金属服务器和云计算资源两种特点的服务器，是一种云计算服务，下面我们就来了解一下弹性裸金属服务器和传统裸金属服务器之间有什么区别吧！
ClickHouse集成Mysql表引擎跨服务器读表说明
从未完美过的博客
11-05 717
MySQL引擎用于将远程的MySQL服务器中的表映射到ClickHouse中，并允许您对表进行。数据库引擎会将对其的查询转换为MySQL语法并发送到MySQL服务器中，因此您可以执行诸如。Clickhouse 上的MySQL引擎可以对存在远程MySQL。查询，以方便您在ClickHouse与MySQL之间进行数据交换。将转换为指定列类型的默认值（通常为0或空字符串）。采样约束语句仅在对MySQL的查询完成后才在。值，因此，当从MySQL表中读取数据时，）是在MySQL服务器上执行。
如何使用SSH密钥和公钥加密技术保护您的cPanel服务器
web_geek的博客
11-06 350
简而言之，公钥加密是一种加密方法，它使用一对密钥：公钥和私钥。公钥用于加密，私钥用于解密。即使别人获得了公钥，也无法解密出私钥加密的信息。比如，你想发送一条加密消息给朋友，你会使用朋友的公钥进行加密，然后朋友用他们的私钥解密。只要私钥未被泄露，只有你的朋友才能解读这条信息。公钥加密的这一特性使其广泛应用于网络安全领域，例如HTTPS加密和SSH密钥。通过使用SSH密钥，你不仅可以提高服务器的安全性，还能简化了登录过程。
dell服务器安装ESXI8
m0_65482680的博客
11-08 232
本文主要记录一下安装ESXI的过程，其中选择的是vm的基本镜像，也可现在厂商提供的专用版本，本次安装没有遇到问题。
关于Dell r730xd 老服务器的阵列卡 配置系统盘RAID 1
Connor_xie的博客
11-08 250
完成后，OK 确认，完成第一个 RAID 1 480GB 系统盘的制作，后续的磁盘可以有相同的操作步骤。最后保存退出重启，安装操作系统。– 选择 RAID 1 模式，选择两块相同大小型号的磁盘，480GB ，空格键是选择磁盘的。– 再次选择 ID:0 , 446,625GB 虚拟磁盘选项，按 2F 进入后修改一下 虚拟磁盘的名称。– 进入Advanced 后，选择 Initialize 初始化磁盘，不然安装系统时无法识别到磁盘。–最后确认并退出，回到主页后会出现一个提示框，直接 回车确定就好了。
Exchange2007 学习笔记：服务器角色详解
"Exch2007学习笔记主要介绍了Exchange Server 2007的不同服务器角色，包括邮箱服务器、客户端访问服务器、统一消息服务器、集线器传输服务器和边缘传输服务器，以及它们的功能和部署策略。这些笔记旨在帮助IT专业...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值