cmhi
/
vcpe
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

OCT 重新格式化代码

This commit is contained in:
huangxin 2022-11-08 10:37:52 +08:00
parent 1aaad54c7e
commit b8ece8e445
33 changed files with 2389 additions and 2484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
srcs/httpserver/CMakeLists.txt
View File

@ -20,7 +20,7 @@ if (UNIX)
add_definitions(-DUNIX)
endif (UNIX)
INCLUDE_DIRECTORIES(./include ./src)
INCLUDE_DIRECTORIES(./include ./src ../libs/include)
file(GLOB_RECURSE HW_HEADS
./src/haywire/*.h

2
srcs/httpserver/include/haywire.h
View File

@ -185,7 +185,7 @@ HAYWIRE_EXTERN void hw_set_response_status_code(hw_http_response* response, hw_s
HAYWIRE_EXTERN void hw_set_response_header(hw_http_response* response, hw_string* name, hw_string* value);
HAYWIRE_EXTERN void hw_set_body(hw_http_response* response, hw_string* body);
HAYWIRE_EXTERN void hw_http_response_send(hw_http_response* response, void* user_data, http_response_complete_callback callback);
HAYWIRE_EXTERN void hw_http_response_send_error(hw_http_response *response, const char *error, const char *err_msg);
HAYWIRE_EXTERN void hw_print_request_headers(http_request* request);
#ifdef __cplusplus

26
srcs/httpserver/src/haywire/configuration/configuration.c
View File

@ -4,33 +4,25 @@
#include "../khash.h"
#include "ini.h"
KHASH_MAP_INIT_STR(route_hashes, char*)
KHASH_MAP_INIT_STR(route_hashes, char *)
int configuration_handler(void* user, const char* section, const char* name, const char* value)
{
configuration* config = (configuration*)user;
int configuration_handler(void *user, const char *section, const char *name, const char *value) {
configuration *config = (configuration *)user;
#define MATCH(s, n) strcmp(section, s) == 0 && strcmp(name, n) == 0
if (MATCH("http", "listen_address"))
{
if (MATCH("http", "listen_address")) {
config->http_listen_address = dupstr(value);
}
else if (MATCH("http", "listen_port"))
{
} else if (MATCH("http", "listen_port")) {
config->http_listen_port = atoi(value);
}
else
{
} else {
return 0; /* unknown section/name, error */
}
return 1;
}
configuration* load_configuration(const char* filename)
{
configuration* config = malloc(sizeof(configuration));
if (ini_parse(filename, configuration_handler, config) < 0)
{
configuration *load_configuration(const char *filename) {
configuration *config = malloc(sizeof(configuration));
if (ini_parse(filename, configuration_handler, config) < 0) {
dzlog_error("Can't load configuration\n");
return NULL;
}

2
srcs/httpserver/src/haywire/configuration/configuration.h
View File

@ -1,4 +1,4 @@
#pragma once
#include "haywire.h"
configuration* load_configuration(const char* filename);
configuration *load_configuration(const char *filename);

48
srcs/httpserver/src/haywire/configuration/ini.c
View File

@ -19,58 +19,50 @@
#define MAX_NAME 50
/* Strip whitespace chars off end of given string, in place. Return s. */
static char* rstrip(char* s)
{
char* p = s + strlen(s);
static char *rstrip(char *s) {
char *p = s + strlen(s);
while (p > s && isspace(*--p))
*p = '\0';
return s;
}
/* Return pointer to first non-whitespace char in given string. */
static char* lskip(const char* s)
{
static char *lskip(const char *s) {
while (*s && isspace(*s))
s++;
return (char*)s;
return (char *)s;
}
/* Return pointer to first char c or ';' comment in given string, or pointer to
null at end of string if neither found. ';' must be prefixed by a whitespace
character to register as a comment. */
static char* find_char_or_comment(const char* s, char c)
{
static char *find_char_or_comment(const char *s, char c) {
int was_whitespace = 0;
while (*s && *s != c && !(was_whitespace && *s == ';')) {
was_whitespace = isspace(*s);
s++;
}
return (char*)s;
return (char *)s;
}
/* Version of strncpy that ensures dest (size bytes) is null-terminated. */
static char* strncpy0(char* dest, const char* src, size_t size)
{
static char *strncpy0(char *dest, const char *src, size_t size) {
strncpy(dest, src, size);
dest[size - 1] = '\0';
return dest;
}
/* See documentation in header file. */
int ini_parse_file(FILE* file,
int (*handler)(void*, const char*, const char*,
const char*),
void* user)
{
int ini_parse_file(FILE *file, int (*handler)(void *, const char *, const char *, const char *), void *user) {
/* Uses a fair bit of stack (use heap instead if you need to) */
char line[MAX_LINE];
char section[MAX_SECTION] = "";
char prev_name[MAX_NAME] = "";
char* start;
char* end;
char* name;
char* value;
char *start;
char *end;
char *name;
char *value;
int lineno = 0;
int error = 0;
@ -97,13 +89,11 @@ int ini_parse_file(FILE* file,
*end = '\0';
strncpy0(section, start + 1, sizeof(section));
*prev_name = '\0';
}
else if (!error) {
} else if (!error) {
/* No ']' found on section line */
error = lineno;
}
}
else if (*start && *start != ';') {
} else if (*start && *start != ';') {
/* Not a comment, must be a name[=:]value pair */
end = find_char_or_comment(start, '=');
if (*end != '=') {
@ -122,8 +112,7 @@ int ini_parse_file(FILE* file,
strncpy0(prev_name, name, sizeof(prev_name));
if (!handler(user, section, name, value) && !error)
error = lineno;
}
else if (!error) {
} else if (!error) {
/* No '=' or ':' found on name[=:]value line */
error = lineno;
}
@ -134,11 +123,8 @@ int ini_parse_file(FILE* file,
}
/* See documentation in header file. */
int ini_parse(const char* filename,
int (*handler)(void*, const char*, const char*, const char*),
void* user)
{
FILE* file;
int ini_parse(const char *filename, int (*handler)(void *, const char *, const char *, const char *), void *user) {
FILE *file;
int error;
file = fopen(filename, "r");

18
srcs/httpserver/src/haywire/configuration/ini.h
View File

@ -18,7 +18,7 @@ extern "C" {
#include <stdio.h>
/* Parse given INI-style file. May have [section]s, name=value pairs
/* Parse given INI-style file. May have [section]s, name=value pairs
(whitespace stripped), and comments starting with ';' (semicolon). Section
is "" if name=value pair parsed before any section heading. name:value
pairs are also supported as a concession to Python's ConfigParser.
@ -30,19 +30,15 @@ extern "C" {
Returns 0 on success, line number of first error on parse error (doesn't
stop on first error), or -1 on file open error.
*/
int ini_parse(const char* filename,
int (*handler)(void* user, const char* section,
const char* name, const char* value),
void* user);
int ini_parse(const char *filename,
int (*handler)(void *user, const char *section, const char *name, const char *value), void *user);
/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
close the file when it's finished -- the caller must do that. */
int ini_parse_file(FILE* file,
int (*handler)(void* user, const char* section,
const char* name, const char* value),
void* user);
int ini_parse_file(FILE *file, int (*handler)(void *user, const char *section, const char *name, const char *value),
void *user);
/* Nonzero to allow multi-line value parsing, in the style of Python's
/* Nonzero to allow multi-line value parsing, in the style of Python's
ConfigParser. If allowed, ini_parse() will call the handler with the same
name for each subsequent line parsed. */
#ifndef INI_ALLOW_MULTILINE

76
srcs/httpserver/src/haywire/connection_consumer.c
View File

@ -8,15 +8,14 @@
static bool tcp_nodelay;
void ipc_read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf)
{
void ipc_read_cb(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf) {
int rc;
struct ipc_client_ctx* ctx;
uv_loop_t* loop;
struct ipc_client_ctx *ctx;
uv_loop_t *loop;
uv_handle_type type;
uv_pipe_t* ipc_pipe;
uv_pipe_t *ipc_pipe;
ipc_pipe = (uv_pipe_t*)handle;
ipc_pipe = (uv_pipe_t *)handle;
ctx = container_of(ipc_pipe, struct ipc_client_ctx, ipc_pipe);
loop = ipc_pipe->loop;
@ -24,45 +23,40 @@ void ipc_read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf)
type = uv_pipe_pending_type(ipc_pipe);
if (type == UV_TCP) {
rc = uv_tcp_init(loop, (uv_tcp_t*) ctx->server_handle);
rc = uv_tcp_init(loop, (uv_tcp_t *)ctx->server_handle);
if (tcp_nodelay) {
rc = uv_tcp_nodelay((uv_tcp_t*) ctx->server_handle, 1);
rc = uv_tcp_nodelay((uv_tcp_t *)ctx->server_handle, 1);
}
}
else if (type == UV_NAMED_PIPE)
rc = uv_pipe_init(loop, (uv_pipe_t*) ctx->server_handle, 0);
} else if (type == UV_NAMED_PIPE)
rc = uv_pipe_init(loop, (uv_pipe_t *)ctx->server_handle, 0);
rc = uv_accept(handle, ctx->server_handle);
uv_close((uv_handle_t*) &ctx->ipc_pipe, NULL);
uv_close((uv_handle_t *)&ctx->ipc_pipe, NULL);
}
void ipc_alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf)
{
struct ipc_client_ctx* ctx;
void ipc_alloc_cb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
struct ipc_client_ctx *ctx;
ctx = container_of(handle, struct ipc_client_ctx, ipc_pipe);
buf->base = ctx->scratch;
buf->len = sizeof(ctx->scratch);
}
void ipc_connect_cb(uv_connect_t* req, int status)
{
void ipc_connect_cb(uv_connect_t *req, int status) {
int rc;
struct ipc_client_ctx* ctx;
struct ipc_client_ctx *ctx;
ctx = container_of(req, struct ipc_client_ctx, connect_req);
rc = uv_read_start((uv_stream_t*)&ctx->ipc_pipe, ipc_alloc_cb, ipc_read_cb);
rc = uv_read_start((uv_stream_t *)&ctx->ipc_pipe, ipc_alloc_cb, ipc_read_cb);
}
void connection_consumer_alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf)
{
void connection_consumer_alloc(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
static char slab[32];
buf->base = slab;
buf->len = sizeof(slab);
}
void connection_consumer_new_connection(uv_stream_t* server_handle, int status)
{
void connection_consumer_new_connection(uv_stream_t *server_handle, int status) {
int rc = 0;
http_connection* connection = create_http_connection();
http_connection *connection = create_http_connection();
http_parser_init(&connection->parser, HTTP_REQUEST);
connection->parser.data = connection;
@ -71,23 +65,21 @@ void connection_consumer_new_connection(uv_stream_t* server_handle, int status)
rc = uv_tcp_init(server_handle->loop, &connection->stream);
if (tcp_nodelay) {
rc = uv_tcp_nodelay((uv_tcp_t*)&connection->stream, 1);
rc = uv_tcp_nodelay((uv_tcp_t *)&connection->stream, 1);
}
rc = uv_accept(server_handle, (uv_stream_t*)&connection->stream);
rc = uv_read_start((uv_stream_t*)&connection->stream, http_stream_on_alloc, http_stream_on_read);
rc = uv_accept(server_handle, (uv_stream_t *)&connection->stream);
rc = uv_read_start((uv_stream_t *)&connection->stream, http_stream_on_alloc, http_stream_on_read);
}
void connection_consumer_close(uv_async_t* handle, int status)
{
struct server_ctx* ctx;
void connection_consumer_close(uv_async_t *handle, int status) {
struct server_ctx *ctx;
ctx = container_of(handle, struct server_ctx, async_handle);
uv_close((uv_handle_t*) &ctx->server_handle, NULL);
uv_close((uv_handle_t*) &ctx->async_handle, NULL);
uv_close((uv_handle_t *)&ctx->server_handle, NULL);
uv_close((uv_handle_t *)&ctx->async_handle, NULL);
}
void get_listen_handle(uv_loop_t* loop, uv_stream_t* server_handle)
{
void get_listen_handle(uv_loop_t *loop, uv_stream_t *server_handle) {
int rc;
struct ipc_client_ctx ctx;
@ -99,11 +91,9 @@ void get_listen_handle(uv_loop_t* loop, uv_stream_t* server_handle)
rc = uv_run(loop, UV_RUN_DEFAULT);
}
void connection_consumer_start(void *arg)
{
int rc;
void connection_consumer_start(void *arg) {
struct server_ctx *ctx;
uv_loop_t* loop;
uv_loop_t *loop;
ctx = arg;
tcp_nodelay = ctx->tcp_nodelay;
@ -113,16 +103,16 @@ void connection_consumer_start(void *arg)
http_request_cache_configure_listener(loop, &listener_async_handles[ctx->index]);
uv_barrier_wait(listeners_created_barrier);
rc = uv_async_init(loop, &ctx->async_handle, connection_consumer_close);
uv_unref((uv_handle_t*) &ctx->async_handle);
uv_async_init(loop, &ctx->async_handle, connection_consumer_close);
uv_unref((uv_handle_t *)&ctx->async_handle);
/* Wait until the main thread is ready. */
uv_sem_wait(&ctx->semaphore);
get_listen_handle(loop, (uv_stream_t*) &ctx->server_handle);
get_listen_handle(loop, (uv_stream_t *)&ctx->server_handle);
uv_sem_post(&ctx->semaphore);
rc = uv_listen((uv_stream_t*)&ctx->server_handle, ctx->listen_backlog, connection_consumer_new_connection);
rc = uv_run(loop, UV_RUN_DEFAULT);
uv_listen((uv_stream_t *)&ctx->server_handle, ctx->listen_backlog, connection_consumer_new_connection);
uv_run(loop, UV_RUN_DEFAULT);
uv_loop_delete(loop);
}

21
srcs/httpserver/src/haywire/connection_consumer.h
View File

@ -4,22 +4,19 @@
#include "uv.h"
#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#define offsetof(TYPE, MEMBER) ((size_t) & ((TYPE *)0)->MEMBER)
#endif
#define container_of(ptr, type, member) ((type*)(((char*)(ptr)) - offsetof(type, member)))
#define container_of(ptr, type, member) ((type *)(((char *)(ptr)) - offsetof(type, member)))
union stream_handle2
{
union stream_handle2 {
uv_pipe_t pipe;
uv_tcp_t tcp;
};
typedef unsigned char handle_storage_t[sizeof(union stream_handle2)];
struct server_ctx
{
struct server_ctx {
int index;
handle_storage_t server_handle;
unsigned int num_connects;
@ -30,16 +27,14 @@ struct server_ctx
unsigned int listen_backlog;
};
struct ipc_client_ctx
{
struct ipc_client_ctx {
uv_connect_t connect_req;
uv_stream_t* server_handle;
uv_stream_t *server_handle;
uv_pipe_t ipc_pipe;
char scratch[16];
};
struct ipc_server_ctx
{
struct ipc_server_ctx {
handle_storage_t server_handle;
unsigned int num_connects;
uv_pipe_t ipc_pipe;
@ -47,4 +42,4 @@ struct ipc_server_ctx
};
void connection_consumer_start(void *arg);
void connection_consumer_close(uv_async_t* handle, int status);
void connection_consumer_close(uv_async_t *handle, int status);

61
srcs/httpserver/src/haywire/connection_dispatcher.c
View File

@ -6,26 +6,23 @@
static struct sockaddr_in listen_addr;
void ipc_close_cb(uv_handle_t* handle)
{
struct ipc_peer_ctx* ctx;
void ipc_close_cb(uv_handle_t *handle) {
struct ipc_peer_ctx *ctx;
ctx = container_of(handle, struct ipc_peer_ctx, peer_handle);
free(ctx);
}
void ipc_write_cb(uv_write_t* req, int status)
{
struct ipc_peer_ctx* ctx;
void ipc_write_cb(uv_write_t *req, int status) {
struct ipc_peer_ctx *ctx;
ctx = container_of(req, struct ipc_peer_ctx, write_req);
uv_close((uv_handle_t*) &ctx->peer_handle, ipc_close_cb);
uv_close((uv_handle_t *)&ctx->peer_handle, ipc_close_cb);
}
void ipc_connection_cb(uv_stream_t* ipc_pipe, int status)
{
void ipc_connection_cb(uv_stream_t *ipc_pipe, int status) {
int rc;
struct ipc_server_ctx* sc;
struct ipc_peer_ctx* pc;
uv_loop_t* loop;
struct ipc_server_ctx *sc;
struct ipc_peer_ctx *pc;
uv_loop_t *loop;
uv_buf_t buf;
loop = ipc_pipe->loop;
@ -35,24 +32,19 @@ void ipc_connection_cb(uv_stream_t* ipc_pipe, int status)
//ASSERT(pc != NULL);
if (ipc_pipe->type == UV_TCP) {
rc = uv_tcp_init(loop, (uv_tcp_t*) &pc->peer_handle);
rc = uv_tcp_init(loop, (uv_tcp_t *)&pc->peer_handle);
if (sc->tcp_nodelay) {
rc = uv_tcp_nodelay((uv_tcp_t*) &pc->peer_handle, 1);
rc = uv_tcp_nodelay((uv_tcp_t *)&pc->peer_handle, 1);
}
}
else if (ipc_pipe->type == UV_NAMED_PIPE)
rc = uv_pipe_init(loop, (uv_pipe_t*) &pc->peer_handle, 1);
} else if (ipc_pipe->type == UV_NAMED_PIPE)
rc = uv_pipe_init(loop, (uv_pipe_t *)&pc->peer_handle, 1);
rc = uv_accept(ipc_pipe, (uv_stream_t*) &pc->peer_handle);
rc = uv_write2(&pc->write_req,
(uv_stream_t*) &pc->peer_handle,
&buf,
1,
(uv_stream_t*) &sc->server_handle,
ipc_write_cb);
rc = uv_accept(ipc_pipe, (uv_stream_t *)&pc->peer_handle);
rc = uv_write2(
&pc->write_req, (uv_stream_t *)&pc->peer_handle, &buf, 1, (uv_stream_t *)&sc->server_handle, ipc_write_cb);
if (--sc->num_connects == 0)
uv_close((uv_handle_t*) ipc_pipe, NULL);
uv_close((uv_handle_t *)ipc_pipe, NULL);
}
extern void print_configuration();
@ -60,41 +52,40 @@ extern void print_configuration();
* threads. It's kind of cumbersome for such a simple operation, maybe we
* should revive uv_import() and uv_export().
*/
void start_connection_dispatching(uv_handle_type type, unsigned int num_servers, struct server_ctx* servers, char* listen_address, int listen_port, bool tcp_nodelay, int listen_backlog)
{
void start_connection_dispatching(uv_handle_type type, unsigned int num_servers, struct server_ctx *servers,
char *listen_address, int listen_port, bool tcp_nodelay, int listen_backlog) {
int rc;
struct ipc_server_ctx ctx;
uv_loop_t* loop;
uv_loop_t *loop;
unsigned int i;
loop = uv_default_loop();
ctx.num_connects = num_servers;
ctx.tcp_nodelay = tcp_nodelay;
if (type == UV_TCP)
{
if (type == UV_TCP) {
uv_ip4_addr(listen_address, listen_port, &listen_addr);
rc = uv_tcp_init(loop, (uv_tcp_t*) &ctx.server_handle);
rc = uv_tcp_init(loop, (uv_tcp_t *)&ctx.server_handle);
if (ctx.tcp_nodelay) {
rc = uv_tcp_nodelay((uv_tcp_t*) &ctx.server_handle, 1);
rc = uv_tcp_nodelay((uv_tcp_t *)&ctx.server_handle, 1);
}
rc = uv_tcp_bind((uv_tcp_t*) &ctx.server_handle, (const struct sockaddr*)&listen_addr, 0);
rc = uv_tcp_bind((uv_tcp_t *)&ctx.server_handle, (const struct sockaddr *)&listen_addr, 0);
print_configuration();
printf("Listening...\n");
}
rc = uv_pipe_init(loop, &ctx.ipc_pipe, 1);
rc = uv_pipe_bind(&ctx.ipc_pipe, "HAYWIRE_CONNECTION_DISPATCH_PIPE_NAME");
rc = uv_listen((uv_stream_t*) &ctx.ipc_pipe, listen_backlog, ipc_connection_cb);
rc = uv_listen((uv_stream_t *)&ctx.ipc_pipe, listen_backlog, ipc_connection_cb);
for (i = 0; i < num_servers; i++)
uv_sem_post(&servers[i].semaphore);
rc = uv_run(loop, UV_RUN_DEFAULT);
uv_close((uv_handle_t*) &ctx.server_handle, NULL);
uv_close((uv_handle_t *)&ctx.server_handle, NULL);
rc = uv_run(loop, UV_RUN_DEFAULT);
for (i = 0; i < num_servers; i++)

6
srcs/httpserver/src/haywire/connection_dispatcher.h
View File

@ -3,10 +3,10 @@
#include "uv.h"
#include "connection_consumer.h"
struct ipc_peer_ctx
{
struct ipc_peer_ctx {
handle_storage_t peer_handle;
uv_write_t write_req;
};
void start_connection_dispatching(uv_handle_type type, unsigned int num_servers, struct server_ctx* servers, char* listen_address, int listen_port, bool tcp_nodelay, int listen_backlog);
void start_connection_dispatching(uv_handle_type type, unsigned int num_servers, struct server_ctx *servers,
char *listen_address, int listen_port, bool tcp_nodelay, int listen_backlog);

13
srcs/httpserver/src/haywire/http_connection.h
View File

@ -6,16 +6,19 @@
#include "http_request.h"
#include "http_request_buffers.h"
typedef struct
{
typedef struct {
uv_tcp_t stream;
http_parser parser;
uv_write_t write_req;
http_request* request;
http_request *request;
hw_string current_header_key;
hw_string current_header_value;
int keep_alive;
int last_was_value;
enum {OPEN, CLOSING, CLOSED} state;
hw_request_buffer* buffer;
enum {
OPEN,
CLOSING,
CLOSED
} state;
hw_request_buffer *buffer;
} http_connection;

910
srcs/httpserver/src/haywire/http_parser.c
View File

File diff suppressed because it is too large Load Diff

313
srcs/httpserver/src/haywire/http_parser.h
View File

@ -24,35 +24,35 @@
extern "C" {
#endif
/* Also update SONAME in the Makefile whenever you change these. */
/* Also update SONAME in the Makefile whenever you change these. */
#define HTTP_PARSER_VERSION_MAJOR 2
#define HTTP_PARSER_VERSION_MINOR 3
#define HTTP_PARSER_VERSION_PATCH 0
#include <sys/types.h>
#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER<1600)
#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER < 1600)
#include <BaseTsd.h>
#include <stddef.h>
typedef __int8 int8_t;
typedef unsigned __int8 uint8_t;
typedef __int16 int16_t;
typedef unsigned __int16 uint16_t;
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
typedef __int8 int8_t;
typedef unsigned __int8 uint8_t;
typedef __int16 int16_t;
typedef unsigned __int16 uint16_t;
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#else
#include <stdint.h>
#endif
/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
* faster
*/
#ifndef HTTP_PARSER_STRICT
# define HTTP_PARSER_STRICT 1
#define HTTP_PARSER_STRICT 1
#endif
/* Maximium header size allowed. If the macro is not defined
/* Maximium header size allowed. If the macro is not defined
* before including this header then the default is used. To
* change the maximum header size, define the macro in the build
* environment (e.g. -DHTTP_MAX_HEADER_SIZE=<value>). To remove
@ -60,14 +60,13 @@ extern "C" {
* to a very large number (e.g. -DHTTP_MAX_HEADER_SIZE=0x7fffffff)
*/
#ifndef HTTP_MAX_HEADER_SIZE
# define HTTP_MAX_HEADER_SIZE (80*1024)
#define HTTP_MAX_HEADER_SIZE (80 * 1024)
#endif
typedef struct http_parser http_parser;
typedef struct http_parser_settings http_parser_settings;
typedef struct http_parser http_parser;
typedef struct http_parser_settings http_parser_settings;
/* Callbacks should return non-zero to indicate an error. The parser will
/* Callbacks should return non-zero to indicate an error. The parser will
* then halt execution.
*
* The one exception is on_headers_complete. In a HTTP_RESPONSE parser
@ -80,127 +79,120 @@ extern "C" {
* many times for each string. E.G. you might get 10 callbacks for "on_url"
* each providing just a few characters more data.
*/
typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
typedef int (*http_cb) (http_parser*);
typedef int (*http_data_cb)(http_parser *, const char *at, size_t length);
typedef int (*http_cb)(http_parser *);
/* Request Methods */
/* Request Methods */
#define HTTP_METHOD_MAP(XX) \
XX(0, DELETE, DELETE) \
XX(1, GET, GET) \
XX(2, HEAD, HEAD) \
XX(3, POST, POST) \
XX(4, PUT, PUT) \
/* pathological */ \
XX(5, CONNECT, CONNECT) \
XX(6, OPTIONS, OPTIONS) \
XX(7, TRACE, TRACE) \
/* webdav */ \
XX(8, COPY, COPY) \
XX(9, LOCK, LOCK) \
XX(10, MKCOL, MKCOL) \
XX(11, MOVE, MOVE) \
XX(12, PROPFIND, PROPFIND) \
XX(13, PROPPATCH, PROPPATCH) \
XX(14, SEARCH, SEARCH) \
XX(15, UNLOCK, UNLOCK) \
/* subversion */ \
XX(16, REPORT, REPORT) \
XX(17, MKACTIVITY, MKACTIVITY) \
XX(18, CHECKOUT, CHECKOUT) \
XX(19, MERGE, MERGE) \
/* upnp */ \
XX(20, MSEARCH, M-SEARCH) \
XX(21, NOTIFY, NOTIFY) \
XX(22, SUBSCRIBE, SUBSCRIBE) \
XX(23, UNSUBSCRIBE, UNSUBSCRIBE) \
/* RFC-5789 */ \
XX(24, PATCH, PATCH) \
XX(25, PURGE, PURGE) \
/* CalDAV */ \
XX(26, MKCALENDAR, MKCALENDAR) \
XX(0, DELETE, DELETE) \
XX(1, GET, GET) \
XX(2, HEAD, HEAD) \
XX(3, POST, POST) \
XX(4, PUT, PUT) \
/* pathological */ \
XX(5, CONNECT, CONNECT) \
XX(6, OPTIONS, OPTIONS) \
XX(7, TRACE, TRACE) \
/* webdav */ \
XX(8, COPY, COPY) \
XX(9, LOCK, LOCK) \
XX(10, MKCOL, MKCOL) \
XX(11, MOVE, MOVE) \
XX(12, PROPFIND, PROPFIND) \
XX(13, PROPPATCH, PROPPATCH) \
XX(14, SEARCH, SEARCH) \
XX(15, UNLOCK, UNLOCK) \
/* subversion */ \
XX(16, REPORT, REPORT) \
XX(17, MKACTIVITY, MKACTIVITY) \
XX(18, CHECKOUT, CHECKOUT) \
XX(19, MERGE, MERGE) \
/* upnp */ \
XX(20, MSEARCH, M - SEARCH) \
XX(21, NOTIFY, NOTIFY) \
XX(22, SUBSCRIBE, SUBSCRIBE) \
XX(23, UNSUBSCRIBE, UNSUBSCRIBE) \
/* RFC-5789 */ \
XX(24, PATCH, PATCH) \
XX(25, PURGE, PURGE) \
/* CalDAV */ \
XX(26, MKCALENDAR, MKCALENDAR)
enum http_method
{
enum http_method {
#define XX(num, name, string) HTTP_##name = num,
HTTP_METHOD_MAP(XX)
#undef XX
};
};
enum http_parser_type {
HTTP_REQUEST,
HTTP_RESPONSE,
HTTP_BOTH
};
enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
/* Flag values for http_parser.flags field */
enum flags {
F_CHUNKED = 1 << 0,
F_CONNECTION_KEEP_ALIVE = 1 << 1,
F_CONNECTION_CLOSE = 1 << 2,
F_CONNECTION_UPGRADE = 1 << 3,
F_TRAILING = 1 << 4,
F_UPGRADE = 1 << 5,
F_SKIPBODY = 1 << 6
};
/* Flag values for http_parser.flags field */
enum flags
{ F_CHUNKED = 1 << 0
, F_CONNECTION_KEEP_ALIVE = 1 << 1
, F_CONNECTION_CLOSE = 1 << 2
, F_CONNECTION_UPGRADE = 1 << 3
, F_TRAILING = 1 << 4
, F_UPGRADE = 1 << 5
, F_SKIPBODY = 1 << 6
};
/* Map for errno-related constants
/* Map for errno-related constants
*
* The provided argument should be a macro that takes 2 arguments.
*/
#define HTTP_ERRNO_MAP(XX) \
/* No error */ \
XX(OK, "success") \
\
/* Callback-related errors */ \
XX(CB_message_begin, "the on_message_begin callback failed") \
XX(CB_url, "the on_url callback failed") \
XX(CB_header_field, "the on_header_field callback failed") \
XX(CB_header_value, "the on_header_value callback failed") \
XX(CB_headers_complete, "the on_headers_complete callback failed") \
XX(CB_body, "the on_body callback failed") \
XX(CB_message_complete, "the on_message_complete callback failed") \
XX(CB_status, "the on_status callback failed") \
\
/* Parsing-related errors */ \
XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \
XX(HEADER_OVERFLOW, \
"too many header bytes seen; overflow detected") \
XX(CLOSED_CONNECTION, \
"data received after completed connection: close message") \
XX(INVALID_VERSION, "invalid HTTP version") \
XX(INVALID_STATUS, "invalid HTTP status code") \
XX(INVALID_METHOD, "invalid HTTP method") \
XX(INVALID_URL, "invalid URL") \
XX(INVALID_HOST, "invalid host") \
XX(INVALID_PORT, "invalid port") \
XX(INVALID_PATH, "invalid path") \
XX(INVALID_QUERY_STRING, "invalid query string") \
XX(INVALID_FRAGMENT, "invalid fragment") \
XX(LF_EXPECTED, "LF character expected") \
XX(INVALID_HEADER_TOKEN, "invalid character in header") \
XX(INVALID_CONTENT_LENGTH, \
"invalid character in content-length header") \
XX(INVALID_CHUNK_SIZE, \
"invalid character in chunk size header") \
XX(INVALID_CONSTANT, "invalid constant string") \
XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
XX(STRICT, "strict mode assertion failed") \
XX(PAUSED, "parser is paused") \
XX(UNKNOWN, "an unknown error occurred")
/* No error */ \
XX(OK, "success") \
\
/* Callback-related errors */ \
XX(CB_message_begin, "the on_message_begin callback failed") \
XX(CB_url, "the on_url callback failed") \
XX(CB_header_field, "the on_header_field callback failed") \
XX(CB_header_value, "the on_header_value callback failed") \
XX(CB_headers_complete, "the on_headers_complete callback failed") \
XX(CB_body, "the on_body callback failed") \
XX(CB_message_complete, "the on_message_complete callback failed") \
XX(CB_status, "the on_status callback failed") \
\
/* Parsing-related errors */ \
XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \
XX(HEADER_OVERFLOW, "too many header bytes seen; overflow detected") \
XX(CLOSED_CONNECTION, "data received after completed connection: close message") \
XX(INVALID_VERSION, "invalid HTTP version") \
XX(INVALID_STATUS, "invalid HTTP status code") \
XX(INVALID_METHOD, "invalid HTTP method") \
XX(INVALID_URL, "invalid URL") \
XX(INVALID_HOST, "invalid host") \
XX(INVALID_PORT, "invalid port") \
XX(INVALID_PATH, "invalid path") \
XX(INVALID_QUERY_STRING, "invalid query string") \
XX(INVALID_FRAGMENT, "invalid fragment") \
XX(LF_EXPECTED, "LF character expected") \
XX(INVALID_HEADER_TOKEN, "invalid character in header") \
XX(INVALID_CONTENT_LENGTH, "invalid character in content-length header") \
XX(INVALID_CHUNK_SIZE, "invalid character in chunk size header") \
XX(INVALID_CONSTANT, "invalid constant string") \
XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state") \
XX(STRICT, "strict mode assertion failed") \
XX(PAUSED, "parser is paused") \
XX(UNKNOWN, "an unknown error occurred")
/* Define HPE_* values for each errno value above */
/* Define HPE_* values for each errno value above */
#define HTTP_ERRNO_GEN(n, s) HPE_##n,
enum http_errno {
enum http_errno {
HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
};
};
#undef HTTP_ERRNO_GEN
/* Get an http_errno value from an http_parser */
#define HTTP_PARSER_ERRNO(p) ((enum http_errno)(p)->http_errno)
/* Get an http_errno value from an http_parser */
#define HTTP_PARSER_ERRNO(p) ((enum http_errno) (p)->http_errno)
struct http_parser {
struct http_parser {
/** PRIVATE **/
unsigned int type : 2; /* enum http_parser_type */
unsigned int flags : 6; /* F_* values from 'flags' enum; semi-public */
@ -227,10 +219,9 @@ XX(UNKNOWN, "an unknown error occurred")
/** PUBLIC **/
void *data; /* A pointer to get hook to the "connection" or "socket" object */
};
};
struct http_parser_settings {
struct http_parser_settings {
http_cb on_message_begin;
http_data_cb on_url;
http_data_cb on_status;
@ -239,29 +230,27 @@ XX(UNKNOWN, "an unknown error occurred")
http_cb on_headers_complete;
http_data_cb on_body;
http_cb on_message_complete;
};
};
enum http_parser_url_fields {
UF_SCHEMA = 0,
UF_HOST = 1,
UF_PORT = 2,
UF_PATH = 3,
UF_QUERY = 4,
UF_FRAGMENT = 5,
UF_USERINFO = 6,
UF_MAX = 7
};
enum http_parser_url_fields
{ UF_SCHEMA = 0
, UF_HOST = 1
, UF_PORT = 2
, UF_PATH = 3
, UF_QUERY = 4
, UF_FRAGMENT = 5
, UF_USERINFO = 6
, UF_MAX = 7
};
/* Result structure for http_parser_parse_url().
/* Result structure for http_parser_parse_url().
*
* Callers should index into field_data[] with UF_* values iff field_set
* has the relevant (1 << UF_*) bit set. As a courtesy to clients (and
* because we probably have padding left over), we convert any port to
* a uint16_t.
*/
struct http_parser_url {
struct http_parser_url {
uint16_t field_set; /* Bitmask of (1 << UF_*) values */
uint16_t port; /* Converted UF_PORT string */
@ -269,10 +258,9 @@ XX(UNKNOWN, "an unknown error occurred")
uint16_t off; /* Offset into buffer in which field starts */
uint16_t len; /* Length of run in buffer */
} field_data[UF_MAX];
};
};
/* Returns the library version. Bits 16-23 contain the major version number,
/* Returns the library version. Bits 16-23 contain the major version number,
* bits 8-15 the minor version number and bits 0-7 the patch level.
* Usage example:
*
@ -282,46 +270,39 @@ XX(UNKNOWN, "an unknown error occurred")
* unsigned patch = version & 255;
* printf("http_parser v%u.%u.%u\n", major, minor, patch);
*/
unsigned long http_parser_version(void);
unsigned long http_parser_version(void);
void http_parser_init(http_parser *parser, enum http_parser_type type);
void http_parser_init(http_parser *parser, enum http_parser_type type);
/* Executes the parser. Returns number of parsed bytes. Sets
/* Executes the parser. Returns number of parsed bytes. Sets
* `parser->http_errno` on error. */
size_t http_parser_execute(http_parser *parser,
const http_parser_settings *settings,
const char *data,
size_t len);
size_t http_parser_execute(http_parser *parser, const http_parser_settings *settings, const char *data, size_t len);
/* If http_should_keep_alive() in the on_headers_complete or
/* If http_should_keep_alive() in the on_headers_complete or
* on_message_complete callback returns 0, then this should be
* the last message on the connection.
* If you are the server, respond with the "Connection: close" header.
* If you are the client, close the connection.
*/
int http_should_keep_alive(const http_parser *parser);
int http_should_keep_alive(const http_parser *parser);
/* Returns a string version of the HTTP method. */
const char *http_method_str(enum http_method m);
/* Returns a string version of the HTTP method. */
const char *http_method_str(enum http_method m);
/* Return a string name of the given error */
const char *http_errno_name(enum http_errno err);
/* Return a string name of the given error */
const char *http_errno_name(enum http_errno err);
/* Return a string description of the given error */
const char *http_errno_description(enum http_errno err);
/* Return a string description of the given error */
const char *http_errno_description(enum http_errno err);
/* Parse a URL; return nonzero on failure */
int http_parser_parse_url(const char *buf, size_t buflen,
int is_connect,
struct http_parser_url *u);
/* Parse a URL; return nonzero on failure */
int http_parser_parse_url(const char *buf, size_t buflen, int is_connect, struct http_parser_url *u);
/* Pause or un-pause the parser; a nonzero value pauses */
void http_parser_pause(http_parser *parser, int paused);
/* Pause or un-pause the parser; a nonzero value pauses */
void http_parser_pause(http_parser *parser, int paused);
/* Checks if this is the final chunk of the body. */
int http_body_is_final(const http_parser *parser);
/* Checks if this is the final chunk of the body. */
int http_body_is_final(const http_parser *parser);
#ifdef __cplusplus
}

201
srcs/httpserver/src/haywire/http_request.c
View File

@ -10,67 +10,58 @@
#include "http_server.h"
#include "server_stats.h"
#include "route_compare_method.h"
#include "misc.h"
extern char* uv__strndup(const char* s, size_t n);
extern char *uv__strndup(const char *s, size_t n);
#define CRLF "\r\n"
static const char response_404[] =
"HTTP/1.1 404 Not Found" CRLF
"Server: Haywire/master" CRLF
"Date: Fri, 26 Aug 2011 00:31:53 GMT" CRLF
"Connection: Keep-Alive" CRLF
"Content-Type: text/html" CRLF
"Content-Length: 16" CRLF
CRLF
"404 Not Found" CRLF
;
static const char response_404[] = "HTTP/1.1 404 Not Found" CRLF "Server: Haywire/master" CRLF
"Date: Fri, 26 Aug 2011 00:31:53 GMT" CRLF "Connection: Keep-Alive" CRLF
"Content-Type: text/html" CRLF "Content-Length: 16" CRLF CRLF "404 Not Found" CRLF;
static kh_inline khint_t hw_string_hash_func(hw_string* s)
{
static kh_inline khint_t hw_string_hash_func(hw_string *s) {
khint_t h = s->length > 0 ? (khint_t)*s->value : 0;
if (h) for (int i = 0; i < s->length; i++) h = (h << 5) - h + (khint_t)*(s->value + i);
if (h)
for (int i = 0; i < s->length; i++)
h = (h << 5) - h + (khint_t) * (s->value + i);
return h;
}
#define hw_string_hash_equal(a, b) (hw_strcmp(a, b) == 0)
KHASH_INIT(hw_string_hashmap, hw_string*, hw_string*, 1, hw_string_hash_func, hw_string_hash_equal)
KHASH_MAP_INIT_STR(string_hashmap, char*)
KHASH_INIT(hw_string_hashmap, hw_string *, hw_string *, 1, hw_string_hash_func, hw_string_hash_equal)
KHASH_MAP_INIT_STR(string_hashmap, char *)
KHASH_MAP_INIT_INT64(offset_hashmap, int)
void hw_print_request_headers(http_request* request)
{
hw_string* k;
hw_string* v;
void hw_print_request_headers(http_request *request) {
hw_string *k;
hw_string *v;
khash_t(hw_string_hashmap) *h = request->headers;
kh_foreach(h, k, v, {
char* key = uv__strndup(k->value, k->length + 1);
char* value = uv__strndup(v->value, v->length + 1);
char *key = uv__strndup(k->value, k->length + 1);
char *value = uv__strndup(v->value, v->length + 1);
printf("KEY: %s VALUE: %s\n", key, value);
free(key);
free(value);
});
}
void hw_print_body(http_request* request)
{
void hw_print_body(http_request *request) {
if (request->body->length > 0) {
char* body = uv__strndup(request->body->value, request->body->length);
char *body = uv__strndup(request->body->value, request->body->length);
printf("BODY: %s\n", body);
free(body);
}
else {
} else {
printf("BODY is empty!\n");
}
}
void* get_header(http_request* request, hw_string* name)
{
void *get_header(http_request *request, hw_string *name) {
khash_t(hw_string_hashmap) *h = request->headers;
khiter_t k = kh_get(hw_string_hashmap, h, name);
void* val;
void *val;
int is_missing = (k == kh_end(h));
if (is_missing) {
@ -81,18 +72,16 @@ void* get_header(http_request* request, hw_string* name)
return val;
}
void set_header(http_request* request, hw_string* name, hw_string* value)
{
void set_header(http_request *request, hw_string *name, hw_string *value) {
int ret, i;
khiter_t k;
khash_t(hw_string_hashmap) *h = request->headers;
for (i = 0; i < name->length; i++)
{
for (i = 0; i < name->length; i++) {
name->value[i] = tolower(name->value[i]);
}
void* prev = get_header(request, name);
void *prev = get_header(request, name);
if (prev) {
free(prev);
}
@ -101,9 +90,8 @@ void set_header(http_request* request, hw_string* name, hw_string* value)
kh_value(h, k) = value;
}
http_request* create_http_request(http_connection* connection)
{
http_request* request = calloc(1, sizeof(http_request));
http_request *create_http_request(http_connection *UNUSED(connection)) {
http_request *request = calloc(1, sizeof(http_request));
request->headers = kh_init(hw_string_hashmap);
request->url = calloc(1, sizeof(hw_string));
request->body = calloc(1, sizeof(hw_string));
@ -112,17 +100,15 @@ http_request* create_http_request(http_connection* connection)
return request;
}
void free_http_request(http_request* request)
{
void free_http_request(http_request *request) {
khash_t(hw_string_hashmap) *h = request->headers;
hw_string* k;
hw_string* v;
hw_string *k;
hw_string *v;
kh_foreach(h, k, v,
{
free((hw_string*)k);
free((hw_string*)v);
kh_foreach(h, k, v, {
free((hw_string *)k);
free((hw_string *)v);
});
kh_destroy(hw_string_hashmap, h);
@ -135,15 +121,13 @@ void free_http_request(http_request* request)
INCREMENT_STAT(stat_requests_destroyed_total);
}
hw_string* hw_get_header(http_request* request, hw_string* key)
{
void* value = get_header(request, key);
hw_string *hw_get_header(http_request *request, hw_string *key) {
void *value = get_header(request, key);
return value;
}
int http_request_on_message_begin(http_parser* parser)
{
http_connection* connection = (http_connection*)parser->data;
int http_request_on_message_begin(http_parser *parser) {
http_connection *connection = (http_connection *)parser->data;
if (connection->request) {
/* We're seeing a new request on the same connection, so it's time to free up the old one
* and create a new one.
@ -156,11 +140,10 @@ int http_request_on_message_begin(http_parser* parser)
return 0;
}
int http_request_on_url(http_parser *parser, const char *at, size_t length)
{
http_connection* connection = (http_connection*)parser->data;
http_request* request = connection->request;
hw_string* url = request->url;
int http_request_on_url(http_parser *parser, const char *at, size_t length) {
http_connection *connection = (http_connection *)parser->data;
http_request *request = connection->request;
hw_string *url = request->url;
if (url->length) {
/* This is not the first URL chunk that has been seen in the buffer. Since we've already captured the initial pointer in the branch below,
@ -176,9 +159,9 @@ int http_request_on_url(http_parser *parser, const char *at, size_t length)
return 0;
}
void http_request_save_current_header(http_connection* connection) {
hw_string* header_key_copy = hw_strdup(&connection->current_header_key);
hw_string* header_value_copy = hw_strdup(&connection->current_header_value);
void http_request_save_current_header(http_connection *connection) {
hw_string *header_key_copy = hw_strdup(&connection->current_header_key);
hw_string *header_value_copy = hw_strdup(&connection->current_header_value);
/* We duplicate the current header key/value, so we actually need to use the new pointers as pin ids, as
* those will be the IDs we'll use later on to locate the headers */
@ -187,20 +170,18 @@ void http_request_save_current_header(http_connection* connection) {
/* Set headers is going to need to have the values of header key/value, so we need to make sure we get
* the pointers pointing at the right place in the buffer */
header_key_copy->value = http_request_buffer_locate(connection->buffer, header_key_copy,
connection->current_header_key.value);
header_key_copy->value = http_request_buffer_locate(
connection->buffer, header_key_copy, connection->current_header_key.value);
header_value_copy->value = http_request_buffer_locate(connection->buffer, header_value_copy,
connection->current_header_value.value);
header_value_copy->value = http_request_buffer_locate(
connection->buffer, header_value_copy, connection->current_header_value.value);
/* Save last header key/value pair that was read */
set_header(connection->request, header_key_copy, header_value_copy);
}
int http_request_on_header_field(http_parser *parser, const char *at, size_t length)
{
http_connection* connection = (http_connection*)parser->data;
int http_request_on_header_field(http_parser *parser, const char *at, size_t length) {
http_connection *connection = (http_connection *)parser->data;
if (connection->last_was_value && connection->current_header_key.length > 0) {
http_request_save_current_header(connection);
@ -225,9 +206,8 @@ int http_request_on_header_field(http_parser *parser, const char *at, size_t len
return 0;
}
int http_request_on_header_value(http_parser *parser, const char *at, size_t length)
{
http_connection* connection = (http_connection*)parser->data;
int http_request_on_header_value(http_parser *parser, const char *at, size_t length) {
http_connection *connection = (http_connection *)parser->data;
if (!connection->last_was_value) {
connection->current_header_value.value = at;
@ -244,9 +224,8 @@ int http_request_on_header_value(http_parser *parser, const char *at, size_t len
return 0;
}
int http_request_on_headers_complete(http_parser* parser)
{
http_connection* connection = (http_connection*)parser->data;
int http_request_on_headers_complete(http_parser *parser) {
http_connection *connection = (http_connection *)parser->data;
if (connection->current_header_key.length > 0 && connection->current_header_value.length > 0) {
http_request_save_current_header(connection);
@ -262,13 +241,11 @@ int http_request_on_headers_complete(http_parser* parser)
return 0;
}
int http_request_on_body(http_parser *parser, const char *at, size_t length)
{
http_connection* connection = (http_connection*)parser->data;
http_request* request = connection->request;
hw_string* body = request->body;
if (length != 0)
{
int http_request_on_body(http_parser *parser, const char *at, size_t length) {
http_connection *connection = (http_connection *)parser->data;
http_request *request = connection->request;
hw_string *body = request->body;
if (length != 0) {
if (body->length == 0) {
body->value = at;
body->length = length;
@ -284,30 +261,26 @@ int http_request_on_body(http_parser *parser, const char *at, size_t length)
return 0;
}
hw_route_entry* get_route_callback(hw_string* url)
{
hw_route_entry* route_entry = NULL;
hw_route_entry *get_route_callback(hw_string *url) {
hw_route_entry *route_entry = NULL;
const char* k;
const char* v;
const char *k;
const char *v;
khash_t(string_hashmap) *h = routes;
kh_foreach(h, k, v,
{
kh_foreach(h, k, v, {
int found = hw_route_compare_method(url, k);
if (found)
{
route_entry = (hw_route_entry*)v;
if (found) {
route_entry = (hw_route_entry *)v;
}
});
return route_entry;
}
void send_error_response(http_request* request, http_response* response, const char* error_code,
const char* error_message)
{
void send_error_response(http_request *request, http_response *response, const char *error_code,
const char *error_message) {
hw_string status_code;
hw_string content_type_name;
hw_string content_type_value;
@ -328,15 +301,12 @@ void send_error_response(http_request* request, http_response* response, const c
body.length = strlen(error_message);
hw_set_body(response, &body);
if (request->keep_alive)
{
if (request->keep_alive) {
SETSTRING(keep_alive_name, "Connection");
SETSTRING(keep_alive_value, "Keep-Alive");
hw_set_response_header(response, &keep_alive_name, &keep_alive_value);
}
else
{
} else {
hw_set_http_version(response, 1, 0);
}
@ -348,15 +318,14 @@ void send_error_response(http_request* request, http_response* response, const c
* This is because the underlying buffers might have been reallocated/resized,
* so we can't use the pointers of where data chunks (e.g. URL start) were originally seen.
*/
void http_request_locate_members(http_connection* connection)
{
hw_request_buffer* buffer = connection->buffer;
http_request* request = connection->request;
void http_request_locate_members(http_connection *connection) {
hw_request_buffer *buffer = connection->buffer;
http_request *request = connection->request;
request->url->value = http_request_buffer_locate(buffer, request->url, request->url->value);
request->body->value = http_request_buffer_locate(buffer, request->body, request->body->value);
hw_string* header_name;
hw_string* header_value;
hw_string *header_name;
hw_string *header_value;
khash_t(hw_string_hashmap) *h = request->headers;
kh_foreach(h, header_name, header_value, {
@ -365,13 +334,12 @@ void http_request_locate_members(http_connection* connection)
});
}
int http_request_on_message_complete(http_parser* parser)
{
http_connection* connection = (http_connection*)parser->data;
http_request* request = connection->request;
hw_http_response* response = hw_create_http_response(connection);
int http_request_on_message_complete(http_parser *parser) {
http_connection *connection = (http_connection *)parser->data;
http_request *request = connection->request;
hw_http_response *response = hw_create_http_response(connection);
char* error = NULL;
char *error = NULL;
if (connection->request->state == SIZE_EXCEEDED) {
// 413 Request entity too large
@ -384,14 +352,11 @@ int http_request_on_message_complete(http_parser* parser)
} else {
http_request_locate_members(connection);
hw_route_entry* route_entry = request != NULL ? get_route_callback(request->url) : NULL;
hw_route_entry *route_entry = request != NULL ? get_route_callback(request->url) : NULL;
if (route_entry != NULL)
{
if (route_entry != NULL) {
route_entry->callback(request, response, route_entry->user_data);
}
else
{
} else {
// 404 Not Found.
error = HTTP_STATUS_404;
}
@ -408,7 +373,7 @@ int http_request_on_message_complete(http_parser* parser)
}
if (error) {
send_error_response(request, (http_response*)response, error, error);
send_error_response(request, (http_response *)response, error, error);
}
return 0;

2
srcs/httpserver/src/haywire/http_request.h
View File

@ -6,7 +6,7 @@
extern int last_was_value;
void free_http_request(http_request* request);
void free_http_request(http_request *request);
int http_request_on_message_begin(http_parser *parser);
int http_request_on_url(http_parser *parser, const char *at, size_t length);
int http_request_on_header_field(http_parser *parser, const char *at, size_t length);

68
srcs/httpserver/src/haywire/http_request_buffers.c
View File

@ -7,7 +7,7 @@
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
KHASH_MAP_INIT_INT64(pointer_hashmap, void*)
KHASH_MAP_INIT_INT64(pointer_hashmap, void *)
typedef struct {
size_t max_size;
@ -15,28 +15,28 @@ typedef struct {
size_t mark;
size_t used;
size_t used_before;
void* current;
khash_t(pointer_hashmap)* offsets;
void *current;
khash_t(pointer_hashmap) * offsets;
bool offsets_active;
} http_request_buffer;
void http_request_buffer_consume(hw_request_buffer* buf, size_t consumed) {
http_request_buffer* buffer = (http_request_buffer*) buf;
void http_request_buffer_consume(hw_request_buffer *buf, size_t consumed) {
http_request_buffer *buffer = (http_request_buffer *)buf;
buffer->used_before = buffer->used;
buffer->used += consumed;
}
void http_request_buffer_mark(hw_request_buffer* buf) {
http_request_buffer* buffer = (http_request_buffer*) buf;
void http_request_buffer_mark(hw_request_buffer *buf) {
http_request_buffer *buffer = (http_request_buffer *)buf;
/* unfortunately, the parser doesn't tell us where the request ends exactly,
* so the only thing we can be sure is that it ends in the current buffer chunk, so anything before it can
* effectively be swept, so we're placing the mark at that point now. */
buffer->mark = buffer->used_before;
}
void http_request_buffer_sweep(hw_request_buffer* buf) {
http_request_buffer* buffer = (http_request_buffer*) buf;
void* pointer;
void http_request_buffer_sweep(hw_request_buffer *buf) {
http_request_buffer *buffer = (http_request_buffer *)buf;
void *pointer;
int offset;
int used = buffer->used - buffer->mark;
@ -87,8 +87,8 @@ void http_request_buffer_sweep(hw_request_buffer* buf) {
}
}
hw_request_buffer* http_request_buffer_init(size_t max_size) {
http_request_buffer* buffer = malloc(sizeof(http_request_buffer));
hw_request_buffer *http_request_buffer_init(size_t max_size) {
http_request_buffer *buffer = malloc(sizeof(http_request_buffer));
buffer->max_size = max_size;
buffer->size = 0;
buffer->used = 0;
@ -100,16 +100,16 @@ hw_request_buffer* http_request_buffer_init(size_t max_size) {
return buffer;
}
void http_request_buffer_chunk(hw_request_buffer* buf, hw_request_buffer_chunk* chunk) {
http_request_buffer *buffer = (http_request_buffer *) buf;
void http_request_buffer_chunk(hw_request_buffer *buf, hw_request_buffer_chunk *chunk) {
http_request_buffer *buffer = (http_request_buffer *)buf;
chunk->size = buffer->size ? buffer->size - buffer->used : 0;
chunk->buffer = buffer->current + buffer->used;
}
bool http_request_buffer_alloc(hw_request_buffer* buf, size_t requested_size) {
http_request_buffer* buffer = (http_request_buffer*) buf;
bool http_request_buffer_alloc(hw_request_buffer *buf, size_t requested_size) {
http_request_buffer *buffer = (http_request_buffer *)buf;
bool ret = true;
void* previous = NULL;
void *previous = NULL;
size_t requested_size_capped = MIN(buffer->max_size, requested_size);
@ -148,18 +148,18 @@ bool http_request_buffer_alloc(hw_request_buffer* buf, size_t requested_size) {
return ret;
}
void http_request_buffer_print(hw_request_buffer* buf) {
http_request_buffer* buffer = (http_request_buffer*) buf;
void http_request_buffer_print(hw_request_buffer *buf) {
http_request_buffer *buffer = (http_request_buffer *)buf;
printf("Buffer: current=%u; size=%u; used=%u\n", buffer->current, buffer->size, buffer->used);
printf(" 0\t");
for (int i = 0; i < buffer->used; i++) {
if (((char*) buffer->current)[i] == '\n') {
if (((char *)buffer->current)[i] == '\n') {
printf("\\n");
} else if (((char*) buffer->current)[i] == '\r') {
} else if (((char *)buffer->current)[i] == '\r') {
printf("\\r");
} else {
printf("%c", ((char*) buffer->current)[i]);
printf("%c", ((char *)buffer->current)[i]);
}
if ((i + 1) % 10 == 0) {
@ -170,16 +170,14 @@ void http_request_buffer_print(hw_request_buffer* buf) {
}
printf("\n");
void* pointer;
void *pointer;
int offset;
kh_foreach(buffer->offsets, pointer, offset, {
printf("\tPointer %u -> offset=%u\n", pointer, offset);
});
kh_foreach(buffer->offsets, pointer, offset, { printf("\tPointer %u -> offset=%u\n", pointer, offset); });
printf("----\n");
}
void http_request_buffer_pin(hw_request_buffer* buf, void* key, void* pointer) {
http_request_buffer* buffer = (http_request_buffer*) buf;
void http_request_buffer_pin(hw_request_buffer *buf, void *key, void *pointer) {
http_request_buffer *buffer = (http_request_buffer *)buf;
khiter_t offset_key = kh_get(pointer_hashmap, buffer->offsets, key);
@ -194,8 +192,8 @@ void http_request_buffer_pin(hw_request_buffer* buf, void* key, void* pointer) {
kh_value(buffer->offsets, offset_key) = offset;
}
void http_request_buffer_reassign_pin(hw_request_buffer* buf, void* old_key, void* new_key) {
http_request_buffer* buffer = (http_request_buffer*) buf;
void http_request_buffer_reassign_pin(hw_request_buffer *buf, void *old_key, void *new_key) {
http_request_buffer *buffer = (http_request_buffer *)buf;
khiter_t old_offset_key = kh_get(pointer_hashmap, buffer->offsets, old_key);
@ -213,9 +211,9 @@ void http_request_buffer_reassign_pin(hw_request_buffer* buf, void* old_key, voi
}
}
void* http_request_buffer_locate(hw_request_buffer* buf, void* key, void* default_pointer) {
http_request_buffer* buffer = (http_request_buffer*) buf;
void* location = default_pointer;
void *http_request_buffer_locate(hw_request_buffer *buf, void *key, void *default_pointer) {
http_request_buffer *buffer = (http_request_buffer *)buf;
void *location = default_pointer;
khiter_t offset_key = kh_get(pointer_hashmap, buffer->offsets, key);
int offset, is_missing;
@ -231,8 +229,8 @@ void* http_request_buffer_locate(hw_request_buffer* buf, void* key, void* defaul
return location;
}
void http_request_buffer_destroy(hw_request_buffer* buf) {
http_request_buffer* buffer = (http_request_buffer*) buf;
void http_request_buffer_destroy(hw_request_buffer *buf) {
http_request_buffer *buffer = (http_request_buffer *)buf;
kh_destroy(pointer_hashmap, buffer->offsets);
free(buffer->current);
free(buffer);

26
srcs/httpserver/src/haywire/http_request_buffers.h
View File

@ -4,38 +4,38 @@
#include "haywire.h"
typedef struct {
void* buffer;
void *buffer;
size_t size;
} hw_request_buffer_chunk;
typedef void* hw_request_buffer;
typedef void *hw_request_buffer;
/**
* Initializes a new buffer. The caller is responsible for calling http_request_buffer_destroy to free up memory.
*/
hw_request_buffer* http_request_buffer_init(size_t max_size);
hw_request_buffer *http_request_buffer_init(size_t max_size);
/**
* Signals that "size" bytes from the buffer are now in use.
*/
void http_request_buffer_consume(hw_request_buffer* buffer, size_t size);
void http_request_buffer_consume(hw_request_buffer *buffer, size_t size);
/**
* Marks all buffer chunks up to the last one allocated (exclusive) for removal when
* http_request_buffer_sweep gets called.
*/
void http_request_buffer_mark(hw_request_buffer* buffer);
void http_request_buffer_mark(hw_request_buffer *buffer);
/**
* Sweeps all buffer chunks up to the mark. Data for the last chunk is copied to the beginning of the buffer
* and the offsets are updates accordingly.
*/
void http_request_buffer_sweep(hw_request_buffer* buffer);
void http_request_buffer_sweep(hw_request_buffer *buffer);
/**
* Prints the buffer.
*/
void http_request_buffer_print(hw_request_buffer* buffer);
void http_request_buffer_print(hw_request_buffer *buffer);
/**
* Ensures that there's will be a sizable chunk available when the it's requested via http_request_buffer_chunk.
@ -45,24 +45,24 @@ void http_request_buffer_print(hw_request_buffer* buffer);
*
* Returns true if the allocation succeeds, false otherwise (errno is set accordingly).
*/
bool http_request_buffer_alloc(hw_request_buffer* buf, size_t requested_size);
bool http_request_buffer_alloc(hw_request_buffer *buf, size_t requested_size);
/**
* Returns a new buffer chunk to be used by request reader.
*/
void http_request_buffer_chunk(hw_request_buffer* buffer, hw_request_buffer_chunk* chunk);
void http_request_buffer_chunk(hw_request_buffer *buffer, hw_request_buffer_chunk *chunk);
/**
* Informs the buffer manager that *pointer is a memory region of interest and that will have to be made available to
* the caller eventually, when http_request_buffer_locate is called. The pin is given a key by the caller so it can be
* retrieved later. Pins will be overwritten if the same key is used multiple times.
*/
void http_request_buffer_pin(hw_request_buffer* buffer, void* key, void* pointer);
void http_request_buffer_pin(hw_request_buffer *buffer, void *key, void *pointer);
/**
* Allows the caller to assign a new key to a pin.
*/
void http_request_buffer_reassign_pin(hw_request_buffer* buffer, void* old_key, void* new_key);
void http_request_buffer_reassign_pin(hw_request_buffer *buffer, void *old_key, void *new_key);
/**
* Returns the pointer to the memory region associated with a pin. If there isn't a pin with that key, then
@ -73,9 +73,9 @@ void http_request_buffer_reassign_pin(hw_request_buffer* buffer, void* old_key,
* sequentially. It's the responsibility of the caller to know how long that region is, by keeping track of its
* length as it's being read in.
*/
void* http_request_buffer_locate(hw_request_buffer* buffer, void* key, void* default_pointer);
void *http_request_buffer_locate(hw_request_buffer *buffer, void *key, void *default_pointer);
/**
* Destroys the buffer and any underlying buffer chunks.
*/
void http_request_buffer_destroy(hw_request_buffer* buffer);
void http_request_buffer_destroy(hw_request_buffer *buffer);

95
srcs/httpserver/src/haywire/http_response.c
View File

@ -8,11 +8,10 @@
#include "hw_string.h"
#define CRLF "\r\n"
KHASH_MAP_INIT_STR(string_hashmap, char*)
KHASH_MAP_INIT_STR(string_hashmap, char *)
hw_http_response hw_create_http_response(http_connection* connection)
{
http_response* response = malloc(sizeof(http_response));
hw_http_response hw_create_http_response(http_connection *connection) {
http_response *response = malloc(sizeof(http_response));
response->connection = connection;
response->request = connection->request;
response->http_major = 1;
@ -23,44 +22,40 @@ hw_http_response hw_create_http_response(http_connection* connection)
return response;
}
void hw_free_http_response(hw_http_response* response)
{
http_response* resp = (http_response*)response;
void hw_free_http_response(hw_http_response *response) {
http_response *resp = (http_response *)response;
free(resp);
}
void hw_set_http_version(hw_http_response* response, unsigned short major, unsigned short minor)
{
http_response* resp = (http_response*)response;
void hw_set_http_version(hw_http_response *response, unsigned short major, unsigned short minor) {
http_response *resp = (http_response *)response;
resp->http_major = major;
resp->http_minor = minor;
}
void hw_set_response_status_code(hw_http_response* response, hw_string* status_code)
{
http_response* resp = (http_response*)response;
void hw_set_response_status_code(hw_http_response *response, hw_string *status_code) {
http_response *resp = (http_response *)response;
resp->status_code = *status_code;
}
void hw_set_response_header(hw_http_response* response, hw_string* name, hw_string* value)
{
http_response* resp = (http_response*)response;
http_header* header = &resp->headers[resp->number_of_headers];
void hw_set_response_header(hw_http_response *response, hw_string *name, hw_string *value) {
http_response *resp = (http_response *)response;
http_header *header = &resp->headers[resp->number_of_headers];
header->name = *name;
header->value = *value;
resp->headers[resp->number_of_headers] = *header;
resp->number_of_headers++;
}
void hw_set_body(hw_http_response* response, hw_string* body)
{
http_response* resp = (http_response*)response;
void hw_set_body(hw_http_response *response, hw_string *body) {
http_response *resp = (http_response *)response;
resp->body = *body;
}
int num_chars(int n) {
int r = 1;
if (n < 0) n = (n == INT_MIN) ? INT_MAX : -n;
if (n < 0)
n = (n == INT_MIN) ? INT_MAX : -n;
while (n > 9) {
n /= 10;
r++;
@ -68,11 +63,10 @@ int num_chars(int n) {
return r;
}
hw_string* create_response_buffer(hw_http_response* response)
{
http_response* resp = (http_response*)response;
hw_string* response_string = malloc(sizeof(hw_string));
hw_string* cached_entry = get_cached_request(resp->status_code.value);
hw_string *create_response_buffer(hw_http_response *response) {
http_response *resp = (http_response *)response;
hw_string *response_string = malloc(sizeof(hw_string));
hw_string *cached_entry = get_cached_request(resp->status_code.value);
hw_string content_length;
int i = 0;
@ -83,20 +77,20 @@ hw_string* create_response_buffer(hw_http_response* response)
int header_buffer_incr = 512;
int body_size = resp->body.length;
int header_size_remaining = header_buffer_incr;
int response_size = header_size_remaining + sizeof(length_header) + num_chars(resp->body.length) + 2 * line_sep_size + body_size + line_sep_size;
int response_size = header_size_remaining + sizeof(length_header) + num_chars(resp->body.length) + 2 * line_sep_size
+ body_size + line_sep_size;
response_string->value = malloc(response_size);
response_string->length = 0;
append_string(response_string, cached_entry);
for (i=0; i< resp->number_of_headers; i++)
{
for (i = 0; i < resp->number_of_headers; i++) {
http_header header = resp->headers[i];
header_size_remaining -= header.name.length + 2 + header.value.length + line_sep_size;
if (header_size_remaining < 0) {
header_size_remaining += header_buffer_incr * ((-header_size_remaining/header_buffer_incr) + 1);
header_size_remaining += header_buffer_incr * ((-header_size_remaining / header_buffer_incr) + 1);
response_size += header_size_remaining;
response_string->value = realloc(response_string->value, response_size);
}
@ -114,8 +108,7 @@ hw_string* create_response_buffer(hw_http_response* response)
if (body_size > 0) {
append_string(response_string, &content_length);
}
else {
} else {
hw_string zero_content;
zero_content.value = "0";
zero_content.length = 1;
@ -124,20 +117,17 @@ hw_string* create_response_buffer(hw_http_response* response)
APPENDSTRING(response_string, CRLF CRLF);
if (body_size > 0)
{
if (body_size > 0) {
append_string(response_string, &resp->body);
}
return response_string;
}
void hw_http_response_send(hw_http_response* response, void* user_data, http_response_complete_callback callback)
{
hw_write_context* write_context = malloc(sizeof(hw_write_context));
http_response* resp = (http_response*)response;
hw_string* response_buffer = create_response_buffer(response);
void hw_http_response_send(hw_http_response *response, void *user_data, http_response_complete_callback callback) {
hw_write_context *write_context = malloc(sizeof(hw_write_context));
http_response *resp = (http_response *)response;
hw_string *response_buffer = create_response_buffer(response);
write_context->connection = resp->connection;
write_context->user_data = user_data;
@ -150,3 +140,28 @@ void hw_http_response_send(hw_http_response* response, void* user_data, http_res
free(response_buffer);
hw_free_http_response(response);
}
void hw_http_response_send_error(hw_http_response *response, const char *error, const char *err_msg) {
hw_string status_code;
hw_string content_type_name;
hw_string content_type_value;
hw_string body;
hw_string keep_alive_name;
hw_string keep_alive_value;
SETSTRING(content_type_name, "Content-Type");
SETSTRING(content_type_value, "text/html");
hw_set_response_header(response, &content_type_name, &content_type_value);
SETSTRING(status_code, error);
SETSTRING(body, err_msg);
hw_set_body(response, &body);
hw_set_response_status_code(response, &status_code);
SETSTRING(keep_alive_name, "Connection");
SETSTRING(keep_alive_value, "close");
hw_set_response_header(response, &keep_alive_name, &keep_alive_value);
hw_http_response_send(response, NULL, NULL);
}

23
srcs/httpserver/src/haywire/http_response.h
View File

@ -2,17 +2,15 @@
#include "haywire.h"
#include "http_connection.h"
typedef struct
{
typedef struct {
hw_string name;
hw_string value;
} http_header;
#define MAX_HEADERS 64
typedef struct
{
http_connection* connection;
http_request* request;
typedef struct {
http_connection *connection;
http_request *request;
unsigned short http_major;
unsigned short http_minor;
hw_string status_code;
@ -22,13 +20,12 @@ typedef struct
int sent;
} http_response;
typedef struct
{
http_connection* connection;
http_request* request;
void* user_data;
typedef struct {
http_connection *connection;
http_request *request;
void *user_data;
http_response_complete_callback callback;
} hw_write_context;
hw_http_response hw_create_http_response(http_connection* connection);
hw_string* create_response_buffer(hw_http_response* response);
hw_http_response hw_create_http_response(http_connection *connection);
hw_string *create_response_buffer(hw_http_response *response);

84
srcs/httpserver/src/haywire/http_response_cache.c
View File

@ -11,52 +11,45 @@
#include "http_server.h"
#define CRLF "\r\n"
KHASH_MAP_INIT_STR(string_hashmap, hw_string*)
KHASH_MAP_INIT_STR(string_hashmap, hw_string *)
static uv_timer_t cache_invalidation_timer;
static uv_key_t thread_cache_key;
void initialize_http_request_cache();
void free_http_request_cache();
void http_request_cache_timer(uv_timer_t* handle);
void create_cached_http_request(khash_t(string_hashmap)* http_request_cache, const char* http_status);
void set_cached_request(khash_t(string_hashmap)* http_request_cache, char* http_status, hw_string* cache_entry);
hw_string* get_cached_request(const char* http_status);
void http_request_cache_timer(uv_timer_t *handle);
void create_cached_http_request(khash_t(string_hashmap) * http_request_cache, const char *http_status);
void set_cached_request(khash_t(string_hashmap) * http_request_cache, char *http_status, hw_string *cache_entry);
hw_string *get_cached_request(const char *http_status);
void initialize_http_request_cache()
{
void initialize_http_request_cache() {
uv_key_create(&thread_cache_key);
}
void http_request_cache_configure_listener(uv_loop_t* loop, uv_async_t* handle)
{
uv_timer_t* cache_invalidation_timer = malloc(sizeof(uv_timer_t));
void http_request_cache_configure_listener(uv_loop_t *loop, uv_async_t *handle) {
uv_timer_t *cache_invalidation_timer = malloc(sizeof(uv_timer_t));
uv_timer_init(loop, cache_invalidation_timer);
uv_timer_start(cache_invalidation_timer, http_request_cache_timer, 500, 500);
if (handle != NULL)
{
uv_unref((uv_handle_t*) cache_invalidation_timer);
if (handle != NULL) {
uv_unref((uv_handle_t *)cache_invalidation_timer);
}
}
void http_request_cache_timer(uv_timer_t* timer)
{
khash_t(string_hashmap)* http_request_cache = uv_key_get(&thread_cache_key);
if (http_request_cache != NULL)
{
void http_request_cache_timer(uv_timer_t *timer) {
khash_t(string_hashmap) *http_request_cache = uv_key_get(&thread_cache_key);
if (http_request_cache != NULL) {
free_http_request_cache(http_request_cache);
}
}
void free_http_request_cache(khash_t(string_hashmap)* http_request_cache)
{
const char* k;
hw_string* v;
void free_http_request_cache(khash_t(string_hashmap) * http_request_cache) {
const char *k;
hw_string *v;
kh_foreach(http_request_cache, k, v,
{
free((char*)k);
kh_foreach(http_request_cache, k, v, {
free((char *)k);
free(v->value);
free(v);
});
@ -65,9 +58,8 @@ void free_http_request_cache(khash_t(string_hashmap)* http_request_cache)
uv_key_set(&thread_cache_key, NULL);
}
void create_cached_http_request(khash_t(string_hashmap)* http_request_cache, const char* http_status)
{
hw_string* cache_entry = malloc(sizeof(hw_string));
void create_cached_http_request(khash_t(string_hashmap) * http_request_cache, const char *http_status) {
hw_string *cache_entry = malloc(sizeof(hw_string));
cache_entry->value = calloc(1024, 1);
cache_entry->length = 0;
hw_string status;
@ -83,7 +75,7 @@ void create_cached_http_request(khash_t(string_hashmap)* http_request_cache, con
// Add the current time.
time_t curtime;
time(&curtime);
char* current_time = ctime(&curtime);
char *current_time = ctime(&curtime);
hw_string current_datetime;
current_datetime.value = current_time;
current_datetime.length = strlen(current_time);
@ -93,60 +85,48 @@ void create_cached_http_request(khash_t(string_hashmap)* http_request_cache, con
set_cached_request(http_request_cache, http_status, cache_entry);
}
void set_cached_request(khash_t(string_hashmap)* http_request_cache, char* http_status, hw_string* cache_entry)
{
void set_cached_request(khash_t(string_hashmap) * http_request_cache, char *http_status, hw_string *cache_entry) {
int ret;
khiter_t key;
key = kh_get(string_hashmap, http_request_cache, http_status);
if (key == kh_end(http_request_cache))
{
if (key == kh_end(http_request_cache)) {
key = kh_put(string_hashmap, http_request_cache, dupstr(http_status), &ret);
kh_value(http_request_cache, key) = cache_entry;
}
}
hw_string* get_cached_request(const char* http_status)
{
hw_string *get_cached_request(const char *http_status) {
int is_missing = 0;
void* val;
khash_t(string_hashmap)* http_request_cache;
void *val;
khash_t(string_hashmap) * http_request_cache;
khiter_t key = 0;
/* This thread hasn't created a response cache so create one */
http_request_cache = uv_key_get(&thread_cache_key);
if (http_request_cache == NULL)
{
if (http_request_cache == NULL) {
http_request_cache = kh_init(string_hashmap);
uv_key_set(&thread_cache_key, http_request_cache);
}
key = kh_get(string_hashmap, http_request_cache, http_status);
if (key == kh_end(http_request_cache))
{
if (key == kh_end(http_request_cache)) {
create_cached_http_request(http_request_cache, http_status);
}
else
{
} else {
val = kh_value(http_request_cache, key);
}
key = kh_get(string_hashmap, http_request_cache, http_status);
if (key == kh_end(http_request_cache))
{
if (key == kh_end(http_request_cache)) {
is_missing = 1;
}
else
{
} else {
val = kh_value(http_request_cache, key);
is_missing = 0;
}
if (is_missing)
{
if (is_missing) {
return NULL;
}
return val;
}

4
srcs/httpserver/src/haywire/http_response_cache.h
View File

@ -3,5 +3,5 @@
#include "haywire.h"
void initialize_http_request_cache();
hw_string* get_cached_request(const char* http_status);
void http_request_cache_configure_listener(uv_loop_t* loop, uv_async_t* handle);
hw_string *get_cached_request(const char *http_status);
void http_request_cache_configure_listener(uv_loop_t *loop, uv_async_t *handle);

289
srcs/httpserver/src/haywire/http_server.c
View File

@ -1,6 +1,6 @@
#ifdef PLATFORM_POSIX
#include <signal.h>
#endif // PLATFORM_POSIX
#endif// PLATFORM_POSIX
#include <stdio.h>
#include <stdlib.h>
@ -19,35 +19,37 @@
#include "configuration/configuration.h"
#include "http_connection.h"
#include "http_request.h"
#include "misc.h"
#define UVERR(err, msg) dzlog_error("%s: %s\n", msg, uv_strerror(err))
//fprintf(stderr, "%s: %s\n", msg, uv_strerror(err))
//fprintf(stderr, "%s: %s\n", msg, uv_strerror(err))
#if 0
#define CHECK(r, msg) \
if (r) { \
uv_err_t err = uv_last_error(uv_loop); \
UVERR(err, msg); \
exit(1); \
}
if (r) { \
uv_err_t err = uv_last_error(uv_loop); \
UVERR(err, msg); \
exit(1); \
}
#endif
KHASH_MAP_INIT_STR(string_hashmap, hw_route_entry*)
KHASH_MAP_INIT_STR(string_hashmap, hw_route_entry *)
configuration* config;
configuration *config;
static uv_tcp_t server;
static http_parser_settings parser_settings;
static struct sockaddr_in listen_address;
uv_loop_t* uv_loop;
void* routes;
hw_string* http_v1_0;
hw_string* http_v1_1;
hw_string* server_name;
uv_loop_t *uv_loop;
void *routes;
//hw_string* http_v1_0;
hw_string *http_v1_1;
hw_string *server_name;
int listener_count;
uv_async_t* listener_async_handles;
uv_loop_t* listener_event_loops;
uv_barrier_t* listeners_created_barrier;
uv_async_t *listener_async_handles;
//uv_loop_t* listener_event_loops;
uv_barrier_t *listeners_created_barrier;
int hw_init_with_config(configuration* c)
{
int hw_init_with_config(configuration *c) {
#ifdef DEBUG
char route[] = "/stats";
hw_http_add_route(route, get_server_stats, NULL);
@ -58,7 +60,7 @@ int hw_init_with_config(configuration* c)
config->http_listen_port = c->http_listen_port;
config->thread_count = c->thread_count;
config->tcp_nodelay = c->tcp_nodelay;
config->listen_backlog = c->listen_backlog? c->listen_backlog : SOMAXCONN;
config->listen_backlog = c->listen_backlog ? c->listen_backlog : SOMAXCONN;
config->parser = dupstr(c->parser);
config->balancer = dupstr(c->balancer);
config->max_request_size = c->max_request_size;
@ -67,26 +69,22 @@ int hw_init_with_config(configuration* c)
http_v1_1 = create_string("HTTP/1.1 ");
server_name = create_string("Server: Haywire/master");
if (strcmp(config->parser, "http_parser") == 0)
{
if (strcmp(config->parser, "http_parser") == 0) {
http_stream_on_read = &http_stream_on_read_http_parser;
}
http_server_write_response = &http_server_write_response_single;
return 0;
}
int hw_init_from_config(char* configuration_filename)
{
configuration* config = load_configuration(configuration_filename);
if (config == NULL)
{
int hw_init_from_config(char *configuration_filename) {
configuration *config = load_configuration(configuration_filename);
if (config == NULL) {
return 1;
}
return hw_init_with_config(config);
}
void print_configuration()
{
void print_configuration() {
#if 0
dzlog_debug("Address: %s\n\tPort: %d\n\tThreads: %d\n\tBalancer: %s\n\t"
"Parser: %s\n\tTCP No Delay: %s\n\tListen backlog: %d\n\tMaximum request size: %d\n",
@ -101,18 +99,15 @@ void print_configuration()
#endif
}
http_connection* create_http_connection()
{
http_connection* connection = calloc(1, sizeof(http_connection));
http_connection *create_http_connection() {
http_connection *connection = calloc(1, sizeof(http_connection));
connection->buffer = http_request_buffer_init(config->max_request_size);
INCREMENT_STAT(stat_connections_created_total);
return connection;
}
void free_http_connection(http_connection* connection)
{
if (connection->request)
{
void free_http_connection(http_connection *connection) {
if (connection->request) {
free_http_request(connection->request);
}
http_request_buffer_destroy(connection->buffer);
@ -120,8 +115,7 @@ void free_http_connection(http_connection* connection)
INCREMENT_STAT(stat_connections_destroyed_total);
}
void set_route(void* hashmap, char* name, hw_route_entry* route_entry)
{
void set_route(void *hashmap, char *name, hw_route_entry *route_entry) {
int ret;
khiter_t k;
khash_t(string_hashmap) *h = hashmap;
@ -129,37 +123,35 @@ void set_route(void* hashmap, char* name, hw_route_entry* route_entry)
kh_value(h, k) = route_entry;
}
void hw_http_add_route(char *route, http_request_callback callback, void* user_data)
{
hw_route_entry* route_entry = malloc(sizeof(hw_route_entry));
void hw_http_add_route(char *route, http_request_callback callback, void *user_data) {
hw_route_entry *route_entry = malloc(sizeof(hw_route_entry));
route_entry->callback = callback;
route_entry->user_data = user_data;
if (routes == NULL)
{
if (routes == NULL) {
routes = kh_init(string_hashmap);
}
set_route(routes, route, route_entry);
dzlog_debug("Added route %s\n", route); // TODO: Replace with logging instead.
dzlog_debug("Added route %s\n", route);// TODO: Replace with logging instead.
}
void free_http_server()
{
void free_http_server() {
/* TODO: Shut down accepting incoming requests */
khash_t(string_hashmap) *h = routes;
const char* k;
const char* v;
kh_foreach(h, k, v, { free((char*)k); free((char*)v); });
const char *k;
const char *v;
kh_foreach(h, k, v, {
free((char *)k);
free((char *)v);
});
kh_destroy(string_hashmap, routes);
}
int hw_http_open()
{
int threads = config->thread_count;
uv_async_t* service_handle = 0;
int hw_http_open() {
int threads = (int)config->thread_count;
uv_async_t *service_handle;
if (routes == NULL)
{
if (routes == NULL) {
routes = kh_init(string_hashmap);
}
@ -173,7 +165,7 @@ int hw_http_open()
#ifdef UNIX
signal(SIGPIPE, SIG_IGN);
#endif // UNIX
#endif// UNIX
listener_count = threads;
@ -189,30 +181,25 @@ int hw_http_open()
service_handle = malloc(sizeof(uv_async_t));
uv_async_init(uv_loop, service_handle, NULL);
if (listener_count == 0)
{
if (listener_count == 0) {
/* If running single threaded there is no need to use the IPC pipe
to distribute requests between threads so lets avoid the IPC overhead */
to distribute requests between threads so let's avoid the IPC overhead */
int rc;
rc = uv_tcp_init_ex(uv_loop, &server, AF_INET);
if (rc != 0)
{
if (rc != 0) {
dzlog_warn("TWO %d\n", rc);
}
if (strcmp(config->balancer, "reuseport") == 0)
{
if (strcmp(config->balancer, "reuseport") == 0) {
uv_os_fd_t fd;
int on = 1;
rc = uv_fileno(&server, &fd);
if (rc != 0)
{
if (rc != 0) {
dzlog_warn("ONE %d\n", rc);
}
rc = setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (char*)&on, sizeof(on));
if (rc != 0)
{
rc = setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (char *)&on, sizeof(on));
if (rc != 0) {
dzlog_warn("THREE %d\n", errno);
}
}
@ -220,52 +207,52 @@ int hw_http_open()
initialize_http_request_cache();
http_request_cache_configure_listener(uv_loop, NULL);
uv_ip4_addr(config->http_listen_address, config->http_listen_port, &listen_address);
uv_tcp_bind(&server, (const struct sockaddr*)&listen_address, 0);
uv_ip4_addr(config->http_listen_address, (int)config->http_listen_port, &listen_address);
uv_tcp_bind(&server, (const struct sockaddr *)&listen_address, 0);
if (config->tcp_nodelay) {
uv_tcp_nodelay(&server, 1);
}
uv_listen((uv_stream_t*)&server, config->listen_backlog, http_stream_on_connect);
uv_listen((uv_stream_t *)&server, (int)config->listen_backlog, http_stream_on_connect);
print_configuration();
dzlog_debug("Listening...\n");
//uv_run(uv_loop, UV_RUN_DEFAULT);
}
else if (listener_count > 0 && strcmp(config->balancer, "ipc") == 0)
{
int i = 0;
} else if (listener_count > 0 && strcmp(config->balancer, "ipc") == 0) {
int i;
/* If we are running multi-threaded spin up the dispatcher that uses
/* If we are running multithreaded spin up the dispatcher that uses
an IPC pipe to send socket connection requests to listening threads */
struct server_ctx* servers;
struct server_ctx *servers;
servers = calloc(threads, sizeof(servers[0]));
for (i = 0; i < threads; i++)
{
int rc = 0;
struct server_ctx* ctx = servers + i;
for (i = 0; i < threads; i++) {
//int rc;
struct server_ctx *ctx = servers + i;
ctx->index = i;
ctx->listen_backlog = config->listen_backlog;
rc = uv_sem_init(&ctx->semaphore, 0);
rc = uv_thread_create(&ctx->thread_id, connection_consumer_start, ctx);
uv_sem_init(&ctx->semaphore, 0);
uv_thread_create(&ctx->thread_id, connection_consumer_start, ctx);
}
uv_barrier_wait(listeners_created_barrier);
initialize_http_request_cache();
start_connection_dispatching(UV_TCP, threads, servers, config->http_listen_address, config->http_listen_port, config->tcp_nodelay, config->listen_backlog);
}
else if (listener_count > 0 && strcmp(config->balancer, "reuseport") == 0)
{
struct server_ctx* servers;
start_connection_dispatching(UV_TCP,
threads,
servers,
config->http_listen_address,
(int)config->http_listen_port,
config->tcp_nodelay,
(int)config->listen_backlog);
} else if (listener_count > 0 && strcmp(config->balancer, "reuseport") == 0) {
struct server_ctx *servers;
servers = calloc(threads, sizeof(servers[0]));
for (int i = 0; i < threads; i++)
{
struct server_ctx* ctx = servers + i;
for (int i = 0; i < threads; i++) {
struct server_ctx *ctx = servers + i;
ctx->index = i;
int rc = uv_thread_create(&ctx->thread_id, reuseport_thread_start, ctx);
uv_thread_create(&ctx->thread_id, reuseport_thread_start, ctx);
}
print_configuration();
@ -276,12 +263,10 @@ int hw_http_open()
return 0;
}
void reuseport_thread_start(void *arg)
{
void reuseport_thread_start(void *arg) {
int rc;
struct server_ctx* ctx;
uv_loop_t* loop;
uv_tcp_t svr;
struct server_ctx *ctx;
uv_loop_t *loop;
ctx = arg;
loop = uv_loop_new();
@ -293,28 +278,26 @@ void reuseport_thread_start(void *arg)
struct sockaddr_in addr;
uv_tcp_t server;
rc = uv_tcp_init_ex(loop, &server, AF_INET);
uv_ip4_addr(config->http_listen_address, config->http_listen_port, &addr);
uv_tcp_init_ex(loop, &server, AF_INET);
uv_ip4_addr(config->http_listen_address, (int)config->http_listen_port, &addr);
uv_os_fd_t fd;
int on = 1;
uv_fileno(&server, &fd);
rc = setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (char*)&on, sizeof(on));
if (rc != 0)
{
rc = setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (char *)&on, sizeof(on));
if (rc != 0) {
dzlog_warn("%d\n", errno);
}
uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);
int r = uv_listen((uv_stream_t*) &server, 128, http_stream_on_connect);
uv_tcp_bind(&server, (const struct sockaddr *)&addr, 0);
uv_listen((uv_stream_t *)&server, 128, http_stream_on_connect);
rc = uv_run(loop, UV_RUN_DEFAULT);
uv_run(loop, UV_RUN_DEFAULT);
uv_loop_delete(loop);
}
void http_stream_on_connect(uv_stream_t* stream, int status)
{
http_connection* connection = create_http_connection();
void http_stream_on_connect(uv_stream_t *stream, int UNUSED(status)) {
http_connection *connection = create_http_connection();
uv_tcp_init(stream->loop, &connection->stream);
http_parser_init(&connection->parser, HTTP_REQUEST);
@ -322,14 +305,13 @@ void http_stream_on_connect(uv_stream_t* stream, int status)
connection->stream.data = connection;
/* TODO: Use the return values from uv_accept() and uv_read_start() */
uv_accept(stream, (uv_stream_t*)&connection->stream);
uv_accept(stream, (uv_stream_t *)&connection->stream);
connection->state = OPEN;
uv_read_start((uv_stream_t*)&connection->stream, http_stream_on_alloc, http_stream_on_read);
uv_read_start((uv_stream_t *)&connection->stream, http_stream_on_alloc, http_stream_on_read);
}
void http_stream_on_alloc(uv_handle_t* client, size_t suggested_size, uv_buf_t* buf)
{
http_connection* connection = (http_connection*)client->data;
void http_stream_on_alloc(uv_handle_t *client, size_t suggested_size, uv_buf_t *buf) {
http_connection *connection = (http_connection *)client->data;
bool success = http_request_buffer_alloc(connection->buffer, suggested_size);
hw_request_buffer_chunk chunk;
@ -345,28 +327,26 @@ void http_stream_on_alloc(uv_handle_t* client, size_t suggested_size, uv_buf_t*
*buf = uv_buf_init(chunk.buffer, chunk.size);
}
void http_stream_on_close(uv_handle_t* handle)
{
uv_handle_t* stream = handle;
http_connection* connection = stream->data;
void http_stream_on_close(uv_handle_t *handle) {
uv_handle_t *stream = handle;
http_connection *connection = stream->data;
if (connection->state != CLOSED) {
connection->state = CLOSED;
http_connection* connection = (http_connection*)handle->data;
http_connection *connection = (http_connection *)handle->data;
free_http_connection(connection);
}
}
void http_stream_close_connection(http_connection* connection) {
void http_stream_close_connection(http_connection *connection) {
if (connection->state == OPEN) {
connection->state = CLOSING;
uv_close(&connection->stream, http_stream_on_close);
}
}
void handle_request_error(http_connection* connection)
{
uv_handle_t* stream = &connection->stream;
void handle_request_error(http_connection *connection) {
uv_handle_t *stream = &connection->stream;
if (connection->state == OPEN) {
uv_read_stop(stream);
@ -384,8 +364,7 @@ void handle_request_error(http_connection* connection)
}
}
void handle_bad_request(http_connection* connection)
{
void handle_bad_request(http_connection *connection) {
if (connection->request) {
connection->request->state = BAD_REQUEST;
}
@ -393,8 +372,7 @@ void handle_bad_request(http_connection* connection)
handle_request_error(connection);
}
void handle_buffer_exceeded_error(http_connection* connection)
{
void handle_buffer_exceeded_error(http_connection *connection) {
if (connection->request) {
connection->request->state = SIZE_EXCEEDED;
}
@ -402,8 +380,7 @@ void handle_buffer_exceeded_error(http_connection* connection)
handle_request_error(connection);
}
void handle_internal_error(http_connection* connection)
{
void handle_internal_error(http_connection *connection) {
if (connection->request) {
connection->request->state = INTERNAL_ERROR;
}
@ -411,25 +388,23 @@ void handle_internal_error(http_connection* connection)
handle_request_error(connection);
}
void http_stream_on_shutdown(uv_shutdown_t* req, int status)
{
http_connection* connection = req->data;
uv_handle_t* stream = &connection->stream;
void http_stream_on_shutdown(uv_shutdown_t *req, int UNUSED(status)) {
http_connection *connection = req->data;
// uv_handle_t *stream = &connection->stream;
if (connection->state == OPEN) {
http_stream_close_connection(connection);
}
free(req);
}
void http_stream_on_read_http_parser(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf)
{
http_connection* connection = (http_connection*)tcp->data;
void http_stream_on_read_http_parser(uv_stream_t *tcp, ssize_t nread, const uv_buf_t *buf) {
http_connection *connection = (http_connection *)tcp->data;
if (nread > 0) {
/* Need to tell the buffer that we care about the next nread bytes */
http_request_buffer_consume(connection->buffer, nread);
http_parser_execute(&connection->parser, &parser_settings, (const char*) buf->base, nread);
http_parser_execute(&connection->parser, &parser_settings, (const char *)buf->base, nread);
if (connection->parser.http_errno) {
handle_bad_request(connection);
@ -443,16 +418,13 @@ void http_stream_on_read_http_parser(uv_stream_t* tcp, ssize_t nread, const uv_b
}
} else if (nread == 0) {
/* no-op - there's no data to be read, but there might be later */
}
else if (nread == UV_ENOBUFS) {
} else if (nread == UV_ENOBUFS) {
handle_buffer_exceeded_error(connection);
}
else if (nread == UV_EOF){
uv_shutdown_t* req = malloc(sizeof(uv_shutdown_t));
} else if (nread == UV_EOF) {
uv_shutdown_t *req = malloc(sizeof(uv_shutdown_t));
req->data = connection;
uv_shutdown(req, &connection->stream, http_stream_on_shutdown);
}
else if (nread == UV_ECONNRESET || nread == UV_ECONNABORTED) {
} else if (nread == UV_ECONNRESET || nread == UV_ECONNABORTED) {
/* Let's close the connection as the other peer just disappeared */
http_stream_close_connection(connection);
} else {
@ -462,30 +434,28 @@ void http_stream_on_read_http_parser(uv_stream_t* tcp, ssize_t nread, const uv_b
}
}
void http_server_cleanup_write(char* response_string, hw_write_context* write_context, uv_write_t* write_req)
{
void http_server_cleanup_write(char *response_string, hw_write_context *write_context, uv_write_t *write_req) {
free(response_string);
free(write_context);
free(write_req);
}
int http_server_write_response_single(hw_write_context* write_context, hw_string* response)
{
http_connection* connection = write_context->connection;
int http_server_write_response_single(hw_write_context *write_context, hw_string *response) {
http_connection *connection = write_context->connection;
if (connection->state == OPEN) {
uv_write_t *write_req = (uv_write_t *) malloc(sizeof(*write_req) + sizeof(uv_buf_t));
uv_buf_t *resbuf = (uv_buf_t *) (write_req + 1);
uv_write_t *write_req = (uv_write_t *)malloc(sizeof(*write_req) + sizeof(uv_buf_t));
uv_buf_t *resbuf = (uv_buf_t *)(write_req + 1);
resbuf->base = response->value;
resbuf->len = response->length;
write_req->data = write_context;
uv_stream_t *stream = (uv_stream_t *) &write_context->connection->stream;
uv_stream_t *stream = (uv_stream_t *)&write_context->connection->stream;
if (uv_is_writable(stream)) {
/* Ensuring that the the response can still be written. */
/* Ensuring that the response can still be written. */
uv_write(write_req, stream, resbuf, 1, http_server_after_write);
/* TODO: Use the return values from uv_write() */
} else {
@ -497,23 +467,20 @@ int http_server_write_response_single(hw_write_context* write_context, hw_string
return 0;
}
void http_server_after_write(uv_write_t* req, int status)
{
hw_write_context* write_context = (hw_write_context*)req->data;
uv_buf_t *resbuf = (uv_buf_t *)(req+1);
uv_handle_t* stream = (uv_handle_t*) req->handle;
void http_server_after_write(uv_write_t *req, int UNUSED(status)) {
hw_write_context *write_context = (hw_write_context *)req->data;
uv_buf_t *resbuf = (uv_buf_t *)(req + 1);
//uv_handle_t *stream = (uv_handle_t *)req->handle;
http_connection* connection = write_context->connection;
http_connection *connection = write_context->connection;
if (!connection->keep_alive && connection->state == OPEN) {
http_stream_close_connection(connection);
}
if (write_context->callback)
{
if (write_context->callback) {
write_context->callback(write_context->user_data);
}
http_server_cleanup_write(resbuf->base, write_context, req);
}

42
srcs/httpserver/src/haywire/http_server.h
View File

@ -5,36 +5,34 @@
#include "http_parser.h"
#include "http_response.h"
typedef struct
{
typedef struct {
http_request_callback callback;
void* user_data;
void *user_data;
} hw_route_entry;
union stream_handle
{
union stream_handle {
uv_pipe_t pipe;
uv_tcp_t tcp;
};
extern void* routes;
extern uv_loop_t* uv_loop;
extern hw_string* http_v1_0;
extern hw_string* http_v1_1;
extern hw_string* server_name;
extern void *routes;
extern uv_loop_t *uv_loop;
extern hw_string *http_v1_0;
extern hw_string *http_v1_1;
extern hw_string *server_name;
extern int listener_count;
extern uv_async_t* listener_async_handles;
extern uv_loop_t* listener_event_loops;
extern uv_barrier_t* listeners_created_barrier;
extern uv_async_t *listener_async_handles;
extern uv_loop_t *listener_event_loops;
extern uv_barrier_t *listeners_created_barrier;
void (*http_stream_on_read)(uv_stream_t*, ssize_t, const uv_buf_t*);
int (*http_server_write_response)(hw_write_context*, hw_string*);
void (*http_stream_on_read)(uv_stream_t *, ssize_t, const uv_buf_t *);
int (*http_server_write_response)(hw_write_context *, hw_string *);
http_connection* create_http_connection();
void http_stream_on_connect(uv_stream_t* stream, int status);
void http_stream_on_alloc(uv_handle_t* client, size_t suggested_size, uv_buf_t* buf);
void http_stream_on_close(uv_handle_t* handle);
int http_server_write_response_single(hw_write_context* write_context, hw_string* response);
void http_server_after_write(uv_write_t* req, int status);
void http_stream_on_read_http_parser(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf);
http_connection *create_http_connection();
void http_stream_on_connect(uv_stream_t *stream, int status);
void http_stream_on_alloc(uv_handle_t *client, size_t suggested_size, uv_buf_t *buf);
void http_stream_on_close(uv_handle_t *handle);
int http_server_write_response_single(hw_write_context *write_context, hw_string *response);
void http_server_after_write(uv_write_t *req, int status);
void http_stream_on_read_http_parser(uv_stream_t *tcp, ssize_t nread, const uv_buf_t *buf);
void reuseport_thread_start(void *arg);

33
srcs/httpserver/src/haywire/hw_string.c
View File

@ -3,25 +3,23 @@
#include <string.h>
#include "haywire.h"
hw_string* create_string(const char* value)
{
hw_string *create_string(const char *value) {
int length = (int)strlen(value);
hw_string* str = malloc(sizeof(hw_string));
hw_string *str = malloc(sizeof(hw_string));
str->value = malloc(length);
memcpy(str->value, value, length);
str->length = length;
return str;
}
hw_string* hw_strdup(hw_string* tocopy)
{
hw_string* str = malloc(sizeof(hw_string));
hw_string *hw_strdup(hw_string *tocopy) {
hw_string *str = malloc(sizeof(hw_string));
str->value = tocopy->value;
str->length = tocopy->length;
return str;
}
int hw_strcmp(hw_string* a, hw_string* b) {
int hw_strcmp(hw_string *a, hw_string *b) {
int ret;
if (a->length > b->length) {
@ -41,36 +39,31 @@ int hw_strcmp(hw_string* a, hw_string* b) {
return ret;
}
void append_string(hw_string* destination, hw_string* source)
{
void* location = (void*) (destination->value + destination->length);
void append_string(hw_string *destination, hw_string *source) {
void *location = (void *)(destination->value + destination->length);
memcpy(location, source->value, source->length);
destination->length += source->length;
}
/* Added because of http://stackoverflow.com/questions/8359966/strdup-returning-address-out-of-bounds */
char* dupstr(const char *s)
{
char* result = malloc(strlen(s) + 1);
if (result != NULL)
{
char *dupstr(const char *s) {
char *result = malloc(strlen(s) + 1);
if (result != NULL) {
strcpy(result, s);
}
return result;
}
void string_from_int(hw_string* str, int val, int base)
{
void string_from_int(hw_string *str, int val, int base) {
static char buf[32] = {0};
int i = 30;
int length = 0;
for(; val && i ; --i, val /= base)
{
for (; val && i; --i, val /= base) {
buf[i] = "0123456789abcdef"[val % base];
length++;
}
str->value = &buf[i+1];
str->value = &buf[i + 1];
str->length = length;
}

14
srcs/httpserver/src/haywire/hw_string.h
View File

@ -1,9 +1,9 @@
#pragma once
hw_string* create_string(const char* value);
int hw_strcmp(hw_string* a, hw_string* b);
hw_string* hw_strdup(hw_string* tocopy);
void append_string(hw_string* destination, hw_string* source);
char* dupstr(const char *s);
void string_from_int(hw_string* str, int val, int base);
int hw_strcmp(hw_string* a, hw_string* b);
hw_string *create_string(const char *value);
int hw_strcmp(hw_string *a, hw_string *b);
hw_string *hw_strdup(hw_string *tocopy);
void append_string(hw_string *destination, hw_string *source);
char *dupstr(const char *s);
void string_from_int(hw_string *str, int val, int base);
int hw_strcmp(hw_string *a, hw_string *b);

441
srcs/httpserver/src/haywire/khash.h
View File

@ -113,7 +113,6 @@
* Added destructor
*/
#ifndef __AC_KHASH_H
#define __AC_KHASH_H
@ -152,28 +151,29 @@ typedef unsigned long long khint64_t;
typedef khint32_t khint_t;
typedef khint_t khiter_t;
#define __ac_isempty(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2)
#define __ac_isdel(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&1)
#define __ac_iseither(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&3)
#define __ac_set_isdel_false(flag, i) (flag[i>>4]&=~(1ul<<((i&0xfU)<<1)))
#define __ac_set_isempty_false(flag, i) (flag[i>>4]&=~(2ul<<((i&0xfU)<<1)))
#define __ac_set_isboth_false(flag, i) (flag[i>>4]&=~(3ul<<((i&0xfU)<<1)))
#define __ac_set_isdel_true(flag, i) (flag[i>>4]|=1ul<<((i&0xfU)<<1))
#define __ac_isempty(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 2)
#define __ac_isdel(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 1)
#define __ac_iseither(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 3)
#define __ac_set_isdel_false(flag, i) (flag[i >> 4] &= ~(1ul << ((i & 0xfU) << 1)))
#define __ac_set_isempty_false(flag, i) (flag[i >> 4] &= ~(2ul << ((i & 0xfU) << 1)))
#define __ac_set_isboth_false(flag, i) (flag[i >> 4] &= ~(3ul << ((i & 0xfU) << 1)))
#define __ac_set_isdel_true(flag, i) (flag[i >> 4] |= 1ul << ((i & 0xfU) << 1))
#define __ac_fsize(m) ((m) < 16? 1 : (m)>>4)
#define __ac_fsize(m) ((m) < 16 ? 1 : (m) >> 4)
#ifndef kroundup32
#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
#define kroundup32(x) \
(--(x), (x) |= (x) >> 1, (x) |= (x) >> 2, (x) |= (x) >> 4, (x) |= (x) >> 8, (x) |= (x) >> 16, ++(x))
#endif
#ifndef kcalloc
#define kcalloc(N,Z) calloc(N,Z)
#define kcalloc(N, Z) calloc(N, Z)
#endif
#ifndef kmalloc
#define kmalloc(Z) malloc(Z)
#endif
#ifndef krealloc
#define krealloc(P,Z) realloc(P,Z)
#define krealloc(P, Z) realloc(P, Z)
#endif
#ifndef kfree
#define kfree(P) free(P)
@ -182,178 +182,207 @@ typedef khint_t khiter_t;
static const double __ac_HASH_UPPER = 0.77;
#define __KHASH_TYPE(name, khkey_t, khval_t) \
typedef struct { \
khint_t n_buckets, size, n_occupied, upper_bound; \
khint32_t *flags; \
khkey_t *keys; \
khval_t *vals; \
} kh_##name##_t;
typedef struct { \
khint_t n_buckets, size, n_occupied, upper_bound; \
khint32_t *flags; \
khkey_t *keys; \
khval_t *vals; \
} kh_##name##_t;
#define __KHASH_PROTOTYPES(name, khkey_t, khval_t) \
extern kh_##name##_t *kh_init_##name(void); \
extern void kh_destroy_##name(kh_##name##_t *h); \
extern void kh_clear_##name(kh_##name##_t *h); \
extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key); \
extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \
extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \
extern void kh_del_##name(kh_##name##_t *h, khint_t x);
extern kh_##name##_t *kh_init_##name(void); \
extern void kh_destroy_##name(kh_##name##_t *h); \
extern void kh_clear_##name(kh_##name##_t *h); \
extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key); \
extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \
extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \
extern void kh_del_##name(kh_##name##_t *h, khint_t x);
#define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
SCOPE kh_##name##_t *kh_init_##name(void) { \
return (kh_##name##_t*)kcalloc(1, sizeof(kh_##name##_t)); \
} \
SCOPE void kh_destroy_##name(kh_##name##_t *h) \
{ \
if (h) { \
kfree((void *)h->keys); kfree(h->flags); \
kfree((void *)h->vals); \
kfree(h); \
} \
} \
SCOPE void kh_clear_##name(kh_##name##_t *h) \
{ \
if (h && h->flags) { \
memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t)); \
h->size = h->n_occupied = 0; \
} \
} \
SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) \
{ \
if (h->n_buckets) { \
khint_t k, i, last, mask, step = 0; \
mask = h->n_buckets - 1; \
k = __hash_func(key); i = k & mask; \
last = i; \
while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
i = (i + (++step)) & mask; \
if (i == last) return h->n_buckets; \
} \
return __ac_iseither(h->flags, i)? h->n_buckets : i; \
} else return 0; \
} \
SCOPE int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \
{ /* This function uses 0.25*n_buckets bytes of working space instead of [sizeof(key_t+val_t)+.25]*n_buckets. */ \
khint32_t *new_flags = 0; \
khint_t j = 1; \
{ \
kroundup32(new_n_buckets); \
if (new_n_buckets < 4) new_n_buckets = 4; \
if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0; /* requested size is too small */ \
else { /* hash table size to be changed (shrink or expand); rehash */ \
new_flags = (khint32_t*)kmalloc(__ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
if (!new_flags) return -1; \
memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
if (h->n_buckets < new_n_buckets) { /* expand */ \
khkey_t *new_keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
if (!new_keys) return -1; \
h->keys = new_keys; \
if (kh_is_map) { \
khval_t *new_vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
if (!new_vals) return -1; \
h->vals = new_vals; \
} \
} /* otherwise shrink */ \
} \
} \
if (j) { /* rehashing is needed */ \
for (j = 0; j != h->n_buckets; ++j) { \
if (__ac_iseither(h->flags, j) == 0) { \
khkey_t key = h->keys[j]; \
khval_t val; \
khint_t new_mask; \
new_mask = new_n_buckets - 1; \
if (kh_is_map) val = h->vals[j]; \
__ac_set_isdel_true(h->flags, j); \
while (1) { /* kick-out process; sort of like in Cuckoo hashing */ \
khint_t k, i, step = 0; \
k = __hash_func(key); \
i = k & new_mask; \
while (!__ac_isempty(new_flags, i)) i = (i + (++step)) & new_mask; \
__ac_set_isempty_false(new_flags, i); \
if (i < h->n_buckets && __ac_iseither(h->flags, i) == 0) { /* kick out the existing element */ \
{ khkey_t tmp = h->keys[i]; h->keys[i] = key; key = tmp; } \
if (kh_is_map) { khval_t tmp = h->vals[i]; h->vals[i] = val; val = tmp; } \
__ac_set_isdel_true(h->flags, i); /* mark it as deleted in the old hash table */ \
} else { /* write the element and jump out of the loop */ \
h->keys[i] = key; \
if (kh_is_map) h->vals[i] = val; \
break; \
} \
} \
} \
} \
if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \
h->keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
if (kh_is_map) h->vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
} \
kfree(h->flags); /* free the working space */ \
h->flags = new_flags; \
h->n_buckets = new_n_buckets; \
h->n_occupied = h->size; \
h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5); \
} \
return 0; \
} \
SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) \
{ \
khint_t x; \
if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \
if (h->n_buckets > (h->size<<1)) { \
if (kh_resize_##name(h, h->n_buckets - 1) < 0) { /* clear "deleted" elements */ \
*ret = -1; return h->n_buckets; \
} \
} else if (kh_resize_##name(h, h->n_buckets + 1) < 0) { /* expand the hash table */ \
*ret = -1; return h->n_buckets; \
} \
} /* TODO: to implement automatically shrinking; resize() already support shrinking */ \
{ \
khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0; \
x = site = h->n_buckets; k = __hash_func(key); i = k & mask; \
if (__ac_isempty(h->flags, i)) x = i; /* for speed up */ \
else { \
last = i; \
while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
if (__ac_isdel(h->flags, i)) site = i; \
i = (i + (++step)) & mask; \
if (i == last) { x = site; break; } \
} \
if (x == h->n_buckets) { \
if (__ac_isempty(h->flags, i) && site != h->n_buckets) x = site; \
else x = i; \
} \
} \
} \
if (__ac_isempty(h->flags, x)) { /* not present at all */ \
h->keys[x] = key; \
__ac_set_isboth_false(h->flags, x); \
++h->size; ++h->n_occupied; \
*ret = 1; \
} else if (__ac_isdel(h->flags, x)) { /* deleted */ \
h->keys[x] = key; \
__ac_set_isboth_false(h->flags, x); \
++h->size; \
*ret = 2; \
} else *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \
return x; \
} \
SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x) \
{ \
if (x != h->n_buckets && !__ac_iseither(h->flags, x)) { \
__ac_set_isdel_true(h->flags, x); \
--h->size; \
} \
}
SCOPE kh_##name##_t *kh_init_##name(void) { return (kh_##name##_t *)kcalloc(1, sizeof(kh_##name##_t)); } \
SCOPE void kh_destroy_##name(kh_##name##_t *h) { \
if (h) { \
kfree((void *)h->keys); \
kfree(h->flags); \
kfree((void *)h->vals); \
kfree(h); \
} \
} \
SCOPE void kh_clear_##name(kh_##name##_t *h) { \
if (h && h->flags) { \
memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t)); \
h->size = h->n_occupied = 0; \
} \
} \
SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) { \
if (h->n_buckets) { \
khint_t k, i, last, mask, step = 0; \
mask = h->n_buckets - 1; \
k = __hash_func(key); \
i = k & mask; \
last = i; \
while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
i = (i + (++step)) & mask; \
if (i == last) \
return h->n_buckets; \
} \
return __ac_iseither(h->flags, i) ? h->n_buckets : i; \
} else \
return 0; \
} \
SCOPE int kh_resize_##name( \
kh_##name##_t *h, \
khint_t \
new_n_buckets) { /* This function uses 0.25*n_buckets bytes of working space instead of [sizeof(key_t+val_t)+.25]*n_buckets. */ \
khint32_t *new_flags = 0; \
khint_t j = 1; \
{ \
kroundup32(new_n_buckets); \
if (new_n_buckets < 4) \
new_n_buckets = 4; \
if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) \
j = 0; /* requested size is too small */ \
else { /* hash table size to be changed (shrink or expand); rehash */ \
new_flags = (khint32_t *)kmalloc(__ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
if (!new_flags) \
return -1; \
memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
if (h->n_buckets < new_n_buckets) { /* expand */ \
khkey_t *new_keys = (khkey_t *)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
if (!new_keys) \
return -1; \
h->keys = new_keys; \
if (kh_is_map) { \
khval_t *new_vals = (khval_t *)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
if (!new_vals) \
return -1; \
h->vals = new_vals; \
} \
} /* otherwise shrink */ \
} \
} \
if (j) { /* rehashing is needed */ \
for (j = 0; j != h->n_buckets; ++j) { \
if (__ac_iseither(h->flags, j) == 0) { \
khkey_t key = h->keys[j]; \
khval_t val; \
khint_t new_mask; \
new_mask = new_n_buckets - 1; \
if (kh_is_map) \
val = h->vals[j]; \
__ac_set_isdel_true(h->flags, j); \
while (1) { /* kick-out process; sort of like in Cuckoo hashing */ \
khint_t k, i, step = 0; \
k = __hash_func(key); \
i = k & new_mask; \
while (!__ac_isempty(new_flags, i)) \
i = (i + (++step)) & new_mask; \
__ac_set_isempty_false(new_flags, i); \
if (i < h->n_buckets && __ac_iseither(h->flags, i) == 0) { /* kick out the existing element */ \
{ \
khkey_t tmp = h->keys[i]; \
h->keys[i] = key; \
key = tmp; \
} \
if (kh_is_map) { \
khval_t tmp = h->vals[i]; \
h->vals[i] = val; \
val = tmp; \
} \
__ac_set_isdel_true(h->flags, i); /* mark it as deleted in the old hash table */ \
} else { /* write the element and jump out of the loop */ \
h->keys[i] = key; \
if (kh_is_map) \
h->vals[i] = val; \
break; \
} \
} \
} \
} \
if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \
h->keys = (khkey_t *)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
if (kh_is_map) \
h->vals = (khval_t *)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
} \
kfree(h->flags); /* free the working space */ \
h->flags = new_flags; \
h->n_buckets = new_n_buckets; \
h->n_occupied = h->size; \
h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5); \
} \
return 0; \
} \
SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) { \
khint_t x; \
if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \
if (h->n_buckets > (h->size << 1)) { \
if (kh_resize_##name(h, h->n_buckets - 1) < 0) { /* clear "deleted" elements */ \
*ret = -1; \
return h->n_buckets; \
} \
} else if (kh_resize_##name(h, h->n_buckets + 1) < 0) { /* expand the hash table */ \
*ret = -1; \
return h->n_buckets; \
} \
} /* TODO: to implement automatically shrinking; resize() already support shrinking */ \
{ \
khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0; \
x = site = h->n_buckets; \
k = __hash_func(key); \
i = k & mask; \
if (__ac_isempty(h->flags, i)) \
x = i; /* for speed up */ \
else { \
last = i; \
while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
if (__ac_isdel(h->flags, i)) \
site = i; \
i = (i + (++step)) & mask; \
if (i == last) { \
x = site; \
break; \
} \
} \
if (x == h->n_buckets) { \
if (__ac_isempty(h->flags, i) && site != h->n_buckets) \
x = site; \
else \
x = i; \
} \
} \
} \
if (__ac_isempty(h->flags, x)) { /* not present at all */ \
h->keys[x] = key; \
__ac_set_isboth_false(h->flags, x); \
++h->size; \
++h->n_occupied; \
*ret = 1; \
} else if (__ac_isdel(h->flags, x)) { /* deleted */ \
h->keys[x] = key; \
__ac_set_isboth_false(h->flags, x); \
++h->size; \
*ret = 2; \
} else \
*ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \
return x; \
} \
SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x) { \
if (x != h->n_buckets && !__ac_iseither(h->flags, x)) { \
__ac_set_isdel_true(h->flags, x); \
--h->size; \
} \
}
#define KHASH_DECLARE(name, khkey_t, khval_t) \
__KHASH_TYPE(name, khkey_t, khval_t) \
__KHASH_PROTOTYPES(name, khkey_t, khval_t)
__KHASH_TYPE(name, khkey_t, khval_t) \
__KHASH_PROTOTYPES(name, khkey_t, khval_t)
#define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
__KHASH_TYPE(name, khkey_t, khval_t) \
__KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
__KHASH_TYPE(name, khkey_t, khval_t) \
__KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
KHASH_INIT2(name, static kh_inline, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
KHASH_INIT2(name, static kh_inline, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
/* --- BEGIN OF HASH FUNCTIONS --- */
@ -372,7 +401,7 @@ KHASH_INIT2(name, static kh_inline, khkey_t, khval_t, kh_is_map, __hash_func, __
@param key The integer [khint64_t]
@return The hash value [khint_t]
*/
#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11)
#define kh_int64_hash_func(key) (khint32_t)((key) >> 33 ^ (key) ^ (key) << 11)
/*! @function
@abstract 64-bit integer comparison function
*/
@ -382,10 +411,11 @@ KHASH_INIT2(name, static kh_inline, khkey_t, khval_t, kh_is_map, __hash_func, __
@param s Pointer to a null terminated string
@return The hash value
*/
static kh_inline khint_t __ac_X31_hash_string(const char *s)
{
static kh_inline khint_t __ac_X31_hash_string(const char *s) {
khint_t h = (khint_t)*s;
if (h) for (++s ; *s; ++s) h = (h << 5) - h + (khint_t)*s;
if (h)
for (++s; *s; ++s)
h = (h << 5) - h + (khint_t)*s;
return h;
}
/*! @function
@ -399,8 +429,7 @@ static kh_inline khint_t __ac_X31_hash_string(const char *s)
*/
#define kh_str_hash_equal(a, b) (strcmp(a, b) == 0)
static kh_inline khint_t __ac_Wang_hash(khint_t key)
{
static kh_inline khint_t __ac_Wang_hash(khint_t key) {
key += ~(key << 15);
key ^= (key >> 10);
key += (key << 3);
@ -544,13 +573,17 @@ static kh_inline khint_t __ac_Wang_hash(khint_t key)
@param vvar Variable to which value will be assigned
@param code Block of code to execute
*/
#define kh_foreach(h, kvar, vvar, code) { khint_t __i; \
for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
if (!kh_exist(h,__i)) continue; \
(kvar) = kh_key(h,__i); \
(vvar) = kh_val(h,__i); \
code; \
} }
#define kh_foreach(h, kvar, vvar, code) \
{ \
khint_t __i; \
for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
if (!kh_exist(h, __i)) \
continue; \
(kvar) = kh_key(h, __i); \
(vvar) = kh_val(h, __i); \
code; \
} \
}
/*! @function
@abstract Iterate over the values in the hash table
@ -558,12 +591,16 @@ code; \
@param vvar Variable to which value will be assigned
@param code Block of code to execute
*/
#define kh_foreach_value(h, vvar, code) { khint_t __i; \
for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
if (!kh_exist(h,__i)) continue; \
(vvar) = kh_val(h,__i); \
code; \
} }
#define kh_foreach_value(h, vvar, code) \
{ \
khint_t __i; \
for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
if (!kh_exist(h, __i)) \
continue; \
(vvar) = kh_val(h, __i); \
code; \
} \
}
/* More conenient interfaces */
@ -571,23 +608,20 @@ code; \
@abstract Instantiate a hash set containing integer keys
@param name Name of the hash table [symbol]
*/
#define KHASH_SET_INIT_INT(name) \
KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal)
#define KHASH_SET_INIT_INT(name) KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal)
/*! @function
@abstract Instantiate a hash map containing integer keys
@param name Name of the hash table [symbol]
@param khval_t Type of values [type]
*/
#define KHASH_MAP_INIT_INT(name, khval_t) \
KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
#define KHASH_MAP_INIT_INT(name, khval_t) KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
/*! @function
@abstract Instantiate a hash map containing 64-bit integer keys
@param name Name of the hash table [symbol]
*/
#define KHASH_SET_INIT_INT64(name) \
KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
#define KHASH_SET_INIT_INT64(name) KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
/*! @function
@abstract Instantiate a hash map containing 64-bit integer keys
@ -595,23 +629,20 @@ KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
@param khval_t Type of values [type]
*/
#define KHASH_MAP_INIT_INT64(name, khval_t) \
KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal)
KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal)
typedef const char *kh_cstr_t;
/*! @function
@abstract Instantiate a hash map containing const char* keys
@param name Name of the hash table [symbol]
*/
#define KHASH_SET_INIT_STR(name) \
KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal)
#define KHASH_SET_INIT_STR(name) KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal)
/*! @function
@abstract Instantiate a hash map containing const char* keys
@param name Name of the hash table [symbol]
@param khval_t Type of values [type]
*/
#define KHASH_MAP_INIT_STR(name, khval_t) \
KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
#define KHASH_MAP_INIT_STR(name, khval_t) KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
#endif /* __AC_KHASH_H */

72
srcs/httpserver/src/haywire/picohttpparser.c
View File

@ -91,7 +91,8 @@
toklen = buf - tok_start; \
} while (0)
static const char *token_char_map = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
static const char *token_char_map =
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\1\1\1\1\1\1\1\0\0\1\1\0\1\1\0\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0"
"\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\1\1"
"\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\1\0\1\0"
@ -100,8 +101,8 @@ static const char *token_char_map = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
static const char *findchar_fast(const char *buf, const char *buf_end, const char *ranges, size_t ranges_size, int *found)
{
static const char *findchar_fast(const char *buf, const char *buf_end, const char *ranges, size_t ranges_size,
int *found) {
*found = 0;
#if __SSE4_2__
if (likely(buf_end - buf >= 16)) {
@ -110,7 +111,8 @@ static const char *findchar_fast(const char *buf, const char *buf_end, const cha
size_t left = (buf_end - buf) & ~15;
do {
__m128i b16 = _mm_loadu_si128((void *)buf);
int r = _mm_cmpestri(ranges16, ranges_size, b16, 16, _SIDD_LEAST_SIGNIFICANT | _SIDD_CMP_RANGES | _SIDD_UBYTE_OPS);
int r = _mm_cmpestri(
ranges16, ranges_size, b16, 16, _SIDD_LEAST_SIGNIFICANT | _SIDD_CMP_RANGES | _SIDD_UBYTE_OPS);
if (unlikely(r != 16)) {
buf += r;
*found = 1;
@ -124,12 +126,13 @@ static const char *findchar_fast(const char *buf, const char *buf_end, const cha
return buf;
}
static const char *get_token_to_eol(const char *buf, const char *buf_end, const char **token, size_t *token_len, int *ret)
{
static const char *get_token_to_eol(const char *buf, const char *buf_end, const char **token, size_t *token_len,
int *ret) {
const char *token_start = buf;
#ifdef __SSE4_2__
static const char ranges1[] = "\0\010"
static const char ranges1
[] = "\0\010"
/* allow HT */
"\012\037"
/* allow SP and up to but not including DEL */
@ -191,8 +194,7 @@ FOUND_CTL:
return buf;
}
static const char *is_complete(const char *buf, const char *buf_end, size_t last_len, int *ret)
{
static const char *is_complete(const char *buf, const char *buf_end, size_t last_len, int *ret) {
int ret_cnt = 0;
buf = last_len < 3 ? buf : buf + last_len - 3;
@ -220,8 +222,7 @@ static const char *is_complete(const char *buf, const char *buf_end, size_t last
}
/* *_buf is always within [buf, buf_end) upon success */
static const char *parse_int(const char *buf, const char *buf_end, int *value, int *ret)
{
static const char *parse_int(const char *buf, const char *buf_end, int *value, int *ret) {
int v;
CHECK_EOF();
if (!('0' <= *buf && *buf <= '9')) {
@ -243,8 +244,7 @@ static const char *parse_int(const char *buf, const char *buf_end, int *value, i
}
/* returned pointer is always within [buf, buf_end), or null */
static const char *parse_http_version(const char *buf, const char *buf_end, int *minor_version, int *ret)
{
static const char *parse_http_version(const char *buf, const char *buf_end, int *minor_version, int *ret) {
EXPECT_CHAR('H');
EXPECT_CHAR('T');
EXPECT_CHAR('T');
@ -256,8 +256,7 @@ static const char *parse_http_version(const char *buf, const char *buf_end, int
}
static const char *parse_headers(const char *buf, const char *buf_end, struct phr_header *headers, size_t *num_headers,
size_t max_headers, int *ret)
{
size_t max_headers, int *ret) {
for (;; ++*num_headers) {
CHECK_EOF();
if (*buf == '\015') {
@ -308,17 +307,17 @@ static const char *parse_headers(const char *buf, const char *buf_end, struct ph
headers[*num_headers].name = NULL;
headers[*num_headers].name_len = 0;
}
if ((buf = get_token_to_eol(buf, buf_end, &headers[*num_headers].value, &headers[*num_headers].value_len, ret)) == NULL) {
if ((buf = get_token_to_eol(buf, buf_end, &headers[*num_headers].value, &headers[*num_headers].value_len, ret))
== NULL) {
return NULL;
}
}
return buf;
}
static const char *parse_request(const char *buf, const char *buf_end, const char **method, size_t *method_len, const char **path,
size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers,
size_t max_headers, int *ret)
{
static const char *parse_request(const char *buf, const char *buf_end, const char **method, size_t *method_len,
const char **path, size_t *path_len, int *minor_version, struct phr_header *headers,
size_t *num_headers, size_t max_headers, int *ret) {
/* skip first empty line (some clients add CRLF after POST content) */
CHECK_EOF();
if (*buf == '\015') {
@ -350,8 +349,8 @@ static const char *parse_request(const char *buf, const char *buf_end, const cha
}
int phr_parse_request(const char *buf_start, size_t len, const char **method, size_t *method_len, const char **path,
size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len)
{
size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers,
size_t last_len) {
const char *buf = buf_start, *buf_end = buf_start + len;
size_t max_headers = *num_headers;
int r;
@ -369,17 +368,18 @@ int phr_parse_request(const char *buf_start, size_t len, const char **method, si
return r;
}
if ((buf = parse_request(buf, buf_end, method, method_len, path, path_len, minor_version, headers, num_headers, max_headers,
&r)) == NULL) {
if ((buf = parse_request(
buf, buf_end, method, method_len, path, path_len, minor_version, headers, num_headers, max_headers, &r))
== NULL) {
return r;
}
return (int)(buf - buf_start);
}
static const char *parse_response(const char *buf, const char *buf_end, int *minor_version, int *status, const char **msg,
size_t *msg_len, struct phr_header *headers, size_t *num_headers, size_t max_headers, int *ret)
{
static const char *parse_response(const char *buf, const char *buf_end, int *minor_version, int *status,
const char **msg, size_t *msg_len, struct phr_header *headers, size_t *num_headers,
size_t max_headers, int *ret) {
/* parse "HTTP/1.x" */
if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
return NULL;
@ -406,9 +406,8 @@ static const char *parse_response(const char *buf, const char *buf_end, int *min
return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
}
int phr_parse_response(const char *buf_start, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len,
struct phr_header *headers, size_t *num_headers, size_t last_len)
{
int phr_parse_response(const char *buf_start, size_t len, int *minor_version, int *status, const char **msg,
size_t *msg_len, struct phr_header *headers, size_t *num_headers, size_t last_len) {
const char *buf = buf_start, *buf_end = buf + len;
size_t max_headers = *num_headers;
int r;
@ -425,15 +424,16 @@ int phr_parse_response(const char *buf_start, size_t len, int *minor_version, in
return r;
}
if ((buf = parse_response(buf, buf_end, minor_version, status, msg, msg_len, headers, num_headers, max_headers, &r)) == NULL) {
if ((buf = parse_response(buf, buf_end, minor_version, status, msg, msg_len, headers, num_headers, max_headers, &r))
== NULL) {
return r;
}
return (int)(buf - buf_start);
}
int phr_parse_headers(const char *buf_start, size_t len, struct phr_header *headers, size_t *num_headers, size_t last_len)
{
int phr_parse_headers(const char *buf_start, size_t len, struct phr_header *headers, size_t *num_headers,
size_t last_len) {
const char *buf = buf_start, *buf_end = buf + len;
size_t max_headers = *num_headers;
int r;
@ -462,8 +462,7 @@ enum {
CHUNKED_IN_TRAILERS_LINE_MIDDLE
};
static int decode_hex(int ch)
{
static int decode_hex(int ch) {
if ('0' <= ch && ch <= '9') {
return ch - '0';
} else if ('A' <= ch && ch <= 'F') {
@ -475,8 +474,7 @@ static int decode_hex(int ch)
}
}
ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *_bufsz)
{
ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *_bufsz) {
size_t dst = 0, src = 0, bufsz = *_bufsz;
ssize_t ret = -2; /* incomplete */

5
srcs/httpserver/src/haywire/picohttpparser.h
View File

@ -50,8 +50,9 @@ struct phr_header {
/* returns number of bytes consumed if successful, -2 if request is partial,
* -1 if failed */
int phr_parse_request(const char *buf, size_t len, const char **method, size_t *method_len, const char **path, size_t *path_len,
int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len);
int phr_parse_request(const char *buf, size_t len, const char **method, size_t *method_len, const char **path,
size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers,
size_t last_len);
/* ditto */
int phr_parse_response(const char *_buf, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len,

32
srcs/httpserver/src/haywire/route_compare_method.c
View File

@ -10,7 +10,7 @@ typedef struct hw_route_token_st {
int start;
} hw_route_token;
void hw_route_next_token(hw_string* url, int start, hw_route_token* result) {
void hw_route_next_token(hw_string *url, int start, hw_route_token *result) {
while (start < url->length && (url->value[start] == '/')) {
start++;
}
@ -25,16 +25,14 @@ void hw_route_next_token(hw_string* url, int start, hw_route_token* result) {
result->string.value = url->value + start;
result->string.length = end - start;
result->start = start;
}
else {
} else {
result->string.value = NULL;
result->string.length = 0;
result->start = -1;
}
}
int hw_route_compare_method(hw_string* url, char* route)
{
int hw_route_compare_method(hw_string *url, char *route) {
int equal = 0;
int match = 0;
@ -49,21 +47,15 @@ int hw_route_compare_method(hw_string* url, char* route)
hw_route_next_token(url, 0, &request_token);
hw_route_next_token(&hw_route, 0, &route_token);
while (route_token.string.value != NULL && request_token.string.value != NULL)
{
while (route_token.string.value != NULL && request_token.string.value != NULL) {
if (route_token.string.value[0] == '*') {
// wildcard support: any route fragment marked with '*' matches the corresponding url fragment
equal = 1;
}
else
{
} else {
match = hw_strcmp(&route_token.string, &request_token.string);
if (!match)
{
if (!match) {
equal = 1;
}
else
{
} else {
equal = 0;
break;
}
@ -73,17 +65,15 @@ int hw_route_compare_method(hw_string* url, char* route)
hw_route_next_token(&hw_route, route_token.start + route_token.string.length + 1, &route_token);
}
if (!equal)
{
if (!equal) {
match = hw_strcmp(url, &hw_route);
if (!match)
{
if (!match) {
equal = 1;
}
}
if ((route_token.string.value == NULL && request_token.string.value != NULL) || (route_token.string.value != NULL && request_token.string.value == NULL))
{
if ((route_token.string.value == NULL && request_token.string.value != NULL)
|| (route_token.string.value != NULL && request_token.string.value == NULL)) {
equal = 0;
}

2
srcs/httpserver/src/haywire/route_compare_method.h
View File

@ -1,3 +1,3 @@
#include "haywire.h"
int hw_route_compare_method(hw_string* url, char* route);
int hw_route_compare_method(hw_string *url, char *route);

26
srcs/httpserver/src/haywire/server_stats.c
View File

@ -9,18 +9,11 @@ int stat_requests_destroyed_total;
#define CRLF "\r\n"
static const char stats_response[] =
"HTTP/1.1 200 OK" CRLF
"Server: Haywire/master" CRLF
"Date: Fri, 26 Aug 2011 00:31:53 GMT" CRLF
"Connection: Keep-Alive" CRLF
"Content-Type: text/html" CRLF
"Content-Length: 16" CRLF
CRLF
"stats printed" CRLF;
static const char stats_response[] = "HTTP/1.1 200 OK" CRLF "Server: Haywire/master" CRLF
"Date: Fri, 26 Aug 2011 00:31:53 GMT" CRLF "Connection: Keep-Alive" CRLF
"Content-Type: text/html" CRLF "Content-Length: 16" CRLF CRLF "stats printed" CRLF;
void get_server_stats(http_request* request, hw_http_response* response, void* user_data)
{
void get_server_stats(http_request *request, hw_http_response *response, void *user_data) {
hw_string status_code;
hw_string content_type_name;
hw_string content_type_value;
@ -39,21 +32,20 @@ void get_server_stats(http_request* request, hw_http_response* response, void* u
SETSTRING(body, "stats printed");
hw_set_body(response, &body);
if (request->keep_alive)
{
if (request->keep_alive) {
SETSTRING(keep_alive_name, "Connection");
SETSTRING(keep_alive_value, "Keep-Alive");
hw_set_response_header(response, &keep_alive_name, &keep_alive_value);
}
else
{
} else {
hw_set_http_version(response, 1, 0);
}
hw_http_response_send(response, NULL, NULL);
printf("connections_created_total: %d\nconnections_destroyed_total: %d\nrequests_created_total: %d\nrequests_destroyed_total: %d\n\n",
printf(
"connections_created_total: %d\nconnections_destroyed_total: %d\nrequests_created_total: "
"%d\nrequests_destroyed_total: %d\n\n",
stat_connections_created_total,
stat_connections_destroyed_total,
stat_requests_created_total,

3
srcs/httpserver/src/haywire/server_stats.h
View File

@ -7,10 +7,9 @@
#define INCREMENT_STAT(stat)
#endif /* DEBUG */
extern int stat_connections_created_total;
extern int stat_connections_destroyed_total;
extern int stat_requests_created_total;
extern int stat_requests_destroyed_total;
void get_server_stats(http_request* request, hw_http_response* response, void* user_data);
void get_server_stats(http_request *request, hw_http_response *response, void *user_data);

1
srcs/libs/network/http_svr.c
View File

@ -4,7 +4,6 @@
#include "http_svr.h"
#include "user_errno.h"
#include "haywire.h"
#include "misc.h"
#include "config.h"
int http_svr_init() {