• Linux网络编程11——简单的web服务器

    学习视频链接

    02-web大练习的概述_bilibili_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1iJ411S7UA/?p=132&spm_id_from=pageDriver&vd_source=0471cde1c644648fafd07b54e303c905

    目录

    一、项目展示

    二、HTTP 协议基础

    2.1 HTTP协议基础。

    2.2 请求消息(Request)

    2.3 响应消息 (Response)

    三、简单的代码

    3.1 代码

    3.2 后续需要增加的内容

    3.3 获取需要的数据

    3.4 错误处理函数

    3.5 正则表达式

    3.6 判断文件是否存在

    3.7 应答回复客户端

    3.8 文件类型区分

             3.9 细节处理

    3.10 文件夹处理

    3.11 汉字字符编码和解码 

    学习目标：实现一个简单的 web 服务器 myhttpd 能够给浏览器提供服务，供用户借助浏览器访问服务器主机中的文件

    一、项目展示

    启动服务器

    访问路径

    访问文件

    输入了错误的地址，访问不到需要的文件，就会展示错误页面

    二、HTTP 协议基础

    2.1 HTTP协议基础。

    HTTP，超文本传输协议 (HyperText Transfer Protocol)。互联网应用最为广泛的一种网络应用层协议。它可以减少网络传输，使浏览器更加高效。通常 HTTP 消息包括客户机向服务器的请求消息和服务器向客户机的响应消息

    2.2 请求消息(Request)

    浏览器 -> 发给 -> 服务器。主旨内容包含 4 部分：

    请求行：说明请求类型，要访问的资源，以及使用的 http 版本

    请求头：说明服务器要使用的附加信息

    空行：必须！即使没有请求数据

    请求数据：也叫主体，可以添加任意的其他数据

    2.3 响应消息 (Response)

    服务器 -> 发给 -> 浏览器。主旨内容包含 4 部分：

    状态行：包括 http 协议版本号，状态码，状态信息

    消息报头：说明客户端要使用的一些附加信息

    空行：必须！

    响应正文：服务器返回给客户端的文本信息

    三、简单的代码

    3.1 代码

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5. #include   
    6. #include   
    7. #include   
    8. #include   
    9. #include   
    10. #include   
    11.   
    12. #define MAXSIZE 2048  
    13.  
    14.   
    15. int init_listen_fd(int port, int epfd)  
    16. {  
    17.     //　创建监听的套接字 lfd  
    18.     int lfd = socket(AF_INET, SOCK_STREAM, 0);  
    19.     if (lfd == -1) {      
    20.         perror("socket error");  
    21.         exit(1);  
    22.     }  
    23.     // 创建服务器地址结构 IP+port  
    24.     struct sockaddr_in srv_addr;  
    25.       
    26.     bzero(&srv_addr, sizeof(srv_addr));  
    27.     srv_addr.sin_family = AF_INET;  
    28.     srv_addr.sin_port = htons(port);  
    29.     srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);  
    30.   
    31.     // 端口复用  
    32.     int opt = 1;  
    33.     setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));  
    34.       
    35.     // 给 lfd 绑定地址结构  
    36.     int ret = bind(lfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr));  
    37.     if (ret == -1) {     
    38.         perror("bind error");  
    39.         exit(1);  
    40.     }  
    41.     // 设置监听上限  
    42.     ret = listen(lfd, 128);  
    43.     if (ret == -1) {   
    44.         perror("listen error");  
    45.         exit(1);  
    46.     }  
    47.       
    48.     // lfd 添加到 epoll 树上  
    49.     struct epoll_event ev;  
    50.     ev.events = EPOLLIN;  
    51.     ev.data.fd = lfd;  
    52.       
    53.     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);  
    54.     if (ret == -1) {   
    55.         perror("epoll_ctl add lfd error");  
    56.         exit(1);  
    57.     }  
    58.   
    59.     return lfd;  
    60. }  
    61.   
    62. void do_accept(int lfd, int epfd)  
    63. {  
    64.     struct sockaddr_in clt_addr;  
    65.     socklen_t clt_addr_len = sizeof(clt_addr);  
    66.       
    67.     int cfd = accept(lfd, (struct sockaddr*)&clt_addr, &clt_addr_len);  
    68.     if (cfd == -1) {     
    69.         perror("accept error");  
    70.         exit(1);  
    71.     }  
    72.   
    73.     // 打印客户端IP+port  
    74.     char client_ip[64] = {0};  
    75.     printf("New Client IP: %s, Port: %d, cfd = %d\n",  
    76.            inet_ntop(AF_INET, &clt_addr.sin_addr.s_addr, client_ip, sizeof(client_ip)),  
    77.            ntohs(clt_addr.sin_port), cfd);  
    78.   
    79.     // 设置 cfd 非阻塞  
    80.     int flag = fcntl(cfd, F_GETFL);  
    81.     flag |= O_NONBLOCK;  
    82.     fcntl(cfd, F_SETFL, flag);  
    83.   
    84.     // 将新节点cfd 挂到 epoll 监听树上  
    85.     struct epoll_event ev;  
    86.     ev.data.fd = cfd;  
    87.       
    88.     // 边沿非阻塞模式  
    89.     ev.events = EPOLLIN | EPOLLET;  
    90.       
    91.     int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);  
    92.     if (ret == -1)  {  
    93.         perror("epoll_ctl add cfd error");  
    94.         exit(1);  
    95.     }  
    96. }  
    97.   
    98. void do_read(int cfd, int epfd)  
    99. {  
    100.     // read cfd 小 -- 大 write 回  
    101.     // 读取一行http协议， 拆分， 获取 get 文件名 协议号  
    102. }  
    103.   
    104. void epoll_run(int port)  
    105. {  
    106.     int i = 0;  
    107.     struct epoll_event all_events[MAXSIZE];  
    108.   
    109.     // 创建一个epoll监听树根  
    110.     int epfd = epoll_create(MAXSIZE);  
    111.     if (epfd == -1) {   
    112.         perror("epoll_create error");  
    113.         exit(1);  
    114.     }  
    115.       
    116.     // 创建lfd，并添加至监听树  
    117.     int lfd = init_listen_fd(port, epfd);  
    118.      
    119.     while (1) {  
    120.         // 监听节点对应事件  
    121.         int ret = epoll_wait(epfd, all_events, MAXSIZE, -1);  
    122.         if (ret == -1) {        
    123.             perror("epoll_wait error");  
    124.             exit(1);  
    125.         }  
    126.   
    127.         for (i=0; i
    128.                   
    129.             // 只处理读事件, 其他事件默认不处理  
    130.             struct epoll_event *pev = &all_events[i];  
    131.               
    132.             // 不是读事件  
    133.             if (!(pev->events & EPOLLIN)) {                       
    134.                 continue;  
    135.             }  
    136.             if (pev->data.fd == lfd) {       // 接受连接请求     
    137.                   
    138.                 do_accept(lfd, epfd);  
    139.                   
    140.             } else {                        // 读数据  
    141.                   
    142.                 do_read(pev->data.fd, epfd);  
    143.             }  
    144.         }  
    145.     }  
    146. }  
    147.   
    148.   
    149. int main(int argc, char *argv[])  
    150. {   
    151.     // 命令行参数获取 端口 和 server提供的目录  
    152.     if (argc < 3)   
    153.     {  
    154.         printf("./server port path\n");   
    155.     }  
    156.       
    157.     // 获取用户输入的端口   
    158.     int port = atoi(argv[1]);  
    159.       
    160.     // 改变进程工作目录  
    161.     int ret = chdir(argv[2]);  
    162.     if (ret != 0) {  
    163.         perror("chdir error");    
    164.         exit(1);  
    165.     }  
    166.   
    167.     // 启动 epoll监听  
    168.     epoll_run(port);  
    169.   
    170.     return 0;  
    171. }

    3.2 后续需要增加的内容

    3.3 获取需要的数据

    1. nt get_line(int cfd, char *buf, int size)
    2. {
    3.     int i = 0;
    4. 	char c = '\0';
    5. 	int n;
    6. 	//每次读一个字节，判断合理就放入缓冲区中
    7. 	while ((i < size - 1) && (c != '\n')) {
    8. 		n = recv(cfd, &c, 1, 0);
    9. 		if (n > 0) {
    10. 			if (c == '\r') {
    11. 				//MSG_PEEK 使得recv以拷贝的方式从缓冲区中读取数据（否则读取之后，缓冲区中的数据就没了）
    12. 				//试探性的获取缓冲区中的数据量
    13. 				n = recv(cfd, &c, 1, MSG_PEEK);
    14. 				//缓冲区中有数据并且结尾是 \n  ，则读取数据
    15. 				if ((n > 0) && (c == '\n')) {
    16. 					recv(cfd, &c, 1, 0);
    17. 				}
    18. 				else {
    19. 					c = '\n';
    20. 				}
    21. 			}
    22. 			buf[i] = c;
    23. 			i++;
    24. 		}
    25. 		else {
    26. 			c = '\n';
    27. 		}
    28. 	}
    29. 	buf[i] = '\0';
    30.  
    31. 	//recv失败
    32. 	if (n == -1) {
    33. 		i = -1;
    34. 	}
    35.  
    36. 	return i;
    37. }

    3.4 错误处理函数

    1. // 断开连接
    2. void disconnect(int cfd, int epfd)
    3. {
    4.     int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, cfd, NULL);
    5.     if(ret != 0) {
    6.         perror("epoll_ctl error");
    7.         exit(1);
    8.     }
    9.     close(cfd);
    10. }
    11.   
    12. void do_read(int cfd, int epfd)  
    13. {  
    14.     // 读取一行http协议， 拆分， 获取 get 文件名 协议号
    15.     char line[1024] = { 0 };
    16.     int len = get_line(cfd, line, sizeof(line));  // 确定读出 GET /hello.c HTTP/1.1
    17.     if (len == 0) {
    18.         printf("服务器检测到客户端关闭\n");
    19.         disconnect(cfd, epfd);
    20.     }
    21.     else {
    22.         // 现在要按照空格分割得到 /hello.c
    23.     }
    24.  
    25. }

    3.5 正则表达式

    1. void do_read(int cfd, int epfd)  
    2. {  
    3.     // 读取一行http协议， 拆分， 获取 get 文件名 协议号
    4.     char line[1024] = { 0 };
    5.     int len = get_line(cfd, line, sizeof(line));  // 确定读出 GET /hello.c HTTP/1.1
    6.     if (len == 0) {
    7.         printf("服务器检测到客户端关闭\n");
    8.         disconnect(cfd, epfd);
    9.     }
    10.     else {
    11.         // 现在要按照空格分割得到 /hello.c
    12.         char method[16], path[256], protocol[16];
    13.  
    14.         sscanf(line, "%[^ ] %[^ ] %[^ ]", method, path, protocol);
    15.  
    16.         printf("method=%s, path=%s, protocol=%s\n", method, path, protocol);
    17.     }
    18.  
    19. }

    现在测试代码

    正则表达式字符类

    正则表达式数量限定 

    3.6 判断文件是否存在

    1. // 处理http请求，判断文件是否存在，回发
    2. void http_request(const char *file)
    3. {
    4.     struct stat sbuf;
    5.  
    6.     // 判断文件是否存在
    7.     int ret = stat(file, &sbuf);
    8.     if (ret != 0) {
    9.         // 回发浏览器 404 错误页面
    10.         perror("stat");
    11.         exit(1);
    12.     }
    13.  
    14.     if(S_ISREG(sbuf.st_mode)) {  // 是一个普通文件
    15.         printf("It's a file\n");
    16.     }
    17. }
    18.   
    19. void do_read(int cfd, int epfd)  
    20. {  
    21.     // 读取一行http协议， 拆分， 获取 get 文件名 协议号
    22.     char line[1024] = { 0 };
    23.     int len = get_line(cfd, line, sizeof(line));  // 确定读出 GET /hello.c HTTP/1.1
    24.     if (len == 0) {
    25.         printf("服务器检测到客户端关闭\n");
    26.         disconnect(cfd, epfd);
    27.     }
    28.     else {
    29.         // 现在要按照空格分割得到 /hello.c
    30.         char method[16], path[256], protocol[16];
    31.         sscanf(line, "%[^ ] %[^ ] %[^ ]", method, path, protocol);
    32.         printf("method=%s, path=%s, protocol=%s\n", method, path, protocol);
    33.  
    34.         // 丢弃缓冲区中后面的数据
    35.         while (1) {
    36.             char buf[1024] = { 0 };
    37.             len = get_line(cfd, buf, sizeof(buf));
    38.             printf("-- len = %d\n", len);
    39.             if (len == '\n') {
    40.                 break;
    41.             }
    42.             if(len == -1) {
    43.                 break;
    44.             }
    45.         }
    46.  
    47.         if(strncasecmp(method, "GET", 3) == 0)
    48.         {
    49.             char *file = path + 1;  // 取出客户端要访问的文件名
    50.             http_request(file);
    51.         }
    52.     }
    53. }

    3.7 应答回复客户端

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5. #include   
    6. #include   
    7. #include   
    8. #include 
    9. #include 
    10. #include   
    11. #include   
    12.   
    13. #define MAXSIZE 2048  
    14.  
    15.   
    16. int init_listen_fd(int port, int epfd)  
    17. {  
    18.     //　创建监听的套接字 lfd  
    19.     int lfd = socket(AF_INET, SOCK_STREAM, 0);  
    20.     if (lfd == -1) {      
    21.         perror("socket error");  
    22.         exit(1);  
    23.     }  
    24.     // 创建服务器地址结构 IP+port  
    25.     struct sockaddr_in srv_addr;  
    26.       
    27.     bzero(&srv_addr, sizeof(srv_addr));  
    28.     srv_addr.sin_family = AF_INET;  
    29.     srv_addr.sin_port = htons(port);  
    30.     srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);  
    31.   
    32.     // 端口复用  
    33.     int opt = 1;  
    34.     setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));  
    35.       
    36.     // 给 lfd 绑定地址结构  
    37.     int ret = bind(lfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr));  
    38.     if (ret == -1) {     
    39.         perror("bind error");  
    40.         exit(1);  
    41.     }  
    42.     // 设置监听上限  
    43.     ret = listen(lfd, 128);  
    44.     if (ret == -1) {   
    45.         perror("listen error");  
    46.         exit(1);  
    47.     }  
    48.       
    49.     // lfd 添加到 epoll 树上  
    50.     struct epoll_event ev;  
    51.     ev.events = EPOLLIN;  
    52.     ev.data.fd = lfd;  
    53.       
    54.     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);  
    55.     if (ret == -1) {   
    56.         perror("epoll_ctl add lfd error");  
    57.         exit(1);
    58.     }
    59.   
    60.     return lfd;  
    61. }  
    62.   
    63. void do_accept(int lfd, int epfd)  
    64. {  
    65.     struct sockaddr_in clt_addr;  
    66.     socklen_t clt_addr_len = sizeof(clt_addr);  
    67.       
    68.     int cfd = accept(lfd, (struct sockaddr*)&clt_addr, &clt_addr_len);  
    69.     if (cfd == -1) {     
    70.         perror("accept error");  
    71.         exit(1);  
    72.     }  
    73.   
    74.     // 打印客户端IP+port  
    75.     char client_ip[64] = {0};  
    76.     printf("New Client IP: %s, Port: %d, cfd = %d\n",  
    77.            inet_ntop(AF_INET, &clt_addr.sin_addr.s_addr, client_ip, sizeof(client_ip)),  
    78.            ntohs(clt_addr.sin_port), cfd);  
    79.   
    80.     // 设置 cfd 非阻塞  
    81.     int flag = fcntl(cfd, F_GETFL);  
    82.     flag |= O_NONBLOCK;  
    83.     fcntl(cfd, F_SETFL, flag);  
    84.   
    85.     // 将新节点cfd 挂到 epoll 监听树上  
    86.     struct epoll_event ev;  
    87.     ev.data.fd = cfd;  
    88.       
    89.     // 边沿非阻塞模式  
    90.     ev.events = EPOLLIN | EPOLLET;  
    91.       
    92.     int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);  
    93.     if (ret == -1)  {  
    94.         perror("epoll_ctl add cfd error");  
    95.         exit(1);  
    96.     }  
    97. }
    98.  
    99. // 通过文件名获取文件的类型
    100. const char *get_file_type(const char *name)
    101. {
    102.     char *dot;   
    103.     
    104.     // 自右向左查找‘.’字符, 如不存在返回NULL  
    105.     dot = strrchr(name, '.');     
    106.     if (dot == NULL)  
    107.         return "text/plain; charset=utf-8";  
    108.     if (strcmp(dot, ".html") == 0 || strcmp(dot, ".htm") == 0)  
    109.         return "text/html; charset=utf-8";
    110.     if (strcmp(dot, ".jpg") == 0 || strcmp(dot, ".jpeg") == 0)  
    111.         return "image/jpeg";  
    112.     if (strcmp(dot, ".gif") == 0)  
    113.         return "image/gif";  
    114.     if (strcmp(dot, ".png") == 0)  
    115.         return "image/png";  
    116.     if (strcmp(dot, ".css") == 0)  
    117.         return "text/css";  
    118.     if (strcmp(dot, ".au") == 0)  
    119.         return "audio/basic";  
    120.     if (strcmp(dot, ".wav" ) == 0)  
    121.         return "audio/wav";  
    122.     if (strcmp(dot, ".avi") == 0)  
    123.         return "video/x-msvideo";  
    124.     if (strcmp(dot, ".mov") == 0 || strcmp(dot, ".qt") == 0)  
    125.         return "video/quicktime";  
    126.     if (strcmp(dot, ".mpeg") == 0 || strcmp(dot, ".mpe") == 0)  
    127.         return "video/mpeg";  
    128.     if (strcmp(dot, ".vrml") == 0 || strcmp(dot, ".wrl") == 0)  
    129.         return "model/vrml";  
    130.     if (strcmp(dot, ".midi") == 0 || strcmp(dot, ".mid") == 0)  
    131.         return "audio/midi";  
    132.     if (strcmp(dot, ".mp3") == 0)  
    133.         return "audio/mpeg";  
    134.     if (strcmp(dot, ".ogg") == 0)  
    135.         return "application/ogg";  
    136.     if (strcmp(dot, ".pac") == 0)  
    137.         return "application/x-ns-proxy-autoconfig";  
    138.  
    139.     return "text/plain; charset=utf-8";  
    140. }
    141.  
    142. int get_line(int cfd, char *buf, int size)
    143. {
    144.     int i = 0;
    145. 	char c = '\0';
    146. 	int n;
    147. 	//每次读一个字节，判断合理就放入缓冲区中
    148. 	while ((i < size - 1) && (c != '\n')) {
    149. 		n = recv(cfd, &c, 1, 0);
    150. 		if (n > 0) {
    151. 			if (c == '\r') {
    152. 				//MSG_PEEK 使得recv以拷贝的方式从缓冲区中读取数据（否则读取之后，缓冲区中的数据就没了）
    153. 				//试探性的获取缓冲区中的数据量
    154. 				n = recv(cfd, &c, 1, MSG_PEEK);
    155. 				//缓冲区中有数据并且结尾是 \n  ，则读取数据
    156. 				if ((n > 0) && (c == '\n')) {
    157. 					recv(cfd, &c, 1, 0);
    158. 				}
    159. 				else {
    160. 					c = '\n';
    161. 				}
    162. 			}
    163. 			buf[i] = c;
    164. 			i++;
    165. 		}
    166. 		else {
    167. 			c = '\n';
    168. 		}
    169. 	}
    170. 	buf[i] = '\0';
    171.  
    172. 	//recv失败
    173. 	if (n == -1) {
    174. 		i = -1;
    175. 	}
    176.  
    177. 	return i;
    178. }
    179.  
    180. // 断开连接
    181. void disconnect(int cfd, int epfd)
    182. {
    183.     int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, cfd, NULL);
    184.     if(ret != 0) {
    185.         perror("epoll_ctl error");
    186.         exit(1);
    187.     }
    188.     close(cfd);
    189. }
    190.  
    191. // 客户端的fd，错误号，错误描述，回发文件类型，文件长度
    192. void send_respond(int cfd, int no, char *disp, char *type, int len)
    193. {
    194.     char buf[1024] = { 0 };
    195.     sprintf (buf, "HTTP/1.1 %d %s\r\n", no, disp);
    196.     sprintf(buf + strlen(buf), "%s\r\n", type) ;
    197.     sprintf(buf + strlen(buf), "Content-Length:%d\r\n", len);
    198.     send(cfd, buf, strlen(buf), 0);
    199.     send(cfd, "\r\n", 2, 0);
    200. }
    201.  
    202. // 发送服务器本地文件给浏览器
    203. void send_file(int cfd, const char *file)
    204. {
    205.     int n = 0;
    206.     char buf[1024];
    207.  
    208.     // 打开的服务器本地文件 —— cfd 能访问客户端的 socket
    209.     int fd = open(file, O_RDONLY);
    210.     if (fd == -1) {
    211.         // 404 错误页面
    212.         perror("open error");
    213.         exit(1);
    214.     }
    215.  
    216.     int ret;
    217.     while ((n = read(fd, buf, sizeof(buf))) > 0) {
    218.         ret = send(cfd, buf, n, 0);
    219.         if (ret == -1) {
    220.             if (ret == -1) {  
    221.                 perror("send error");     
    222.                 exit(1);
    223.             }  
    224.         }
    225.     }
    226.  
    227.     close(fd);
    228. }
    229.  
    230. // 处理http请求，判断文件是否存在，回发
    231. void http_request(int cfd, const char *file)
    232. {
    233.     struct stat sbuf;
    234.  
    235.     // 判断文件是否存在
    236.     int ret = stat(file, &sbuf);
    237.     if (ret != 0) {
    238.         // 回发浏览器 404 错误页面
    239.         perror("stat");
    240.         //exit(1);
    241.     }
    242.  
    243.     if(S_ISREG(sbuf.st_mode)) {  // 是一个普通文件
    244.         // 回发 http 协议应答
    245.         // send_respond(cfd, 200, "OK", "Content-Type: text/plain; charset=iso-8859-1", sbuf.st_size);
    246.         char *type = get_file_type(file);
    247.         send_respond(cfd, 200, "OK", type, sbuf.st_size);
    248.         // 回发 给客户端请求数据内容
    249.         send_file(cfd, file);
    250.     }
    251. }
    252.   
    253. void do_read(int cfd, int epfd)  
    254. {  
    255.     // 读取一行http协议， 拆分， 获取 get 文件名 协议号
    256.     char line[1024] = { 0 };
    257.     int len = get_line(cfd, line, sizeof(line));  // 确定读出 GET /hello.c HTTP/1.1
    258.     if (len == 0) {
    259.         printf("服务器检测到客户端关闭\n");
    260.         disconnect(cfd, epfd);
    261.     }
    262.     else {
    263.         // 现在要按照空格分割得到 /hello.c
    264.         char method[16], path[256], protocol[16];
    265.         sscanf(line, "%[^ ] %[^ ] %[^ ]", method, path, protocol);
    266.         printf("method=%s, path=%s, protocol=%s\n", method, path, protocol);
    267.  
    268.         // 丢弃缓冲区中后面的数据
    269.         while (1) {
    270.             char buf[1024] = { 0 };
    271.             len = get_line(cfd, buf, sizeof(buf));
    272.             if (len == '\n') {
    273.                 break;
    274.             }
    275.             if(len == -1) {
    276.                 break;
    277.             }
    278.         }
    279.  
    280.         if(strncasecmp(method, "GET", 3) == 0)
    281.         {
    282.             char *file = path + 1;  // 取出客户端要访问的文件名
    283.             http_request(cfd, file);
    284.         }
    285.     }
    286. }  
    287.   
    288. void epoll_run(int port)  
    289. {  
    290.     int i = 0;  
    291.     struct epoll_event all_events[MAXSIZE];  
    292.   
    293.     // 创建一个epoll监听树根  
    294.     int epfd = epoll_create(MAXSIZE);  
    295.     if (epfd == -1) {   
    296.         perror("epoll_create error");  
    297.         exit(1);  
    298.     }  
    299.       
    300.     // 创建lfd，并添加至监听树  
    301.     int lfd = init_listen_fd(port, epfd);  
    302.      
    303.     while (1) {  
    304.         // 监听节点对应事件  
    305.         int ret = epoll_wait(epfd, all_events, MAXSIZE, -1);  
    306.         if (ret == -1) {        
    307.             perror("epoll_wait error");  
    308.             exit(1);  
    309.         }  
    310.   
    311.         for (i=0; i
    312.                   
    313.             // 只处理读事件, 其他事件默认不处理  
    314.             struct epoll_event *pev = &all_events[i];  
    315.               
    316.             // 不是读事件  
    317.             if (!(pev->events & EPOLLIN)) {                       
    318.                 continue;  
    319.             }  
    320.             if (pev->data.fd == lfd) {       // 接受连接请求     
    321.                   
    322.                 do_accept(lfd, epfd);  
    323.                   
    324.             } else {                        // 读数据  
    325.                   
    326.                 do_read(pev->data.fd, epfd);  
    327.             }  
    328.         }  
    329.     }  
    330. }  
    331.   
    332.   
    333. int main(int argc, char *argv[])  
    334. {   
    335.     // 命令行参数获取 端口 和 server提供的目录  
    336.     if (argc < 3)   
    337.     {  
    338.         printf("./server port path\n");   
    339.     }  
    340.       
    341.     // 获取用户输入的端口   
    342.     int port = atoi(argv[1]);  
    343.       
    344.     // 改变进程工作目录  
    345.     int ret = chdir(argv[2]);  
    346.     if (ret != 0) {  
    347.         perror("chdir error");    
    348.         exit(1);  
    349.     }  
    350.   
    351.     // 启动 epoll监听  
    352.     epoll_run(port);  
    353.   
    354.     return 0;  
    355. }

    单个文件请求成功

    mp3 格式，他的头文件是这样的

    3.8 文件类型区分

    1. // 通过文件名获取文件的类型
    2. const char *get_file_type(const char *name)
    3. {
    4.     char *dot;   
    5.     
    6.     // 自右向左查找‘.’字符, 如不存在返回NULL  
    7.     dot = strrchr(name, '.');     
    8.     if (dot == NULL)  
    9.         return "text/plain; charset=utf-8";  
    10.     if (strcmp(dot, ".html") == 0 || strcmp(dot, ".htm") == 0)  
    11.         return "text/html; charset=utf-8";
    12.     if (strcmp(dot, ".jpg") == 0 || strcmp(dot, ".jpeg") == 0)  
    13.         return "image/jpeg";  
    14.     if (strcmp(dot, ".gif") == 0)  
    15.         return "image/gif";  
    16.     if (strcmp(dot, ".png") == 0)  
    17.         return "image/png";  
    18.     if (strcmp(dot, ".css") == 0)  
    19.         return "text/css";  
    20.     if (strcmp(dot, ".au") == 0)  
    21.         return "audio/basic";  
    22.     if (strcmp(dot, ".wav" ) == 0)  
    23.         return "audio/wav";  
    24.     if (strcmp(dot, ".avi") == 0)  
    25.         return "video/x-msvideo";  
    26.     if (strcmp(dot, ".mov") == 0 || strcmp(dot, ".qt") == 0)  
    27.         return "video/quicktime";  
    28.     if (strcmp(dot, ".mpeg") == 0 || strcmp(dot, ".mpe") == 0)  
    29.         return "video/mpeg";  
    30.     if (strcmp(dot, ".vrml") == 0 || strcmp(dot, ".wrl") == 0)  
    31.         return "model/vrml";  
    32.     if (strcmp(dot, ".midi") == 0 || strcmp(dot, ".mid") == 0)  
    33.         return "audio/midi";  
    34.     if (strcmp(dot, ".mp3") == 0)  
    35.         return "audio/mpeg";  
    36.     if (strcmp(dot, ".ogg") == 0)  
    37.         return "application/ogg";  
    38.     if (strcmp(dot, ".pac") == 0)  
    39.         return "application/x-ns-proxy-autoconfig";  
    40.  
    41.     return "text/plain; charset=utf-8";  
    42. }
    43.  
    44. // 处理http请求，判断文件是否存在，回发
    45. void http_request(int cfd, const char *file)
    46. {
    47.     struct stat sbuf;
    48.  
    49.     // 判断文件是否存在
    50.     int ret = stat(file, &sbuf);
    51.     if (ret != 0) {
    52.         // 回发浏览器 404 错误页面
    53.         perror("stat");
    54.         //exit(1);
    55.     }
    56.  
    57.     if(S_ISREG(sbuf.st_mode)) {  // 是一个普通文件
    58.         // 回发 http 协议应答
    59.         // send_respond(cfd, 200, "OK", "Content-Type: text/plain; charset=iso-8859-1", sbuf.st_size);
    60.         char *type = get_file_type(file);
    61.         send_respond(cfd, 200, "OK", type, sbuf.st_size);
    62.         // 回发 给客户端请求数据内容
    63.         send_file(cfd, file);
    64.     }
    65. }

    3.9 细节处理

    1、没有找到文件的页面

    也可以自己在文件夹中写一个错误页面，然后没找到的发发送写过的错误页面

    2、和客户端第二次请求 ico 文件处理

    如上图，只需要在文件夹中放一个需要的 ico 文件，浏览器就能获取需要的网页图标

    3、get 处理完成后删除服务器和客户端的连接

    3.10 文件夹处理

    拼接一个 html 页面

    3.11 汉字字符编码和解码 

     

  • 相关阅读:
    spring boot破解xjar.go加密后的jar包
    Godot 4.0 加载为占位符(InstancePlaceholder)的用法和特点
    【FISCO-BCOS】十七、角色的权限控制
    docker 启动 centos/golang 容器 及参数说明
    中国信息通信设备行业发展趋势及投资风险研究报告
    【Obsidian样式】修改文件夹名称和文件名称前的图标
    Eclipse项目导入笔记大全&踩坑大全
    AI智能文案写作工具，迅速生成高质量的文案
    【Vue.js生命周期】什么是生命周期？声明周期详解
    分享一个java+springboot+vue校园电动车租赁系统（源码、调试、开题、lw）
  • 原文地址：https://blog.csdn.net/HuanBianCheng27/article/details/127814345