epoll的http服务器

于 2019-07-11 02:28:05 发布
阅读量260 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： unixc 帮别人写作业 文章标签： epoll http服务器 基于EPOLL的http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dashoumeixi/article/details/95413950
该博客介绍了一个简易的HTTP服务器，可在Linux下直接运行。代码未处理EPOLLOUT事件，处理方法可参考相关触发条件。代码能配合线程池使用，基于EPOLLOUT例子，有很多细节未处理，仅为简单示例，代码无注释，注释可在相关帖子查看，例子仅用Firefox测试过。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一个简易的http服务器 , linux下可直接运行

代码里没有处理EPOLLOUT事件,需要处理的参考:EPOLLOUT触发条件

代码可配合线程池使用 : 线程池

代码基于EPOLLOUT例子 EPOLLOUT触发条件 第2个例子

有很多细节上的东西都没处理, 只是一个简单的例子,

下面代码中没有注释, 上面连接中的帖子里都有注释;

例子只用firefox跑过;

 

 

serv.c

#include "util.h"
#include <dirent.h>
#include <wchar.h>
#define MAX_EVENTS 512
#define BUFF_SIZE 4096
typedef  struct _ev_data
{
    int fd;
    char * buffer;
    int nread;
    int start_write_index;
    int epfd;
    int events;
}ev_data;


ev_data * new_event(int fd ,int epfd,int events,int needbuff){
    ev_data * p = malloc(sizeof(ev_data));
    if(p){
        memset(p,0,sizeof(ev_data));
        if(needbuff) {
            char *buf = (char *) malloc(BUFF_SIZE);
            if (!buf) {
                free(p);
                return 0;
            }
            p->buffer = buf;
        }
        p->fd = fd;
        p->epfd = epfd;
        p->events = events;
    }
    return p;
}
void free_event(ev_data * ptr){
    if(!ptr)
        return;
    close(ptr->fd);
    if(ptr->buffer){
        free(ptr->buffer);
    }
    free(ptr);
}

int update_event(int events , void * ptr , int epfd , int op , int fd){
    static struct epoll_event ev;
    memset(&ev,0,sizeof(ev));
    ev.events = events;
    ((ev_data*)ptr)->events = events;
    ev.data.ptr = ptr;
    return epoll_ctl(epfd,op,fd,&ev);
}

static int setnonblock(int fd , int nonblock){
    int flag = fcntl(fd,F_GETFL,0);
    if(nonblock)
        return fcntl(fd,F_SETFL,flag|O_NONBLOCK);
    else
        return fcntl(fd,F_SETFL,flag&~O_NONBLOCK);
}

int write_data(ev_data * pdata);
void send_response_header(int fd, int http_err_no,int length){
    static char buf[1024];
    static char no_text[10] = "ok";
    static char type_text[50] = "text/html; charset=UTF-8";
    int len = 0;
    len+= sprintf(buf,"http/1.1 %d %s\r\n",http_err_no,no_text);
    len += sprintf(buf+len,"content-Type:%s\r\n",type_text);
    len += sprintf(buf+len,"content-length:%d\r\n",length);
    len += sprintf(buf+len,"server:localhost\r\n");
    len += sprintf(buf+len,"\r\n");
    write(fd,buf,len);
}
void send_response(int sockfd, const char *path,int is_dir){
    static char buf[8192];
    int len = 0;
    if(!is_dir) {
        int fd = open(path, O_RDONLY);
        if (fd < 0) {
            puts("open failed");
            return;
        }
        while ((len = read(fd, buf, sizeof(buf))) > 0) {
            write(sockfd, buf, len);
        }
    }
    else{
        static char fullpath[1024];
        int nlen = 0;
        len = sprintf(buf,"<html><head><title>fuckyou</title></head>");
        len += sprintf(buf+len,"<body>");
        write(sockfd,buf,len);
        struct dirent ** ent =  NULL;
        int n  = scandir(path,&ent,NULL, alphasort);
        if(n < 0){
            len = sprintf(buf,"forbidden 403 </body></html>");
            write(sockfd,buf,len);
            puts("scandir error");
            return;
        }

        while(n--){
            if(strcmp(ent[n]->d_name,".") == 0 || strcmp(ent[n]->d_name,"..") == 0)
                continue;
            nlen = sprintf(fullpath,"%s%s",path,ent[n]->d_name);
            fullpath[nlen] = 0;
            len = sprintf(buf ,"<p><a href=\"%s\">%s</a></p>" ,fullpath,ent[n]->d_name);
            free(ent[n]);
            write(sockfd,buf,len);
        }
        free(ent);
        len = sprintf(buf,"</body></html>");
        write(sockfd,buf,len);

    }

}
int is_http_get(char * pbuffer){
    if(strncasecmp("get",pbuffer,3) == 0){
        return 1;
    }
    return 0;
}
void send_error_msg(){
    static char error_msg[] = "404 not found";
    static int len = strlen(error_msg);
    send_response_header(pdata->fd,404,len);
    write(pdata->fd,error_msg,len);
}
void http_request(ev_data * pdata){
    char * pbuffer = pdata->buffer;
    static char method[5],path[1024],protocal[10];

    sscanf(pbuffer, "%[^ ] %[^ ] %[^\r\n]" , method,path,protocal);
    printf("method:%s, path:%s, protocal:%s\n"  , method , path,protocal);

    struct stat st;
    static char rpath[2048];
    int len = sprintf(rpath,".%s",path);
    rpath[len] = 0;
    printf("rpath:%s \n" , rpath );


    if( stat(rpath,&st) < 0){
        send_error_msg();
        perror("stat ");
        goto done;
    }



    //dir
    if(S_ISDIR(st.st_mode)){
        puts("read dir");
        send_response_header(pdata->fd,200,st.st_size);
        send_response(pdata->fd,rpath,1);
    }
    else if(S_ISREG(st.st_mode)){
        //file
        puts("read file");
        send_response_header(pdata->fd,200,st.st_size);
        send_response(pdata->fd,rpath,0);
    }


    done:
    puts("send  and close......");
    free_event(pdata);




}
void read_data(ev_data * pdata){
    if(!pdata){
        puts("empty ptr");
        return;
    }
    if(!pdata->buffer){
        printf("empty ptr->buff , sock%d\n" , pdata->fd);
        return;
    }
    int fd = pdata->fd;
    int epfd = pdata->epfd;
    char * pbuffer = pdata->buffer;
    int left = BUFF_SIZE - pdata->nread;
    int len = 0,write_bytes = 0;

    while(left > 0){
        len = read(fd,pbuffer + pdata->nread,left);
        if(len < 0){
            if(errno == EAGAIN || errno == EWOULDBLOCK){
                puts("read all , done");
                break;
            }
            else{
                perror("read error :");
                free_event(pdata);
                return;
            }
        }
        else if( 0 == len){
            puts("closed");
            free_event(pdata);
            return;
        }
        left -= len;
        pdata->nread += len;
        if( pdata->nread > 4 ){
            if ( !is_http_get(pdata->buffer) ){
                free_event(pdata);
                return;
            }
        }


//        write_bytes = write_data(pdata);
//        if(write_bytes < 0){
//            break;
//        }
//        left += write_bytes;
    }
    http_request(pdata);
}
int write_data(ev_data * pdata){
    if(!pdata || !pdata->buffer){
        puts("empty ptr");
        return 0;
    }
    if(pdata->nread <= 0){
        printf("buffer is empty , ptr->nread:%d \n",pdata->nread);
        return 0;
    }
    int fd = pdata->fd;
    int epfd = pdata->epfd;
    char * pbuffer = pdata->buffer;
    int left = pdata->nread - pdata->start_write_index;

    int nwrite = 0 , write_bytes = 0;
    while(left > 0){
        nwrite = write(fd,pbuffer + pdata->start_write_index,left);
        if(nwrite <= 0){
            if(nwrite < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)){
                perror("sock send buff is full ");
                if(EPOLLOUT & pdata->events){
                    return write_bytes;
                }
                int new_events = pdata->events;
                new_events |= EPOLLOUT;
                update_event(new_events,pdata,pdata->epfd,EPOLL_CTL_MOD,pdata->fd);
                return write_bytes;
            }
            else{
                perror("write error , close socket ");
                free_event(pdata);
                return -1;
            }
        }
        left -= nwrite;
        pdata->start_write_index += nwrite;
        write_bytes += nwrite;
    }

    pdata->start_write_index = pdata->nread = 0;
    if(pdata->events & EPOLLOUT){
        update_event( EPOLLIN | EPOLLET,pdata,pdata->epfd,EPOLL_CTL_MOD,pdata->fd);
    }
    return write_bytes;
}


int main(int argc, char**argv)
{
    if(argc < 3){
        puts("epoll_httpserv port path");
        return 0;
    }
    sigset_t mask;
    sigfillset(&mask);
    sigdelset(&mask,SIGINT);
    pthread_sigmask(SIG_BLOCK,&mask,NULL);//sigwait / sigwaitinfo

    unsigned short port = atoi(argv[1]);

    if( chdir(argv[2]) != 0){
        perror("chdir failed :");
        return 0;
    }

    int epfd = epoll_create(EPOLL_SIZE);
    if(epfd < 0){
        perror("epoll_create ");
        return 0;
    }

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if(listenfd < 0){
        perror("socket failed");
        return 0;
    }
    setnonblock(listenfd,1);
    struct sockaddr_in serv_addr;
    memset(&serv_addr ,0,sizeof(serv_addr));
    serv_addr.sin_port = htons(port);
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    int on = 1;
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(int));
    if(bind(listenfd,(SA*)&serv_addr,sizeof(serv_addr)) < 0){
        perror("bind ");
        return 0;
    }
    if(listen(listenfd,BACKLOG) < 0){
        perror("listen ");
        return 0;
    }

    int events = EPOLLIN|EPOLLET;
    ev_data * ev = new_event(listenfd,epfd,events,0);
    if(!ev){
        puts("new failed");
        return 0;
    }
    update_event(events,ev,epfd,EPOLL_CTL_ADD,listenfd);
    struct epoll_event * epoll_arr = calloc(MAX_EVENTS, sizeof(struct epoll_event));
    if(!epoll_arr){
        puts("epoll arr failed");
        return 0;
    }
    printf("serv start port:%d , path:%s\n",port, argv[2]);
    int nready = 0,clt_fd = -1 , clt_events = EPOLLIN | EPOLLET;
    ev_data * clt_data = 0;
    while(1){
        nready = epoll_wait(epfd,epoll_arr,MAX_EVENTS,-1);
        if(nready < 0){
            perror("epoll_wait failed ");
            break;
        }
        for(int i = 0; i < nready ; ++i){
            if( (epoll_arr[i].events & EPOLLERR) || (epoll_arr[i].events & EPOLLHUP)){
                ev_data * pdata = epoll_arr[i].data.ptr;
                printf("index:%d ,occurs error:%d, fd:%d,epollfd:%d.\n",
                i,epoll_arr[i].events,pdata->fd,pdata->epfd);
                close(pdata->fd);
                free_event(pdata);
                continue;
            }
            if( epoll_arr[i].events & EPOLLIN){
                ev_data * pdata = epoll_arr[i].data.ptr;
                if(!pdata){
                    printf("EPOLLIN error, empty ptr\n");
                    continue;
                }
                if(listenfd == pdata->fd){
                    clt_fd = accept(listenfd,NULL,NULL);
                    if(clt_fd < 0){
                        perror("accept ");
                        continue;
                    }
                    setnonblock(clt_fd,1);
                    clt_data = new_event(clt_fd,epfd,clt_events,1);
                    if(!clt_data){
                        puts("new_event failed");
                        continue;
                    }
                    update_event(clt_events,clt_data,epfd,EPOLL_CTL_ADD,clt_fd);
                    printf("sock:%d accept ok !\n" , clt_fd);
                }
                else{
                    read_data(pdata);
                }
            }
            if(epoll_arr[i].events & EPOLLOUT){
                write_data(epoll_arr[i].data.ptr);
            }
        }
    }



    return 0;
}

 

基于的epoll模型的简单http服务器
baudgg1992的专栏
04-14 2116
epoll模型主要有2种工作方式：水平触发(LT)和边缘触发(ET)，本文主要是关于边缘触发的。 本文实现的epoll多线程模型主要是，主线程等待事件触发，然后把相关事件放入队列，线程池从队列中取出数据处理事件。
epoll实现http
weixin_44786231的博客
04-16 568
import socket import re import select def service_client(new_socket, request): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... # request = new_socket.recv...
epoll实现HTTP服务器.rar
07-24
（无需积分，免费！！！）fd_event_list = epl.poll() # 进行循环解包，进一步判断 for fd, event in fd_event_list: # 循环第一次，如果 文件描述符 是tcp_socket的，就进行侦听分离new_socket if fd == tcp_socket.fileno(): # 等待客户端到来 new_socket, user_addr = tcp_socket.accept() # 把 new_socket 加入创建的空间中 epl.register(new_socket.fileno(), select.EPOLLIN) # 这里，需要标记 new_socket fd_newsock_dict[new_socket.fileno()] = new_socket elif event == select.EPOLLIN: receve_msg = fd_newsock_dict[fd].recv(1024).decode("utf-8") if receve_msg: server_c(receve_msg) else: print("-------------客户端已经关闭的-----------") fd_newsock_dict[fd].close() epl.unregister(fd) del fd_newsock_dict[fd]
epoll模型 http server
11-11
epoll模型http server
linux下基于epoll的简单http协议
07-01
linux平台下基于epoll的简单http协议，有测试客户端代码，以及使用说用，是初学者使用的好资料，大家可以到博客上发表意见，我也会改进代码，谢谢，博客地址：http://write.blog.csdn.net/postedit/34415651
tinyserver:C++实现的简单http服务器（进程池+epoll）
05-10
使用进程池+epoll方式实现的简单http服务器。父程序创建进程池，并监听客户端连接。父进程与子进程池之间利用管道进行通信，父进程将连接请求通知子进程处理（采用轮询方式选择），子进程完成客户端http请求处理过程...
ehttp：基于epoll的简单http服务器
02-03
**ehttp：基于epoll的简单HTTP服务器** `ehttp` 是一个小型的HTTP服务器，其核心特性是利用了Linux内核的`epoll`机制，以实现高性能、低延迟的网络I/O处理。`epoll`是Linux系统提供的一种I/O多路复用技术，适用于高...
(源码)基于C++和epoll的HTTP服务器.zip
03-20
# 基于C++和epoll的HTTP服务器 ## 项目简介 本项目是一个基于C++和epoll的高性能HTTP服务器。它通过使用epoll事件驱动机制和线程池来处理并发连接，支持长连接、定时器管理、日志记录等功能。服务器能够高效地处理...
【Linux服务器开发】基于epoll的高并发HTTP服务器设计与优化：核心技术原理、实战项目及性能调优
最新发布
07-03
实战项目以高性能HTTP服务器为例，采用Reactor+线程池架构，支持静态资源服务，目标是实现10万+并发连接、QPS达1万+、响应延迟。性能优化涉及I/O模型、TCP参数调优、资源池化及缓存策略。测试验证涵盖功能测试、性能...
用 Linux epoll 实现高性能 HTTP 服务器
ZiFung_Yip的博客
11-30 1820
用 Linux epoll 实现高性能 HTTP 服务器 为了代码的整洁性，本文章所介绍功能将使用 C++ 实现。实际使用中可转为 C 语言使用。 此项目只能在Linux下使用，windows请绕道。 项目概括 本项目是使用 Linux epoll 实现的一个简单的 HTTP 服务器。仅支持 GET 和 HEAD 方法，对 HTTP 请求报文仅使用正则表达式进行解析。在实际使用中，请使用词法和...
http server&client;(epoll模型)
02-16
http server&client;(epoll模型)，支持文件下载，续传，IPV6，页面展示，hls协议。本代码已经商用。压力测试通过
从零开始学写HTTP服务器（五）IO复用使用epoll
上善若水
12-21 1958
之前已经实现了一个及其简陋的HTTP服务器，今天花点时间改造了一下，用epoll来处理连接。
HTTP服务实现——Epoll+线程池
yw8355507的专栏
05-22 1513
前言：   之前几次面试，总是在问到网络编程的时候，提及epoll，问我有没有写过什么服务，总是答简单的回射服务器，自己感觉这样的东西还是太浅。总得做点能证明自己水平的东西。于是决定还是用Epoll来写一个HTTP服务器吧。 我的github： 我的HTTP服务器是从TinyHTTP上发展而来的，tinyHTTP是CSAPP上给出的一个例子，我看完之后就明白基本的HTTP
基于epoll的简单的http服务器
fangjian1204的专栏
06-25 4862
本人用epoll写了一个简单的http服务器，该服务器在客户端第一次发送数据时可以正确处理，但是当客户端不关闭继续发送数据时，服务器无法读取，请求大家帮忙看看哪里有问题，谢谢server.h/* * server.h * * Created on: Jun 23, 2014 * Author: fangjian */ #include #ifndef SERVER_H_
Linux 用epoll实现的简单http服务器
weixin_30664051的博客
07-09 243
Linux 用epoll实现的简单http服务器 main.c #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> #in...
epoll版本的http服务器
qq_40439977的博客
11-19 292
import socket import re import select def service_client(client_socket,request): """为客户端服务""" # 1.提取文件名 request_lines = request.splitlines() request_first_line = request_lines[0]
徒手撸个http服务器(三)------epoll 实现
unicxitoiv的博客
08-19 816
epoll_wait(2)SYNOPSIS#include <sys/epoll.h> int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);DESCRIPTIONepoll_wait()系统调用等待文件描述符epfd引用的epoll实例上的事件. 事件指向的内存区域将包含可用于调用者的事件.
基于epoll的简单的httpserver
weixin_34033624的博客
04-17 203
该httpserver已经能够处理并发连接，支持多个client并发訪问，每一个连接能够持续读写数据。当然。这仅仅是一个简单的学习样例。还有非常多bug，发表出来仅仅是希望大家能够互相学习。我也在不断的改进，希望大家有什么意见能够多多指点，谢谢 server.h /* * server.h * * Created on: Jun 23, 2014 * Aut...
Linux下使用epoll实现简单HTTP服务器教程
- webServrer_fj：这可能是实现epoll的简单HTTP服务器的源代码文件，文件名中的“fj”可能是指“飞杰”（FeiJie），表明作者或项目名。 在阅读这些文件的过程中，可以进一步了解如何在Linux下使用C++和epoll构建一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值