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

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

@ -6,31 +6,23 @@
KHASH_MAP_INIT_STR(route_hashes, char *)
int configuration_handler(void* user, const char* section, const char* name, const char* value)
{
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 *load_configuration(const char *filename) {
configuration *config = malloc(sizeof(configuration));
if (ini_parse(filename, configuration_handler, config) < 0)
{
if (ini_parse(filename, configuration_handler, config) < 0) {
dzlog_error("Can't load configuration\n");
return NULL;
}

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

@ -19,8 +19,7 @@
#define MAX_NAME 50
/* Strip whitespace chars off end of given string, in place. Return s. */
static char* rstrip(char* s)
{
static char *rstrip(char *s) {
char *p = s + strlen(s);
while (p > s && isspace(*--p))
*p = '\0';
@ -28,8 +27,7 @@ static char* rstrip(char* 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;
@ -38,8 +36,7 @@ static char* lskip(const 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);
@ -49,19 +46,14 @@ static char* find_char_or_comment(const char* s, char c)
}
/* 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] = "";
@ -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,10 +123,7 @@ 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)
{
int ini_parse(const char *filename, int (*handler)(void *, const char *, const char *, const char *), void *user) {
FILE *file;
int error;

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

@ -31,15 +31,11 @@ extern "C" {
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 (*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
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),
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

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

@ -8,8 +8,7 @@
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;
@ -28,39 +27,34 @@ void ipc_read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf)
if (tcp_nodelay) {
rc = uv_tcp_nodelay((uv_tcp_t *)ctx->server_handle, 1);
}
}
else if (type == UV_NAMED_PIPE)
} 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);
}
void ipc_alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf)
{
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;
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);
}
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_parser_init(&connection->parser, HTTP_REQUEST);
@ -78,16 +72,14 @@ void connection_consumer_new_connection(uv_stream_t* server_handle, int status)
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)
{
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);
}
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,9 +91,7 @@ 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;
@ -113,7 +103,7 @@ 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_async_init(loop, &ctx->async_handle, connection_consumer_close);
uv_unref((uv_handle_t *)&ctx->async_handle);
/* Wait until the main thread is ready. */
@ -121,8 +111,8 @@ void connection_consumer_start(void *arg)
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);
}

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

@ -9,17 +9,14 @@
#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_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;

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

@ -6,22 +6,19 @@
static struct sockaddr_in listen_addr;
void ipc_close_cb(uv_handle_t* handle)
{
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)
{
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);
}
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;
@ -39,17 +36,12 @@ void ipc_connection_cb(uv_stream_t* ipc_pipe, int status)
if (sc->tcp_nodelay) {
rc = uv_tcp_nodelay((uv_tcp_t *)&pc->peer_handle, 1);
}
}
else if (ipc_pipe->type == UV_NAMED_PIPE)
} 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_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);
@ -60,8 +52,8 @@ 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;
@ -71,8 +63,7 @@ void start_connection_dispatching(uv_handle_type type, unsigned int num_servers,
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);

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);

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

@ -6,8 +6,7 @@
#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;
@ -16,6 +15,10 @@ typedef struct
hw_string current_header_value;
int keep_alive;
int last_was_value;
enum {OPEN, CLOSING, CLOSED} state;
enum {
OPEN,
CLOSING,
CLOSED
} state;
hw_request_buffer *buffer;
} http_connection;

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

File diff suppressed because it is too large Load Diff

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

@ -66,7 +66,6 @@ extern "C" {
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
* then halt execution.
*
@ -117,30 +116,30 @@ XX(23, UNSUBSCRIBE, UNSUBSCRIBE) \
XX(24, PATCH, PATCH) \
XX(25, PURGE, PURGE) \
/* CalDAV */ \
XX(26, MKCALENDAR, MKCALENDAR) \
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 };
/* 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
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
};
/* Map for errno-related constants
*
@ -162,10 +161,8 @@ 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(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") \
@ -177,17 +174,14 @@ 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_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 HTTP_ERRNO_GEN(n, s) HPE_##n,
enum http_errno {
@ -195,11 +189,9 @@ XX(UNKNOWN, "an unknown error occurred")
};
#undef HTTP_ERRNO_GEN
/* Get an http_errno value from an http_parser */
#define HTTP_PARSER_ERRNO(p) ((enum http_errno)(p)->http_errno)
struct http_parser {
/** PRIVATE **/
unsigned int type : 2; /* enum http_parser_type */
@ -229,7 +221,6 @@ XX(UNKNOWN, "an unknown error occurred")
void *data; /* A pointer to get hook to the "connection" or "socket" object */
};
struct http_parser_settings {
http_cb on_message_begin;
http_data_cb on_url;
@ -241,19 +232,17 @@ XX(UNKNOWN, "an unknown error occurred")
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().
*
* Callers should index into field_data[] with UF_* values iff field_set
@ -271,7 +260,6 @@ XX(UNKNOWN, "an unknown error occurred")
} field_data[UF_MAX];
};
/* 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:
@ -286,14 +274,9 @@ XX(UNKNOWN, "an unknown error occurred")
void http_parser_init(http_parser *parser, enum http_parser_type type);
/* 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
* on_message_complete callback returns 0, then this should be
@ -313,9 +296,7 @@ XX(UNKNOWN, "an unknown error occurred")
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);
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);

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

@ -10,25 +10,20 @@
#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);
#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;
}
@ -38,8 +33,7 @@ KHASH_INIT(hw_string_hashmap, hw_string*, hw_string*, 1, hw_string_hash_func, h
KHASH_MAP_INIT_STR(string_hashmap, char *)
KHASH_MAP_INIT_INT64(offset_hashmap, int)
void hw_print_request_headers(http_request* request)
{
void hw_print_request_headers(http_request *request) {
hw_string *k;
hw_string *v;
@ -53,20 +47,17 @@ void hw_print_request_headers(http_request* request)
});
}
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);
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);
@ -81,14 +72,12 @@ 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]);
}
@ -101,8 +90,7 @@ 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 *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));
@ -112,15 +100,13 @@ 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;
kh_foreach(h, k, v,
{
kh_foreach(h, k, v, {
free((hw_string *)k);
free((hw_string *)v);
});
@ -135,14 +121,12 @@ void free_http_request(http_request* request)
INCREMENT_STAT(stat_requests_destroyed_total);
}
hw_string* hw_get_header(http_request* request, hw_string* 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)
{
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
@ -156,8 +140,7 @@ 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)
{
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;
@ -187,19 +170,17 @@ 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)
{
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) {
@ -225,8 +206,7 @@ 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)
{
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) {
@ -244,8 +224,7 @@ 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)
{
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) {
@ -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)
{
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 (length != 0) {
if (body->length == 0) {
body->value = at;
body->length = length;
@ -284,8 +261,7 @@ 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 *get_route_callback(hw_string *url) {
hw_route_entry *route_entry = NULL;
const char *k;
@ -293,11 +269,9 @@ hw_route_entry* get_route_callback(hw_string* url)
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)
{
if (found) {
route_entry = (hw_route_entry *)v;
}
});
@ -306,8 +280,7 @@ hw_route_entry* get_route_callback(hw_string* url)
}
void send_error_response(http_request *request, http_response *response, const char *error_code,
const char* error_message)
{
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,8 +318,7 @@ 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)
{
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);
@ -365,8 +334,7 @@ void http_request_locate_members(http_connection* connection)
});
}
int http_request_on_message_complete(http_parser* parser)
{
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);
@ -386,12 +354,9 @@ int http_request_on_message_complete(http_parser* parser)
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;
}

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

@ -172,9 +172,7 @@ void http_request_buffer_print(hw_request_buffer* buf) {
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");
}

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

@ -10,8 +10,7 @@
#define CRLF "\r\n"
KHASH_MAP_INIT_STR(string_hashmap, char *)
hw_http_response hw_create_http_response(http_connection* connection)
{
hw_http_response hw_create_http_response(http_connection *connection) {
http_response *response = malloc(sizeof(http_response));
response->connection = connection;
response->request = connection->request;
@ -23,27 +22,23 @@ hw_http_response hw_create_http_response(http_connection* connection)
return response;
}
void hw_free_http_response(hw_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)
{
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)
{
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)
{
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;
@ -52,15 +47,15 @@ void hw_set_response_header(hw_http_response* response, hw_string* name, hw_stri
resp->number_of_headers++;
}
void hw_set_body(hw_http_response* response, hw_string* body)
{
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,8 +63,7 @@ int num_chars(int n) {
return r;
}
hw_string* create_response_buffer(hw_http_response* response)
{
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);
@ -83,15 +77,15 @@ 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;
@ -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,17 +117,14 @@ 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)
{
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);
@ -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);
}

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

@ -2,15 +2,13 @@
#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
{
typedef struct {
http_connection *connection;
http_request *request;
unsigned short http_major;
@ -22,8 +20,7 @@ typedef struct
int sent;
} http_response;
typedef struct
{
typedef struct {
http_connection *connection;
http_request *request;
void *user_data;

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

@ -23,39 +23,32 @@ void create_cached_http_request(khash_t(string_hashmap)* http_request_cache, con
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)
{
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)
{
if (handle != NULL) {
uv_unref((uv_handle_t *)cache_invalidation_timer);
}
}
void http_request_cache_timer(uv_timer_t* 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)
{
if (http_request_cache != NULL) {
free_http_request_cache(http_request_cache);
}
}
void free_http_request_cache(khash_t(string_hashmap)* http_request_cache)
{
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,
{
kh_foreach(http_request_cache, k, v, {
free((char *)k);
free(v->value);
free(v);
@ -65,8 +58,7 @@ 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)
{
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;
@ -93,21 +85,18 @@ 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;
@ -115,38 +104,29 @@ hw_string* get_cached_request(const char* http_status)
/* 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;
}

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

@ -19,15 +19,18 @@
#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))
#if 0
#define CHECK(r, msg) \
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 *)
@ -38,16 +41,15 @@ static struct sockaddr_in listen_address;
uv_loop_t *uv_loop;
void *routes;
hw_string* http_v1_0;
//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_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);
@ -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)
{
int hw_init_from_config(char *configuration_filename) {
configuration *config = load_configuration(configuration_filename);
if (config == NULL)
{
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 *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)
{
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.
}
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); });
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);
}
@ -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)
{
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_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;
servers = calloc(threads, sizeof(servers[0]));
for (i = 0; i < threads; i++)
{
int rc = 0;
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)
{
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++)
{
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;
ctx = arg;
loop = uv_loop_new();
@ -293,27 +278,25 @@ 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)
{
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_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)
{
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);
@ -327,8 +310,7 @@ void http_stream_on_connect(uv_stream_t* stream, int status)
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)
{
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);
@ -345,8 +327,7 @@ 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)
{
void http_stream_on_close(uv_handle_t *handle) {
uv_handle_t *stream = handle;
http_connection *connection = stream->data;
@ -364,8 +345,7 @@ void http_stream_close_connection(http_connection* connection) {
}
}
void handle_request_error(http_connection* connection)
{
void handle_request_error(http_connection *connection) {
uv_handle_t *stream = &connection->stream;
if (connection->state == OPEN) {
@ -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,18 +388,16 @@ void handle_internal_error(http_connection* connection)
handle_request_error(connection);
}
void http_stream_on_shutdown(uv_shutdown_t* req, int status)
{
void http_stream_on_shutdown(uv_shutdown_t *req, int UNUSED(status)) {
http_connection *connection = req->data;
uv_handle_t* stream = &connection->stream;
// 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)
{
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) {
@ -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){
} 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,15 +434,13 @@ 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)
{
int http_server_write_response_single(hw_write_context *write_context, hw_string *response) {
http_connection *connection = write_context->connection;
if (connection->state == OPEN) {
@ -485,7 +455,7 @@ int http_server_write_response_single(hw_write_context* write_context, hw_string
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,11 +467,10 @@ 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)
{
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;
//uv_handle_t *stream = (uv_handle_t *)req->handle;
http_connection *connection = write_context->connection;
@ -509,11 +478,9 @@ void http_server_after_write(uv_write_t* req, int status)
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);
}

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

@ -5,14 +5,12 @@
#include "http_parser.h"
#include "http_response.h"
typedef struct
{
typedef struct {
http_request_callback callback;
void *user_data;
} hw_route_entry;
union stream_handle
{
union stream_handle {
uv_pipe_t pipe;
uv_tcp_t tcp;
};

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

@ -3,8 +3,7 @@
#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));
str->value = malloc(length);
@ -13,8 +12,7 @@ hw_string* create_string(const char* value)
return str;
}
hw_string* hw_strdup(hw_string* tocopy)
{
hw_string *hw_strdup(hw_string *tocopy) {
hw_string *str = malloc(sizeof(hw_string));
str->value = tocopy->value;
str->length = tocopy->length;
@ -41,32 +39,27 @@ int hw_strcmp(hw_string* a, hw_string* b) {
return ret;
}
void append_string(hw_string* destination, hw_string* source)
{
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 *dupstr(const char *s) {
char *result = malloc(strlen(s) + 1);
if (result != NULL)
{
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++;
}

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

@ -113,7 +113,6 @@
* Added destructor
*/
#ifndef __AC_KHASH_H
#define __AC_KHASH_H
@ -163,7 +162,8 @@ typedef khint_t khiter_t;
#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
@ -199,57 +199,63 @@ 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) \
{ \
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->keys); \
kfree(h->flags); \
kfree((void *)h->vals); \
kfree(h); \
} \
} \
SCOPE void kh_clear_##name(kh_##name##_t *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) \
{ \
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; \
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; \
if (i == last) \
return h->n_buckets; \
} \
return __ac_iseither(h->flags, i) ? h->n_buckets : i; \
} else return 0; \
} 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. */ \
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 */ \
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; \
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; \
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; \
if (!new_vals) \
return -1; \
h->vals = new_vals; \
} \
} /* otherwise shrink */ \
@ -262,21 +268,32 @@ 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]; \
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; \
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; } \
{ \
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; \
if (kh_is_map) \
h->vals[i] = val; \
break; \
} \
} \
@ -284,7 +301,8 @@ 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)); \
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; \
@ -294,50 +312,61 @@ 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) \
{ \
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; \
*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; \
*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 */ \
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; \
if (__ac_isdel(h->flags, i)) \
site = i; \
i = (i + (++step)) & mask; \
if (i == last) { x = site; break; } \
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, 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; \
++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 */ \
} 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) \
{ \
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; \
@ -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; \
#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; \
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; \
#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; \
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
@ -602,16 +636,13 @@ typedef const char *kh_cstr_t;
@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,

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

@ -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;
}

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,

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

@ -7,7 +7,6 @@
#define INCREMENT_STAT(stat)
#endif /* DEBUG */
extern int stat_connections_created_total;
extern int stat_connections_destroyed_total;
extern int stat_requests_created_total;

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() {