Linux多线程Web服务器（C++实现）

已于 2023-01-19 19:42:10 修改
阅读量1.9k 收藏 24
点赞数 6
分类专栏： webServer 文章标签： c++ mysql 数据库 http 服务器 Powered by 金山文档
于 2023-01-13 12:27:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50437588/article/details/128667510
版权

本文实现的是基于Reactor模式+epoll（边缘触发）+非阻塞socket+非阻塞IO+线程池的Web服务器，可以处理GET、POST两种请求，完成展示主页、获取图片、获取视频、登录及注册共五种功能。

原理图：

上图为本文实现的服务器的原理图，采用了单Reactor多线程的模式，在主线程中用epoll监听一个listenFd与多个connFd。

  • 若发生建立连接的事件，则交给accept单元处理，再把生成的connFd传给epoll管理；

  • 若发生可读\可写事件，则添加到线程池的任务队列中，由池中空闲的子线程拿取任务并处理；

  • 此外，若是客户端请求涉及数据库文件，则还需要从数据库连接池中拿出一个空闲的数据库连接，通过这个连接进行数据库文件的增删查改操作。

本文实现的服务器还采用了epoll的边缘触发模式，相比于水平触发减少了更多的epoll系统调用次数，在高并发的情况下效率更高。下面就ET(边缘触发)和LT(水平)触发进行介绍，并给出基于此实现的读写函数。

关于上图的详解：彻底学会使用epoll(一)——ET模式实现分析

因为在ET模式下，如果read一次没有读尽buffer中的数据，那么下次将得不到读就绪的通知，造成buffer中已有的数据无机会读出，除非有新的数据再次到达，write也同理。所以为了解决这一问题，就需要在读的时候尽力去读，写的时候尽力去写，即使用while循环去读写，直至出错或读写完毕。

使用while循环读写见： HTTP连接（读取请求+解析请求+生成响应+回送响应）
循环读：ssize_t HttpConn::read(int* errno_)
循环写：ssize_t HttpConn::write(int* errno_)

使用while循环去读写时，如果是阻塞IO就会因为 无数据可读/没空间可写 而一直阻塞在那里，所以采用非阻塞IO，一旦 无数据可读/没空间可写 就立刻返回-1，errno=EAGAIN（设置socket为非阻塞socke）。

bool WebServer::setFdNonblock(int fd)
{
    int flags;
    if((flags=fcntl(fd,F_GETFL,0))<0)    
        return false;
    flags |= O_NONBLOCK;
    if(fcntl(fd,F_SETFL,flags)<0)
        return false;
    return true;
}

因为ET模式下被唤醒（返回就绪）的条件为：

对于读取操作：

(1) 当buffer由不可读状态变为可读的时候，即由空变为不空的时候。

(2) 当有新数据到达时，即buffer中的待读内容变多的时候。

(3) 当buffer中有数据可读（即buffer不空）且用户对相应fd进行epoll_mod IN事件时。

对于写操作：

(1) 当buffer由不可写变为可写的时候，即由满状态变为不满状态的时候。

(2) 当有旧数据被发送走时，即buffer中待写的内容变少得时候。

(3) 当buffer中有可写空间（即buffer不满）且用户对相应fd进行epoll_mod OUT事件时

所以下面实现的逻辑为：

readFrom调用client->read(&readErrno)循环读取，直至读取完成/读取失败，读取完成也就是read返回0，代表服务器端read到了客户端发来的FIN请求，所以关闭连接；而读取失败又分为“暂时无数据可读”或”其他原因“，如果是其他原因则直接关闭连接，如果是"暂时无数据可读"（即没有新的HTTP请求发来）则进入process函数，判断读缓冲区内是否存在收集到的请求，有则解析请求+完成响应报文，然后更换监听的事件为EPOLLOUT，没有则继续监听EPOLLIN事件，继续读取客户端请求。

writeTo调用client->write(&writeErrno)循环写入，直至全部写完/写入失败，写入失败又分为”暂时无空间可写“或”其他原因“，如果是其他原因则直接关闭连接，如果是”暂时无空间可写“，则继续监听EPOLLOUT事件，继续写入响应。如果全部写完了，需要判断是否建立了HTTP长连接，如果建立了，那么就要尽量在一个TCP连接内完成多条HTTP报文的传送，所以进入process函数，判断读缓冲区内是否存在收集到的请求，有则继续监听EPOLLOUT，让本条请求的响应在下一轮epoll_wait中就绪；无则改为监听EPOLLIN，继续读取客户端请求；如果不建立HTTP长连接，则发送完毕HTTP响应后就应直接关闭连接。

void WebServer::readFrom(HttpConn* client)
{
    int readErrno=0;
    int ret=client->read(&readErrno);//client->raed()用while循环去尽力读
    if(ret<=0&&readErrno!=EAGAIN)//读出错，关闭连接
    {
        closeConn(client);
        return ;
    }
    process(client);
}

void WebServer::writeTo(HttpConn* client)
{
    int writeErrno=0;
    int ret=client->write(&writeErrno);//client->write()用while循环去尽力写
    if(client->isWriteOver())//数据已全部写完 
    {
        if(client->isKeepAlive()) //建立的是Http长连接
        {
            process(client);
            return;
        }
    }
    if(ret<0&&writeErrno==EAGAIN) //数据未读完，加入rdlist中下次继续读
    {
        epoller_p->modFd(client->getFd(), connEvent | EPOLLOUT);
        return ;
    }
    closeConn(client);
}

void WebServer::process(HttpConn* client)
{
    if(client->process()) //处理客户端请求成功
    {
        epoller_p->modFd(client->getFd(), connEvent | EPOLLOUT);//监听事件改为EPOLLOUT
    } 
    else 
    {
        epoller_p->modFd(client->getFd(), connEvent | EPOLLIN);//监听事件仍为EPOLLIN，继续读
    }
}

本文实现的Web服务器还设置了优雅关闭的选项：

struct linger optLinger;
    optLinger.l_onoff=1;
    optLinger.l_linger=1;
    if(setsockopt(listenFd,SOL_SOCKET,SO_LINGER,&optLinger,sizeof(optLinger))<0)
    {
        LOG_ERROR("%s","Set SO_LINGER Option Error!");
        return false;
    }

开启此套接字选项后，close()不会在调用后立刻返回，而是在延滞optLinger.l_linger 时间后才返回，在这一段时间内，close()函数并未关闭读写端，所以可以获取到客户端对于发往它的数据和FIN的ACK确认，故称优雅关闭。

当然，如果optLinger.l_linger设置不合理，在延滞时间内并未收到对端的确认，那么close返回-1，errno=EWOULDBLOCK，服务器端关闭，此后如果客户端的确认姗姗来迟，面对已经关闭的服务器端，只会收到RST，这是我们不想看到的。

所以，最好的办法其实是服务器端采用shutdown半关闭(关闭写端)，这样读端read函数就会一直阻塞，可以读取到客户端发来的对于数据和FIN的确认，也可以在之后读取到客户端在处理完发来数据后调用close发出的FIN，服务器的读端read读到FIN后，直接返回，读取结束。

所以read的成功返回表明了：服务器端既获得了客户端对于发往它的数据和FIN的确认(TCP)，又获得了客户端正确读取发来数据的确认(客户端的用户进程)。相比于close()+SO_LINGER，得到的消息更多。

此外，本文的Web服务器还设置了地址复用的选项：

int optReuseaddr=1;
    if(setsockopt(listenFd,SOL_SOCKET,SO_REUSEADDR,&optReuseaddr,sizeof(optReuseaddr))<0)
    {
        LOG_ERROR("%s","Set SO_REUSEADDR Option Error!");
        return false;
    }

它的功能是，允许启动一个监听服务器并捆绑其众所周知的端口，即使以前建立的将该端口用作它们的本地端口的连接仍然存在。

这种情况常见于：

先启动一个监听服务器，连接请求到达，派生一个子进程来处理该客户，之后监听服务器终止，但是子进程仍然继续为该连接上的客户提供服务，重启监听服务器时就会失败。

这里重启失败是失败在bind函数绑定端口时，它试图绑定一个已有连接上的端口，所以失败。

当然，本文实现的基于多线程的Web服务器，一旦主线程的监听服务器终止，派生的子线程也会随之终止，大家都关闭了，也就不存在上述的重启失败问题。

以上就是本文实现的Web服务器的重点内容，下面是全部代码：

WebServer类结构 webserver.h

#ifndef WEBSERVER_H
#define WEBSERVER_H
 
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unordered_map>
#include <errno.h>
#include <assert.h>
 
#include "heaptimer.h"
#include "epoller.h"
#include "../pool/threadpool.h"
#include "../pool/sqlconnpool.h"
#include "../http/httpconn.h"
#include "../log/log.h"
 
class  WebServer
{
public:
    WebServer();
    ~WebServer();
    bool loadConfigFile();
    void start();
 
private:
    void dealListen();
    void dealRead(HttpConn* client);
    void dealWrite(HttpConn* client);
    void closeConn(HttpConn* client);
 
    void flushTime(HttpConn* client);
    void addClient(int fd,const sockaddr_in& addr);
    void readFrom(HttpConn* client);
    void writeTo(HttpConn* client);
    void process(HttpConn* client);
 
    bool setFdNonblock(int fd);
    bool initSocket();
    
    int port;
    int timeOutMs;
    bool isClose;
    int listenFd;
    char* srcDir;
 
    uint32_t listenEvent;
    uint32_t connEvent;
    std::unique_ptr<HeapTimer> timer_p;
    std::unique_ptr<ThreadPool> threadPool_p;
    std::unique_ptr<Epoller> epoller_p;
    std::unordered_map<int,HttpConn> users;
    const int maxUserNum = 65536;
};
 
#endif // !WEBSERVER_H

WebServer类实现 webserver.cpp

#include "webserver.h"
 
bool WebServer::loadConfigFile()//加载配置文件
{
    FILE* fp = fopen("./webserver.ini", "r");
    if(fp==nullptr)
    {
        return false;
    }    
    while(!feof(fp)) 
    {
        char line[1024] = {0};
        fgets(line, 1024, fp);
        string str = line;
        int idx = str.find('=', 0);
        if (idx == -1)
            continue;
        int endidx = str.find('\n', idx);
        string key = str.substr(0, idx);
        string value = str.substr(idx+1,endidx-idx-1);
        if (key == "port")    
            port = stoi(value);
        else if (key == "timeOutMs")
            timeOutMs = stoi(value);
        else if (key == "sqlConnMaxNum")
            SqlConnPool::getInstance(stoi(value));
        else if (key == "threadNum") 
            threadPool_p=std::unique_ptr<ThreadPool>(new ThreadPool(stoi(value)));
        else if (key == "logQueSize")
            Log::getInstance()->init(stoi(value));
    }
    fclose(fp);
    return true;
}
 
WebServer::WebServer():isClose(false),timer_p(new HeapTimer()),epoller_p(new Epoller())
{
    if (!loadConfigFile())//配置失败
    {
        isClose=true;
        LOG_ERROR("%s","Load Config File Fail!");
        return ;
    }
    srcDir=getcwd(nullptr,256);
    strncat(srcDir,"/resources/",15);
    HttpConn::userCount=0;
    HttpConn::srcDir=srcDir;
    listenEvent=EPOLLRDHUP|EPOLLIN|EPOLLET;
    connEvent=EPOLLONESHOT|EPOLLRDHUP|EPOLLET;
    if(!initSocket())
        isClose=true;
    if(isClose)
        LOG_ERROR("%s","========== Server init error!==========");
    else
        LOG_INFO("%s", "========== Server init success!========");
}
 
WebServer::~WebServer()
{
    close(listenFd);
    isClose=true;
    free(srcDir);
}
 
void WebServer::start() 
{
    int timeMs=-1;
    while(!isClose)
    {
        if(timeOutMs>0)
        {
            timeMs=timer_p->getNextTick();
        }
        int eventCnt=epoller_p->wait(timeMs);
        for(int i=0;i<eventCnt;i++)
        {
            int fd=epoller_p->getEventFd(i);
            uint32_t events=epoller_p->getEvents(i);
            if(fd==listenFd)
            {
                dealListen();
            }
            else if(events&EPOLLIN)
            {
                dealRead(&users[fd]);
            }
            else if(events&EPOLLOUT)
            {
                dealWrite(&users[fd]);
            }
            else if(events&(EPOLLRDHUP|EPOLLHUP|EPOLLERR))
            {
                closeConn(&users[fd]);
            }
            else
            {
                LOG_ERROR("%s","Unexpected Event Happen!");
            }
        }
    }
    
}
 
void WebServer::dealListen()
{
    struct sockaddr_in addr;
    socklen_t len=sizeof(addr);
    while(true)
    {
        int connfd=accept(listenFd,(struct sockaddr*)&addr,&len);
        if(HttpConn::userCount>=maxUserNum)
        {
            close(connfd);
            LOG_ERROR("%s","Server Users Full!");
            return ;
        }
        if(connfd<=0)
        {
            return ;
        }
        else
        {
            addClient(connfd,addr);
        }
    }
}
 
 void WebServer::dealRead(HttpConn* client)
 {
    flushTime(client);
    threadPool_p->addTask(std::bind(&WebServer::readFrom,this,client));
 }
 
void WebServer::dealWrite(HttpConn* client)
{
    flushTime(client);
    threadPool_p->addTask(std::bind(&WebServer::writeTo,this,client));
}
 
void WebServer::closeConn(HttpConn* client)
{
    epoller_p->delFd(client->getFd());
    client->closeConn();
}
 
void WebServer::flushTime(HttpConn* client)
{
    if(timeOutMs>0)
    {
        timer_p->adjust(client->getFd(),timeOutMs);
    }
}
 
void WebServer::addClient(int connfd,const sockaddr_in& addr)
{
    users[connfd].init(connfd,addr);   
    if(timeOutMs>0)
    {
        timer_p->add(connfd,timeOutMs,std::bind(&WebServer::closeConn,this,&users[connfd]));
    }
    epoller_p->addFd(connfd,connEvent|EPOLLIN);
    setFdNonblock(connfd);
}
 
void WebServer::readFrom(HttpConn* client)
{
    int readErrno=0;
    int ret=client->read(&readErrno);
    if(ret<=0&&readErrno!=EAGAIN)
    {
        closeConn(client);
        return ;
    }
    process(client);
}
 
void WebServer::writeTo(HttpConn* client)
{
    int writeErrno=0;
    int ret=client->write(&writeErrno);
    if(client->isWriteOver()) 
    {
        if(client->isKeepAlive()) 
        {
            process(client);
            return;
        }
    }
    if(ret<0&&writeErrno==EAGAIN) 
    {
        epoller_p->modFd(client->getFd(), connEvent | EPOLLOUT);
        return ;
    }
    closeConn(client);
}
 
void WebServer::process(HttpConn* client)
{
    if(client->process()) 
    {
        epoller_p->modFd(client->getFd(), connEvent | EPOLLOUT);
    } 
    else 
    {
        epoller_p->modFd(client->getFd(), connEvent | EPOLLIN);
    }
}
 
bool WebServer::setFdNonblock(int fd)
{
    int flags;
    if((flags=fcntl(fd,F_GETFL,0))<0)    
        return false;
    flags |= O_NONBLOCK;
    if(fcntl(fd,F_SETFL,flags)<0)
        return false;
    return true;
}
 
bool WebServer::initSocket()
{
    if(port>65535||port<1024)
    {
        LOG_ERROR("Select Port:%d Error!",port);
        return false;
    }
    listenFd=socket(AF_INET,SOCK_STREAM,0);
    if(listenFd<0)
    {
        LOG_ERROR("%s","Create Socket Error!");
        return false;
    }
    struct linger optLinger;
    optLinger.l_onoff=1;
    optLinger.l_linger=1;
    if(setsockopt(listenFd,SOL_SOCKET,SO_LINGER,&optLinger,sizeof(optLinger))<0)
    {
        LOG_ERROR("%s","Set SO_LINGER Option Error!");
        return false;
    }
    int optReuseaddr=1;
    if(setsockopt(listenFd,SOL_SOCKET,SO_REUSEADDR,&optReuseaddr,sizeof(optReuseaddr))<0)
    {
        LOG_ERROR("%s","Set SO_REUSEADDR Option Error!");
        return false;
    }
    struct sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_addr.s_addr=htonl(INADDR_ANY);
    addr.sin_port=htons(port);
    if(bind(listenFd,(struct sockaddr*)&addr,sizeof(addr))<0)
    {
        LOG_ERROR("%s","Bind Port:%d Error!",port);
        return false;
    }
    if(listen(listenFd,5)<0)
    {
        LOG_ERROR("%s","Listen Port:%d Error!",port);
        return false;
    }
    if(!epoller_p->addFd(listenFd,listenEvent))
    {
        LOG_ERROR("%s","Add ListenFd:%d in Epoll Error!",listenFd);
        return false;
    }
    if(!setFdNonblock(listenFd))
    {
        LOG_ERROR("%s","Set ListenFd:%d Nonblock Error!",listenFd);
        return false;
    }
    return true;
}

webserver.ini

# WEB服务器配置文件
#端口号
port=8888
#超时时间
timeOutMs=500
#最大sql连接数
sqlConnMaxNum=1000
#线程数 
threadNum=8
#日志队列最大容量
logQueSize=1024

本项目已在github开源，全部代码见：

1410138/MyWebServer: C++ Linux Web服务器 (github.com)

其余部分的介绍及部分代码见本专栏：

webServer_{(sunburst)}的博客-CSDN博客

{(sunburst)}
关注
  • 6
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++项目实战与经验分享：从零构建一个简单的Web服务器
一个梦想做程序员的编程小白
02-14 570
通过这个项目，我们学习了如何使用C++和Boost.Asio库构建一个简单的Web服务器。未来，我们可以进一步扩展这个项目，添加更多的功能和优化措施，以构建一个更加健壮和高效的Web服务器。通过这个项目，我们将学习到如何使用C++编写网络编程相关的代码，并了解Web服务器的基本工作原理。在这个项目中，我们将使用C++从零开始构建一个简单的Web服务器，并分享在此过程中的一些经验和技巧。Boost.Asio是一个跨平台的C++库，提供了异步I/O操作的功能，非常适合用于构建网络应用程序。
C++ Linux WebServer服务器
最新发布
05-13
用C++实现的高性能WEB服务器，经过webbenchh压力测试可以实现上万的QPS 功能 利用IO复用技术Epoll与线程池实现多线程的Reactor高并发模型； 利用正则与状态机解析HTTP请求报文，实现处理静态资源的请求； 利用...
epoll多线程高并发服务器代码
09-22
linux下完整的epoll多线程高并发服务器代码
02_C++实现多线程服务器代码（linux系统）
suren_jun的博客
09-04 1703
socket编程，多线程实现，服务器通过TCP与客户端通信且可以与串口终端设备通信，端口号和串口号波特率采用带参执行，服务端可以支持多个客户端和多个串口，makefile文件编写，如果连接客户端过多，则随机踢掉一个，通过简易私有协议实现串口和服务器之间的双向通信等多种功能
从零开始实现一个C++高性能服务器框架----TcpServer模块
lwx666sl的博客
05-11 272
项目介绍：实现了一个基于协程的服务器框架，支持多线程、多协程协同调度；支持以异步处理的方式提高服务器性能；封装了网络相关的模块，包括socket、http、servlet等，支持快速搭建HTTP服务器或WebSokcet服务器。日志模块，使用宏实现流式输出，支持同步日志与异步日志、自定义日志格式、日志级别、多日志分离等功能。线程模块，封装pthread相关方法，封装常用的锁包括（信号量，读写锁，自旋锁等）。
Linux C简单的web服务器
血染风采2019
06-06 2737
Linux C简单的web服务器 目录 Linux C简单的web服务器 一、基础类型重命名 二、包裹函数（wrap.h/wrap.c 主要是网络通讯和多线程的包裹函数） 三、服务端程序（web_server.h/web_server.c）—— 使用EPOLL高并发机制 四、HTTP解析（http.h/http.c写了...
Linux下C++轻量级WebServer服务器 框架梳理
qq_58220428的博客
03-02 2444
WebServer是一个很好的入门级C++项目，因为它涉及到了方方面面，不仅可以提高编程能力，还包括了操作系统、计算机网络、数据库等方面的知识，所以我很推荐大家去入手这个项目。说细一点这个项目包含锁机制、日志系统、线程池、http处理、并发模型等实现，但是很多人一开始做这个项目的时候，会觉得逻辑很混乱从而无从下手，所以我写下这篇文章目的就是帮助大家起到一个梳理逻辑的作用，好了废话不多说，咱们往下看！
Linux项目实战C++轻量级Web服务器源码分析TinyWebServer
Binge的Blog，一起加油鸭！
04-06 3148
TinyWebServer是Linux下C++轻量级Web服务器，助力初学者快速实践网络编程，搭建属于自己的服务器.作为新手拿它练手入门再好不过的不二之选，作者也写了一些文章帮助初学者理解，但是，非学习总结的总是容易忘，这里记录一下学习过程。以上列表的文章立下flag，都要更新完毕！每更新一篇文章就会修改上面的文字为具体链接，希望不要又被打脸了，不要啦！！！
99-Linux_C语言实现web服务器
Eccentric哈哈的博客
04-29 729
【代码】99-Linux_C语言实现web服务器。
服务端使用C++实现非阻塞的websocket
秋雨 De Blog
11-22 1588
客户端有socket，但网页端有类似socket的websocekt，那么webscoekt到底是如何实现的，今天我们来研究一下。
Linux C/C++ Server websocket协议与服务器实现
C/C++Linux、音视频、DPDK
11-02 752
原文 https://www.cnblogs.com/go-ahead-wsg/p/17294745.html服务器需要主动推送（长连接）给客户端数据，通常使用websocket协议，比如股票信息实时数据等；websocket服务器为websocket协议+reactor实现websocket协议与http协议对比，http协议是针对网页设计的协议，为一请求一连接形式适合短连接，而websocket为长连接，握手使用文本字符串，传输为二进制数据，数据包更小更快，可主动推送数据给客户端。
WebServer:C ++ Linux Web服务器服务器
03-19
网络服务器 用C ++实现的高性能WEB服务器，通过webbenchh压力测试可以实现上万的QPS 功能 利用IO复合技术Epoll与线程池实现多线程的React器高并发模型； 利用正则与状态机解析HTTP请求报文，实现处理静态资源的请求； 利用标准库容器封装char，实现自动增长的边界； 基于小根堆实现的计时器，关闭超时的非活动连接； 利用单例模式与双向同步实现异步的日志系统，记录服务器运行状态； 利用RAII机制实现了数据库连接池，减少了数据库连接建立与关闭的开销，同时实现了用户注册登录功能。 增加logsys，threadpool测试单元（待办事项：计时器，sqlconnpool，httprequest，httpresponse） 环境要求 Linux C ++ 14 的MySql 目录树 . ├── code 源代码 │ ├── buffer │   ├─
基于linux c实现web服务器
09-16
基于linux通过c实现web服务器，适合新手 学习了知识点，然后通过项目巩固一下知识点，也可以了解http协议。
多线程服务器端C++设计（吴静).doc
06-26
利用线程实现接受客户机的C#编程的服务器和客户机程序，基于TCP/IP协议
linux-linux下C++轻量级WebServer服务器实现.zip
02-26
在Linux环境下，使用C++开发轻量级Web服务器是一个典型的系统编程任务，涉及到网络编程、多线程、I/O模型等多个重要知识点。本项目旨在通过C++实现一个基础的HTTP服务器，以处理简单的HTTP请求，如GET和POST，提供...
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码） 技术框架： 1. 线程池 + 非阻塞 socket + epoll + 事件处理的并发模型 2. 状态机解析HTTP请求 3. 心跳机制 4. 简易日志系统 主要内容： 1. ...
基于c++及linux网络编程的web服务器源码.zip
06-13
基于c++及linux网络编程的web服务器源码.zip 基于c++及linux网络编程的web服务器 该web服务器的主要内容如下： 使用了epoll边沿触发+EPOLLONESHOT+非阻塞IO 使用了一个固定线程数的线程池 实现了一个任务队列，...
一个基于epoll的多线程 linux c http web服务器.zip
03-17
包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【项目质量】： 所有源码都经过严格测试，可以直接运行。 功能在确认正常工作后才上传。 【适用人群】...
C语言开发Linux下web服务器(支持GET/POST,SSL,目录显示等)
he91-com
12-29 557
这个主要是在CSAPP基础上做的，添加了POST，SSL，目录显示等功能。 一、 实现功能： 1. 支持GET/POST方法 2. 支持SSL安全连接即HTTPS 3. 支持CGI 4. 基于IP地址和掩码的认证 5. 目录显示 6. 日志功能7. 错误提示页面 源代码下载地址：点击打开链接 二、设计原理 首先介绍一些HTTP协议基本知识。 #1.GET/POST 本实...
用C++写一个在linux上运行的web后台服务器
05-24
要用C++编写运行在Linux上的Web后端服务器，可以使用一些流行的网络库，例如Boost.Asio或libevent。这些库提供了处理网络请求和响应的功能，使得开发Web服务器变得更加容易。 以下是一个简单的示例程序，演示如何使用Boost.Asio来编写一个简单的Web服务器。 ```cpp #include <boost/asio.hpp> #include <iostream> #include <string> using boost::asio::ip::tcp; int main() { try { boost::asio::io_service io_service; // 监听端口为8080 tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 8080)); std::cout << "Server started. Listening on port 8080." << std::endl; while (true) { // 等待新的连接 tcp::socket socket(io_service); acceptor.accept(socket); std::cout << "New connection established." << std::endl; // 读取并解析HTTP请求 boost::asio::streambuf request_buffer; boost::asio::read_until(socket, request_buffer, "\r\n\r\n"); std::string request_data = boost::asio::buffer_cast<const char*>(request_buffer.data()); std::cout << "Received request:\n" << request_data << std::endl; // 构造HTTP响应 std::string response_body = "<html><body><h1>Hello, World!</h1></body></html>"; std::string response_headers = "HTTP/1.1 200 OK\r\nContent-Length: " + std::to_string(response_body.length()) + "\r\n\r\n"; // 发送响应 boost::asio::write(socket, boost::asio::buffer(response_headers)); boost::asio::write(socket, boost::asio::buffer(response_body)); std::cout << "Response sent." << std::endl; } } catch (std::exception& e) { std::cerr << "Exception: " << e.what() << std::endl; } return 0; } ``` 这个程序会监听8080端口，并且每当有新的连接请求时，会读取请求并发送“Hello, World!”作为响应。如果需要在更复杂的情况下使用，可以将其改写为支持多线程或异步I/O的服务器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值