linux c/c++服务器开发-网络编程-reactor模型简单http服务器应用

最新推荐文章于 2024-08-23 20:35:15 发布
最新推荐文章于 2024-08-23 20:35:15 发布
阅读量80 收藏
点赞数
文章标签： 服务器 网络 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34569744/article/details/132157946
版权 
#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 <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/time.h>

#include <sys/sendfile.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

int curfds = 0;

#define TIME_SUB_MS(tv1, tv2)  ((tv1.tv_sec - tv2.tv_sec) * 1000 + (tv1.tv_usec - tv2.tv_usec) / 1000)

struct timeval tv_begin;

#define HTTP_WEB_ROOT	"/home/0Voice/practice/2_1_1_multi-io/index.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;
	
	// http reqeust
	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;
}

// request
// location  /0voice/king/index.html HTTP/1.1
int readline(char* allbuf,int idx,char* linebuf)
{
	int len = strlen(allbuf);
	
	for (;idx < len; ++idx)
	{
		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);
	if (strstr(linebuffer, "GET"))
	{
		ev->method = HTTP_METHOD_GET;
		
		int i = 0;
		while(linebuffer[sizeof("GET ") + i] != ' ') 
			i++;
		linebuffer[sizeof("GET ") + i] = '\0';
		
		//sprintf(ev->resource, "%s/%s", HTTP_WEB_ROOT, linebuffer+sizeof("GET "));
		sprintf(ev->resource, "%s", HTTP_WEB_ROOT);
		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)
{
	int filefd = open(ev->resource, O_RDONLY);
	int len = 0;
	if (filefd == -1) //fail
	{
		int len = sprintf(ev->wbuffer, 
			"HTTP/1.1 200 OK\r\n"
			"Accept-Ranges: bytes\r\n"
			"Content-Length: 78\r\n"
			"Content-Type: text/html\r\n"
			"Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n"
			"<html><head><title>qq.com</title></head><body><h1>Com</h1><body/></html>");
		ev->wlength = len;
	}
	else
	{
		printf("open resource ok \n");
		struct stat stat_buf;
		fstat(filefd, &stat_buf);
		close(filefd);
		
		int len = sprintf(ev->wbuffer, 
			"HTTP/1.1 200 OK\r\n"
			"Accept-Ranges: bytes\r\n"
			"Content-Length: %ld\r\n"
			"Content-Type: text/html\r\n"
			"Date: Sat, 06 Aug 2022 13:16:46 GMT\r\n\r\n", stat_buf.st_size);
		ev->wlength = len;
	}

	return len;
}

int nty_http_response(struct ntyevent *ev)
{
	// ev->method, ev->resouces
	if (ev->method == HTTP_METHOD_GET)
	{
		return nty_http_response_get_method(ev);
	}
	else if (ev->method == HTTP_METHOD_POST)
	{
		
	}
}
	
// connection
// sock_item --> fd, rbuffer, wbuffer, clientaddr
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 hdr
		
		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); //send header
	if (len > 0)
	{
		int filefd = open(ev->resource, O_RDONLY);
		if (filefd < 0) return -1;
		
		struct stat stat_buf;
		fstat(filefd, &stat_buf);
		
		int flag = fcntl(fd, F_GETFL, 0);
		flag &= ~O_NONBLOCK;
		fcntl(fd, F_SETFL, flag);
			
		int ret = sendfile(fd, filefd, NULL, stat_buf.st_size); //sendbody
		if (ret == -1)
		{
			printf("sendfile: errno: %d\n", errno);
		}
		
		flag |= O_NONBLOCK;
		fcntl(fd, F_SETFL, flag);
		
		close(filefd);
		
		send(fd, "\r\n", 2, 0);
		
		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 = -1;
	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 = -1;
	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);

	if (curfds++ % 1000 == 999) {
		struct timeval tv_cur;
		memcpy(&tv_cur, &tv_begin, sizeof(struct timeval));
		
		gettimeofday(&tv_begin, NULL);
		
		int time_used = TIME_SUB_MS(tv_begin, tv_cur);
		printf("connections: %d, sockfd:%d, time_used:%d\n", curfds, clientfd, time_used);
	}
	
	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);
	
	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);
	gettimeofday(&tv_begin, NULL);
	
	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;
}

在这里插入图片描述在这里插入图片描述在这里插入图片描述

qq_34569744
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux C 实现简单的HTTP服务器
wwxy1995的博客
07-11 3538
要实现HTTP服务器，首先要了解HTTP请求报文格式和HTTP相应报文格式 HTTP请求报文 HTTP响应报文 HTTP方法 GET：获取资源 POST：传输实体主体 POST 主要目的不是获取资源，而是传输实体主体数据。 GET 和 POST 的请求都能使用额外的参数，但是 GET 的参数是以查询字符串出现在 URL中，而 POST 的参数存储在实体主体部分。 ...
linux平台下C语言实现一个简单的httpsever
05-14
linux 平台下实现一个简单httpserver 具体可以参考个人博客。
Linux下编写C++服务器(HTTP服务器)
qq_39554698的博客
08-14 6134
今天使用Makefile写一个HTTP的服务器，之前没有接触过Makefile，需要探索一下。 VS2015下测试Makefile 新建一个Makefile Project(Linux)，这里名为HTTPTest； 添加新建项， 添加C ++文件（.cpp）,名为main.cpp， 内容如下： #pragma once #pragma execution_character_set("ut...
linux c/c++服务器开发-网络编程-reactor模型
qq_34569744的博客
08-06 57
linux c/c++服务器开发-网络编程-reactor模型
linux c/c++服务器开发-网络编程-reactor模型（理论）
qq_34569744的博客
08-19 51
linux c/c++服务器开发-网络编程-reactor模型（理论）
Linux C_C++后端服务器架构开发1
08-03
2. **高性能网络设计**：网络编程是后端开发的核心，课程会讲解网络I/O模型（如select、poll、epoll），reactor模式，HTTP/HTTPS服务器的实现，WebSocket协议，以及如何实现百万并发的服务器。还会涉及POSIX API、...
linux C++ 服务器/后台开发 秋招整理资料
10-03
Linux C++ 服务器/后台开发是信息...这些知识点是Linux C++服务器/后台开发的基础，通过深入学习和实践，开发者可以构建稳定、高效的服务端应用。对于求职者来说，熟练掌握这些内容将大大提高在秋招面试中的竞争力。
多线程服务器的常用编程模型.zip
06-12
在IT领域，多线程服务器编程是构建高性能网络服务的核心技术之一。服务器通常需要处理大量并发请求，而多线程模型能有效地利用系统资源，提高响应速度和吞吐量。本压缩包“多线程服务器的常用编程模型.zip”包含了...
多进程和多线程基础概念LINUX
2301_79109608的博客
08-22 1033
直接访问物理地址,会导致地址空间没有隔离,很容易导致数据被修改通过虚拟地址空间可以实现每个进程空间都是独立的，操作系统会映射到不用的物理地址区间，在访问时互不干扰.进程状态分为三个基本状态，即运行态，就绪态，阻塞态。在五态模型中，进程分为新建态、终止态，运行态，就绪态，阻塞态。并发：有限的 cpu 核芯的情况下 ,利用快速交替(时间片轮转)执行来达到宏观上的同时执行。虚拟地址 : 虚拟地址并不代表真实的内存空间,而是一个用于寻址的编号。并行：在 cpu 多核的支持下，实现物理上的同时执行。
黑神话悟空无法登录服务器怎么办
IDC_USA的博客
08-23 457
黑神话悟空游戏在登录的时候会遇到无法登录服务器的问题，玩家可以采用一些有效的方法进行解决，其中最主要的措施就是优化网络环境和减少网络干扰。Rak小编为您整理黑神话悟空无法登录服务器如何解决的步骤及注意事项。
仿Muduo库实现高并发服务器——Acceptor模块
2201_75324712的博客
08-22 428
Acceptor模块是为了创建套接字，并且接收新到来的客户端套接字，将对应套接字的Channel对象添加到Poller对象中，进行事件监控。
Windows Server查看W3SVC IIS服务器中对应的网站日志
滴水石穿
08-22 303
W3SVC1、W3SVC2、W3SVC3…基本上每个网站存放日志的文件夹名称都是以W3SVC开头，区别在于后面的ID/编号/序号，对应的是网站各自的ID。如果没有自定义站点的日志路径，日志默认的路径是C:\inetpub\logs\LogFiles\。W3SVC日志文件夹中序号的含义，格式就是W3SVC+网站ID。
仿Muduo库实现高并发服务器——Server.hpp框架的简单描述
2201_75324712的博客
08-21 1308
下面这张图 是channel模块，poller模块，TimerWheel模块，EventLoop模块，LoopThreadPool模块进行组合。便于大家对这个项目的理解，因为代码看起来挺复杂的。下面这个图，加入了Connection模块，Buffer模块，socket模块，Acceptor模块，Tcpserver模块。算是将server.hpp，进行了框架描述。
【网络编程】select实现服务器与客户端进行通信
2301_77133426的博客
08-21 310
select实现服务器与客户端进行通信
高防服务器租用多少钱
IDC_USA的博客
08-20 467
高防服务器租用的具体价格受多种因素影响。通常情况下，高防服务器的租用费用可能从数百元到数万元不等，具体取决于服务提供商、服务器配置、防护级别等因素。下面将详细探讨决定高防服务器租用价格的几个主要因素，rak小编为您整理发布高防服务器租用多少钱。
搭建NFS服务器
最新发布
codelearning的专栏
08-23 795
记录linux下搭建使用NFS服务器的一般步骤，以和centos7.9操作进行记录。
简化登录流程，助力应用建立用户体系
HarmonyOS SDK闭源开放能力技术团队
08-22 722
随着智能手机和移动应用的普及，用户需要在不同的应用中注册和登录账号，传统的账号注册和登录流程需要用户输入用户名和密码，这不仅繁琐而且容易造成用户流失。（Account Kit）提供简单、快速、安全的登录功能，让用户快捷地使用华为账号登录应用。用户授权后，华为账号可提供头像、昵称、手机号码等信息，帮助应用更了解用户。其中一键登录功能是基于和构建的OAuth2.0 授权登录系统，应用可以通过华为账号方便地获取华为账号用户的身份标识和手机号，快速建立应用内的用户体系。
CentOS7发送邮件如何配置SMTP服务器发信？
DengHua2203的博客
08-22 665
无论是配置SMTP服务器、解决常见问题，还是提高邮件发送的安全性，这些内容都将帮助你顺利完成CentOS7发送邮件的任务。AokSend：CentOS7上的邮件发送专家，API+SMTP双重保障，邮件营销更安心！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值