devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

c/c++ webserver项目（linux 高性能服务器编程，游双）

作者：你好赵伟 | 2024-07-27 07:50:43

赞

踩

游双

项目介绍：最近在阅读游双的《linux高性能服务器编程》，看到后面跟着里面的代码敲了一个webserver。该项目采用同步模拟的proactor框架，采用半同步半异步的并法模式，用epoll实现io多路复用。

（1）locker.h文件是一个线程同步机制包装类，封装了sem_t，pthread_mutex_t，pthread_cond_t 三个用于线程同步的机制。

（2）threadpool.h 为线程池类，成员变量主要有任务队列m_workqueue 和线程数组 m_threads。各个线程通过竞争sem_t 信号量来从 任务队列获得任务，执行任务对象的process()函数来处理http请求与写http响应。

（3）http_conn.h 为任务类，主要封装了如何处理http请求 与 如何写http响应，主要流程为将读入的http请求写入缓存区m_read_buf，通过对m_read_buf 的操作来获得请求的信息。在对请求的信息判断正确后，将http响应报文写入 m_write_buf ，然后发送该响应报文来完成与浏览器的交互。 

http_conn.cpp文件中的doc_root为网站根目录，将文件放入该根目录中即可被访问。

编译：先在终端输入如下指令生成 server 可执行文件

g++ -o server main.cpp http_conn.cpp -lpthread -g

 运行：

./server ip地址 端口号

Locker.h 

  1. /线程同步机制包装类
  2. #ifndef LOCKER_H
  3. #define LOCKER_H
  4.  
  5. #include <exception>
  6. #include <pthread.h>
  7. #include <semaphore.h>
  8.  
  9. //封装信号量的类
  10. class sem
  11. {
  12. public:
  13.     sem()
  14.     {
  15.         if(sem_init(&m_sem, 0, 0) != 0)
  16.         {
  17.             throw std::exception();
  18.         }
  19.     }
  20.     //销毁信号量
  21.     ~sem()
  22.     {
  23.         sem_destroy(&m_sem);
  24.     }
  25.     //等待信号量
  26.     bool wait()
  27.     {
  28.         return sem_wait(&m_sem) == 0;
  29.     }
  30.     bool post()
  31.     {
  32.         return sem_post(&m_sem) == 0;
  33.     }
  34. private:
  35.     sem_t m_sem;
  36. };
  37.  
  38.  
  39. class locker
  40. {
  41. public:
  42.     locker()
  43.     {
  44.         if(pthread_mutex_init(&m_mutex, NULL) != 0)
  45.         {
  46.             throw std::exception();
  47.         }
  48.     }
  49.     ~locker()
  50.     {
  51.         pthread_mutex_destroy(&m_mutex);
  52.     }
  53.  
  54.     bool lock()
  55.     {
  56.         return pthread_mutex_lock(&m_mutex) == 0;
  57.     }
  58.  
  59.     bool unlock()
  60.     {
  61.         return pthread_mutex_unlock(&m_mutex) == 0;
  62.     }
  63.  
  64. private:
  65.     pthread_mutex_t m_mutex;
  66.  
  67. };
  68. //phtread
  69.  
  70. class cond
  71. {
  72.  
  73. public:
  74.     cond()
  75.     {
  76.         if(pthread_mutex_init(&m_mutex, NULL) != 0)
  77.         {
  78.             throw std::exception();
  79.         }
  80.         if(pthread_cond_init(&m_cond, NULL) != 0)
  81.         {
  82.             //出现问题得释放已经分配的资源
  83.             pthread_mutex_destroy(&m_mutex);
  84.             throw std::exception();
  85.         }
  86.     }
  87.  
  88.     ~cond()
  89.     {
  90.         pthread_mutex_destroy(&m_mutex);
  91.         pthread_cond_destroy(&m_cond);
  92.     }
  93.  
  94.     bool wait()
  95.     {
  96.         int ret = 0;
  97.         pthread_mutex_lock(&m_mutex);
  98.         ret = pthread_cond_wait(&m_cond, &m_mutex);
  99.         pthread_mutex_unlock(&m_mutex);
  100.         return ret == 0;
  101.     }
  102.  
  103.     bool signal()
  104.     {
  105.         return pthread_cond_signal(&m_cond) == 0;
  106.     }
  107.  
  108. private:
  109.     pthread_mutex_t m_mutex;
  110.     pthread_cond_t m_cond;
  111.  
  112. };
  113.  
  114.  
  115. #endif

threadpool.h

  1. #ifndef THREADPOOL_H
  2. #define THREADPOOL_H
  3.  
  4. #include<list>
  5. #include<cstdio>
  6. #include<exception>
  7. #include<pthread.h>
  8. #include"locker.h"
  9.  
  10. template<typename T>
  11. class threadpool
  12. {
  13. private:
  14.     std::list<T*> m_workequeue;
  15.     pthread_t* m_threads;
  16.     int m_thread_number;
  17.     int m_max_requests;
  18.     locker m_queuelocker;
  19.     sem m_queuestat;
  20.     bool m_stop;    
  21.  
  22. private:
  23.     static void* worker(void* arg);
  24.     void run();
  25.  
  26. public:
  27.     threadpool(int thread_number = 8 , int max_requests = 10000);
  28.     ~threadpool();
  29.     bool append(T* request);
  30. };
  31.  
  32. template<typename T>
  33. threadpool<T>::threadpool(int thread_number,int max_requests):m_thread_number(thread_number),m_max_requests(max_requests),m_threads(NULL),m_stop(false)
  34. {
  35.     if((thread_number<=0) || (max_requests<=0)){
  36.         throw std::exception();
  37.     }
  38.  
  39.     m_threads = new pthread_t[m_thread_number];
  40.     if(!m_threads){
  41.         throw std::exception();
  42.     }
  43.     for(int i=0;i<thread_number;++i){
  44.         printf("create the %dth thread\n",i+1);
  45.         pthread_create(m_threads+i,NULL,worker,this);
  46.         pthread_detach(m_threads[i]);      
  47.     }
  48. }
  49. template<typename T>
  50. threadpool<T>::~threadpool()
  51. {
  52.     delete[] m_threads;
  53.     m_stop = true;
  54. }
  55. template<typename T>
  56. bool threadpool<T>::append(T* request){
  57.     m_queuelocker.lock();
  58.     if(m_workequeue.size()>=m_max_requests){
  59.         m_queuelocker.unlock();
  60.         return false;
  61.     }
  62.     m_workequeue.push_back(request);
  63.     m_queuelocker.unlock();
  64.     m_queuestat.post();
  65.     return true;
  66. }
  67. template<typename T>
  68. void* threadpool<T>::worker(void* arg){
  69.     threadpool* pool = (threadpool*)arg;
  70.     pool->run();
  71.     return pool;
  72. }
  73. template<typename T>
  74. void threadpool<T>::run(){
  75.     while(!m_stop){
  76.         m_queuestat.wait();
  77.         m_queuelocker.lock();
  78.         if(m_workequeue.empty()){
  79.             m_queuelocker.unlock();
  80.             continue;
  81.         }
  82.         T* request = m_workequeue.front();
  83.         m_workequeue.pop_front();
  84.         m_queuelocker.unlock();
  85.         if(!request){
  86.             continue;
  87.         }
  88.         request->process();
  89.     }
  90. }
  91.  
  92. #endif

http_conn.h

  1. #ifndef HTTP_CONN_h
  2. #define HTTP_CONN_h
  3.  
  4. #include <unistd.h>
  5. #include <signal.h>
  6. #include <sys/types.h>
  7. #include <sys/epoll.h>
  8. #include <fcntl.h>
  9. #include <sys/socket.h>
  10. #include <netinet/in.h>
  11. #include <arpa/inet.h>
  12. #include <assert.h>
  13. #include <sys/stat.h>
  14. #include <string.h>
  15. #include <pthread.h>
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <sys/mman.h>
  19. #include <stdarg.h>
  20. #include <errno.h>
  21. #include <sys/uio.h>
  22. #include "locker.h"
  23.  
  24. class http_conn
  25. {
  26. public:
  27.     
  28.     static const int FILENAME_LEN = 200;//文件名的最大长度
  29.     
  30.     static const int READ_BUFFER_SIZE = 2048;//缓冲区的大小
  31.     
  32.     static const int WRITE_BUFFER_SIZE = 1024;//写缓冲区的大小
  33.  
  34.  
  35.     //HTTP请求方法
  36.     //HTTP请求方法,但本代码中仅仅支持GET
  37.     enum METHOD{
  38.         GET = 0,
  39.         POST,
  40.         HEAD,
  41.         PUT,
  42.         DELETE,
  43.         TRACE,
  44.         OPTIONS,
  45.         CONNECT,
  46.         PATCH
  47.     };
  48.  
  49.  
  50.     //主状态机可能的状态
  51.     enum CHECK_STATE
  52.     {
  53.         CHECK_STATE_REQUESTION = 0,//正在分析当前请求行
  54.         CHECK_STATE_HEADER,//正在分析头部字段
  55.         CHECK_STATE_CONTENT
  56.     };
  57.  
  58.     //从状态机可能的状态
  59.     enum LINE_STATUS
  60.     {
  61.         LINE_OK = 0,//读取到一个完整的行
  62.         LINE_BAD,//行出错
  63.         LINE_OPEN//行数据尚且不完整
  64.     };
  65.  
  66.     //服务器处理http请求的结果
  67.     enum HTTP_CODE
  68.     {
  69.         NO_REQUEST,//请求不完整需要继续读取
  70.         GET_REQUEST,//得到了一个完整的请求
  71.         BAD_REQUEST,//请求有语法错误
  72.         NO_RESOURCE,//没有资源
  73.         FORBIDDEN_REQUEST,//没有足够的权限
  74.         FILE_REQUEST,//文件已被请求
  75.         INTERNAL_ERROR,//服务器内部错误
  76.         CLOSED_CONNECTION//客户端连接已关闭
  77.     };
  78.  
  79. public:
  80.     http_conn(){}
  81.     ~http_conn(){}
  82. public:
  83.     void init(int sockfd,const sockaddr_in& addr);
  84.     void close_conn(bool real_close = true);
  85.     bool read();
  86.     bool write();
  87.     void process();
  88.  
  89. private:
  90.     void init();
  91.     HTTP_CODE process_read();
  92.     bool process_write(HTTP_CODE ret);
  93.  
  94.     //下面一组函数被process_read调用以分析HTTP请求
  95.     HTTP_CODE parse_request_line(char* text);
  96.     HTTP_CODE parse_header(char* text);
  97.     HTTP_CODE parse_content(char* text);
  98.     HTTP_CODE do_request();
  99.     char* get_line(){ return m_read_buf + m_start_line; }
  100.     LINE_STATUS parse_line();
  101.  
  102.     //下面一组函数被process_write调用以填充HTTP应答
  103.     void unmap();
  104.     bool add_response(const char* format, ...);
  105.     bool add_content(const char* content);
  106.     bool add_status_line(int status, const char* title);
  107.     bool add_headers(int content_length);
  108.     bool add_content_length(int content_length);
  109.     bool add_linger();
  110.     bool add_blank_line();
  111.  
  112. public:
  113.     static int m_epollfd;
  114.     static int m_user_count;
  115.  
  116. private:
  117.     int m_sockfd;
  118.     sockaddr_in m_address;
  119.  
  120.     char m_read_buf[READ_BUFFER_SIZE];
  121.     int m_read_idx;
  122.     int m_check_idx;
  123.     int m_start_line;
  124.     char m_write_buf[WRITE_BUFFER_SIZE];
  125.     int m_write_idx;
  126.  
  127.     CHECK_STATE m_check_state;
  128.     METHOD m_method;
  129.     
  130.     char m_real_file[FILENAME_LEN];
  131.     char* m_url;
  132.     char* m_version;
  133.     char* m_host;
  134.     int m_content_length;
  135.     bool m_linger;
  136.  
  137.     char* m_file_address;
  138.     struct stat m_file_stat;
  139.     struct iovec m_iv[2];
  140.     int m_iv_count;
  141. };
  142.  
  143. #endif

http_conn.cpp

  1. #include"http_conn.h"
  2. //定义一些HTTP响应的状态信息
  3. const char* ok_200_title = "OK";
  4. const char* error_400_title = "Bad Request";
  5. const char* error_400_form = "Your request has bad syntax or is inherently impossible to satisfy.\n";
  6. const char* error_403_title = "Forbidden";
  7. const char* error_403_form = "you do not have permisson to get file from this server.\n";
  8. const char* error_404_title = "Not Found";
  9. const char* error_404_form = "The requested file was not found on this server.\n";
  10. const char* error_500_title = "Internal Error";
  11. const char* error_500_form = "There was an unusual problem serving the requested file.\n";
  12.  
  13. //网站的根目录
  14. const char* doc_root = "/home/ross/Documents";
  15.  
  16. int setnonblocking(int fd){
  17.     int old_option = fcntl(fd,F_GETFL);
  18.     int new_option = old_option | O_NONBLOCK;
  19.     fcntl(fd,F_SETFL,new_option);
  20.     return old_option;
  21. }
  22.  
  23. void addfd(int epollfd,int fd,bool one_shot){
  24.     epoll_event event;
  25.     event.data.fd = fd;
  26.     event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
  27.     if(one_shot){
  28.         event.events |= EPOLLONESHOT;
  29.     }
  30.     epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&event);
  31.     setnonblocking(fd);
  32. }
  33.  
  34. void removefd(int epollfd,int fd){
  35.     epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,0);
  36.     close(fd);
  37. }
  38.  
  39. void modfd(int epollfd,int fd,int ev){
  40.     epoll_event event;
  41.     event.data.fd = fd;
  42.     event.events = ev | EPOLLET | EPOLLONESHOT | EPOLLRDHUP;
  43.     epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&event);
  44. }
  45.  
  46. int http_conn::m_user_count = 0;
  47. int http_conn::m_epollfd = -1;
  48.  
  49. void http_conn::close_conn(bool real_close){
  50.     if(real_close && (m_sockfd != -1)){
  51.         removefd(m_epollfd,m_sockfd);
  52.         m_sockfd = -1;
  53.         m_user_count --;
  54.     }
  55. }
  56.  
  57. void http_conn::init(int sockfd,const sockaddr_in& addr){
  58.     m_sockfd = sockfd;
  59.     m_address = addr;
  60.     addfd(m_epollfd,sockfd,true);
  61.     m_user_count ++;
  62.     init();
  63. }
  64.  
  65. void http_conn::init(){
  66.     m_check_state = CHECK_STATE_REQUESTION;
  67.     m_linger = false;
  68.  
  69.     m_method = GET;
  70.     m_url = 0;
  71.     m_version = 0;
  72.     m_content_length = 0;
  73.     m_host = 0;
  74.     m_start_line = 0;
  75.     m_check_idx = 0;
  76.     m_read_idx = 0;
  77.     m_write_idx = 0;
  78.     memset(m_read_buf,'\0',READ_BUFFER_SIZE);
  79.     memset(m_write_buf,'\0',WRITE_BUFFER_SIZE);
  80.     memset(m_real_file,'\0',FILENAME_LEN);
  81. }
  82.  
  83. http_conn::LINE_STATUS http_conn::parse_line(){
  84.     char temp;
  85.     for(;m_check_idx<m_read_idx;++m_check_idx){
  86.         temp = m_read_buf[m_check_idx];
  87.         if(temp == '\r'){
  88.             if(m_read_buf[m_check_idx+1] == '\n'){
  89.                 m_read_buf[m_check_idx++] = '\0';
  90.                 m_read_buf[m_check_idx++] = '\0';
  91.                 return LINE_OK;
  92.             }
  93.             else if( (m_check_idx+1) == m_read_idx){
  94.                 return LINE_OPEN;
  95.             }
  96.             else
  97.                 return LINE_BAD;
  98.         }
  99.         else if(temp == '\n'){
  100.             if((m_check_idx>1) && (m_read_buf[m_check_idx-1] == '\r'))
  101.             {
  102.                 m_read_buf[m_check_idx-1] = '\0';
  103.                 m_read_buf[m_check_idx++] = '\0';
  104.                 return LINE_OK;
  105.             }
  106.             else{
  107.                 return LINE_BAD;
  108.             }
  109.         }
  110.     }
  111.     return LINE_OPEN;
  112. }
  113.  
  114. bool http_conn::read(){
  115.     if(m_read_idx >= READ_BUFFER_SIZE){
  116.         return false;
  117.     }
  118.     int bytes_read = 0;
  119.     while(true){
  120.         bytes_read = recv(m_sockfd,m_read_buf,READ_BUFFER_SIZE-m_read_idx,0);
  121.         if(bytes_read == -1){
  122.             if( errno == EAGAIN || errno == EWOULDBLOCK){
  123.                 break;
  124.             }
  125.             return false;
  126.         }
  127.         else if(bytes_read == 0){
  128.             return false;
  129.         }
  130.         m_read_idx += bytes_read;
  131.     }
  132.     return true;
  133. }
  134.  
  135. http_conn::HTTP_CODE http_conn::parse_request_line(char* text){
  136.     m_url = strpbrk(text," \t");
  137.     if(!m_url){
  138.         return BAD_REQUEST;
  139.     }
  140.     *m_url++ = '\0';
  141.     m_url += strspn(m_url," \t");
  142.     
  143.     char* method = text;
  144.     if(strcasecmp(method,"GET") == 0){
  145.         m_method = GET;
  146.     }
  147.     else{
  148.         return BAD_REQUEST;
  149.     }
  150.  
  151.     m_version = strpbrk(m_url," \t");
  152.     if(!m_version){
  153.         return BAD_REQUEST;
  154.     }
  155.     *m_version++ = '\0';
  156.     m_version+=strspn(m_version," \t");
  157.     if(strcasecmp(m_version,"HTTP/1.1") != 0){
  158.         return BAD_REQUEST;
  159.     }
  160.  
  161.     if(strncasecmp(m_url,"http://",7)==0){
  162.         m_url+=7;
  163.         m_url = strchr(m_url,'/');
  164.     }
  165.     if(!m_url || m_url[0]!= '/'){
  166.         return BAD_REQUEST;
  167.     }
  168.  
  169.     m_check_state = CHECK_STATE_HEADER;
  170.     return NO_REQUEST;
  171. }
  172.  
  173. http_conn::HTTP_CODE http_conn::parse_header(char* text){
  174.     if(text[0] == '\0'){
  175.         if(m_content_length != 0){
  176.             m_check_state = CHECK_STATE_CONTENT;
  177.             return NO_REQUEST;
  178.         }
  179.         printf("parse_header OK\n");
  180.         return GET_REQUEST;
  181.     }
  182.     else if(strncasecmp(text,"Connection:",11) == 0){
  183.         text+=11;
  184.         text += strspn(text," \t");
  185.         if(strcasecmp(text,"keep-alive") == 0){
  186.             m_linger = true;
  187.         }
  188.     }
  189.     else if(strncasecmp(text,"Content-Length",15)==0){
  190.         text += 15;
  191.         text += strspn(text," \t");
  192.         m_content_length += atol(text);
  193.     }
  194.     else if(strncasecmp(text,"Host:",5) == 0){
  195.         text+=5;
  196.         text+=strspn(text," \t");
  197.         m_host = text;
  198.     }
  199.     else{
  200.         printf("oh no! I can't handle this header %s\n",text);
  201.     }
  202.     return NO_REQUEST;
  203. }
  204.  
  205. http_conn::HTTP_CODE http_conn::parse_content(char* text){
  206.     if(m_read_idx >= m_content_length+m_check_idx){
  207.         text[m_content_length] = '\0';
  208.         return GET_REQUEST;
  209.     }
  210.     return NO_REQUEST;
  211. }
  212.  
  213. http_conn::HTTP_CODE http_conn::process_read(){
  214.     LINE_STATUS line_status = LINE_OK;
  215.     HTTP_CODE ret = NO_REQUEST;
  216.     char* text = 0;
  217.     while(((m_check_state == CHECK_STATE_CONTENT) && (line_status == LINE_OK)) || ((line_status=parse_line()) ==LINE_OK) ){
  218.         text = get_line();
  219.         m_start_line = m_check_idx;
  220.         printf("I got 1 line %s\n",text);
  221.         switch(m_check_state)
  222.         {
  223.         case CHECK_STATE_REQUESTION:{
  224.             ret = parse_request_line(text);
  225.             if(ret == BAD_REQUEST){
  226.                 return BAD_REQUEST;
  227.             }
  228.             break;
  229.         }
  230.         case CHECK_STATE_HEADER:{
  231.             ret = parse_header(text);
  232.             if(ret == BAD_REQUEST){
  233.                 return BAD_REQUEST;
  234.             }
  235.             else if(ret == GET_REQUEST){
  236.                 return do_request();
  237.             }
  238.             break;
  239.         }
  240.         case CHECK_STATE_CONTENT:{
  241.             ret = parse_content(text);
  242.             if(ret == GET_REQUEST){
  243.                 return do_request();
  244.             }
  245.             line_status = LINE_OPEN;
  246.             break;
  247.         }
  248.         default:
  249.             return INTERNAL_ERROR;
  250.         }
  251.     }
  252.     return NO_REQUEST;
  253. }
  254.  
  255. http_conn::HTTP_CODE http_conn::do_request(){
  256.     strcpy(m_real_file,doc_root);
  257.     int len = strlen(doc_root);
  258.     strncpy(m_real_file+len,m_url,FILENAME_LEN-len-1);
  259.     if(stat(m_real_file,&m_file_stat) < 0){
  260.         return NO_RESOURCE;
  261.     }
  262.     if(!(m_file_stat.st_mode & S_IROTH)){
  263.         return FORBIDDEN_REQUEST;
  264.     }
  265.     if(S_ISDIR(m_file_stat.st_mode)){
  266.         return BAD_REQUEST;
  267.     }
  268.  
  269.     int fd = open(m_real_file,O_RDONLY);
  270.     m_file_address = (char*)mmap(0,m_file_stat.st_size,PROT_READ,MAP_PRIVATE,fd,0);
  271.     close(fd);
  272.     return FILE_REQUEST;
  273. }
  274.  
  275. void http_conn::unmap(){
  276.     if(m_file_address){
  277.         munmap(m_file_address,m_file_stat.st_size);
  278.         m_file_address = 0;
  279.     }
  280. }
  281.  
  282. bool http_conn::add_response(const char* format, ...){
  283.     if(m_write_idx>WRITE_BUFFER_SIZE){
  284.         return false;
  285.     }
  286.     va_list arg_list;
  287.     va_start(arg_list,format);
  288.     int len = vsnprintf(m_write_buf+m_write_idx,WRITE_BUFFER_SIZE-1-m_write_idx,format,arg_list);
  289.     if(len >= (WRITE_BUFFER_SIZE-1-m_write_idx)){
  290.         return false;
  291.     }
  292.     m_write_idx+=len;
  293.     va_end(arg_list);
  294.     return true;
  295. }
  296.  
  297. bool http_conn::add_status_line(int status,const char* title){
  298.     return add_response("%s %d %s\r\n","HTTP/1.1",status,title);
  299. }
  300.  
  301. bool http_conn::add_headers(int content_len){
  302.     add_content_length(content_len);
  303.     add_linger();
  304.     add_blank_line();
  305.     return true;    
  306. }
  307.  
  308. bool http_conn::add_content_length(int content_len){
  309.     return add_response("Content-Length: %d\r\n",content_len);
  310. }
  311.  
  312. bool http_conn::add_linger(){
  313.     return add_response("Connection: %s\r\n",(m_linger == true)?"keep-alive":"close");
  314. }
  315.  
  316. bool http_conn::add_blank_line(){
  317.     return add_response("%s","\r\n");
  318. }
  319.  
  320. bool http_conn::add_content(const char* content){
  321.     return add_response("%s",content);
  322. }
  323.  
  324. bool http_conn::process_write(HTTP_CODE ret){
  325.     switch ((ret))
  326.     {
  327.     case INTERNAL_ERROR:
  328.     {
  329.         add_status_line(500,error_500_title);
  330.         add_headers(strlen(error_500_form));
  331.         if(!add_content(error_500_form)){
  332.             return false;
  333.         }
  334.         break;
  335.     }
  336.     case BAD_REQUEST:
  337.     {
  338.         add_status_line(400,error_400_title);
  339.         add_headers(strlen(error_400_form));
  340.         if(! add_content(error_500_form)){
  341.             return false;
  342.         }
  343.         break;
  344.     }
  345.     case NO_RESOURCE:
  346.     {
  347.         add_status_line(404,error_404_title);
  348.         add_headers(strlen(error_404_form));
  349.         if(! add_content(error_404_form)){
  350.             return false;
  351.         }
  352.         break;
  353.     }
  354.     case FORBIDDEN_REQUEST:
  355.     {
  356.         add_status_line(403,error_403_title);
  357.         add_headers(strlen(error_403_form));
  358.         if(! add_content(error_403_form)){
  359.             return false;
  360.         }
  361.         break;
  362.     }
  363.     case FILE_REQUEST:
  364.     {
  365.         add_status_line(200,ok_200_title);
  366.         if(m_file_stat.st_size !=0){
  367.             add_headers(m_file_stat.st_size);
  368.             m_iv[0].iov_base = m_write_buf;
  369.             m_iv[0].iov_len = m_write_idx;
  370.             m_iv[1].iov_base = m_file_address;
  371.             m_iv[1].iov_len = m_file_stat.st_size;
  372.             m_iv_count = 2;
  373.             printf("process_write ok\n");
  374.             return true;
  375.         }
  376.         else{
  377.             const char* ok_string = "<html><body></body></html>";
  378.             add_headers(strlen(ok_string));
  379.             if(! add_content(ok_string)){
  380.                 return false;
  381.             }
  382.             break;
  383.         }
  384.     }
  385.  
  386.     default:
  387.     {
  388.         return false;
  389.     }
  390.     }
  391.     m_iv[0].iov_base = m_write_buf;
  392.     m_iv[0].iov_len = m_write_idx;
  393.     m_iv_count = 1;
  394.     return true;
  395. }
  396.  
  397. bool http_conn::write(){
  398.     int temp = 0;
  399.     int bytes_have_send = 0;
  400.     int bytes_to_send = m_write_idx;
  401.     if(bytes_to_send == 0){
  402.         modfd(m_epollfd,m_sockfd,EPOLLOUT);
  403.         init();
  404.         return true;
  405.     }
  406.     while(1)
  407.     {
  408.         temp = writev(m_sockfd,m_iv,m_iv_count);
  409.         if(temp < 0){
  410.             if(errno == EAGAIN){
  411.                 modfd(m_epollfd,m_sockfd,EPOLLOUT);
  412.                 return true;
  413.             }
  414.             unmap();
  415.             return false;
  416.         }
  417.  
  418.         bytes_have_send+=temp;
  419.         bytes_to_send-= temp;
  420.         if(bytes_to_send<=bytes_have_send){
  421.             unmap();
  422.             if(m_linger){
  423.                 init();
  424.                 modfd(m_epollfd,m_sockfd,EPOLLIN);
  425.                 return true;
  426.             }
  427.             else{
  428.                 modfd(m_epollfd,m_sockfd,EPOLLIN);
  429.                 return false;
  430.             }
  431.         }
  432.     }
  433. }
  434.  
  435. void http_conn::process()
  436. {
  437.     HTTP_CODE read_ret = process_read();
  438.     if(read_ret == NO_REQUEST){
  439.         modfd(m_epollfd,m_sockfd,EPOLLIN);
  440.         return;
  441.     }
  442.     bool write_ret = process_write(read_ret);
  443.     if(!write_ret){
  444.         close_conn();
  445.     }
  446.     modfd(m_epollfd,m_sockfd,EPOLLOUT);
  447. }

main.cpp

  1. #include <unistd.h>
  2. #include <signal.h>
  3. #include <sys/types.h>
  4. #include <sys/epoll.h>
  5. #include <fcntl.h>
  6. #include <sys/socket.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9. #include <assert.h>
  10. #include <sys/stat.h>
  11. #include <string.h>
  12. #include <pthread.h>
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <sys/mman.h>
  16. #include <stdarg.h>
  17. #include <errno.h>
  18.  
  19. #include "locker.h"
  20. #include "threadpool.h"
  21. #include "http_conn.h"
  22.  
  23. #define MAX_FD 65536
  24. #define MAX_EVENT_NUMBER 10000
  25.  
  26. extern int addfd(int epollfd, int fd, bool one_shot);
  27. extern int removefd(int epollfd, int fd);
  28.  
  29. void addsig(int sig,void(handler)(int),bool restart = true){
  30.     struct sigaction sa;
  31.     memset(&sa,'\0',sizeof(sa));
  32.     sa.sa_handler =  handler;
  33.     if(restart){
  34.         sa.sa_flags |= SA_RESTART;
  35.     }
  36.     sigfillset(&sa.sa_mask);
  37.     assert(sigaction(sig,&sa,NULL) != -1);
  38. }
  39.  
  40. void show_error(int sockfd,const char* info){
  41.     printf("%s\n",info);
  42.     send(sockfd,info,strlen(info),0);
  43.     close(sockfd);
  44. }
  45.  
  46. int main(int argc,char* argv[]){
  47.     if(argc <= 2){
  48.         printf("usage:%s ip port\n",basename(argv[0]));
  49.         return 1;
  50.     }
  51.  
  52.     const char* ip = argv[1];
  53.     int port = atoi(argv[2]);
  54.  
  55.     addsig(SIGPIPE,SIG_IGN);
  56.  
  57.     threadpool<http_conn>* pool = NULL;
  58.     try
  59.     {
  60.         pool = new threadpool<http_conn>;
  61.     }
  62.     catch(...)
  63.     {
  64.         printf("error\n");
  65.         return 1;   
  66.     }
  67.     printf("creat a threadpool\n");
  68.  
  69.     http_conn* users = new http_conn[MAX_FD];
  70.     assert(users);
  71.     int user_count = 0;
  72.     printf("create some users\n");
  73.  
  74.     sockaddr_in addr;
  75.     bzero(&addr,sizeof(addr));
  76.     addr.sin_family = AF_INET;
  77.     inet_pton(AF_INET6,ip,&addr.sin_addr);
  78.     addr.sin_port = htons(port);
  79.  
  80.     int listenfd = socket(PF_INET,SOCK_STREAM,0);
  81.     assert(listenfd>=0);
  82.     linger tmp = {1,0};
  83.     setsockopt(listenfd,SOL_SOCKET,SO_LINGER,&tmp,sizeof(tmp));
  84.  
  85.     int ret = bind(listenfd,(sockaddr*)&addr,sizeof(addr));
  86.     assert(ret != -1);
  87.  
  88.     ret = listen(listenfd,5);
  89.     assert(ret != -1);
  90.     printf("listening\n");
  91.  
  92.     int epollfd = epoll_create(5);
  93.     assert(epollfd != -1);
  94.     epoll_event events[MAX_EVENT_NUMBER];
  95.     addfd(epollfd,listenfd,false);
  96.     http_conn::m_epollfd = epollfd;
  97.  
  98.     while(true){
  99.         int number = epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-1);
  100.         if((number < 0) && (errno!=EAGAIN)){
  101.             printf("epoll failure\n");
  102.             break;
  103.         }
  104.         
  105.         for(int i=0;i<number;++i){
  106.             int sockfd = events[i].data.fd;
  107.             if(sockfd == listenfd){
  108.                 sockaddr_in clientAddr;
  109.                 socklen_t len = sizeof(clientAddr);
  110.                 int connfd = accept(listenfd,(sockaddr*)&clientAddr,&len);
  111.                 if(connfd < 0){
  112.                     printf("accept errno\n");
  113.                     continue;
  114.                 }
  115.                 if(http_conn::m_user_count >= MAX_FD){
  116.                     show_error(connfd,"Internal server busy\n");
  117.                     continue;
  118.                 }
  119.                 users[connfd].init(connfd,clientAddr);
  120.             }
  121.             else if(events[i].events & (EPOLLRDBAND | EPOLLHUP | EPOLLERR)){
  122.                 users[sockfd].close_conn();
  123.             }
  124.             else if(events[i].events & EPOLLIN){
  125.                 if(users[sockfd].read()){
  126.                     pool->append(users + sockfd);
  127.                 }
  128.                 else{
  129.                     users[sockfd].close_conn();
  130.                 }
  131.             }
  132.             else if(events[i].events & EPOLLOUT){
  133.                 if(!users[sockfd].write()){
  134.                     users[sockfd].close_conn();
  135.                 }
  136.                 printf("write ok\n");
  137.             }
  138.             else{}
  139.         }
  140.     }
  141.     close(epollfd);
  142.     close(listenfd);
  143.     delete[] users;
  144.     delete pool;
  145.     return 0;
  146. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/889292
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号