Linux:epoll模式web服务器代码,代码debug

源码：

https://blog.csdn.net/weixin_44718794/article/details/107206136

修改的地方：

在这里插入图片描述

修改后代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
//#include “epoll_server.h”

#ifndef _EPOLL_SERVER_H
#define _EPOLL_SERVER_H

int init_listen_fd(int port, int epfd);
void epoll_run(int port);
void do_accept(int lfd, int epfd);
void do_read(int cfd, int epfd);
int get_line(int sock, char buf, int size);
void disconnect(int cfd, int epfd);
void http_request(const char request, int cfd);
void send_respond_head(int cfd, int no, const char* desp, const char* type, long len);
void send_file(int cfd, const char* filename);
void send_dir(int cfd, const char* dirname);
void encode_str(char* to, int tosize, const char* from);
void decode_str(char *to, char *from);
const char *get_file_type(const char *name);

#endif

int main(int argc, const char* argv[]){
if(argc < 3){
printf(“eg: ./a.out port path\n”);
exit(1);
}

// 端口 字符串转整数
int port = atoi(argv[1]);

// 修改进程的工作目录, 方便后续操作
int ret = chdir(argv[2]);
if(ret == -1){
    perror("chdir error");
    exit(1);
}
// 启动epoll模型 
epoll_run(port);
return 0;

}

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <dirent.h>
#include <sys/stat.h>
#include <ctype.h>
//#include “epoll_server.h”

#define MAXSIZE 2000

void epoll_run(int port) {

// 创建一个epoll树的根节点
int epfd = epoll_create(MAXSIZE);
if (epfd == -1) {
	perror("epoll_create error");
	exit(1);
}

// 添加要监听的节点
// 先添加监听lfd
int lfd = init_listen_fd(port, epfd);

// 委托内核检测添加到树上的节点
struct epoll_event all[MAXSIZE];
while (1) {
	//epfd是epoll树的根节点，如果有树上某个文件描述符对应的缓冲区发生了变换
    //则会被拷贝到结构体数组all中
	// MAXSIZE是数组的大小， -1是一直阻塞，直到有节点发生变化的时候再发生返回
    //返回值ret是发生变化的文件描述符个数
	int ret = epoll_wait(epfd, all, MAXSIZE, -1);
	if (ret == -1) {
		perror("epoll_wait error");
		exit(1);
	}

	// 遍历发生变化的节点
    int i = 0;
	for (i = 0; i < ret; ++i) {
		// 只处理读事件, 其他事件默认不处理
		struct epoll_event *pev = &all[i];
		if (!(pev->events & EPOLLIN)) {
			// 不是读事件
			continue;
		}

		if (pev->data.fd == lfd) {
			// 接受连接请求
			do_accept(lfd, epfd);
		}
		else {
			// 读数据
			do_read(pev->data.fd, epfd);
		}
	}
}

}

// 读数据
void do_read(int cfd, int epfd) {

// 将浏览器发过来的数据, 读到buf中 
char line[1024] = { 0 };
// 读请求行
int len = get_line(cfd, line, sizeof(line));

//get_line调用的是recv，recv返回值为0则说明客户端断开了链接
if (len == 0) {
	printf("客户端cfd(%d)断开了连接...\n",cfd);
	// 关闭套接字, cfd从epoll上删除
	disconnect(cfd, epfd);
}
//recv失败了
else if (len == -1) {
	// perror("recv error"); // delete michael 
	// exit(1);                 // delete michael 
}
else {
	printf("cfd(%d)请求行数据: %s",cfd, line);
	printf("cfd(%d)============= 请求头 ============\n",cfd);
	// 还有数据没读完，继续读
	while (len > 0) { // michael change for (len) to (len > 0)
		char buf[1024] = { 0 };
		len = get_line(cfd, buf, sizeof(buf));
		printf("cfd:%d-----: %s", cfd,buf);
        sleep(0.2);//michael add
	}
	printf("cfd: %d============= The End ============\n",cfd);
}

// 请求行: get /xxx http/1.1
// 判断是不是get请求  strncasecmp函数用于比较两个字符串，不区分大小写的比较前n个字符
if (strncasecmp("get", line, 3) == 0) {
	// 处理http请求
	http_request(line, cfd);
	// 关闭套接字, cfd从epoll上del
	disconnect(cfd, epfd);
}

}

// 断开连接的函数
void disconnect(int cfd, int epfd) {
int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, cfd, NULL);
if (ret == -1) {
perror(“epoll_ctl del cfd error”);
exit(1);
}
close(cfd);
}

// http请求处理，传入request和
void http_request(const char* request, int cfd) {

// 拆分http请求行
//    get        /xxx        http/1.1
char method[12], path[1024], protocol[12];
//%[^ ]匹配遇到空格为止
sscanf(request, "%[^ ] %[^ ] %[^ ]", method, path, protocol);

printf("method = %s, path = %s, protocol = %s\n", method, path, protocol);

// 转码 将不能识别的中文乱码 - > 中文
// 解码 %23 %34 %5f
decode_str(path, path);
// 处理path  /xx（有可能是目录，也有可能是文件）
// 去掉path中的/
char* file = path + 1;
// 如果没有指定访问的资源, 默认显示资源目录中的内容
if (strcmp(path, "/") == 0) {
	// file的值, 资源目录的当前位置
	file = "./";
}

// 获取文件属性
struct stat st;
int ret = stat(file, &st);
if (ret == -1) {   //michael delete
	// show 404
	send_respond_head(cfd, 404, "File Not Found", ".html", -1);
	send_file(cfd, "404.html");
}

// 判断是目录还是文件
// 如果是目录
if (S_ISDIR(st.st_mode)) {
	// 发送头信息
	send_respond_head(cfd, 200, "OK", get_file_type(".html"), -1);
	// 发送目录信息
	send_dir(cfd, file);
}
else if (S_ISREG(st.st_mode))
{
	// 文件
	// 发送消息报头
	send_respond_head(cfd, 200, "OK", get_file_type(file), st.st_size);
	// 发送文件内容
	send_file(cfd, file);
}

}

// 发送目录内容，拼写一个html表格
void send_dir(int cfd, const char* dirname) {

// 拼一个html页面<table></table> table可以显示多行多列，便于显示文件信息
char buf[4096] = { 0 };

//目录名
sprintf(buf, "<html><head><title>目录名: %s</title></head>", dirname);
//当前目录
sprintf(buf + strlen(buf), "<body><h1>当前目录: %s</h1><table>", dirname);

/*-------------------------------获取当前目录中的所有内容---------------------------*/
char enstr[1024] = { 0 };
char path[1024] = { 0 };

// 目录项二级指针
struct dirent** ptr;
int num = scandir(dirname, &ptr, NULL, alphasort);

// 遍历
int i = 0;
for (i = 0; i < num; ++i){
	//获取文件名
	char* name = ptr[i]->d_name;

	// 拼接文件的完整路径
	sprintf(path, "%s/%s", dirname, name);
	printf("michael add path = %s ===================\n", path);
	struct stat st;
	stat(path, &st);

	encode_str(enstr, sizeof(enstr), name);
	// 如果是文件
	if (S_ISREG(st.st_mode)){
		sprintf(buf + strlen(buf),
			"<tr><td><a href=\"%s\">%s</a></td><td>%ld</td></tr>",
			enstr, name, (long)st.st_size);
	}
	// 如果是目录
	else if (S_ISDIR(st.st_mode)){
		sprintf(buf + strlen(buf),
			"<tr><td><a href=\"%s/\">%s/</a></td><td>%ld</td></tr>",
			enstr, name, (long)st.st_size);
	}
	//每循环一次就发送异常，清空buf，防止buf溢出
	send(cfd, buf, strlen(buf), 0);
	memset(buf, 0, sizeof(buf));
	// 字符串拼接
}

sprintf(buf + strlen(buf), "</table></body></html>");
send(cfd, buf, strlen(buf), 0);

printf("dir message send OK!!!!\n");

#if 0
// 打开目录
DIR* dir = opendir(dirname);
if (dir == NULL){
perror(“opendir error”);
exit(1);
}

// 读目录
struct dirent* ptr = NULL;
while ((ptr = readdir(dir)) != NULL){
	char* name = ptr->d_name;
}
closedir(dir);

#endif
}

// 发送响应头 cfd（服务器和浏览器通讯的文件描述符），no（状态码）
//desp（对状态码的描述），type（Content-Type），len（发送的数据长度）
void send_respond_head(int cfd, int no, const char* desp, const char* type, long len) {
char buf[1024] = { 0 };

// 状态行 http不区分大小写
sprintf(buf, "http/1.1 %d %s\r\n", no, desp);
//防止buf溢出，先把里面的数据发送出去
send(cfd, buf, strlen(buf), 0);

// 消息报头
sprintf(buf, "Content-Type:%s\r\n", type);
sprintf(buf + strlen(buf), "Content-Length:%ld\r\n", len);
send(cfd, buf, strlen(buf), 0);

// 空行
send(cfd, "\r\n", 2, 0);

}

// 发送文件
void send_file(int cfd, const char* filename){
// 打开文件
int fd = open(filename, O_RDONLY);
if (fd == -1){
// show 404
return;
}

// 循环读文件
char buf[4096] = { 0 };
int len = 0;
while ((len = read(fd, buf, sizeof(buf))) > 0){
	// 发送读出的数据
	send(cfd, buf, len, 0);
}
if (len == -1){
	// perror("read file error"); // delete michael 
	// exit(1); // delete michael 
}

close(fd);

}

// 解析http请求消息的每一行内容
int get_line(int sock, char *buf, int size) {
int i = 0;
char c = ‘\0’;
int n;
//每次读一个字节，判断合理就放入缓冲区中
while ((i < size - 1) && (c != ‘\n’)) {
n = recv(sock, &c, 1, 0);
if (n > 0) {
if (c == ‘\r’) {
//MSG_PEEK 使得recv以拷贝的方式从缓冲区中读取数据（否则读取之后，缓冲区中的数据就没了）
//试探性的获取缓冲区中的数据量
n = recv(sock, &c, 1, MSG_PEEK);
//缓冲区中有数据并且结尾是 \n ，则读取数据
if ((n > 0) && (c == ‘\n’)) {
recv(sock, &c, 1, 0);
}
else {
c = ‘\n’;
}
}
buf[i] = c;
i++;
}
else {
c = ‘\n’;
}
}
buf[i] = ‘\0’;

//recv失败
if (n == -1) {
	i = -1;
}

return i;

}

// 接受新连接处理
void do_accept(int lfd, int epfd) {
struct sockaddr_in client;
socklen_t len = sizeof(client);
int cfd = accept(lfd, (struct sockaddr*)&client, &len);
if (cfd == -1) {
perror(“accept error”);
exit(1);
}

// 打印客户端信息
char ip[64] = { 0 };
//inet_ntop大端整型转淀粉十进制ip地址
printf("New Client IP: %s, Port: %d, cfd = %d\n",
	inet_ntop(AF_INET, &client.sin_addr.s_addr, ip, sizeof(ip)),
	ntohs(client.sin_port), cfd);

// 设置cfd为非阻塞（默认是阻塞的）
int flag = fcntl(cfd, F_GETFL);
flag |= O_NONBLOCK; //非阻塞
fcntl(cfd, F_SETFL, flag);

// 得到的新节点挂到epoll树上
struct epoll_event ev;
ev.data.fd = cfd;
// 边沿非阻塞模式
ev.events = EPOLLIN | EPOLLET;
int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
if (ret == -1) {
	perror("epoll_ctl add cfd error");
	exit(1);
}

}

//初始化监听，传入端口号和epoll书的根节点
int init_listen_fd(int port, int epfd) {

//　创建监听的套接字
int lfd = socket(AF_INET, SOCK_STREAM, 0);
if (lfd == -1) {
	perror("socket error");
	exit(1);
}

// lfd绑定本地IP和port
struct sockaddr_in serv;
memset(&serv, 0, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(port);
serv.sin_addr.s_addr = htonl(INADDR_ANY);

// 端口复用
int flag = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));
int ret = bind(lfd, (struct sockaddr*)&serv, sizeof(serv));    //绑定
if (ret == -1) {
	perror("bind error");
	exit(1);
}

// 设置监听，最大是128，这里写个64是随意写的
ret = listen(lfd, 64);
if (ret == -1) {
	perror("listen error");
	exit(1);
}

// lfd添加到epoll树上
struct epoll_event ev;  //创建节点
ev.events = EPOLLIN;
ev.data.fd = lfd;
ret = epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev); //把节点挂上
if (ret == -1) {
	perror("epoll_ctl add lfd error");
	exit(1);
}

return lfd;

}

// 16进制数转化为10进制
int hexit(char c) {
if (c >= ‘0’ && c <= ‘9’)
return c - ‘0’;
if (c >= ‘a’ && c <= ‘f’)
return c - ‘a’ + 10;
if (c >= ‘A’ && c <= ‘F’)
return c - ‘A’ + 10;

return 0;

}

//字符转成16进制数
void encode_str(char* to, int tosize, const char* from) {
int tolen;

for (tolen = 0; *from != '\0' && tolen + 4 < tosize; ++from) {
	//isalnum判断字符是不是数字（判断字符是否需要解码）
	//http协议中， /_.~这四个不需要转
	if (isalnum(*from) || strchr("/_.-~", *from) != (char*)0) {
		//不需要转，则原封不动的拷贝一份
		*to = *from;
		++to;
		++tolen;
	}
	else {
		//字符转成十六进制数—— *from取字符值，然后与十六进制数字做按位与
		sprintf(to, "%%%02x", (int)*from & 0xff);
		//to永远指向字符从末尾
		to += 3;
		tolen += 3;
	}
}
*to = '\0';

}

//编码，用作回写浏览器的时候，将除字母、数字以及 /_.~以外的字符转义后回写
//将16进制数转换成字符
void decode_str(char *to, char *from) {
for (; *from != ‘\0’; ++to, ++from) {
//十六进制转十进制
if (from[0] == ‘%’ && isxdigit(from[1]) && isxdigit(from[2])) {
//依次判断from中 %20 三个字符
*to = hexit(from[1]) * 16 + hexit(from[2]);
//移除已经处理的两个字符
from += 2;
}else {
*to = *from;
}
}
*to = ‘\0’;
}

// 通过文件名获取文件的类型
const char *get_file_type(const char name){
char dot;

// 自右向左查找‘.’字符, 如不存在返回NULL
dot = strrchr(name, '.');
if (dot == NULL)
	return "text/plain; charset=utf-8";
if (strcmp(dot, ".html") == 0 || strcmp(dot, ".htm") == 0)
	return "text/html; charset=utf-8";
if (strcmp(dot, ".jpg") == 0 || strcmp(dot, ".jpeg") == 0)
	return "image/jpeg";
if (strcmp(dot, ".gif") == 0)
	return "image/gif";
if (strcmp(dot, ".png") == 0)
	return "image/png";
if (strcmp(dot, ".css") == 0)
	return "text/css";
if (strcmp(dot, ".au") == 0)
	return "audio/basic";
if (strcmp(dot, ".wav") == 0)
	return "audio/wav";
if (strcmp(dot, ".avi") == 0)
	return "video/x-msvideo";
if (strcmp(dot, ".mov") == 0 || strcmp(dot, ".qt") == 0)
	return "video/quicktime";
if (strcmp(dot, ".mpeg") == 0 || strcmp(dot, ".mpe") == 0)
	return "video/mpeg";
if (strcmp(dot, ".vrml") == 0 || strcmp(dot, ".wrl") == 0)
	return "model/vrml";
if (strcmp(dot, ".midi") == 0 || strcmp(dot, ".mid") == 0)
	return "audio/midi";
if (strcmp(dot, ".mp3") == 0)
	return "audio/mpeg";
if (strcmp(dot, ".ogg") == 0)
	return "application/ogg";
if (strcmp(dot, ".pac") == 0)
	return "application/x-ns-proxy-autoconfig";

return "text/plain; charset=utf-8";

}