WebServer v1.0 文档

概述

WebServer 1.0 简单实现了一个基础的 多并发网络服务程序 。在该版本中,主要实现了以下重要内容:

  • 线程互斥锁 & 条件变量的封装
  • 线程池的设计,以支持并发
  • 基础网络连接的实现
  • http 协议的简略支持
    • 支持部分常用 HTTP 报文
      • 200 OK
      • 400 Bad Request
      • 500 Internal Server Error
      • 501 Not Implemented
      • 505 HTTP Version Not Supported
    • 支持 HTTP GET 请求
    • 支持 HTTP/1.1 持续连接 特性

1.0 版本的项目代码位于 Kiprey/WebServer CommitID: 4095cc - github

最新版本的项目代码位于 Kiprey/WebServer - github

运行示例:

image-20210512133857068

注意:该程序的实现大量参考了 linyacool/WebServer - github 的代码。

一、互斥锁 & 条件变量

1. 互斥锁

对于当前的多线程程序来说,可能会出现多个线程同时读写同一个数据结构的情况,那么此时势必会造成脏读这种错误情况。而互斥锁的使用,是为了保证数据共享操作的完整性,确保任一时刻,只能有一个线程访问目标对象。

在linux中,互斥锁主要使用以下函数来实现:

1
2
3
4
5
6
7
8
9
10
11
12
// 初始化 mutex 对象
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
// mutex 加锁,在获得锁之前将会阻塞
int pthread_mutex_lock(pthread_mutex_t *mutex);
// mutex 加锁,如果能马上获取锁则返回0,无法获取锁则马上返回errno
int pthread_mutex_trylock(pthread_mutex_t *mutex);
// mutex 释放锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);
// 销毁 mutex 对象
int pthread_mutex_destroy(pthread_mutex_t *mutex);

由于 pthread 族的库函数名称较长,并且调用方式也互不相同,因此在这些库函数上做了一个简单的封装:

注意,这实际上就是RAII(资源获取即初始化),是C++等编程语言常用的管理资源、避免内存泄露的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* @brief MutexLock 将 pthread_mutex 封装成一个类,
* 这样做的好处是不用记住那些繁杂的 pthread 开头的函数使用方式
*/
class MutexLock
{
private:
pthread_mutex_t mutex_;
public:
MutexLock() { pthread_mutex_init(&mutex_, nullptr); }
~MutexLock() { pthread_mutex_destroy(&mutex_); }
void lock() { pthread_mutex_lock(&mutex_); }
void unlock() { pthread_mutex_unlock(&mutex_); }
pthread_mutex_t* getMutex() { return &mutex_; };
};

正常来说,我们使用锁时,需要经过以下过程:获取锁->进入临界区->释放锁。但在实际使用锁时,容易忘记释放锁,而这是一个非常严重的错误。因此我们可以实现一个 MutexLockGuard类,借助类的构造函数和析构函数,来帮助我们自动获取锁和释放锁,只需一个简单的声明即可获取锁&释放锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
* @brief MutexLockGuard 主要是为了自动获取锁/释放锁, 防止意外情况下忘记释放锁
* 而且块状的锁定区域更容易让人理解代码
*/
class MutexLockGuard
{
private:
MutexLock& lock_;
public:
/**
* @brief 声明 MutexLockGuard 时自动上锁
* @param lock 待锁定的资源
*/
MutexLockGuard(MutexLock& mutex) : lock_(mutex) { lock_.lock(); }
/**
* @brief 当前作用域结束时自动释放锁, 防止遗忘
*/
~MutexLockGuard() { lock_.unlock(); }
};

2. 条件变量

一说起条件变量,就不得不说先说起管程。管程保证了同一时刻只有一个线程在管程内活动,但不能保证线程在进入管程后,能继续一次性执行下去直到管程结束。

例如某个线程好不容易进入了管程,但执行了一段时间,突然发现某个条件没有满足,使得当前线程必须阻塞,无法继续执行。但要是该线程原地阻塞,一直占用这个管程,那其他的线程自然就无法进入管程,造成死锁。

那该怎么办呢?这就轮到条件变量出场了。

继续以上面的这个例子为例,由于该线程进入管程后可能会阻塞,因此非常肯定的是,必须在该进程进入阻塞状态前释放管程,否则会造成死锁。但是该线程已经进入管程,且没办法继续执行下去,因此只能原地释放管程,并等待条件满足后,重新获取管程锁,并将该线程唤醒,使其继续执行。

条件变量起到的作用,就相当于控制线程在管程中挂起和唤醒的作用。上面的语句可能有点难以理解,请思考一下这个例子:

线程池中,当子线程需要读取事件队列来获取事件之前,需要先获取队列的锁。当子线程获取到锁以后,如果队列为空,则条件不满足(注意这里的条件是:队列非空),因此子线程就无法从中获取事件,没法继续执行。此时可以使用条件变量让子线程在管程中挂起,等到条件满足时再通过条件变量来唤醒,回到管程继续执行。

注意:使用条件变量时,一定要确保在已经获取到管程锁的前提下使用,否则条件变量容易被多个子线程修改/使用。

条件变量相关的函数如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 初始化条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
// 唤醒 **至少一个** 被目标条件变量阻塞的线程
int pthread_cond_signal(pthread_cond_t *cond);
// 唤醒 **所有** 被目标条件变量阻塞的线程
int pthread_cond_broadcast(pthread_cond_t *cond);
// 让目标条件变量阻塞当前线程
int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
// 让目标条件变量阻塞当前线程,并设置最大阻塞时间
int pthread_cond_timedwait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime);
// 销毁条件变量
int pthread_cond_destroy(pthread_cond_t *cond);

与上面的互斥锁一样,这里也实现了一个 Condition类来简化条件变量的使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/**
* @brief 条件变量,主要用于多线程中的锁
* 与 MutexLock 一致,无需记住繁杂的函数名称
* 条件变量主要是与mutex进行搭配,常用于资源分配相关的场景,
* 例如当某个线程获取到锁以后,发现没有资源,则此时可以释放资源并等待条件变量
* @note 注意: 使用条件变量时,必须上锁,防止出现多个线程共同使用条件变量
*/
class Condition
{
private:
MutexLock& lock_; // 目标 Mutex 互斥锁
pthread_cond_t cond_; // 条件变量
public:
Condition(MutexLock& mutex) : lock_(mutex) { pthread_cond_init(&cond_, nullptr); }
~Condition() { pthread_cond_destroy(&cond_); }
void notify() { pthread_cond_signal(&cond_); }
void notifyAll() { pthread_cond_broadcast(&cond_); }
void wait() { pthread_cond_wait(&cond_, lock_.getMutex()); }
/**
* @brief 等待当前的条件变量一段时间
* @param sec 等待的时间(单位:秒)
* @return 成功在时间内等待到则返回 true, 超时则返回 false
*/
bool waitForSeconds(size_t sec)
{
timespec abstime;
// 获取当前系统真实时间
clock_gettime(CLOCK_REALTIME, &abstime);
abstime.tv_sec += (time_t)sec;
return ETIMEDOUT != pthread_cond_timedwait(&cond_, lock_.getMutex(), &abstime);
}
};

二、线程池

1. 概述

  • 线程池是一种多线程的处理方式,常常用在高并发服务器上。线程池可以有效的利用高并发服务器上的线程资源。

  • 线程用于处理各个请求,其流程大致为:创建线程 => 传递信息至子线程 => 线程分离 => 线程运行 => 线程销毁。对于较小规模的通信来说,上述的这个流程可以满足基本需求。但是对于高并发服务器来说,重复的创建线程与销毁线程,其开销不可忽视。因此可以使用线程池来让线程复用。

2. 实现前的准备工作

  • 对于一个线程所要执行的任务,我们需要明确以下几点:

    • 当前线程所要执行的函数,最好是与主线程没有较大关联的,即尽量降低耦合性。
  • 所要执行的事件,可以传入一个参数,但需要明确不能有返回值

    要想有应该也可以做,不过这就是后面的事情了。

    因此,我们便可以设计出以下的 task 结构体

    1
    2
    3
    4
    5
    6
    // 每个线程的基本事件单元
    struct ThreadpoolTask
    {
    void (*function)(void*);
    void* arguments;
    };
  • 线程池除了一些特定的变量(线程个数、事件队列等等)以外,还需要互斥锁以及条件变量

    • 对于每个线程来说,这些线程是有可能同时访问线程池,因此需要在每个线程访问之前加以上锁
    • 上锁之后,对于每个线程来说,有可能出现这种获取到锁,但没有事件可以执行的情况。对于这类情况,子线程必须先释放锁等待事件的到来,等到事件到来之后再重新上锁,获取事件,而这就是条件变量的用处。

3. 子线程的目标函数

由于子线程只会在线程池创建之时创建,在线程池销毁之时销毁,因此,在子线程中必然要执行一个事件循环,其中重复执行 获取事件、执行事件 的动作。

但这里需要注意两件事情,

  1. 获取事件时,需要给线程池上锁,因为要访问消息队列;必要时刻还需要设置条件变量来暂时释放锁。
  2. 当线程池被销毁时,子线程该如何终止?

针对问题2,有两种方式:

  1. 一种是在线程池设置一个标志,子线程定期轮询该标志以确认是否退出。
  2. 再一种就是当前所实现的:添加一个退出事件至事件队列中,子线程执行到该事件时自动退出。

因此具体实现的代码如下所示:

注意,pthread_cond_signal 会唤醒至少一个线程,注意是至少。因此可能会出现唤醒多个线程但只有一个事件等待处理的情况。针对于这种情况,只需设置子线程在被唤醒后,循环检测是否有剩余事件等待处理即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
void* ThreadPool::TaskForWorkerThreads_(void* arg)
{
ThreadPool* pool = (ThreadPool*)arg;
// 启动当前线程
ThreadpoolTask task;
// 对于子线程来说,事件循环开始
for(;;)
{
// 首先获取事件
{
// 获取事件时需要上个锁
MutexLockGuard guard(pool->threadpool_mutex_);

/**
* 如果好不容易获得到锁了,但是没有事件可以执行
* 则陷入沉睡,释放锁,并等待唤醒
* NOTE: 注意, pthread_cond_signal 会唤醒至少一个线程
* 也就是说,可能存在被唤醒的线程仍然没有事件处理的情况
* 这时只需循环wait即可.
*/
while(pool->task_queue_.size() == 0)
pool->threadpool_cond_.wait();
// 唤醒后一定有事件
assert(pool->task_queue_.size() != 0);
task = pool->task_queue_.front();
pool->task_queue_.pop();
}
// 执行事件
(task.function)(task.arguments);
}
// 注意: UNREACHABLE, 控制流不可能会到达此处
// 因为线程的退出不会走这条控制流,而是执行退出事件
assert(0 && "TaskForWorkerThreads_ UNREACHABLE!");
return nullptr;
}

4. 创建线程池

创建线程池较为简单,直接循环创建线程即可。

需要注意的是,这里设置了销毁线程池时的处理方式。具体信息将在下面销毁线程池的那部分中详细讲解。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
ThreadPool::ThreadPool(size_t threadNum, ShutdownMode shutdown_mode, size_t maxQueueSize)
: threadNum_(threadNum),
maxQueueSize_(maxQueueSize),
// 使用 类成员变量 threadpool_mutex_ 来初始化 threadpool_cond_
threadpool_cond_(threadpool_mutex_),
shutdown_mode_(shutdown_mode)
{
// 开始循环创建线程
while(threads_.size() < threadNum_)
{
pthread_t thread;
// 如果线程创建成功,则将其压入栈内存中
if(!pthread_create(&thread, nullptr, TaskForWorkerThreads_, this))
{
threads_.push_back(thread);
// // 注意这里只修改已启动的线程数量
// startedThreadNum_++;
}
}
}

5. 添加事件

添加新事件时,需要设置一下锁,防止脏读。在新事件添加完成后,使用条件变量来唤醒其中某一个空闲线程以执行新事件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
bool ThreadPool::appendTask(void (*function)(void*), void* arguments)
{
// 由于会操作事件队列,因此需要上锁
MutexLockGuard guard(threadpool_mutex_);
// 如果队列长度过长,则将当前task丢弃
if(task_queue_.size() > maxQueueSize_)
return false;
else
{
// 添加task至列表中
ThreadpoolTask task = { function, arguments };
task_queue_.push(task);
// 每当有新事件进入之时,只唤醒一个等待线程
threadpool_cond_.notify();
return true;
}
}

6. 销毁线程池

销毁线程池时,需要判断销毁的方式。

这里设置了两种销毁方式,分别是

  1. IMMEDIATE_SHUTDOWN

  2. GRACEFUL_QUIT

对于第一种销毁方式,线程池将马上清空事件队列中的全部事件,并添加与线程个数相对应量的退出事件。这将会使每个子线程在执行完当前事件后,马上执行退出事件以退出。

退出事件如下:每个线程简单执行 pthread_exit 以退出。

1
auto pthreadExit = [](void*) { pthread_exit(0); };

而对于第二种销毁方式来说,只是简单的添加退出事件,没有额外的清空之前的事件。这样线程池只会在所有事件全部结束后才真正的被销毁。

以下是具体的实现代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
ThreadPool::~ThreadPool()
{
// 向任务队列中添加退出线程事件,注意上锁
// 注意在 cond 使用之前一定要上 mutex
{
// 操作 task_queue_ 时一定要上锁
MutexLockGuard guard(threadpool_mutex_);
// 如果需要立即关闭当前的线程池,则
if(shutdown_mode_ == IMMEDIATE_SHUTDOWN)
// 先将当前队列清空
while(!task_queue_.empty())
task_queue_.pop();

// 往任务队列中添加退出线程任务
for(size_t i = 0; i < threadNum_; i++)
{
auto pthreadExit = [](void*) { pthread_exit(0); };
ThreadpoolTask task = { pthreadExit, nullptr };
task_queue_.push(task);
}
// 唤醒所有线程以执行退出操作
threadpool_cond_.notifyAll();
}
for(size_t i = 0; i < threadNum_; i++)
{
// 回收线程资源
pthread_join(threads_[i], nullptr);
}
}

7. 参考链接

三、网络连接

1. 概述

执行一次完整的网络连接通常需要执行数个 socket 类 函数。

为了弄懂这些函数的使用,本人将在下面随着代码的编写,尽量讲解所使用到的函数内容。

注:以下部分主要参考自 Linux/Posix manual pageman指令真是一个好东西 XD)。

2. socket

  • socket 函数主要用于创建网络交互(communication)中的一个终端(endpoint),即创建一个 socket fd 文件描述符。

  • socket 函数的类型声明如下:

    1
    2
    3
    4
    5
    #include <sys/types.h>          /* See NOTES */
    #include <sys/socket.h>

    // 执行成功则返回一个新文件描述符fd,失败则返回-1并设置errno
    int socket(int domain, int type, int protocol);

    其中,对于参数 domain,我们主要用到以下两种类型:

    • AF_UNIX / AF_LOCAL:本地通信,通常用于进程间通信。其通信不经过网卡,速度远远大于 AF_INET。
    • AF_INET: IPv4 协议通信,数据需要经过网卡。

    IPv6 和 bluetooth 等类型暂且不表。比较诧异的是,AF_VSOCK用于虚拟机程序与宿主机进行通信。

    对于参数 type,常用的主要有以下几种:

    • SOCK_STREAM: TCP 通信

    • SOCK_DGRAM: UDP 通信

    • SOCK_NONBLOCK: 设置非阻塞 socket。使用 or 运算符来附加属性

      与设置 O_NONBLOCK 至对应文件描述符操作等同

    • SOCK_CLOEXEC: 设置若当前程序执行 exec 时,对应文件描述符将在子进程中给关闭。使用 or 运算符来附加属性

      与设置 FD_CLOEXEC 至对应文件描述符等同。

    参数 protocol 通常用于指定某一个特定的套接字协议。如果给定协议系列只有一个协议可以支持特定的套接字类型,则 protocol 可以指定为0。但是若给定协议系列中可能存在多个可以支持套接字的类型,这时候就必须设置 protocol 以指定具体类型。

  • 简单举例:创建一个 IPv4 的 TCP 套接字(最常用)

    1
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);

3. bind

  • 对于一个新创建的 socket(注意是新创建的),还没有任何的地址用于赋给该 socket。而 bind 函数就是用于赋以一个地址给该 socket。

    需要注意的是:如果当前 socket 在执行 bind 前已经被使用,则操作系统将会自动分配地址以及端口号等等,这也是为什么一些网络程序向外通信时使用的端口号是随机的,因为操作系统会在后面调控。

  • bind 函数的声明如下:

    1
    2
    3
    4
    5
    #include <sys/types.h>          /* See NOTES */
    #include <sys/socket.h>

    // 执行成功则返回0,失败则返回-1并设置errno
    int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    • 其中,第一个参数sockfd 用以传入目标 socket 文件描述符

    • 至于第二个参数addr,其中使用的规则与结构体,在地址族之间有所不同。

    • 第三个参数addrlen用于表示第二个参数addr所指向结构体的size。

    对于 AF_INET:所使用到的 address format 如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    #include <netinet/in.h> // ! 注意头文件!!
    struct sockaddr_in {
    sa_family_t sin_family; /* address family: AF_INET */
    in_port_t sin_port; /* port in network byte order */
    struct in_addr sin_addr; /* internet address */
    };

    /* Internet address. */
    struct in_addr {
    uint32_t s_addr; /* address in network byte order */
    };

    其中,sin_family 始终为 AF_INET;sin_port 设置为目标端口;sin_addr用以保存监听目标的地址

    这里多提一句,由于现代计算机可能有多张网卡,因此指定 sin_addr 可以使得只监听特定网卡的连接。如果想监听全部网卡的连接,则可以使用宏定义 INADDR_ANY(实际上就是 0.0.0.0)。

    1
    2
    /* Address to accept any incoming messages.  */
    #define INADDR_ANY ((in_addr_t) 0x00000000)

    而如果绑定 127.0.0.1 回环地址,则只能监听到主动发送至回环地址的请求,其他发送到当前该机器但目标IP非回环地址的请求则不会被处理。

    注意:sin_port、sin_addr 变量都必须以网络端序来保存数据(即大端序)。

    socket提供了端序转换的一些函数,便于转换(其中,h表示host,n表示network)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /* Functions to convert between host and network byte order.

    Please note that these functions normally take `unsigned long int' or
    `unsigned short int' values as arguments and also return them. But
    this was a short-sighted decision since on different systems the types
    may have different representations but the values are always the same. */

    extern uint32_t ntohl (uint32_t __netlong) __THROW __attribute__ ((__const__));
    extern uint16_t ntohs (uint16_t __netshort)
    __THROW __attribute__ ((__const__));
    extern uint32_t htonl (uint32_t __hostlong)
    __THROW __attribute__ ((__const__));
    extern uint16_t htons (uint16_t __hostshort)
    __THROW __attribute__ ((__const__));

如果需要网络端序IP地址<—>字符串类型转变,则请参照以下函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int inet_aton(const char *cp, struct in_addr *inp);

in_addr_t inet_addr(const char *cp);

in_addr_t inet_network(const char *cp);

char *inet_ntoa(struct in_addr in);

struct in_addr inet_makeaddr(in_addr_t net, in_addr_t host);

in_addr_t inet_lnaof(struct in_addr in);

in_addr_t inet_netof(struct in_addr in);

对于一个 AF_NET 地址族来说,执行 bind 的一个简单例子如下:

1
2
3
4
5
6
7
8
9
10
11
12
// 绑定端口
sockaddr_in server_addr;
// 初始化一下
memset(&server_addr, '\0', sizeof(server_addr));
// 设置一下基本操作
server_addr.sin_family = AF_INET;
server_addr.sin_port = htonl((unsigned short)port);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

// 试着bind
if(bind(listen_fd, (sockaddr*)&server_addr, sizeof(server_addr)) == -1)
return -1;

4. listen

listen 函数将会使得传入的 socket fd 变为等待连接状态。该函数原型如下:

1
2
3
4
5
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

// 成功则返回0,失败则返回-1并设置 errno
int listen(int sockfd, int backlog);

该函数主要有两个参数:参数 sockfd 传入目标 fd;backlog 指定最大挂起连接的等待队列长度,如果队列满了,则新连接将会被拒绝(ECONNREFUSED)。而对于某些特殊协议,将会在一段时间后重新发起连接。

5. accept

  • accept 函数将会取出 listen_fd的挂起连接等待队列 中的第一个连接,创建一个新的 socket fd(client fd),并将其返回。后续与该连接的交互都是通过该client fd 完成。

  • 需要注意的是, accept 会从 listen_fd 中取出挂起的连接,并尝试连接。一旦完成连接后,将会创建一个新的 client_fd。原先的 listen_fd 不会有任何改变

  • 如果当前 listen_fd 为阻塞式的,则如果当前挂起连接等待队列中不存在任何连接,那么执行 accept 时将阻塞,直到有新连接的到来。

  • 该函数的原型如下:

    1
    2
    3
    4
    #include <sys/types.h>          /* See NOTES */
    #include <sys/socket.h>

    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    • 第一个参数为传入的监听socket listen_fd
    • 第二个参数为指向 sockaddr 结构体的 一个指针,accept 函数将会把 远程 socket 的address写入目标结构体中
    • 第三个参数是一个存放 sockaddr 结构体大小的指针。

6. read/recv & write/send

由于 read/recv & write/send 操作涉及到阻塞与非阻塞式读写,因此我们需要额外对其做一些异常处理。

需要注意的是,socket读写中,除了使用read/write以外,还可以使用专用于套接字通信的send/recv函数族等等。

a. 错误码

该类函数中最常返回的错误EINTR 以及 EAGAIN,其他错误暂时忽略。其中:

  • EINTR:该错误常见于阻塞式的操作,提示当前操作被中断

    如果一个进程在一个慢系统调用中阻塞时,捕获到信号并执行完信号处理例程返回时,这个系统调用将不再被阻塞,而是被中断,返回 EINTR。

    对于读写函数来说,当返回这类错误时,最常用的做法就是重新执行目标函数。

  • EAGAIN:该错误常见于非阻塞式的操作,提示用户稍后再重新执行

    例如:

    • 当以非阻塞方式大量发送数据时,如果缓冲区爆满,则产生 Resource temporarily unavailable的错误(资源暂时不可用),并返回 EAGAIN。
    • 当以非阻塞模式下读取数据,如果多次读取数据但没有数据可读,则此时不会阻塞等待数据,而是直接返回 EAGAIN

    对于 read 函数来说,由于数据取决于远程,因此当接收到 EAGAIN 时终止读取,直接返回;

    但对于 write 函数来说,由于数据取决于当前服务器,因此可以继续循环写入,直至数据完全写入。

对于 recv/send 函数来说,与 read/write 相比,将会额外多出部分专用于 socket 的错误码,例如 ECONNREFUSED、EPIPE 以及 ECONNRESET 等等。出于调试目的,在实现 读写函数的 wrapper时,将这两类读写函数全部集成在 wrapper中,并用一个bool参数来控制启用 read/write 还是 recv/send 函数。

b. 阻塞/非阻塞 读取

对于读取操作来说,阻塞读取和非阻塞读取又有所不同:

  • 当有数据到来时,阻塞和非阻塞的实现相同,都是读取数据并立即返回
  • 但是当没有数据到来时,由于非阻塞读取时会返回 EAGAIN 错误,因此可以立即返回;而阻塞读取此时就必须阻塞,直到数据到来才返回。

在具体实现 读取操作的wrapper函数时,同样使用一个bool参数来控制是否是阻塞/非阻塞读取。

c. 返回值

read/recv & write/send 函数的返回值

  • 若为负数则说明存在错误
  • 若为0则说明连接中断
  • 若为正数则该数为成功读取/发送的字节数

d. 最终实现的代码

综上所述,read/recv 函数重新实现的 wrapper 如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
ssize_t readn(int fd, void*buf, size_t len, bool isBlock, bool isRead)
{
// 这里将 void* 转换成 char* 是为了在下面进行自增操作
char *pos = (char*)buf;
size_t leftNum = len;
ssize_t readNum = 0;
while(leftNum > 0)
{
ssize_t tmpRead = 0;
// 尝试循环读取,如果报错,则进行判断
// 注意, read 的返回值为0则表示读取到 EOF,是正常现象
if(isRead)
tmpRead = read(fd, pos, leftNum);
else
tmpRead = recv(fd, pos, leftNum, (isBlock ? 0 : MSG_DONTWAIT));

if(tmpRead < 0)
{
if(errno == EINTR)
tmpRead = 0;
// 如果始终读取不到数据,则提前返回,因为这个取决于远程 fd,无法预测要等多久
else if (errno == EAGAIN)
return readNum;
else
return -1;
}
// 读取的0,则说明远程连接已被关闭
if(tmpRead == 0)
break;
readNum += tmpRead;
pos += tmpRead;

// 如果是阻塞模式下,并且读取到的数据较小,则说明数据已经全部读取完成,直接返回
if(isBlock && static_cast<size_t>(tmpRead) < leftNum)
break;

leftNum -= tmpRead;
}
return readNum;
}

write/send 函数的 wrapper 同理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
ssize_t writen(int fd, void*buf, size_t len, bool isWrite)
{
// 这里将 void* 转换成 char* 是为了在下面进行自增操作
char *pos = (char*)buf;
size_t leftNum = len;
ssize_t writtenNum = 0;
while(leftNum > 0)
{
ssize_t tmpWrite = 0;

if(isWrite)
tmpWrite = write(fd, pos, leftNum);
else
tmpWrite = send(fd, pos, leftNum, 0);

// 尝试循环写入,如果报错,则进行判断
if(tmpWrite < 0)
{
// 与read不同的是,如果 EAGAIN,则继续重复写入,因为写入操作是有Server这边决定的
if(errno == EINTR || errno == EAGAIN)
tmpWrite = 0;
else
return -1;
}
if(tmpWrite == 0)
break;
writtenNum += tmpWrite;
pos += tmpWrite;
leftNum -= tmpWrite;
}
return writtenNum;
}

7. 建立连接

综上各类函数的分析,现在我们可以为服务器端开启一个监听套接字,并等待客户端连接:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int socket_bind_and_listen(int port)
{
int listen_fd = 0;
// 开始创建 socket, 注意这是阻塞模式的socket
// AF_INET : IPv4 Internet protocols
// SOCK_STREAM : TCP socket
if((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
return -1;

// 绑定端口
sockaddr_in server_addr;
// 初始化一下
memset(&server_addr, '\0', sizeof(server_addr));
// 设置一下基本操作
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons((unsigned short)port);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
// 端口复用
int opt = 1;
if(setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1)
return -1;
// 试着bind
if(bind(listen_fd, (sockaddr*)&server_addr, sizeof(server_addr)) == -1)
return -1;
// 试着listen, 设置最大队列长度为 1024
if(listen(listen_fd, 1024) == -1)
return -1;

return listen_fd;
}

注意到这部分代码,设置端口复用属性:

1
2
3
4
// 端口复用
int opt = 1;
if(setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1)
return -1;

正常来说,对于某个网络程序,一个端口只能绑定一个套接字,别的套接字无法使用这个端口。而如果需要让同一程序的不同套接字绑定统一端口,则需要设置端口复用属性。

不过在当前WebServer-1.0版本中,设置端口复用貌似是不必要的,就算删除也无伤大雅。

8. 忽略 SIGPIPE 信号

SIGPIPE 信号将在远程连接被中断时发出。默认的处理例程是终止程序,而这很明显不是我们所期望的处理方式。因此我们必须设置 WebServer 忽视 SIGPIPE 信号,以免被意外终止。

1
2
3
4
5
6
7
8
9
void handleSigpipe()
{
struct sigaction sa;
memset(&sa, '\0', sizeof(sa));
sa.sa_handler = SIG_IGN;
sa.sa_flags = 0;
if(sigaction(SIGPIPE, &sa, NULL) == -1)
LOG(ERROR) << "Ignore SIGPIPE failed! " << strerror(errno) << std::endl;
}

四、日志输出

WebServer-1.0版本中实现的输出功能较为简单,只将信息输出到终端的stdout、stderr,没有建立日志文件。

具体实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
* @brief 输出信息相关宏定义与函数
* 使用 `LOG(INFO) << "msg";` 形式以执行信息输出.
* @note 注意: 该宏功能尚未完备,多线程下使用LOG宏将会导致输出数据混杂
*/
#define INFO 1 /* 普通输出 */
#define ERROR 2 /* 错误输出 */
#define LOG(x) logmsg(x) /* 调用输出函数 */

std::ostream& logmsg(int flag)
{
// 输出信息时,设置线程互斥
// 获取线程 TID
long tid = syscall(SYS_gettid);
if(flag == ERROR)
{
std::cerr << tid << ": [ERROR]\t";
return std::cerr;
}
else if(flag == INFO)
{
std::cout << tid << ": [INFO]\t";
return std::cout;
}
else
{
logmsg(ERROR) << "错误的 LOG 选择" << std::endl;
abort();
}
}

如果有信息需要输出到终端,则按照以下调用方式使用即可,简单方便:

1
LOG(INFO) << "my msg" << std::endl;

输出信息时,会自动将当前子线程的 LWP 号以及信息类型(INFO/ERROR)输出,例如:

image-20210512133247864

需要注意的是,该输出功能没有设置多线程互斥,因此可能会造成输出格式异常,即多个线程同时使用LOG功能,输出的数据在终端上揉成一团,显示的不太雅观。

五、http 请求处理

1. 概述

当 Server 成功与 Client 建立连接后,Client 将会发送数据至 Server,此时 Server 就需要解析数据并进一步将目标数据传送回 Client。其中,http报文的解析和http header的处理便是重点。

2. 连接

当建立起一个新的客户端套接字(client_fd)后,目标事件将被放进事件队列中,并等待空闲线程处理。

而这里的事件便是以下函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void handlerConnect(void* arg)
{
int* fd_ptr = (int*)arg;
int client_fd = *fd_ptr;
delete fd_ptr;

if(client_fd < 0)
{
LOG(ERROR) << "client_fd error in handlerConnect" << endl;
return;
}
HttpHandler handler(client_fd);
handler.RunEventLoop();
close(client_fd);
}

我们可以很容易的看到,该函数只做了几件事情:

  1. 取出 client_fd
  2. 初始化 HttpHandler 类实例
  3. 调用 HttpHandler::RunEventLoop 函数
  4. 最终释放 client_fd

这里的 HttpHandler 类,就是下文中的重点。

HttpHandler 支持部分 HTTP/1.1 版本的特性——持续连接。默认情况下,执行其 RunEventLoop 成员函数时,将循环读取来自客户端的请求,处理并返回对应的响应报文。

HttpHandler 的整体代码结构如下所示,主要是由多个成员函数以及少数几个成员变量组成。RunEventLoop 函数是启动整个处理请求循环的一个开关函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/**
* @brief HttpHandler 类处理每一个客户端连接,并根据读入的http报文,动态返回对应的response
* 其支持的 HTTP 版本为 HTTP/1.1
* @note 该类只实现了部分异常处理,没有涵盖大部分的异常(不过暂时也够了)
*/
class HttpHandler
{
public:
/**
* @brief HttpHandler内部状态
*/
enum ERROR_TYPE {
ERR_SUCCESS = 0, // 无错误
ERR_READ_REQUEST_FAIL, // 读取请求数据失败
ERR_NOT_IMPLEMENTED, // 不支持一些特定的请求操作,例如 Post
ERR_HTTP_VERSION_NOT_SUPPORTED, // 不支持当前客户端的http版本
ERR_INTERNAL_SERVER_ERR, // 程序内部错误
ERR_CONNECTION_CLOSED, // 远程连接已关闭
ERR_BAD_REQUEST, // 用户的请求包中存在错误,无法解析
ERR_SEND_RESPONSE_FAIL // 响应包发送失败
};

/**
* @brief 显式指定 client fd
* @param fd 连接的 fd, 初始值为 -1
*/
explicit HttpHandler(int fd = -1);

/**
* @brief 释放所有 HttpHandler 所使用的资源
* @note 注意,不会主动关闭 client_fd
*/
~HttpHandler();

/**
* @brief 为当前连接启动事件循环
* @note 1. 在执行事件循环开始之前,一定要设置 client fd
* 2. 异常处理不完备
*/
void RunEventLoop();

// 只有getFd,没有setFd,因为Fd必须在创造该实例时被设置
int getClientFd() { return client_fd_; }

private:
const size_t MAXBUF = 1024;

int client_fd_;
// http 请求包的所有数据
string request_;
// http 头部
unordered_map<string, string> headers_;

// 请求方式
string method_;
// 请求路径
string path_;
// http版本号
string http_version_;
// 是否是 `持续连接`
// NOTE: 为了防止bug的产生,对于每一个类中的isKeepAlive_来说,
// 值只能从 true -> false,而不能再次从 false -> true
bool isKeepAlive_;

// 当前解析读入数据的位置
/**
* NOTE: 该成员变量只在
* readRequest -> parseURI -> parseHttpHeader -> RunEventLoop
* 内部中使用
*/
size_t pos_;

/**
* @brief 将当前client_fd_对应的连接信息,以 LOG(INFO) 的形式输出
*/
void printConnectionStatus();

/**
* @brief 从client_fd_中读取数据至 request_中
* @return 0 表示读取成功, 其他则表示读取过程存在错误
* @note 内部函数recvn在错误时会产生 errno
*/
ERROR_TYPE readRequest();

/**
* @brief 从0位置处解析 请求方式\URI\HTTP版本等
* @return 0 表示成功解析, 其他则表示解析过程存在错误
*/
ERROR_TYPE parseURI();

/**
* @brief 从request_中的pos位置开始解析 http header
* @return 0 表示成功解析, 其他则表示解析过程存在错误
*/
ERROR_TYPE parseHttpHeader();

/**
* @brief 发送响应报文给客户端
* @param responseCode http 状态码, http报文第二个字段
* @param responseMsg http 报文第三个字段
* @param responseBodyType 返回的body类型,即 Content-type
* @param responseBody 返回的body内容
* @return 0 表示成功发送, 其他则表示发送过程存在错误
*/
ERROR_TYPE sendResponse(const string& responseCode, const string& responseMsg,
const string& responseBodyType, const string& responseBody);

/**
* @brief 发送错误信息至客户端
* @param errCode 错误http状态码
* @param errMsg 错误信息, http报文第三个字段
* @return 0 表示成功发送, 其他则表示发送过程存在错误
*/
ERROR_TYPE handleError(const string& errCode, const string& errMsg);

/**
* @brief 将传入的字符串转义成终端可以直接显示的输出
* @param str 待输出的字符串
* @return 转义后的字符串
* @note 是将 '\r' 等无法在终端上显示的字符,转义成 "\r"字符串 输出
*/
string escapeStr (const string& str);
};

3. 错误类型

HttpHandler 中实现了以下错误类型:

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* @brief HttpHandler内部状态
*/
enum ERROR_TYPE {
ERR_SUCCESS = 0, // 无错误
ERR_READ_REQUEST_FAIL, // 读取请求数据失败
ERR_NOT_IMPLEMENTED, // 不支持一些特定的请求操作,例如 Post
ERR_HTTP_VERSION_NOT_SUPPORTED, // 不支持当前客户端的http版本
ERR_INTERNAL_SERVER_ERR, // 程序内部错误
ERR_CONNECTION_CLOSED, // 远程连接已关闭
ERR_BAD_REQUEST, // 用户的请求包中存在错误,无法解析
ERR_SEND_RESPONSE_FAIL // 响应包发送失败
};

除了第一种 ERR_SUCCESS 表示无错误以外,其余的错误类型都有对应的错误处理方式,例如终止连接或者向客户端发送一个特定的响应报文,我们将在下面的内容中提到这些错误处理方式。

4. 读取请求数据

当远程客户端发送数据至服务器端时,无论传来的是什么数据,首先要做的就是将数据从缓存中读取并保存至自己的缓冲区内。读取时需要明确一点:使用阻塞方式读取。因为每个客户端连接都是由单独的线程进行处理的,倘若服务器端没有将所有的请求数据全部读完,那么自然就无法继续执行下去。

同时还需要明确一点的是,调用 readn 函数读取数据时,有可能客户端传来的数据较多,使得读取到的字节数刚好等于传入 readn 的最大缓冲区大小,那么此时就必须保存并继续循环读取,因为这里可能还有一部分数据没有读取完成,仍然需要继续读取。只有当 readn 函数返回的值小于传入的最大缓冲区大小,才能说明来自客户端的数据已经全部读取完成。此时就可以退出读取请求函数

最后,readn 函数可能会因为出错、远程连接中断等意外情况返回负数,因此这里需要额外写一点错误处理,返回对应原因的错误枚举 ERR_READ_REQUEST_FAIL 或者 ERR_CONNECTION_CLOSED 等等。

综上所述,最终实现的代码如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
HttpHandler::ERROR_TYPE HttpHandler::readRequest()
{
// 清除之前的数据
request_.clear();
pos_ = 0;

char buffer[MAXBUF];

// 循环阻塞读取 ------------------------------------------
for(;;)
{
ssize_t len = readn(client_fd_, buffer, MAXBUF, true, true);
if(len < 0)
return ERR_READ_REQUEST_FAIL;
/**
* 如果此时没读取到信息并且之前已经读取过信息了,则直接返回.
* 这里需要注意,有些连接可能会提前连接过来,但是不会马上发送数据.因此需要阻塞等待
* 这里有个坑点: chromium在每次刷新过后,会额外开一个连接,用来缩短下次发送请求的时间
* 也就是说这里大概率会出现空连接,即连接到了,但是不会马上发送数据,而是等下一次的请求.
*
* 如果读取到的字节数为0,则说明远程连接已经被关闭.
*/
else if(len == 0)
{
// 对于已经读取完所有数据的这种情况
if(request_.length() > 0)
// 直接停止读取
break;
// 如果此时既没读取到数据,之前的 request_也为空,则表示远程连接已经被关闭
else
return ERR_CONNECTION_CLOSED;
}
// 将读取到的数据组装起来
string request(buffer, buffer + len);
request_ += request;

// 由于当前的读取方式为阻塞读取,因此如果读取到的数据已经全部读取完成,则直接返回
if(static_cast<size_t>(len) < MAXBUF)
break;
}
return ERR_SUCCESS;
}

5. 解析URI

接下来是 HTTP 请求报文的解析,我们先简单看看 请求报文的格式:

image-20210507204906032

首先,我们需要从报文中获取第一个以 \r\n结尾的行,并从这行中解析出请求方法目标URL以及HTTP版本。任何一种因为错误报文格式所导致的解析失败,都是 ERR_BAD_REQUEST 错误。

其次,目前 WebServer-1.0 版本只支持 GET 的请求方法,倘若识别到其他请求方法都会返回 ERR_NOT_IMPLEMENTED 错误。

由于请求 URL 可能是一个文件夹地址,而不是文件。因此如果URL指向的是一个文件夹,那么我们就必须在这个URL地址后添加/index.html字符串,使得请求的目标地址一定是一个文件(即便该文件可能不存在)。

最后,目前的 WebServer-1.0版本只支持 HTTP/1.0 和 HTTP/1.1 版本,因此如果识别到了其他的 HTTP版本,则马上返回 ERR_HTTP_VERSION_NOT_SUPPORTED 错误。

综上所述,最后实现的代码如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
HttpHandler::ERROR_TYPE HttpHandler::parseURI()
{
if(request_.empty()) return ERR_BAD_REQUEST;

size_t pos1, pos2;

pos1 = request_.find("\r\n");
if(pos1 == string::npos) return ERR_BAD_REQUEST;
string&& first_line = request_.substr(0, pos1);
// a. 查找get
pos1 = first_line.find(' ');
if(pos1 == string::npos) return ERR_BAD_REQUEST;
method_ = first_line.substr(0, pos1);

string output_method = "Method: ";
if(method_ == "GET")
output_method += "GET";
else
return ERR_NOT_IMPLEMENTED;
LOG(INFO) << output_method << endl;

// b. 查找目标路径
pos1++;
pos2 = first_line.find(' ', pos1);
if(pos2 == string::npos) return ERR_BAD_REQUEST;

// 获取path时,注意去除 path 中的第一个斜杠
pos1++;
path_ = first_line.substr(pos1, pos2 - pos1);
// 如果 path 为空,则添加一个 . 表示当前文件夹
if(path_.length() == 0)
path_ += ".";

// 判断目标路径是否是文件夹
struct stat st;
if(stat(path_.c_str(), &st) == 0)
{
// 如果试图打开一个文件夹,则添加 index.html
if (S_ISDIR(st.st_mode))
path_ += "/index.html";
}

LOG(INFO) << "Path: " << path_ << endl;

// c. 查看HTTP版本
// NOTE 这里只支持 HTTP/1.0 和 HTTP/1.1
pos2++;
http_version_ = first_line.substr(pos2, first_line.length() - pos2);
LOG(INFO) << "HTTP Version: " << http_version_ << endl;

// 检测是否支持客户端 http 版本
if(http_version_ != "HTTP/1.0" && http_version_ != "HTTP/1.1")
return ERR_HTTP_VERSION_NOT_SUPPORTED;
// 设置只在 HTTP/1.1时 允许 持续连接
if(http_version_ != "HTTP/1.1")
isKeepAlive_ = false;

// 更新pos_
pos_ = first_line.length() + 2;
return ERR_SUCCESS;
}

6. 解析 HTTP header

从HTTP报文第二行开始,每个以 \r\n为结尾的一行数据中,都有一个 key: value的键值对(header最后一行除外)。因此我们需要继续遍历请求报文的数据,将每个 HTTP header 存入数据结构中。如果解析报文的时候出现错误,则返回 ERR_BAD_REQUEST 错误。

这里有个点需要注意:HTTP/1.1默认支持持续连接,因此 HttpHandler 的成员变量 isKeepAlive_ 默认为 true。但如果客户端中存在这样的 http header Connection: close,则说明当前连接并非持续性的,因此处理完当前 http 请求后必须马上断开连接。所以当我们接收到了Connection: close这样的http header时,必须设置 isKeepAlive_ 变量为 false。

综上所述,最终实现的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
HttpHandler::ERROR_TYPE HttpHandler::parseHttpHeader()
{
// 清除之前的 http header
headers_.clear();

size_t pos1, pos2;
for(pos1 = pos_;
(pos2 = request_.find("\r\n", pos1)) != string::npos;
pos1 = pos2 + 2)
{
string&& header = request_.substr(pos1, pos2 - pos1);
// 如果遍历到了空头,则表示http header部分结束
if(header.size() == 0)
break;
pos1 = header.find(' ');
if(pos1 == string::npos) return ERR_BAD_REQUEST;
// key处减去1是为了消除key里的最后一个冒号字符
string&& key = header.substr(0, pos1 - 1);
// key 转小写
transform(key.begin(), key.end(), key.begin(), ::tolower);
// 获取 value
string&& value = header.substr(pos1 + 1);

LOG(INFO) << "HTTP Header: [" << key << " : " << value << "]" << endl;

headers_[key] = value;
}
// 获取header完成后,处理一下 Connection 头
auto conHeaderIter = headers_.find("connection");
if(conHeaderIter != headers_.end())
{
string value = conHeaderIter->second;
transform(value.begin(), value.end(), value.begin(), ::tolower);
if(value != "keep-alive")
isKeepAlive_ = false;
}
// 判断处理空 header 条目的 \r\n
if((request_.size() < pos1 + 2) || (request_.substr(pos1, 2) != "\r\n"))
return ERR_BAD_REQUEST;

pos_ = pos1 + 2;
return ERR_SUCCESS;
}

7. 发送响应报文

http响应报文格式如下所示:

image-20210507205312687

照着这个报文格式,照葫芦画瓢构建一个报文并将其发送至客户端即可。

这里要注意一点,当前连接是否继续保持取决于 isKeepAlive_ 变量。具体实现如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
HttpHandler::ERROR_TYPE HttpHandler::sendResponse(const string& responseCode, const string& responseMsg, 
const string& responseBodyType, const string& responseBody)
{
stringstream sstream;
sstream << "HTTP/1.1" << " " << responseCode << " " << responseMsg << "\r\n";
sstream << "Connection: " << (isKeepAlive_ ? "Keep-Alive" : "Close") << "\r\n";
sstream << "Server: WebServer/1.0" << "\r\n";
sstream << "Content-length: " << responseBody.size() << "\r\n";
sstream << "Content-type: " << responseBodyType << "\r\n";
sstream << "\r\n";
sstream << responseBody;

string&& response = sstream.str();
ssize_t len = writen(client_fd_, (void*)response.c_str(), response.size());

// 输出返回的数据
LOG(INFO) << "<<<<- Response Packet ->>>> " << endl;
LOG(INFO) << "{" << escapeStr(response) << "}" << endl;

if(len < 0 || static_cast<size_t>(len) != response.size())
return ERR_SEND_RESPONSE_FAIL;
return ERR_SUCCESS;
}

8. 错误处理

当 handlerError 错误处理函数被调用时,在该函数内部将简单构建一个 html 错误提示页面,并将该页面发送至远程客户端。具体实现如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
HttpHandler::ERROR_TYPE HttpHandler::handleError(const string& errCode, const string& errMsg)
{
string errStr = errCode + " " + errMsg;
string responseBody =
"<html>"
"<title>" + errStr + "</title>"
"<body>" + errStr +
"<hr><em> Kiprey's Web Server</em>"
"</body>"
"</html>";
return sendResponse(errCode, errMsg, "text/html", responseBody);
}

9. 事件循环(重要)

HttpHandler 中的 RunEventLoop 函数维护了整个连接的事件循环。具体操作如下:

  • 首先,由于 HTTP/1.1 协议支持 持续连接,因此控制流将会进入一个 while 循环,循环进行读取请求并发送响应这样的过程。
  • while 循环内部中,首先读取来自客户端的数据,之后进行 URI 与 http header 的解析。如果上面中任何一步存在错误,则发送对应的错误页面给客户端,或者退出循环断开连接。
  • 如果上述步骤没有错误,则打开目标文件,将文件数据通过 mmap 函数映射到内存,读取并发送至远程客户端。而如果目标文件不存在,则返回 404 错误;文件映射失败则返回 500 错误。
  • 最后返回 while 循环头部,继续等待新的请求报文。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
void HttpHandler::RunEventLoop()
{
ERROR_TYPE err_ty;
LOG(INFO) << "------------------- New Connection -------------------" << endl;

// 输出连接
printConnectionStatus();

// 持续连接
while(isKeepAlive_)
{
LOG(INFO) << "<<<<- Request Packet ->>>> " << endl;
// 从socket读取请求数据, 如果读取失败,或者断开连接
// NOTE 这里的 readRequest 必须完整读取整个 http 报文
if((err_ty = readRequest()) != ERR_SUCCESS)
{
if(err_ty == ERR_READ_REQUEST_FAIL)
LOG(ERROR) << "Read request failed ! " << strerror(errno) << endl;
else if(err_ty == ERR_CONNECTION_CLOSED)
LOG(INFO) << "Socket(" << client_fd_ << ") was closed." << endl;
else
assert(0 && "UNREACHABLE");
// 断开连接
break;
}
LOG(INFO) << "{" << escapeStr(request_) << "}" << endl;

// 解析信息 ------------------------------------------
LOG(INFO) << "<<<<- Request Info ->>>> " << endl;

// 1. 先解析第一行
if((err_ty = parseURI()) != ERR_SUCCESS)
{
if(err_ty == ERR_NOT_IMPLEMENTED)
{
LOG(ERROR) << "Request method is not implemented." << endl;
handleError("501", "Not Implemented");
}
else if(err_ty == ERR_HTTP_VERSION_NOT_SUPPORTED)
{
LOG(ERROR) << "Request HTTP Version Not Supported." << endl;
handleError("505", "HTTP Version Not Supported");
}
else if(err_ty == ERR_BAD_REQUEST)
{
LOG(ERROR) << "Bad Request." << endl;
handleError("400", "Bad Request");
}
else
assert(0 && "UNREACHABLE");
continue;
}
// 2. 解析每一条http header
if((err_ty = parseHttpHeader()) != ERR_SUCCESS)
{
if(err_ty == ERR_BAD_REQUEST)
{
LOG(ERROR) << "Bad Request." << endl;
handleError("400", "Bad Request");
}
else
assert(0 && "UNREACHABLE");
continue;
}
// 3. 输出剩余的 HTTP body
LOG(INFO) << "HTTP Body: {"
<< escapeStr(request_.substr(pos_, request_.length() - pos_))
<< "}" << endl;

// 发送目标数据 ------------------------------------------

// 试图打开一个文件
int file_fd;
if((file_fd = open(path_.c_str(), O_RDONLY, 0)) == -1)
{
// 如果打开失败,则返回404
LOG(ERROR) << "File [" << path_ << "] open failed ! " << strerror(errno) << endl;
handleError("404", "Not Found");
continue;
}
else
{
// 获取目标文件的大小
struct stat st;
if(stat(path_.c_str(), &st) == -1)
{
LOG(ERROR) << "Can not get file [" << path_ << "] state ! " << endl;
handleError("500", "Internal Server Error");
continue;
}
// 读取文件, 使用 mmap 来高速读取文件
void* addr = mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, file_fd, 0);
// 记得关闭文件描述符
close(file_fd);
// 异常处理
if(addr == MAP_FAILED)
{
LOG(ERROR) << "Can not map file [" << path_ << "] -> mem ! " << endl;
handleError("500", "Internal Server Error");
continue;
}
// 将数据从内存页存入至 responseBody
char* file_data_ptr = static_cast<char*>(addr);
string responseBody(file_data_ptr, file_data_ptr + st.st_size);
// 记得删除内存
int res = munmap(addr, st.st_size);
if(res == -1)
LOG(ERROR) << "Can not unmap file [" << path_ << "] <-> mem ! " << endl;
// 获取 Content-type
string suffix = path_;
// 通过循环找到最后一个 dot
size_t dot_pos;
while((dot_pos = suffix.find('.')) != string::npos)
suffix = suffix.substr(dot_pos + 1);

// 发送数据
if(sendResponse("200", "OK", MimeType::getMineType(suffix), responseBody) != ERR_SUCCESS)
LOG(ERROR) << "Send Response failed !" << endl;
}
}
LOG(INFO) << "------------------ Connection Closed ------------------" << endl;
}

六、编译 & 调试

最后简单说说编译和调试。使用make命令即可构建带有调试信息的 WebServer 二进制文件。这里的makefile是直接抄自 linyacool/WebServer 中的 makefile,并在其基础之上,修改了编译优化选项为 -O0,以及设置编译时附带额外的调试信息-g3 -ggdb3

-g所携带的调试信息可以被多个调试器所共用,而-ggdb所携带的调试信息是专供 gdb 使用,两者不完全等同。-ggdb3的调试等级甚至可以调试

这里的调试主要是使用 gdb + pwndbg 来完成(gdb 永远的神)。因为多线程程序在gdb下调试非常的方便,它可以很快的切换线程上下文(使用info <threadNum>)以及栈帧上下文(使用f <frameNum>);而且临时查看 errno 以及临时调用 strerror(errno)查看错误信息等等都非常地方便。

  • 版权声明: 本博客所有文章除特别声明外,著作权归作者所有。转载请注明出处!
  • Copyrights © 2020-2021 Kiprey
  • 访问人数: | 浏览次数:

请我喝杯咖啡吧~