• httpserver 下载服务器demo 以及libevent版本的 httpserver

    实现效果如下：

    图片可以直接显示 

    cpp h 这些可以直接显示 其他的 则是提示是否要下载

    单线程 还有bug

    代码如下  先放上来 

    1. #include "httpserver.h"
    2. #include "stdio.h"
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14.  
    15. #define BURSIZE 1024
    16. int hex2dec(char c)
    17. {
    18. 	if ('0' <= c && c <= '9') {
    19. 		return c - '0';
    20. 	} else if ('a' <= c && c <= 'f') {
    21. 		return c - 'a' + 10;
    22. 	} else if ('A' <= c && c <= 'F') {
    23. 		return c - 'A' + 10;
    24. 	} else {
    25. 		return -1;
    26. 	}
    27. }
    28.  
    29. char dec2hex(short int c)
    30. {
    31. 	if (0 <= c && c <= 9) {
    32. 		return c + '0';
    33. 	} else if (10 <= c && c <= 15) {
    34. 		return c + 'A' - 10;
    35. 	} else {
    36. 		return -1;
    37. 	}
    38. }
    39.  
    40.  
    41. /*
    42.  * 编码一个url
    43.  */
    44. void urlencode(char url[])
    45. {
    46. 	int i = 0;
    47. 	int len = strlen(url);
    48. 	int res_len = 0;
    49. 	char res[BURSIZE];
    50. 	for (i = 0; i < len; ++i) {
    51. 		char c = url[i];
    52. 		if (('0' <= c && c <= '9') ||
    53. 				('a' <= c && c <= 'z') ||
    54. 				('A' <= c && c <= 'Z') || c == '/' || c == '.') {
    55. 			res[res_len++] = c;
    56. 		} else {
    57. 			int j = (short int)c;
    58. 			if (j < 0)
    59. 				j += 256;
    60. 			int i1, i0;
    61. 			i1 = j / 16;
    62. 			i0 = j - i1 * 16;
    63. 			res[res_len++] = '%';
    64. 			res[res_len++] = dec2hex(i1);
    65. 			res[res_len++] = dec2hex(i0);
    66. 		}
    67. 	}
    68. 	res[res_len] = '\0';
    69. 	strcpy(url, res);
    70. }
    71.  
    72. /*
    73.  * 解码url
    74.  */
    75. void urldecode(char url[])
    76. {
    77.     
    78. 	int i = 0;
    79. 	int len = strlen(url);
    80. 	int res_len = 0;
    81. 	char res[BURSIZE];
    82. 	for (i = 0; i < len; ++i) {
    83. 		char c = url[i];
    84. 		if (c != '%') {
    85. 			res[res_len++] = c;
    86. 		} else {
    87. 			char c1 = url[++i];
    88. 			char c0 = url[++i];
    89. 			int num = 0;
    90. 			num = hex2dec(c1) * 16 + hex2dec(c0);
    91. 			res[res_len++] = num;
    92. 		}
    93. 	}
    94. 	res[res_len] = '\0';
    95. 	strcpy(url, res);
    96. }
    97.  
    98.  
    99. int CreateSocketFD()
    100. {
    101.     int fd = 0;
    102.     fd = socket(AF_INET,SOCK_STREAM,0);
    103.     if(fd == -1)
    104.     {
    105.         perror("Scoket fd = -1");
    106.         return 0;
    107.     }
    108.  
    109.     int reuseport = 1;
    110.     int ret = setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&reuseport,sizeof(reuseport));
    111.     if(ret == -1)
    112.     {
    113.         perror("setsocketopt failed");
    114.         return -1;
    115.     }
    116.  
    117.     struct sockaddr_in addr;
    118.     addr.sin_family = AF_INET;
    119.     addr.sin_port = htons(8888);
    120.     addr.sin_addr.s_addr = INADDR_ANY;
    121.  
    122.     ret = bind(fd,(struct sockaddr*)&addr,sizeof(addr));
    123.     if(ret == -1)
    124.     {
    125.         perror("bind error");
    126.         return -1;
    127.     }
    128.  
    129.     ret = listen(fd,10);
    130.  
    131.     if(ret == -1)
    132.     {
    133.         perror("listen error ");
    134.         return -1;
    135.     }
    136.  
    137.     return fd;
    138. }
    139.  
    140.  
    141. int AcceptClients(int epoll_fd,int fd)
    142. {
    143.     struct sockaddr addr;
    144.     int cfd = accept(fd,NULL,NULL);
    145.     if(cfd == -1)
    146.     {
    147.         perror("accept failed");
    148.     }
    149.  
    150.  
    151.     int flag = fcntl(cfd,F_GETFL);
    152.     flag |= O_NONBLOCK;
    153.  
    154.     fcntl(cfd,F_SETFL,flag);
    155.  
    156.     struct epoll_event ev;
    157.     ev.data.fd = cfd;
    158.     ev.events = EPOLLIN|EPOLLET;
    159.  
    160.     int ret = epoll_ctl(epoll_fd,EPOLL_CTL_ADD,cfd,&ev);
    161.     if(ret == -1)
    162.     {
    163.         perror("epoll ctl failed");
    164.         return 0;
    165.     }
    166.  
    167.     return 0;
    168. }
    169.  
    170.  
    171.  
    172. const char *GetFileType(const char *filename)
    173. {
    174.     const char *dot = strrchr(filename,'.');
    175.     if(dot == NULL)
    176.     {
    177.         return "text/plain; charset=utf-8";
    178.     }
    179.     if(strcmp(dot,".jpg") == 0 ||strcmp(dot,".jpeg") == 0)
    180.     {
    181.         return "image/jpg";
    182.     }
    183.     if(strcmp(dot,".html") == 0 ||strcmp(dot,".htm") == 0)
    184.     {
    185.         return "text/html; charset=utf-8";
    186.     }    
    187.     if(strcmp(dot,".png") == 0)
    188.     {
    189.         return "image/png";
    190.     }    
    191.     if(strcmp(dot,".bmp") == 0)
    192.     {
    193.         return "image/bmp";
    194.     }        
    195.     if(strcmp(dot,".gif") == 0)
    196.     {
    197.         return "image/gif";
    198.     }            
    199.     if(strcmp(dot,".css") == 0)
    200.     {
    201.         return "text/css";
    202.     }           
    203.     if(strcmp(dot,".mp3") == 0)
    204.     {
    205.         return "audio/mpeg";
    206.     }               
    207.  
    208.     return "text/plain; charset=utf-8";
    209. }
    210.  
    211. int SendHead(int cfd,int status ,const char *desc,const char *type,int size)
    212. {
    213.     char buf[4096] = {0};
    214.     sprintf(buf,"http/1.1 %d %s\r\n",status,desc);
    215.     sprintf(buf+strlen(buf),"content-type: %s\r\n",type);
    216.     sprintf(buf+strlen(buf),"content-length: %d\r\n\r\n",size);    
    217.  
    218.  
    219.     printf("SendHead buf[%s]\n",buf);
    220.  
    221.     send(cfd,buf,strlen(buf),0);
    222.     return 0;
    223. }
    224.  
    225.  
    226. int SendDir(const char *dirname,int cfd)
    227. {
    228.     char buf[4096] = {0};
    229.  
    230.     sprintf(buf,"%s",dirname);
    231.  
    232.     printf("SendDir dirname=[%s]\n",dirname);
    233.     struct dirent **namelist;
    234.     int count = scandir(dirname,&namelist,NULL,alphasort);
    235.     printf("SendDir count=[%d]\n",count);
    236.     for(int i = 0;i< count;i++)
    237.     {
    238.         char *name = namelist[i]->d_name;
    239.         struct stat st;
    240.         char sub_path[1024]={0};
    241.         sprintf(sub_path,"%s/%s",dirname,name);
    242.         stat(sub_path,&st);
    243.         if(S_ISDIR(st.st_mode))
    244.         {
    245.             sprintf(buf+strlen(buf),
    246.                 "
      247. ",name,name,st.st_size);
    247.         }
    248.         else
    249.         {
    250.             sprintf(buf+strlen(buf),
    251.                 "
      252. ",name,name,st.st_size);
    252.         }
    253.  
    254.         printf("cfd:%d Sendbuf[%s]\n",cfd,buf);
    255.         send(cfd,buf,strlen(buf),0);
    256.         memset(buf,0,sizeof(buf));
    257.         free(namelist[i]);
    258.     }
    259.  
    260.     sprintf(buf,"
      261. %s%ld
      %s%ld
      "      );
    261.  
    262.     printf("cfd:%d Sendbuf[%s]\n",cfd,buf);
    263.  
    264.     send(cfd,buf,strlen(buf),0);
    265.     free(namelist);
    266.  
    267.     return 0;
    268. }
    269.  
    270. int SendFile(const char* filename,int cfd)
    271. {
    272.     int fd = open(filename,O_RDONLY);
    273.     if(fd >0)
    274.     {
    275.  
    276.         #if 0
    277.         while(1)
    278.         {
    279.             char buf[1024];
    280.             int len = read(fd,buf,sizeof buf);
    281.             if(len >0)
    282.             {
    283.                 send(cfd,buf,len,0);
    284.                 usleep(10);
    285.             }
    286.             else if(len == 0)
    287.             {
    288.                 printf("Read file end\n");
    289.                 break;
    290.             }
    291.             else
    292.             {
    293.                 perror("read error");
    294.             }
    295.         }
    296.         #else
    297.         off_t offset = 0;
    298.         int file_size = lseek(fd,0,SEEK_END);
    299.         lseek(fd,0,SEEK_SET);
    300.  
    301.         while(offset 
    302.         {
    303.             int send_len = sendfile(cfd,fd,&offset,file_size-offset);
    304.             
    305.             if(send_len == -1)
    306.             {
    307.                 if(errno == EAGAIN)
    308.                 {
    309.                     //perror("sendfile no data send");
    310.                 }
    311.                 else
    312.                 {
    313.                     perror("sendfile ret -1");
    314.                 }
    315.                 
    316.             }
    317.             else
    318.             {
    319.                 printf("Send len:%d\n",send_len);
    320.             }
    321.         }
    322.         
    323.         #endif
    324.     }
    325.     else
    326.     {
    327.         perror("open file failed");
    328.     }
    329.     close(fd);
    330.     return 0;
    331. }
    332.  
    333. int ParseReqLine(const char *line,int cfd)
    334. {
    335.     char method[12];
    336.     char path[1024];
    337.  
    338.     printf("ParseReqLine=[%s]\n",line);
    339.  
    340.     int ret = sscanf(line,"%[^ ] %[^ ]",method,path);
    341.     printf("sscanf ret = %d\n",ret);
    342.     printf("method=[%s],path=[%s]\n",method,path);
    343.  
    344.     urldecode(path);
    345.     printf("afterdecode path=[%s]\n",path);
    346.     if(ret ==2 )
    347.     {
    348.  
    349.     }
    350.     else
    351.     {
    352.         printf("Reqest line parse failed\n");
    353.         return -1;
    354.     }
    355.  
    356.     if(strcasecmp(method,"get") == 0)
    357.     {
    358.  
    359.     }
    360.     else if(strcasecmp(method,"post")==0)
    361.     {
    362.  
    363.     }
    364.     else
    365.     {
    366.         return -1;
    367.     }
    368.  
    369.     char *file = NULL;
    370.     if(strcmp(path,"/") == 0)
    371.     {   
    372.         file = "./";
    373.     }
    374.     else
    375.     {
    376.         file = path+1;
    377.     }
    378.  
    379.     struct stat st;
    380.  
    381.     ret = stat(file,&st);
    382.     if(ret == -1)
    383.     {
    384.         printf("file doest not exist\n");
    385.         SendHead(cfd,404,"Not found",GetFileType(".html"),-1);
    386.         SendFile("404.html",cfd);
    387.         return -1;
    388.     }
    389.  
    390.     if(S_ISDIR(st.st_mode))
    391.     {
    392.         printf("Directory\n");
    393.         SendHead(cfd,200,"OK",GetFileType(".html"),-1);
    394.         SendDir(file,cfd);
    395.     }
    396.     else
    397.     {
    398.         printf("File\n");
    399.         SendHead(cfd,200,"OK",GetFileType(file),st.st_size);
    400.         SendFile(file,cfd);
    401.     }
    402.  
    403.  
    404.     return 0;
    405. }
    406.  
    407. int Request(int epoll_fd,int cfd)
    408. {
    409.     char buffer[4096] = {0};
    410.     char temp_buf[1024] = {0};
    411.     int read_len = 0;
    412.     int total = 0;
    413.     while((read_len = recv(cfd,temp_buf,sizeof(temp_buf),0))>0)
    414.     {
    415.         if(total+read_len <sizeof(buffer))
    416.         {
    417.             memcpy(buffer+total,temp_buf,read_len);
    418.             total+=read_len;
    419.         }
    420.  
    421.     }
    422.  
    423.     if(read_len == -1 && errno == EAGAIN)
    424.     {
    425.         //读取数据结束
    426.         char *p = strstr(buffer,"\r\n");
    427.         if(p)
    428.         {
    429.             int len = p - buffer;
    430.             buffer[len] = 0;
    431.             ParseReqLine(buffer,cfd);
    432.         }
    433.         
    434.     }
    435.     else if(read_len == 0)
    436.     {
    437.         //Client close socket
    438.         epoll_ctl(epoll_fd,EPOLL_CTL_DEL,cfd,NULL);
    439.         close(cfd);
    440.     }
    441.     else
    442.     {
    443.         perror("recv error");
    444.     }
    445.     return 0;
    446. }
    447.  
    448.  
    449. int EPOLL_Run(int server_fd)
    450. {
    451.     int epoll_fd = epoll_create(10);
    452.     if(epoll_fd == -1)
    453.     {
    454.         perror("epoll_create failed");
    455.         return 0;
    456.     }
    457.  
    458.     struct epoll_event ev;
    459.     ev.data.fd = server_fd;
    460.     ev.events = EPOLLIN;
    461.     int ret = epoll_ctl(epoll_fd,EPOLL_CTL_ADD,server_fd,&ev);
    462.     if(ret == -1)
    463.     {
    464.         perror("epoll_ctl failed");
    465.         return 0;
    466.     }
    467.  
    468.     struct epoll_event events[512];
    469.  
    470.     while(true)
    471.     {
    472.         int nReady = epoll_wait(epoll_fd,events,512,-1);
    473.  
    474.         for(int i = 0;i
    475.         {
    476.             int fd = events[i].data.fd;
    477.             if(fd == server_fd)
    478.             {
    479.                 AcceptClients(epoll_fd,fd);
    480.             }
    481.             else
    482.             {
    483.                 if(events[i].events &EPOLLOUT)
    484.                 {
    485.                     //g_writeable = true;
    486.                     printf("客户端可以写数据了");
    487.                 }
    488.                 if(events[i].events &EPOLLIN)
    489.                 {
    490.                     Request(epoll_fd,fd);
    491.                 }
    492.                 
    493.             }
    494.         }
    495.     }
    496.  
    497.     return epoll_fd;
    498. }
    499. int main()
    500. {
    501.     printf("Hello world\n");
    502.  
    503.     char work_dir[] = "/home/develop/httpserver";
    504.     //chdir(work_dir);
    505.  
    506.     int server_fd = CreateSocketFD();
    507.  
    508.     if(server_fd <=0)
    509.     {
    510.         return 0;
    511.     }
    512.  
    513.     EPOLL_Run(server_fd);
    514.  
    515.     close(server_fd);
    516.     return 0;
    517. }

    以上  如果遇到大文件 比如mp3 文件的话  就没办法 预览  试听 下载大文件也有问题  

    跟踪发现是SendFile 那里有问题   会返回-1

    根据网上的例子 改了一个 基于libevent版本的  不会存在这个问题 

    1. #include "sushi.h"
    2. #include "stdio.h"
    3.  
    4.  
    5.  
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16.  
    17.  
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22.  
    23.  
    24.  
    25. #include 
    26. #include 
    27. #include 
    28. #include 
    29. #include 
    30. #include 
    31. #include 
    32. #include 
    33.  
    34. #include 
    35.  
    36.  
    37.  
    38.  
    39.  
    40. #include 
    41. #include 
    42. #include 
    43. #include "event2/http.h"
    44. #include "event2/event.h"
    45. #include "event2/buffer.h"
    46. #include "event2/bufferevent.h"
    47. #include "event2/bufferevent_compat.h"
    48. #include "event2/http_struct.h"
    49. #include "event2/http_compat.h"
    50. #include "event2/util.h"
    51. #include "event2/listener.h"
    52. #include "event2/thread.h"
    53.  
    54.  
    55. #define MAX_EVENTS	100	
    56. #define RECVBUFSIZ	20
    57.  
    58. bool g_run_flag = true;
    59.  
    60.  
    61. void sig_handler(int signo)
    62. {
    63. 	g_run_flag = false;
    64. 	printf("\033[0;31mprogram exit by user cmd !!!!\033[0;39m\n");
    65. }
    66.  
    67.  
    68.  
    69. #define BURSIZE 1024
    70. int hex2dec(char c)
    71. {
    72. 	if ('0' <= c && c <= '9') {
    73. 		return c - '0';
    74. 	} else if ('a' <= c && c <= 'f') {
    75. 		return c - 'a' + 10;
    76. 	} else if ('A' <= c && c <= 'F') {
    77. 		return c - 'A' + 10;
    78. 	} else {
    79. 		return -1;
    80. 	}
    81. }
    82.  
    83. char dec2hex(short int c)
    84. {
    85. 	if (0 <= c && c <= 9) {
    86. 		return c + '0';
    87. 	} else if (10 <= c && c <= 15) {
    88. 		return c + 'A' - 10;
    89. 	} else {
    90. 		return -1;
    91. 	}
    92. }
    93.  
    94.  
    95. /*
    96.  * 编码一个url
    97.  */
    98. void urlencode(char url[])
    99. {
    100. 	int i = 0;
    101. 	int len = strlen(url);
    102. 	int res_len = 0;
    103. 	char res[BURSIZE];
    104. 	for (i = 0; i < len; ++i) {
    105. 		char c = url[i];
    106. 		if (('0' <= c && c <= '9') ||
    107. 				('a' <= c && c <= 'z') ||
    108. 				('A' <= c && c <= 'Z') || c == '/' || c == '.') {
    109. 			res[res_len++] = c;
    110. 		} else {
    111. 			int j = (short int)c;
    112. 			if (j < 0)
    113. 				j += 256;
    114. 			int i1, i0;
    115. 			i1 = j / 16;
    116. 			i0 = j - i1 * 16;
    117. 			res[res_len++] = '%';
    118. 			res[res_len++] = dec2hex(i1);
    119. 			res[res_len++] = dec2hex(i0);
    120. 		}
    121. 	}
    122. 	res[res_len] = '\0';
    123. 	strcpy(url, res);
    124. }
    125.  
    126. /*
    127.  * 解码url
    128.  */
    129. void urldecode(char url[])
    130. {
    131.     
    132. 	int i = 0;
    133. 	int len = strlen(url);
    134. 	int res_len = 0;
    135. 	char res[BURSIZE];
    136. 	for (i = 0; i < len; ++i) {
    137. 		char c = url[i];
    138. 		if (c != '%') {
    139. 			res[res_len++] = c;
    140. 		} else {
    141. 			char c1 = url[++i];
    142. 			char c0 = url[++i];
    143. 			int num = 0;
    144. 			num = hex2dec(c1) * 16 + hex2dec(c0);
    145. 			res[res_len++] = num;
    146. 		}
    147. 	}
    148. 	res[res_len] = '\0';
    149. 	strcpy(url, res);
    150. }
    151.  
    152. const char *GetFileType(const char *filename)
    153. {
    154.     const char *dot = strrchr(filename,'.');
    155.     if(dot == NULL)
    156.     {
    157.         return "text/plain; charset=utf-8";
    158.     }
    159.     if(strcmp(dot,".jpg") == 0 ||strcmp(dot,".jpeg") == 0)
    160.     {
    161.         return "image/jpg";
    162.     }
    163.     if(strcmp(dot,".html") == 0 ||strcmp(dot,".htm") == 0)
    164.     {
    165.         return "text/html; charset=utf-8";
    166.     }    
    167.     if(strcmp(dot,".png") == 0)
    168.     {
    169.         return "image/png";
    170.     }    
    171.     if(strcmp(dot,".bmp") == 0)
    172.     {
    173.         return "image/bmp";
    174.     }        
    175.     if(strcmp(dot,".gif") == 0)
    176.     {
    177.         return "image/gif";
    178.     }            
    179.     if(strcmp(dot,".css") == 0)
    180.     {
    181.         return "text/css";
    182.     }           
    183.     if(strcmp(dot,".mp3") == 0)
    184.     {
    185.         return "audio/mpeg";
    186.     }               
    187.  
    188.     return "text/plain; charset=utf-8";
    189. }
    190.  
    191.  
    192. int SendHead(struct bufferevent *event,int status ,const char *desc,const char *type,int size)
    193. {
    194.     char buf[4096] = {0};
    195.     sprintf(buf,"http/1.1 %d %s\r\n",status,desc);
    196.     sprintf(buf+strlen(buf),"content-type: %s\r\n",type);
    197.     sprintf(buf+strlen(buf),"content-length: %d\r\n\r\n",size);    
    198.  
    199.  
    200.     printf("SendHead buf[%s]\n",buf);
    201.  
    202.     //send(cfd,buf,strlen(buf),0);
    203.     bufferevent_write(event,buf,strlen(buf));
    204.     return 0;
    205. }
    206.  
    207.  
    208. int SendDir(struct bufferevent *event,const char *dirname)
    209. {
    210.     char buf[4096] = {0};
    211.  
    212.     sprintf(buf,"%s",dirname);
    213.  
    214.     printf("SendDir dirname=[%s]\n",dirname);
    215.     struct dirent **namelist;
    216.     int count = scandir(dirname,&namelist,NULL,alphasort);
    217.     printf("SendDir count=[%d]\n",count);
    218.     for(int i = 0;i< count;i++)
    219.     {
    220.         char *name = namelist[i]->d_name;
    221.         struct stat st;
    222.         char sub_path[1024]={0};
    223.         sprintf(sub_path,"%s/%s",dirname,name);
    224.         stat(sub_path,&st);
    225.         if(S_ISDIR(st.st_mode))
    226.         {
    227.             sprintf(buf+strlen(buf),
    228.                 "
      229. ",name,name,st.st_size);
    229.         }
    230.         else
    231.         {
    232.             sprintf(buf+strlen(buf),
    233.                 "
      234. ",name,name,st.st_size);
    234.         }
    235.  
    236.         //printf("cfd:%d Sendbuf[%s]\n",cfd,buf);
    237.         //send(cfd,buf,strlen(buf),0);
    238. 		  	bufferevent_write(event,buf,strlen(buf));    
    239.         memset(buf,0,sizeof(buf));
    240.         free(namelist[i]);
    241.     }
    242.  
    243.     sprintf(buf,"
      244. %s%ld
      %s%ld
      "      );
    244.  
    245.     //printf("cfd:%d Sendbuf[%s]\n",cfd,buf);
    246.  
    247.     //send(cfd,buf,strlen(buf),0);
    248. 		bufferevent_write(event,buf,strlen(buf));    	
    249.     free(namelist);
    250.  
    251.     return 0;
    252. }
    253.  
    254. int SendFile(struct bufferevent *event,const char* filename)
    255. {
    256.     int fd = open(filename,O_RDONLY);
    257.     if(fd >0)
    258.     {
    259.  
    260.         #if 1
    261.         while(1)
    262.         {
    263.             char buf[1024];
    264.             int len = read(fd,buf,sizeof buf);
    265.             if(len >0)
    266.             {
    267.                 //send(cfd,buf,len,0);
    268.                 	bufferevent_write(event,buf,len);    
    269.                 usleep(10);
    270.             }
    271.             else if(len == 0)
    272.             {
    273.                 printf("Read file end\n");
    274.                 break;
    275.             }
    276.             else
    277.             {
    278.                 perror("read error");
    279.             }
    280.         }
    281.         #else
    282.         off_t offset = 0;
    283.         int file_size = lseek(fd,0,SEEK_END);
    284.         lseek(fd,0,SEEK_SET);
    285.  
    286.         while(offset 
    287.         {
    288.             int send_len = sendfile(cfd,fd,&offset,file_size-offset);
    289.             
    290.             if(send_len == -1)
    291.             {
    292.                 if(errno == EAGAIN)
    293.                 {
    294.                     //perror("sendfile no data send");
    295.                 }
    296.                 else
    297.                 {
    298.                     perror("sendfile ret -1");
    299.                 }
    300.                 
    301.             }
    302.             else
    303.             {
    304.                 printf("Send len:%d\n",send_len);
    305.             }
    306.         }
    307.         
    308.         #endif
    309.     }
    310.     else
    311.     {
    312.         perror("open file failed");
    313.     }
    314.     close(fd);
    315.     return 0;
    316. }
    317.  
    318.  
    319.  
    320.  
    321. int http_request(struct bufferevent *event,char *path)
    322. {
    323. 	char *file = NULL;
    324.  
    325. 	if(strcmp(path,"/") == 0)
    326. 	{   
    327. 	  file = "./";
    328. 	}
    329. 	else
    330. 	{
    331. 	  file = path+1;
    332. 	}
    333.  
    334. 	struct stat st;
    335.  
    336. 	int ret = stat(file,&st);
    337. 	if(ret == -1)
    338. 	{
    339. 	  printf("file doest not exist\n");
    340. 	  SendHead(event,404,"Not found",GetFileType(".html"),-1);
    341. 	  SendFile(event,"404.html");
    342. 	  return -1;
    343. 	}
    344.  
    345. 	if(S_ISDIR(st.st_mode))
    346. 	{
    347. 	  printf("Directory\n");
    348. 	  SendHead(event,200,"OK",GetFileType(".html"),-1);
    349. 	  SendDir(event,file);
    350. 	}
    351. 	else
    352. 	{
    353. 	  printf("File\n");
    354. 	  SendHead(event,200,"OK",GetFileType(file),st.st_size);
    355. 	  SendFile(event,file);
    356. 	}
    357. 	
    358. 	return 0;
    359. }
    360.  
    361. void read_cb(struct bufferevent *event,void *arg)
    362. {
    363. 	char buf[256] = {0};
    364. 	char method[10]= {0},path[256]={0},protocol[10]={0};
    365.  
    366. 	int ret = bufferevent_read(event,buf,sizeof(buf));
    367. 	if(ret >0)
    368. 	{
    369. 		sscanf(buf,"%[^ ] %[^ ] %[^ \r\n]",method,path,protocol);
    370. 		if(strcasecmp(method,"get") == 0)
    371. 		{
    372. 			char bufline[256] = {0};
    373. 			write(STDOUT_FILENO,buf,ret);
    374. 			while((ret = bufferevent_read(event,bufline,sizeof(bufline)))>0)
    375. 			{
    376. 				write(STDOUT_FILENO,bufline,ret);
    377. 			}
    378. 			http_request(event,path);
    379. 		}
    380. 	}
    381. }
    382.  
    383.  
    384. void bevent_cb(struct bufferevent *event,short what,void *arg)
    385. {
    386. 	if(what & BEV_EVENT_EOF)
    387. 	{
    388. 		printf("client closeed\n");
    389. 		bufferevent_free(event);
    390. 	}
    391. 	else if(what & BEV_EVENT_ERROR)
    392. 	{
    393. 		printf("client error\n");
    394. 		bufferevent_free(event);
    395. 	}
    396. 	else if(what & BEV_EVENT_CONNECTED)
    397. 	{
    398. 		printf("new client connected\n");
    399. 	}
    400. }
    401.  
    402. void listener_cb(struct evconnlistener *listener,evutil_socket_t fd,struct sockaddr *addr,int socklen,void *arg)
    403. {
    404. 	struct event_base *base = (struct event_base*)arg;
    405. 	struct bufferevent *event=  bufferevent_socket_new(base,fd,BEV_OPT_CLOSE_ON_FREE);
    406. 	bufferevent_setcb(event,read_cb,NULL,bevent_cb,base);
    407. 	bufferevent_enable(event,EV_READ|EV_WRITE);
    408. }
    409.  
    410.  
    411. int main (int argc ,char*argv[])
    412. {
    413. 	
    414.  
    415.  
    416. 	signal(SIGINT, sig_handler);
    417. 	signal(SIGTERM, sig_handler);
    418. 	signal(SIGKILL, sig_handler);//Program can not recieve SIGKILL(9) signal so.... this cmd does not make any sense
    419.  
    420. 	// Ignore broken pipes
    421. 	signal(SIGPIPE, SIG_IGN);
    422.  
    423.  
    424. 	char work_dir[256]={0};
    425. 	strcpy(work_dir,getenv("PWD"));
    426. 	printf("dir:%s\n",work_dir);
    427. 	chdir(work_dir);
    428.  
    429. 	struct event_base *base = event_base_new();
    430. 	struct sockaddr_in server;
    431. 	server.sin_family = AF_INET;
    432. 	server.sin_port = htons(9999);
    433. 	server.sin_addr.s_addr = htonl(INADDR_ANY);
    434. 	struct evconnlistener *listener = evconnlistener_new_bind(base,listener_cb,base,
    435. 		LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE_PORT,-1,
    436. 		(struct sockaddr *)&server,sizeof(server));
    437.  
    438.  
    439. 	event_base_dispatch(base);
    440. 	event_base_free(base);
    441.  
    442. 	evconnlistener_free(listener);
    443. 	
    444.  
    445. 	printf("Exit normally\n");
    446. 	return 0;
    447. }

  • 相关阅读:
    Linux安装与卸载Jenkins
    Java版正则表达式实现
    C语言内功修炼--指针详讲（进阶）
    Websocket升级版
    解读云视商系统开发等主流9大电商APP商业模式
    学习笔记-关于过滤\<\?php标签这件事
    【.NET8】访问私有成员新姿势UnsafeAccessor（上）
    深入理解Linux进程管理与优化：原理、调度和资源控制详解
    GO学习之 远程过程调用(RPC)
    动画详解常用排序算法（1）
  • 原文地址：https://blog.csdn.net/baoecit/article/details/133445242