在自制的C / C++ websocket实现中侦听消息

@Jontahan，

我认为你已经有了良好的开端，这个项目充满了乐趣 - 但这不是一项小努力，而且有很多东西需要学习和修复。

代码中存在一些设计问题：

1. 阻止您进入下一阶段(在接受新连接的同时收听消息);以及
2. 引入可能导致 DoS(拒绝服务)的有意义的安全漏洞。

例如，在阻止accept之后(在此期间，您无法读取传入的客户端消息)，您继续阻止read，等待HTTP请求(同样，您的代码正在等待网络事件，而它可能有更好的事情要做)。

此行为会阻止您的代码执行任务，因为您的代码正在等待 IO (accept/read)，而其他事件可能同时发生(即，如果 websocket 消息到达，而您的代码忙于等待accept最后 10 分钟怎么办？

此外，此行为还引入了与慢速客户端(即接收不良的客户端或恶意攻击者)相关的安全漏洞。例如，如果 HTTP 请求需要整整一分钟才能到达怎么办？如果到达时经过碎片整理怎么办？如果它一次到达一行怎么办？如果它一次到达一封信怎么办？

。

您的代码是测试握手的良好开端，但在将代码用作实际服务器之前，应重新考虑核心设计。

一种解决方案(通常用于小型服务器)是使用每连接线程设计，因此在accept后会生成一个新线程，并负责处理连接(它会阻塞read而不会中断其他线程)。

但是，此解决方案不是最佳的，并且引入了许多较小的安全风险(每个设计都有安全风险，这是关于选择尽可能小的风险)。

另一个解决方案，正如一些最好的(nginx/node.js)所实现的那样，是使用具有单个线程的"事件"设计。这有时被称为"反应堆"设计。

这种设计是迄今为止最好的设计之一，但它确实存在其他问题，并且在代码中需要大量关注，因此运行缓慢的任务/函数不会使整个服务器停止。

这种设计通常使用kqueue，epoll或(由于缺乏更好的选择)poll/select

来实现。在 psedo 代码中，它可能看起来像这样：

void defer_task(void (*func((void *)), void * arg) {
// place task in queue
}
void run_tasks() {
while (queue->not_empty()) {
task = grab_oldest_task();
task.func(task.arg);
}
}
void task_listen(void * data) {
// open listening socket
}
void task_poll(void * _) {
// poll existing clients and listening sockets
// probably using `kqueue`/`epoll`/`poll`/`select`
defer_task(task_ondata, (void*)fd);
// finish with rescheduling the poll task
defer_task(task_poll, NULL);
}
void task_ondata(void * data) {
int fd = (intptr_t)data;
// handle `accept` / `read` making sure all sockets are non-blocking
}
int main(void) {
defer_task(task_listen, NULL);
defer_task(task_poll, NULL);
run_tasks();
}

这是我写的任务调度系统的示例...它没有在生产中进行测试，但它可能会澄清我对defer_task的意思：

/* *****************************************************************************
API declarations - should be moved to a separate .h file.
***************************************************************************** */
/** Defer an execution of a function for later. Returns -1 on error.*/
int defer(void (*func)(void *), void *arg);
/** Performs all deferred functions until the queue had been depleated. */
void defer_perform(void);
/** returns true if there are deferred functions waiting for execution. */
int defer_has_queue(void);
/* *****************************************************************************
Compile time settings
***************************************************************************** */
#ifndef DEFER_QUEUE_BUFFER
#define DEFER_QUEUE_BUFFER 1024
#endif

/* *****************************************************************************
spinlock / sync for tasks
***************************************************************************** */
#if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
#define _GNU_SOURCE
#include <time.h>
#endif /* _GNU_SOURCE */
#include <stdlib.h>
/* manage the way threads "wait" for the lock to release */
#if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
/* nanosleep seems to be the most effective and efficient reschedule */
#define defer_nanosleep(length)                                                
{                                                                            
static const struct timespec tm = {.tv_nsec = length};                     
nanosleep(&tm, NULL);                                                      
}
#define reschedule_thread() defer_nanosleep(1)
#define throttle_thread() defer_nanosleep(8388608UL)
#else /* no effective rescheduling, just spin... */
#define reschedule_thread()
#define throttle_thread()
#endif
/** locks use a single byte */
typedef volatile unsigned char spn_lock_i;
/** The initail value of an unlocked spinlock. */
#define SPN_LOCK_INIT 0
/* Select the correct compiler builtin method. */
#if defined(__has_builtin)
#if __has_builtin(__sync_swap)
#define SPN_LOCK_BUILTIN(...) __sync_swap(__VA_ARGS__)
#elif __has_builtin(__sync_fetch_and_or)
#define SPN_LOCK_BUILTIN(...) __sync_fetch_and_or(__VA_ARGS__)
#else
#error Required builtin "__sync_swap" or "__sync_fetch_and_or" missing from compiler.
#endif /* defined(__has_builtin) */
#elif __GNUC__ > 3
#define SPN_LOCK_BUILTIN(...) __sync_fetch_and_or(__VA_ARGS__)
#else
#error Required builtin "__sync_swap" or "__sync_fetch_and_or" not found.
#endif
/** returns 1 and 0 if the lock was successfully aquired (TRUE == FAIL). */
static inline int spn_trylock(spn_lock_i *lock) {
return SPN_LOCK_BUILTIN(lock, 1);
}
/** Releases a lock. */
static inline __attribute__((unused)) void spn_unlock(spn_lock_i *lock) {
__asm__ volatile("" ::: "memory");
*lock = 0;
}
/** returns a lock's state (non 0 == Busy). */
static inline __attribute__((unused)) int spn_is_locked(spn_lock_i *lock) {
__asm__ volatile("" ::: "memory");
return *lock;
}
/** Busy waits for the lock. */
static inline __attribute__((unused)) void spn_lock(spn_lock_i *lock) {
while (spn_trylock(lock)) {
reschedule_thread();
}
}
/* *****************************************************************************
Data Structures
***************************************************************************** */
typedef struct {
void (*func)(void *);
void *arg;
} task_s;
typedef struct task_node_s {
task_s task;
struct task_node_s *next;
} task_node_s;
static task_node_s tasks_buffer[DEFER_QUEUE_BUFFER];
static struct {
task_node_s *first;
task_node_s **last;
task_node_s *pool;
spn_lock_i lock;
unsigned char initialized;
} deferred = {.first = NULL,
.last = &deferred.first,
.pool = NULL,
.lock = 0,
.initialized = 0};
/* *****************************************************************************
API
***************************************************************************** */
/** Defer an execution of a function for later. */
int defer(void (*func)(void *), void *arg) {
if (!func)
return -1;
task_node_s *task;
spn_lock(&deferred.lock);
if (deferred.pool) {
task = deferred.pool;
deferred.pool = deferred.pool->next;
} else if (deferred.initialized) {
task = malloc(sizeof(task_node_s));
if (!task)
goto error;
} else { /* lazy initialization of task buffer */
deferred.initialized = 1;
task = tasks_buffer;
deferred.pool = tasks_buffer + 1;
for (size_t i = 2; i < DEFER_QUEUE_BUFFER; i++) {
tasks_buffer[i - 1].next = tasks_buffer + i;
}
}
*deferred.last = task;
deferred.last = &task->next;
task->task.func = func;
task->task.arg = arg;
task->next = NULL;
spn_unlock(&deferred.lock);
return 0;
error:
spn_unlock(&deferred.lock);
return -1;
}
/** Performs all deferred functions until the queue had been depleted. */
void defer_perform(void) {
task_node_s *tmp;
task_s task;
restart:
spn_lock(&deferred.lock);
tmp = deferred.first;
if (tmp) {
deferred.first = tmp->next;
if (!deferred.first)
deferred.last = &deferred.first;
task = tmp->task;
if (tmp <= tasks_buffer + (DEFER_QUEUE_BUFFER - 1) && tmp >= tasks_buffer) {
tmp->next = deferred.pool;
deferred.pool = tmp;
} else {
free(tmp);
}
spn_unlock(&deferred.lock);
task.func(task.arg);
goto restart;
} else
spn_unlock(&deferred.lock);
}
/** returns true if there are deferred functions waiting for execution. */
int defer_has_queue(void) { return deferred.first != NULL; }