diff options
| -rw-r--r-- | README.md | 1 | ||||
| -rw-r--r-- | c-httpd/.gitignore | 1 | ||||
| -rw-r--r-- | c-httpd/Makefile | 7 | ||||
| -rw-r--r-- | c-httpd/httpd.c | 25 | ||||
| -rw-r--r-- | c-httpd/httpserver.h | 2818 |
5 files changed, 2852 insertions, 0 deletions
@@ -22,6 +22,7 @@ running it. | [c-embed](./c-embed) | clang-17 | Embedding external resources in compiled binary. | | [c-signals](./c-signals) | clang-17 | Uses SIGUSR1 and SIGUSR2 as IPC mechanism. | | [c-structs](./c-structs) | clang-17 | Saves and reads structs in/from binary files. | +| [c-httpd](./c-httpd) | clang-17 | Simple HTTP server written in C. | | [zig-c-interop](./zig-c-interop) | zig-0.11.0 | Uses functions written in C from Zig code. | | [zig-ppm](./zig-ppm) | zig-0.11.0 | Creates an image with random pixels in PPM image format. | | [zig-struct-json](./zig-struct-json) | zig-0.11.0 | Serialization of a struct into JSON and then reading it back. | diff --git a/c-httpd/.gitignore b/c-httpd/.gitignore new file mode 100644 index 0000000..71e8b8e --- /dev/null +++ b/c-httpd/.gitignore @@ -0,0 +1 @@ +httpd diff --git a/c-httpd/Makefile b/c-httpd/Makefile new file mode 100644 index 0000000..0b90a47 --- /dev/null +++ b/c-httpd/Makefile @@ -0,0 +1,7 @@ +all: httpd + +httpd: httpd.c + gcc httpd.c -o httpd + +clean: + -rm httpd diff --git a/c-httpd/httpd.c b/c-httpd/httpd.c new file mode 100644 index 0000000..cb79df1 --- /dev/null +++ b/c-httpd/httpd.c @@ -0,0 +1,25 @@ +#define EPOLL +#define HTTPSERVER_IMPL +#include "httpserver.h" + +#define SERVER_PORT 6970 +#define RESPONSE "default response" + +void handle_request(struct http_request_s* request) { + http_string_t url = http_request_target(request); + + printf("%s\n", url.buf); + + struct http_response_s* response = http_response_init(); + http_response_status(response, 200); + http_response_header(response, "Content-Type", "text/html"); + http_response_body(response, RESPONSE, sizeof(RESPONSE) - 1); + http_respond(request, response); +} + +int main() { + printf("> starting server on %d\n", SERVER_PORT); + + struct http_server_s* server = http_server_init(SERVER_PORT, handle_request); + http_server_listen(server); +} diff --git a/c-httpd/httpserver.h b/c-httpd/httpserver.h new file mode 100644 index 0000000..26fb0c7 --- /dev/null +++ b/c-httpd/httpserver.h @@ -0,0 +1,2818 @@ +// httpserver.h has been automatically generated from httpserver.m4 and the +// source files under /src +#ifndef HTTPSERVER_H +#define HTTPSERVER_H +#line 1 "api.h" +#ifndef HS_API_H +#define HS_API_H +/** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * @file api.h + * + * MIT License + * + * Copyright (c) 2019 Jeremy Williams + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * + * httpserver.h (0.9.0) + * + * Description: + * + * A single header C library for building non-blocking event driven HTTP + * servers + * + * Usage: + * + * Do this: + * #define HTTPSERVER_IMPL + * before you include this file in *one* C or C++ file to create the + * implementation. + * + * // i.e. it should look like this: + * #include ... + * #include ... + * #include ... + * #define HTTPSERVER_IMPL + * #include "httpserver.h" + * + * There are some #defines that can be configured. This must be done in the + * same file that you define HTTPSERVER_IMPL These defines have default values + * and will need to be #undef'd and redefined to configure them. + * + * HTTP_REQUEST_BUF_SIZE - default 1024 - The initial size in bytes of the + * read buffer for the request. This buffer grows automatically if it's + * capacity is reached but it certain environments it may be optimal to + * change this value. + * + * HTTP_RESPONSE_BUF_SIZE - default 1024 - Same as above except for the + * response buffer. + * + * HTTP_REQUEST_TIMEOUT - default 20 - The amount of seconds the request + * will wait for activity on the socket before closing. This only applies mid + * request. For the amount of time to hold onto keep-alive connections see + * below. + * + * HTTP_KEEP_ALIVE_TIMEOUT - default 120 - The amount of seconds to keep a + * connection alive a keep-alive request has completed. + * + * HTTP_MAX_TOTAL_EST_MEM_USAGE - default 4294967296 (4GB) - This is the + * amount of read/write buffer space that is allowed to be allocated + * across all requests before new requests will get 503 responses. + * + * HTTP_MAX_TOKEN_LENGTH - default 8192 (8KB) - This is the max size of any + * non body http tokens. i.e: header names, header values, url length, + * etc. + * + * HTTP_MAX_REQUEST_BUF_SIZE - default 8388608 (8MB) - This is the maximum + * amount of bytes that the request buffer will grow to. If the body of + * the request + headers cannot fit in this size the request body will be + * streamed in. + * + * For more details see the documentation of the interface and the example + * below. + * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +#ifdef __cplusplus +extern "C" { +#endif + +// String type used to read the request details. The char pointer is NOT null +// terminated. +struct http_string_s; + +struct http_server_s; +struct http_request_s; +struct http_response_s; + +/** + * Get the event loop descriptor that the server is running on. + * + * This will be an epoll fd when running on Linux or a kqueue on BSD. This can + * be used to listen for activity on sockets, etc. The only caveat is that the + * user data must be set to a struct where the first member is the function + * pointer to a callback that will handle the event. i.e: + * + * For kevent: + * + * struct foo { + * void (*handler)(struct kevent*); + * ... + * } + * + * // Set ev.udata to a foo pointer when registering the event. + * + * For epoll: + * + * struct foo { + * void (*handler)(struct epoll_event*); + * ... + * } + * + * // Set ev.data.ptr to a foo pointer when registering the event. + * + * @param server The server. + * + * @return The descriptor of the event loop. + */ +int http_server_loop(struct http_server_s *server); + +/** + * Allocates and initializes the http server. + * + * @param port The port to listen on. + * @param handler The callback that will fire to handle requests. + * + * @return Pointer to the allocated server. + */ +struct http_server_s * +http_server_init(int port, void (*handler)(struct http_request_s *)); + +/** + * Listens on the server socket and starts an event loop. + * + * During normal operation this function will not return. + * + * @param server The server. + * @param ipaddr The ip to bind to if NULL binds to all interfaces. + * + * @return Error code if the server fails. + */ +int http_server_listen_addr(struct http_server_s *server, const char *ipaddr); + +/** + * See http_server_listen_addr + */ +int http_server_listen(struct http_server_s *server); + +/** + * Poll the server socket on specific interface. + * + * Use this listen call in place of the one above when you want to integrate + * an http server into an existing application that has a loop already and you + * want to use the polling functionality instead. This works well for + * applications like games that have a constant update loop. + * + * @param server The server. + * @param ipaddr The ip to bind to if NULL bind to all. + * + * @return Error code if the poll fails. + */ +int http_server_listen_addr_poll(struct http_server_s *server, + const char *ipaddr); + +/** + * Poll the server socket on all interfaces. See http_server_listen_addr_poll + * + * @param server The server. + * + * @return Error code if the poll fails. + */ +int http_server_listen_poll(struct http_server_s *server); +/** + * Poll of the request sockets. + * + * Call this function in your update loop. It will trigger the request handler + * once if there is a request ready. It should be called in a loop until it + * returns 0. + * + * @param server The server. + * + * @return Returns 1 if a request was handled and 0 if no requests were handled. + */ +int http_server_poll(struct http_server_s *server); + +/** + * Check if a request flag is set. + * + * The flags that can be queried are listed below: + * + * HTTP_FLG_STREAMED + * + * This flag will be set when the request body is chunked or the body is too + * large to fit in memory are once. This means that the + * http_request_read_chunk function must be used to read the body piece by + * piece. + * + * @param request The request. + * @param flag One of the flags listed above. + * + * @return 1 or 0 if the flag is set or not respectively. + */ +int http_request_has_flag(struct http_request_s *request, int flag); + +/** + * Returns the request method as it was read from the HTTP request line. + * + * @param request The request. + * + * @return The HTTP method. + */ +struct http_string_s http_request_method(struct http_request_s *request); + +/** + * Returns the full request target (url) from the HTTP request line. + * + * @param request The request. + * + * @return The target. + */ +struct http_string_s http_request_target(struct http_request_s *request); + +/** + * Retrieves the request body. + * + * @param request The request. + * + * @return The request body. If no request body was sent buf and len of the + * string will be set to 0. + */ +struct http_string_s http_request_body(struct http_request_s *request); + +/** + * Returns the request header value for the given header key. + * + * @param request The request. + * @param key The case insensitive header key to search for. + * + * @return The value for the header matching the key. Will be length 0 if not + * found. + */ +struct http_string_s http_request_header(struct http_request_s *request, + char const *key); + +/** + * Iterate over the request headers. + * + * Each call will set key and val to the key and value of the next header. + * + * @param request The request. + * @param[out] key The key of the header. + * @param[out] value The key of the header. + * @param[inout] iter Should be initialized to 0 before calling. Pass back in + * with each consecutive call. + * + * @return 0 when there are no more headers. + */ +int http_request_iterate_headers(struct http_request_s *request, + struct http_string_s *key, + struct http_string_s *val, int *iter); + +/** + * Stores an arbitrary userdata pointer for this request. + * + * This is not used by the library in any way and is strictly for you, the + * application programmer to make use of. + * + * @param request The request. + * @param data Opaque pointer to user data. + */ +void http_request_set_userdata(struct http_request_s *request, void *data); + +/** + * Retrieve the opaque data pointer that was set with http_request_set_userdata. + * + * @param request The request. + */ +void *http_request_userdata(struct http_request_s *request); + +/** + * Stores a server wide opaque pointer for future retrieval. + * + * This is not used by the library in any way and is strictly for you, the + * application programmer to make use of. + * + * @param server The server. + * @param data Opaque data pointer. + */ +void http_server_set_userdata(struct http_server_s *server, void *data); + +/** + * Retrieve the server wide userdata pointer. + * + * @param request The request. + */ +void *http_request_server_userdata(struct http_request_s *request); + +/** + * Sets how the request will handle it's connection + * + * By default the server will inspect the Connection header and the HTTP + * version to determine whether the connection should be kept alive or not. + * Use this function to override that behaviour to force the connection to + * keep-alive or close by passing in the HTTP_KEEP_ALIVE or HTTP_CLOSE + * directives respectively. This may provide a minor performance improvement + * in cases where you control client and server and want to always close or + * keep the connection alive. + * + * @param request The request. + * @param directive One of HTTP_KEEP_ALIVE or HTTP_CLOSE + */ +void http_request_connection(struct http_request_s *request, int directive); + +/** + * Frees the buffer of a request. + * + * When reading in the HTTP request the server allocates a buffer to store + * the request details such as the headers, method, body, etc. By default this + * memory will be freed when http_respond is called. This function lets you + * free that memory before the http_respond call. This can be useful if you + * have requests that take a long time to complete and you don't require the + * request data. Accessing any http_string_s's will be invalid after this call. + * + * @param request The request to free the buffer of. + */ +void http_request_free_buffer(struct http_request_s *request); + +/** + * Allocates an http response. + * + * This memory will be freed when http_respond is called. + * + * @return Allocated response. + */ +struct http_response_s *http_response_init(); + +/** + * Set the response status. + * + * Accepts values between 100 and 599 inclusive. Any other value will map to + * 500. + * + * @param response The response struct to set status on. + * @param status The HTTP status code. + */ +void http_response_status(struct http_response_s *response, int status); + +/** + * Sets an HTTP response header. + * + * @param response The response struct to set the header on. + * @param key The null-terminated key of the header eg: Content-Type + * @param value The null-terminated value of the header eg: application/json + */ +void http_response_header(struct http_response_s *response, char const *key, + char const *value); + +/** + * Set the response body. + * + * The caller is responsible for freeing any memory that + * may have been allocated for the body. It is safe to free this memory AFTER + * http_respond has been called. If responding with chunked transfer encoding + * this will become a single chunk. This procedure can be used again to set + * subsequent chunks. + * + * @param response The response struct to set the body for. + * @param body The body of the response. + * @param length The length of the body + */ +void http_response_body(struct http_response_s *response, char const *body, + int length); + +/** + * Starts writing the response to the client. + * + * Any memory allocated for the response body or response headers is safe to + * free after this call. Adds the default HTTP response headers, Date and + * Connection. + * + * @param request The request to respond to. + * @param response The response to respond with. + */ +void http_respond(struct http_request_s *request, + struct http_response_s *response); + +/** + * Writes a chunk to the client. + * + * The notify_done callback will be called when the write is complete. This call + * consumes the response so a new response will need to be initialized for each + * chunk. The response status of the request will be the response status that is + * set when http_respond_chunk is called the first time. Any headers set for the + * first call will be sent as the response headers. Transfer-Encoding header + * will automatically be set to chunked. Headers set for subsequent calls will + * be ignored. + * + * @param request The request to respond to. + * @param response The response to respond with. + * @param notify_done The callback that's used to signal user code that another + * chunk is ready to be written out. + */ +void http_respond_chunk(struct http_request_s *request, + struct http_response_s *response, + void (*notify_done)(struct http_request_s *)); + +/** + * Ends the chunked response. + * + * Used to signal end of transmission on chunked requests. Any headers set + * before this call will be included as what the HTTP spec refers to as + * 'trailers' which are essentially more response headers. + * + * @param request The request to respond to. + * @param response The response to respond with. + */ +void http_respond_chunk_end(struct http_request_s *request, + struct http_response_s *response); + +/** + * Read a chunk of the request body. + * + * If a request has Transfer-Encoding: chunked or the body is too big to fit in + * memory all at once you cannot read the body in the typical way. Instead you + * need to call this function to read one chunk at a time. To check if the + * request requires this type of reading you can call the http_request_has_flag + * function to check if the HTTP_FLG_STREAMED flag is set. To read a streamed + * body you pass a callback that will be called when the chunk is ready. When + * the callback is called you can use 'http_request_chunk' to get the current + * chunk. When done with that chunk call this function again to request the + * next chunk. If the chunk has size 0 then the request body has been completely + * read and you can now respond. + * + * @param request The request. + * @param chunk_cb Callback for when the chunk is ready. + */ +void http_request_read_chunk(struct http_request_s *request, + void (*chunk_cb)(struct http_request_s *)); + +/** + * Returns the current chunk of the request body. + * + * This chunk is only valid until the next call to 'http_request_read_chunk'. + * + * @param request The request. + * + * @return The chunk data. + */ +struct http_string_s http_request_chunk(struct http_request_s *request); + +#define http_request_read_body http_request_read_chunk + +#ifdef __cplusplus +} +#endif + +// Minimal example usage. +#ifdef HTTPSERVER_EXAMPLE + +#define RESPONSE "Hello, World!" + +void handle_request(struct http_request_s *request) { + struct http_response_s *response = http_response_init(); + http_response_status(response, 200); + http_response_header(response, "Content-Type", "text/plain"); + http_response_body(response, RESPONSE, sizeof(RESPONSE) - 1); + http_respond(request, response); +} + +int main() { + struct http_server_s *server = http_server_init(8080, handle_request); + http_server_listen(server); +} + +#endif + +#endif + +#line 1 "common.h" +#ifndef HS_COMMON_H +#define HS_COMMON_H + +// http session states +#define HTTP_SESSION_INIT 0 +#define HTTP_SESSION_READ 1 +#define HTTP_SESSION_WRITE 2 +#define HTTP_SESSION_NOP 3 + +#define HTTP_REQUEST_TIMEOUT 20 + +#define HTTP_FLAG_SET(var, flag) var |= flag +#define HTTP_FLAG_CLEAR(var, flag) var &= ~flag +#define HTTP_FLAG_CHECK(var, flag) (var & flag) + +#define HTTP_AUTOMATIC 0x8 +#define HTTP_CHUNKED_RESPONSE 0x20 + +#define HTTP_KEEP_ALIVE 1 +#define HTTP_CLOSE 0 + +#include <arpa/inet.h> +#include <sys/socket.h> +#ifdef KQUEUE +#include <sys/event.h> +#else +#include <sys/epoll.h> +#endif + +#ifdef EPOLL +typedef void (*epoll_cb_t)(struct epoll_event *); +#endif + +typedef struct http_ev_cb_s { +#ifdef KQUEUE + void (*handler)(struct kevent *ev); +#else + epoll_cb_t handler; +#endif +} ev_cb_t; + +struct hsh_buffer_s { + char *buf; + int32_t capacity; + int32_t length; + int32_t index; + int32_t after_headers_index; + int8_t sequence_id; +}; + +enum hsh_token_e { + HSH_TOK_METHOD, + HSH_TOK_TARGET, + HSH_TOK_VERSION, + HSH_TOK_HEADER_KEY, + HSH_TOK_HEADER_VALUE, + HSH_TOK_HEADERS_DONE, + HSH_TOK_BODY, + HSH_TOK_NONE, + HSH_TOK_ERR +}; + +struct hsh_token_s { + enum hsh_token_e type; + uint8_t flags; + int len; + int index; +}; + +struct hsh_parser_s { + int64_t content_length; + int64_t content_remaining; + struct hsh_token_s token; + int16_t limit_count; + int16_t limit_max; + int8_t state; + int8_t flags; + int8_t sequence_id; +}; + +struct hs_token_array_s { + struct hsh_token_s *buf; + int capacity; + int size; +}; + +typedef struct http_request_s { +#ifdef KQUEUE + void (*handler)(struct kevent *ev); +#else + epoll_cb_t handler; + epoll_cb_t timer_handler; + int timerfd; +#endif + void (*chunk_cb)(struct http_request_s *); + void *data; + struct hsh_buffer_s buffer; + struct hsh_parser_s parser; + struct hs_token_array_s tokens; + int state; + int socket; + int timeout; + int64_t bytes_written; + struct http_server_s *server; + char flags; +} http_request_t; + +typedef struct http_server_s { +#ifdef KQUEUE + void (*handler)(struct kevent *ev); +#else + epoll_cb_t handler; + epoll_cb_t timer_handler; +#endif + int64_t memused; + int socket; + int port; + int loop; + int timerfd; + socklen_t len; + void (*request_handler)(http_request_t *); + struct sockaddr_in addr; + void *data; + char date[32]; +} http_server_t; + +#endif + +#line 1 "buffer_util.h" +#ifndef HS_BUFFER_UTIL_H +#define HS_BUFFER_UTIL_H + +#include <stdlib.h> + +#ifndef HTTPSERVER_IMPL +// #include "common.h" +#endif + +static inline void _hs_buffer_free(struct hsh_buffer_s *buffer, + int64_t *memused) { + if (buffer->buf) { + free(buffer->buf); + *memused -= buffer->capacity; + buffer->buf = NULL; + } +} + +#endif + +#line 1 "request_util.h" +#ifndef HS_REQUEST_UTIL_H +#define HS_REQUEST_UTIL_H + +// #include "common.h" + +// http version indicators +#define HTTP_1_0 0 +#define HTTP_1_1 1 + +struct http_string_s { + char const *buf; + int len; +}; + +typedef struct http_string_s http_string_t; + +http_string_t hs_get_token_string(http_request_t *request, + enum hsh_token_e token_type); +http_string_t hs_request_header(http_request_t *request, char const *key); +void hs_request_detect_keep_alive_flag(http_request_t *request); +int hs_request_iterate_headers(http_request_t *request, http_string_t *key, + http_string_t *val, int *iter); +void hs_request_set_keep_alive_flag(http_request_t *request, int directive); +http_string_t hs_request_chunk(struct http_request_s *request); + +#endif + +#line 1 "parser.h" +#ifndef HTTP_PARSER_H +#define HTTP_PARSER_H + +// HSH_TOK_HEADERS_DONE flags +#define HSH_TOK_FLAG_NO_BODY 0x1 +#define HSH_TOK_FLAG_STREAMED_BODY 0x2 + +// HSH_TOK_BODY flags +#define HSH_TOK_FLAG_BODY_FINAL 0x1 +#define HSH_TOK_FLAG_SMALL_BODY 0x2 + +struct hsh_token_s hsh_parser_exec(struct hsh_parser_s *parser, + struct hsh_buffer_s *buffer, + int max_buf_capacity); +void hsh_parser_init(struct hsh_parser_s *parser); + +#endif + +#line 1 "read_socket.h" +#ifndef HS_READ_SOCKET_H +#define HS_READ_SOCKET_H + +#define HTTP_FLG_STREAMED 0x1 + +#include <stdint.h> + +struct http_request_s; + +// Response code for hs_read_socket +enum hs_read_rc_e { + // Execution was successful + HS_READ_RC_SUCCESS, + // There was an error parsing the HTTP request + HS_READ_RC_PARSE_ERR, + // There was an error reading the socket + HS_READ_RC_SOCKET_ERR +}; + +// Holds configuration options for the hs_read_socket procedure. +struct hs_read_opts_s { + // Restricts the request buffer from ever growing larger than this size + int64_t max_request_buf_capacity; + // The value to be compared to the return of the read call to determine if + // the connection has been closed. Should generally be 0 in normal operation + // using sockets but can be useful to change if you want to use files instead + // of sockets for testing. + int eof_rc; + // The initial capacity that is allocated for the request buffer + int initial_request_buf_capacity; +}; + +enum hs_read_rc_e +hs_read_request_and_exec_user_cb(struct http_request_s *request, + struct hs_read_opts_s opts); + +#endif + +#line 1 "respond.h" +#ifndef HS_RESPOND_H +#define HS_RESPOND_H + +#define HTTP_RESPONSE_BUF_SIZE 1024 + +struct http_request_s; + +typedef void (*hs_req_fn_t)(struct http_request_s *); + +// Represents a single header of an HTTP response. +typedef struct http_header_s { + // The key of the header eg: Content-Type + char const *key; + // The value of the header eg: application/json + char const *value; + // Pointer to the next header in the linked list. + struct http_header_s *next; +} http_header_t; + +// Represents the response of an HTTP request before it is serialized on the +// wire. +typedef struct http_response_s { + // Head of the linked list of response headers + http_header_t *headers; + // The complete body of the response or the chunk if generating a chunked + // response. + char const *body; + // The length of the body or chunk. + int content_length; + // The HTTP status code for the response. + int status; +} http_response_t; + +http_response_t *hs_response_init(); +void hs_response_set_header(http_response_t *response, char const *key, + char const *value); +void hs_response_set_status(http_response_t *response, int status); +void hs_response_set_body(http_response_t *response, char const *body, + int length); +void hs_request_respond(struct http_request_s *request, + http_response_t *response, hs_req_fn_t http_write); +void hs_request_respond_chunk(struct http_request_s *request, + http_response_t *response, hs_req_fn_t cb, + hs_req_fn_t http_write); +void hs_request_respond_chunk_end(struct http_request_s *request, + http_response_t *response, + hs_req_fn_t http_write); +void hs_request_respond_error(struct http_request_s *request, int code, + char const *message, hs_req_fn_t http_write); + +#endif + +#line 1 "server.h" +#ifndef HS_SERVER_H +#define HS_SERVER_H + +#ifdef KQUEUE + +struct kevent; + +typedef void (*hs_evt_cb_t)(struct kevent *ev); + +#else + +struct epoll_event; + +typedef void (*hs_evt_cb_t)(struct epoll_event *ev); + +#endif + +struct http_request_s; +struct http_server_s; + +void hs_server_listen_on_addr(struct http_server_s *serv, const char *ipaddr); +int hs_server_run_event_loop(struct http_server_s *serv, const char *ipaddr); +void hs_generate_date_time(char *datetime); +struct http_server_s *hs_server_init(int port, + void (*handler)(struct http_request_s *), + hs_evt_cb_t accept_cb, + hs_evt_cb_t timer_cb); +int hs_server_poll_events(struct http_server_s *serv); + +#endif + +#line 1 "write_socket.h" +#ifndef HS_WRITE_SOCKET_H +#define HS_WRITE_SOCKET_H + +#define HTTP_KEEP_ALIVE_TIMEOUT 120 + +struct http_request_s; + +// Response code for hs_write_socket +enum hs_write_rc_e { + // Successful and has written the full response + HS_WRITE_RC_SUCCESS, + // Successful and has written the full chunk + HS_WRITE_RC_SUCCESS_CHUNK, + // Successful, has written the full response and the socket should be closed + HS_WRITE_RC_SUCCESS_CLOSE, + // Successful but has not written the full response, wait for write ready + HS_WRITE_RC_CONTINUE, + // Error writing to the socket + HS_WRITE_RC_SOCKET_ERR +}; + +enum hs_write_rc_e hs_write_socket(struct http_request_s *request); + +#endif + +#line 1 "connection.h" +#ifndef HS_CONNECTION_H +#define HS_CONNECTION_H + +// Forward declarations +struct http_request_s; +struct http_server_s; + +#ifdef KQUEUE +struct kevent; +typedef void (*hs_io_cb_t)(struct kevent *ev); +#else +struct epoll_event; +typedef void (*hs_io_cb_t)(struct epoll_event *ev); +#endif + +/* Closes the requests socket and frees its resources. + * + * Removes all event watchers from the request socket and frees any allocated + * buffers associated with the request struct. + * + * @param request The request to close + */ +void hs_request_terminate_connection(struct http_request_s *request); + +/* Accepts connections on the server socket in a loop until it would block. + * + * When a connection is accepted a request struct is allocated and initialized + * and the request socket is set to non-blocking mode. Event watchers are set + * on the socket to call io_cb with a read/write ready event occurs. If the + * server has reached max_mem_usage the err_responder function is called to + * handle the issue. + * + * @param server The http server struct. + * @param io_cb The callback function to respond to events on the request socket + * @param epoll_timer_cb The callback function to respond to timer events for + * epoll. Can be NULL if not using epoll. + * @param err_responder The procedure to call when memory usage has reached the + * given limit. Typically this could respond with a 503 error and close the + * connection. + * @param max_mem_usage The limit at which err_responder should be called + * instead of regular operation. + */ +struct http_request_s *hs_server_accept_connection(struct http_server_s *server, + hs_io_cb_t io_cb, + hs_io_cb_t epoll_timer_cb); + +#endif + +#line 1 "io_events.h" +#ifndef HS_IO_EVENTS_H +#define HS_IO_EVENTS_H + +#define HTTP_REQUEST_BUF_SIZE 1024 +#define HTTP_MAX_REQUEST_BUF_SIZE 8388608 // 8mb +#define HTTP_MAX_TOTAL_EST_MEM_USAGE 4294967296 // 4gb + +struct http_request_s; + +void hs_request_begin_write(struct http_request_s *request); +void hs_request_begin_read(struct http_request_s *request); + +#ifdef KQUEUE + +struct kevent; + +void hs_on_kqueue_server_event(struct kevent *ev); + +#else + +struct epoll_event; + +void hs_on_epoll_server_connection_event(struct epoll_event *ev); +void hs_on_epoll_server_timer_event(struct epoll_event *ev); + +#endif + +#endif + +#ifdef HTTPSERVER_IMPL +#ifndef HTTPSERVER_IMPL_ONCE +#define HTTPSERVER_IMPL_ONCE +#line 1 "api.c" +#include <stdlib.h> + +#ifndef HTTPSERVER_IMPL +#include "api.h" +#include "buffer_util.h" +#include "common.h" +#include "io_events.h" +#include "request_util.h" +#include "respond.h" +#include "server.h" +#endif + +int http_request_has_flag(http_request_t *request, int flag) { + return HTTP_FLAG_CHECK(request->flags, flag); +} + +int http_server_loop(http_server_t *server) { return server->loop; } + +http_server_t *http_server_init(int port, void (*handler)(http_request_t *)) { +#ifdef KQUEUE + return hs_server_init(port, handler, hs_on_kqueue_server_event, NULL); +#else + return hs_server_init(port, handler, hs_on_epoll_server_connection_event, + hs_on_epoll_server_timer_event); +#endif +} + +void http_request_free_buffer(http_request_t *request) { + _hs_buffer_free(&request->buffer, &request->server->memused); +} + +void *http_request_userdata(http_request_t *request) { return request->data; } + +void http_request_set_userdata(http_request_t *request, void *data) { + request->data = data; +} + +void http_server_set_userdata(struct http_server_s *serv, void *data) { + serv->data = data; +} + +void *http_request_server_userdata(struct http_request_s *request) { + return request->server->data; +} + +int http_request_iterate_headers(http_request_t *request, http_string_t *key, + http_string_t *val, int *iter) { + return hs_request_iterate_headers(request, key, val, iter); +} + +http_string_t http_request_header(http_request_t *request, char const *key) { + return hs_request_header(request, key); +} + +void http_request_connection(http_request_t *request, int directive) { + hs_request_set_keep_alive_flag(request, directive); +} + +http_string_t http_request_chunk(struct http_request_s *request) { + return hs_request_chunk(request); +} + +http_response_t *http_response_init() { return hs_response_init(); } + +void http_response_header(http_response_t *response, char const *key, + char const *value) { + return hs_response_set_header(response, key, value); +} + +void http_response_status(http_response_t *response, int status) { + hs_response_set_status(response, status); +} + +void http_response_body(http_response_t *response, char const *body, + int length) { + hs_response_set_body(response, body, length); +} + +void http_respond(http_request_t *request, http_response_t *response) { + hs_request_respond(request, response, hs_request_begin_write); +} + +void http_respond_chunk(http_request_t *request, http_response_t *response, + void (*cb)(http_request_t *)) { + hs_request_respond_chunk(request, response, cb, hs_request_begin_write); +} + +void http_respond_chunk_end(http_request_t *request, + http_response_t *response) { + hs_request_respond_chunk_end(request, response, hs_request_begin_write); +} + +http_string_t http_request_method(http_request_t *request) { + return hs_get_token_string(request, HSH_TOK_METHOD); +} + +http_string_t http_request_target(http_request_t *request) { + return hs_get_token_string(request, HSH_TOK_TARGET); +} + +http_string_t http_request_body(http_request_t *request) { + return hs_get_token_string(request, HSH_TOK_BODY); +} + +int http_server_listen(http_server_t *serv) { + return hs_server_run_event_loop(serv, NULL); +} + +int http_server_listen_addr(http_server_t *serv, const char *ipaddr) { + return hs_server_run_event_loop(serv, ipaddr); +} + +int http_server_poll(http_server_t *serv) { + return hs_server_poll_events(serv); +} + +int http_server_listen_poll(http_server_t *serv) { + hs_server_listen_on_addr(serv, NULL); + return 0; +} + +int http_server_listen_addr_poll(http_server_t *serv, const char *ipaddr) { + hs_server_listen_on_addr(serv, ipaddr); + return 0; +} + +void http_request_read_chunk(struct http_request_s *request, + void (*chunk_cb)(struct http_request_s *)) { + request->state = HTTP_SESSION_READ; + request->chunk_cb = chunk_cb; + hs_request_begin_read(request); +} + +#line 1 "request_util.c" +#include <stdlib.h> +#include <string.h> + +#ifndef HTTPSERVER_IMPL +#include "common.h" +#include "request_util.h" +#endif + +int _hs_case_insensitive_cmp(char const *a, char const *b, int len) { + for (int i = 0; i < len; i++) { + char c1 = a[i] >= 'A' && a[i] <= 'Z' ? a[i] + 32 : a[i]; + char c2 = b[i] >= 'A' && b[i] <= 'Z' ? b[i] + 32 : b[i]; + if (c1 != c2) + return 0; + } + return 1; +} + +http_string_t hs_get_token_string(http_request_t *request, + enum hsh_token_e token_type) { + http_string_t str = {0, 0}; + if (request->tokens.buf == NULL) + return str; + for (int i = 0; i < request->tokens.size; i++) { + struct hsh_token_s token = request->tokens.buf[i]; + if (token.type == token_type) { + str.buf = &request->buffer.buf[token.index]; + str.len = token.len; + return str; + } + } + return str; +} + +http_string_t hs_request_header(http_request_t *request, char const *key) { + int len = strlen(key); + for (int i = 0; i < request->tokens.size; i++) { + struct hsh_token_s token = request->tokens.buf[i]; + if (token.type == HSH_TOK_HEADER_KEY && token.len == len) { + if (_hs_case_insensitive_cmp(&request->buffer.buf[token.index], key, + len)) { + token = request->tokens.buf[i + 1]; + return (http_string_t){.buf = &request->buffer.buf[token.index], + .len = token.len}; + } + } + } + return (http_string_t){}; +} + +void hs_request_detect_keep_alive_flag(http_request_t *request) { + http_string_t str = hs_get_token_string(request, HSH_TOK_VERSION); + if (str.buf == NULL) + return; + int version = str.buf[str.len - 1] == '1'; + str = hs_request_header(request, "Connection"); + if ((str.len == 5 && _hs_case_insensitive_cmp(str.buf, "close", 5)) || + (str.len == 0 && version == HTTP_1_0)) { + HTTP_FLAG_CLEAR(request->flags, HTTP_KEEP_ALIVE); + } else { + HTTP_FLAG_SET(request->flags, HTTP_KEEP_ALIVE); + } +} + +int _hs_get_header_key_val(http_request_t *request, http_string_t *key, + http_string_t *val, int iter) { + struct hsh_token_s token = request->tokens.buf[iter]; + if (request->tokens.buf[iter].type == HSH_TOK_HEADERS_DONE) + return 0; + *key = (http_string_t){.buf = &request->buffer.buf[token.index], + .len = token.len}; + token = request->tokens.buf[iter + 1]; + *val = (http_string_t){.buf = &request->buffer.buf[token.index], + .len = token.len}; + return 1; +} + +int hs_request_iterate_headers(http_request_t *request, http_string_t *key, + http_string_t *val, int *iter) { + if (*iter == 0) { + for (; *iter < request->tokens.size; (*iter)++) { + struct hsh_token_s token = request->tokens.buf[*iter]; + if (token.type == HSH_TOK_HEADER_KEY) { + int more = _hs_get_header_key_val(request, key, val, *iter); + (*iter)++; + return more; + } + } + return 0; + } else { + (*iter)++; + int more = _hs_get_header_key_val(request, key, val, *iter); + (*iter)++; + return more; + } +} + +void hs_request_set_keep_alive_flag(http_request_t *request, int directive) { + if (directive == HTTP_KEEP_ALIVE) { + HTTP_FLAG_CLEAR(request->flags, HTTP_AUTOMATIC); + HTTP_FLAG_SET(request->flags, HTTP_KEEP_ALIVE); + } else if (directive == HTTP_CLOSE) { + HTTP_FLAG_CLEAR(request->flags, HTTP_AUTOMATIC); + HTTP_FLAG_CLEAR(request->flags, HTTP_KEEP_ALIVE); + } +} + +http_string_t hs_request_chunk(struct http_request_s *request) { + struct hsh_token_s token = request->tokens.buf[request->tokens.size - 1]; + return (http_string_t){.buf = &request->buffer.buf[token.index], + .len = token.len}; +} + +#line 1 "parser.c" + +#line 1 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" +#include <string.h> +#include <stdlib.h> + +#ifndef HTTPSERVER_IMPL +#include "common.h" +#include "parser.h" +#endif + +#define HSH_P_FLAG_CHUNKED 0x1 +#define HSH_P_FLAG_TOKEN_READY 0x2 +#define HSH_P_FLAG_DONE 0x4 + +#define HSH_ENTER_TOKEN(tok_type, max_len) \ + parser->token.type = tok_type; \ + parser->token.index = p - buffer->buf; \ + parser->token.flags = 0; \ + parser->limit_count = 0; \ + parser->limit_max = max_len; + + +#line 232 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + + + +#line 28 "/Users/jeremywilliams/code/httpserver.h/build/src/parser.c" +static const char _hsh_http_actions[] = { + 0, 1, 2, 1, 6, 1, 10, 1, + 13, 1, 14, 1, 15, 1, 16, 1, + 17, 1, 18, 2, 0, 10, 2, 1, + 10, 2, 4, 10, 2, 5, 14, 2, + 5, 16, 2, 5, 17, 2, 7, 10, + 2, 8, 10, 2, 10, 11, 2, 12, + 13, 2, 13, 14, 3, 3, 9, 10, + 3, 4, 10, 6, 3, 7, 4, 10, + 3, 9, 3, 10, 3, 13, 5, 14, + 3, 13, 14, 12, 3, 14, 12, 13, + 4, 5, 14, 12, 13, 4, 13, 5, + 14, 12, 4, 14, 12, 13, 15 +}; + +static const short _hsh_http_key_offsets[] = { + 0, 0, 4, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 20, 21, 22, + 39, 53, 55, 58, 60, 61, 79, 94, + 110, 126, 142, 158, 174, 190, 205, 221, + 237, 253, 269, 285, 301, 315, 317, 322, + 324, 328, 344, 360, 376, 392, 408, 424, + 440, 455, 471, 487, 503, 519, 535, 551, + 567, 583, 597, 599, 603, 606, 609, 612, + 615, 618, 621, 622, 623, 624, 631, 632, + 632, 633, 634, 635, 642, 643, 643, 644, + 652, 661, 669, 677, 686, 688, 697, 698, + 699, 699, 699, 713, 713, 713, 721, 729, + 729, 729 +}; + +static const char _hsh_http_trans_keys[] = { + 65, 90, 97, 122, 32, 65, 90, 97, + 122, 32, 32, 72, 84, 84, 80, 47, + 49, 46, 48, 49, 13, 10, 9, 32, + 34, 44, 47, 67, 84, 99, 116, 123, + 125, 40, 41, 58, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 9, + 13, 32, 10, 13, 10, 9, 13, 32, + 34, 44, 47, 67, 84, 99, 116, 123, + 125, 40, 41, 58, 64, 91, 93, 9, + 10, 32, 34, 44, 47, 58, 123, 125, + 40, 41, 59, 64, 91, 93, 9, 32, + 34, 44, 47, 58, 79, 111, 123, 125, + 40, 41, 59, 64, 91, 93, 9, 32, + 34, 44, 47, 58, 78, 110, 123, 125, + 40, 41, 59, 64, 91, 93, 9, 32, + 34, 44, 47, 58, 84, 116, 123, 125, + 40, 41, 59, 64, 91, 93, 9, 32, + 34, 44, 47, 58, 69, 101, 123, 125, + 40, 41, 59, 64, 91, 93, 9, 32, + 34, 44, 47, 58, 78, 110, 123, 125, + 40, 41, 59, 64, 91, 93, 9, 32, + 34, 44, 47, 58, 84, 116, 123, 125, + 40, 41, 59, 64, 91, 93, 9, 32, + 34, 44, 45, 47, 58, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 34, + 44, 47, 58, 76, 108, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 34, + 44, 47, 58, 69, 101, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 34, + 44, 47, 58, 78, 110, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 34, + 44, 47, 58, 71, 103, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 34, + 44, 47, 58, 84, 116, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 34, + 44, 47, 58, 72, 104, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 34, + 44, 47, 58, 123, 125, 40, 41, 59, + 64, 91, 93, 9, 32, 9, 13, 32, + 48, 57, 10, 13, 10, 13, 48, 57, + 9, 32, 34, 44, 47, 58, 82, 114, + 123, 125, 40, 41, 59, 64, 91, 93, + 9, 32, 34, 44, 47, 58, 65, 97, + 123, 125, 40, 41, 59, 64, 91, 93, + 9, 32, 34, 44, 47, 58, 78, 110, + 123, 125, 40, 41, 59, 64, 91, 93, + 9, 32, 34, 44, 47, 58, 83, 115, + 123, 125, 40, 41, 59, 64, 91, 93, + 9, 32, 34, 44, 47, 58, 70, 102, + 123, 125, 40, 41, 59, 64, 91, 93, + 9, 32, 34, 44, 47, 58, 69, 101, + 123, 125, 40, 41, 59, 64, 91, 93, + 9, 32, 34, 44, 47, 58, 82, 114, + 123, 125, 40, 41, 59, 64, 91, 93, + 9, 32, 34, 44, 45, 47, 58, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 69, 101, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 78, 110, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 67, 99, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 79, 111, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 68, 100, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 73, 105, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 78, 110, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 71, 103, 123, + 125, 40, 41, 59, 64, 91, 93, 9, + 32, 34, 44, 47, 58, 123, 125, 40, + 41, 59, 64, 91, 93, 9, 32, 9, + 13, 32, 99, 10, 13, 104, 10, 13, + 117, 10, 13, 110, 10, 13, 107, 10, + 13, 101, 10, 13, 100, 13, 10, 48, + 13, 48, 57, 65, 70, 97, 102, 10, + 13, 10, 48, 13, 48, 57, 65, 70, + 97, 102, 10, 48, 13, 48, 49, 57, + 65, 70, 97, 102, 10, 13, 48, 49, + 57, 65, 70, 97, 102, 13, 48, 49, + 57, 65, 70, 97, 102, 13, 48, 49, + 57, 65, 70, 97, 102, 10, 13, 48, + 49, 57, 65, 70, 97, 102, 13, 48, + 10, 13, 48, 49, 57, 65, 70, 97, + 102, 13, 10, 9, 32, 34, 44, 47, + 58, 123, 125, 40, 41, 59, 64, 91, + 93, 13, 48, 49, 57, 65, 70, 97, + 102, 13, 48, 49, 57, 65, 70, 97, + 102, 0 +}; + +static const char _hsh_http_single_lengths[] = { + 0, 0, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 0, 1, 1, 11, + 8, 2, 3, 2, 1, 12, 9, 10, + 10, 10, 10, 10, 10, 9, 10, 10, + 10, 10, 10, 10, 8, 2, 3, 2, + 2, 10, 10, 10, 10, 10, 10, 10, + 9, 10, 10, 10, 10, 10, 10, 10, + 10, 8, 2, 4, 3, 3, 3, 3, + 3, 3, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 0, 1, 2, + 3, 2, 2, 3, 2, 3, 1, 1, + 0, 0, 8, 0, 0, 2, 2, 0, + 0, 0 +}; + +static const char _hsh_http_range_lengths[] = { + 0, 2, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 3, + 3, 0, 0, 0, 0, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 0, 1, 0, + 1, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 3, + 3, 3, 3, 3, 0, 3, 0, 0, + 0, 0, 3, 0, 0, 3, 3, 0, + 0, 0 +}; + +static const short _hsh_http_index_offsets[] = { + 0, 0, 3, 7, 9, 11, 13, 15, + 17, 19, 21, 23, 25, 27, 29, 31, + 46, 58, 61, 65, 68, 70, 86, 99, + 113, 127, 141, 155, 169, 183, 196, 210, + 224, 238, 252, 266, 280, 292, 295, 300, + 303, 307, 321, 335, 349, 363, 377, 391, + 405, 418, 432, 446, 460, 474, 488, 502, + 516, 530, 542, 545, 550, 554, 558, 562, + 566, 570, 574, 576, 578, 580, 585, 587, + 588, 590, 592, 594, 599, 601, 602, 604, + 610, 617, 623, 629, 636, 639, 646, 648, + 650, 651, 652, 664, 665, 666, 672, 678, + 679, 680 +}; + +static const char _hsh_http_indicies[] = { + 1, 1, 0, 2, 3, 3, 0, 0, + 4, 6, 5, 7, 0, 8, 0, 9, + 0, 10, 0, 11, 0, 12, 0, 13, + 0, 14, 0, 15, 0, 16, 0, 0, + 0, 0, 0, 0, 18, 19, 18, 19, + 0, 0, 0, 0, 0, 17, 0, 0, + 0, 0, 0, 21, 0, 0, 0, 0, + 0, 20, 22, 22, 0, 24, 25, 24, + 23, 0, 27, 26, 28, 0, 0, 30, + 0, 0, 0, 0, 31, 32, 31, 32, + 0, 0, 0, 0, 0, 29, 0, 33, + 0, 0, 0, 0, 21, 0, 0, 0, + 0, 0, 20, 0, 0, 0, 0, 0, + 21, 34, 34, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 0, 0, 21, 35, + 35, 0, 0, 0, 0, 0, 20, 0, + 0, 0, 0, 0, 21, 36, 36, 0, + 0, 0, 0, 0, 20, 0, 0, 0, + 0, 0, 21, 37, 37, 0, 0, 0, + 0, 0, 20, 0, 0, 0, 0, 0, + 21, 38, 38, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 0, 0, 21, 39, + 39, 0, 0, 0, 0, 0, 20, 0, + 0, 0, 0, 40, 0, 21, 0, 0, + 0, 0, 0, 20, 0, 0, 0, 0, + 0, 21, 41, 41, 0, 0, 0, 0, + 0, 20, 0, 0, 0, 0, 0, 21, + 42, 42, 0, 0, 0, 0, 0, 20, + 0, 0, 0, 0, 0, 21, 43, 43, + 0, 0, 0, 0, 0, 20, 0, 0, + 0, 0, 0, 21, 44, 44, 0, 0, + 0, 0, 0, 20, 0, 0, 0, 0, + 0, 21, 45, 45, 0, 0, 0, 0, + 0, 20, 0, 0, 0, 0, 0, 21, + 46, 46, 0, 0, 0, 0, 0, 20, + 0, 0, 0, 0, 0, 47, 0, 0, + 0, 0, 0, 20, 48, 48, 0, 49, + 25, 49, 50, 23, 28, 27, 26, 0, + 27, 51, 26, 0, 0, 0, 0, 0, + 21, 52, 52, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 0, 0, 21, 53, + 53, 0, 0, 0, 0, 0, 20, 0, + 0, 0, 0, 0, 21, 54, 54, 0, + 0, 0, 0, 0, 20, 0, 0, 0, + 0, 0, 21, 55, 55, 0, 0, 0, + 0, 0, 20, 0, 0, 0, 0, 0, + 21, 56, 56, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 0, 0, 21, 57, + 57, 0, 0, 0, 0, 0, 20, 0, + 0, 0, 0, 0, 21, 58, 58, 0, + 0, 0, 0, 0, 20, 0, 0, 0, + 0, 59, 0, 21, 0, 0, 0, 0, + 0, 20, 0, 0, 0, 0, 0, 21, + 60, 60, 0, 0, 0, 0, 0, 20, + 0, 0, 0, 0, 0, 21, 61, 61, + 0, 0, 0, 0, 0, 20, 0, 0, + 0, 0, 0, 21, 62, 62, 0, 0, + 0, 0, 0, 20, 0, 0, 0, 0, + 0, 21, 63, 63, 0, 0, 0, 0, + 0, 20, 0, 0, 0, 0, 0, 21, + 64, 64, 0, 0, 0, 0, 0, 20, + 0, 0, 0, 0, 0, 21, 65, 65, + 0, 0, 0, 0, 0, 20, 0, 0, + 0, 0, 0, 21, 66, 66, 0, 0, + 0, 0, 0, 20, 0, 0, 0, 0, + 0, 21, 67, 67, 0, 0, 0, 0, + 0, 20, 0, 0, 0, 0, 0, 68, + 0, 0, 0, 0, 0, 20, 69, 69, + 0, 70, 25, 70, 71, 23, 0, 27, + 72, 26, 0, 27, 73, 26, 0, 27, + 74, 26, 0, 27, 75, 26, 0, 27, + 76, 26, 0, 27, 77, 26, 78, 0, + 79, 0, 81, 80, 82, 83, 83, 83, + 0, 84, 0, 85, 86, 0, 87, 0, + 89, 88, 90, 91, 91, 91, 0, 92, + 0, 93, 95, 94, 96, 97, 98, 98, + 98, 94, 99, 96, 97, 98, 98, 98, + 94, 101, 102, 103, 103, 103, 100, 104, + 97, 98, 98, 98, 94, 105, 96, 97, + 98, 98, 98, 94, 106, 95, 94, 107, + 96, 97, 98, 98, 98, 94, 108, 0, + 109, 0, 110, 111, 0, 0, 0, 0, + 0, 21, 0, 0, 0, 0, 0, 20, + 112, 0, 101, 102, 103, 103, 103, 100, + 96, 97, 98, 98, 98, 94, 0, 113, + 114, 0 +}; + +static const char _hsh_http_trans_targs[] = { + 0, 2, 3, 2, 4, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 23, 41, 16, 17, 18, 19, + 18, 39, 19, 20, 21, 16, 22, 23, + 41, 90, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, + 38, 38, 40, 40, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 59, 60, + 61, 62, 63, 64, 65, 19, 67, 68, + 69, 72, 70, 69, 71, 91, 73, 92, + 75, 86, 76, 75, 77, 78, 79, 84, + 80, 82, 79, 81, 79, 80, 82, 79, + 83, 93, 85, 94, 87, 95, 96, 97, + 91, 96, 97 +}; + +static const char _hsh_http_trans_actions[] = { + 17, 19, 3, 5, 22, 5, 3, 1, + 0, 0, 0, 0, 0, 0, 0, 3, + 0, 64, 64, 64, 5, 3, 0, 25, + 25, 56, 5, 3, 5, 52, 52, 52, + 52, 43, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 3, + 0, 25, 60, 37, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 3, 0, 25, 25, + 5, 5, 5, 5, 5, 40, 0, 0, + 46, 0, 0, 7, 0, 28, 0, 11, + 46, 0, 0, 7, 0, 28, 76, 9, + 76, 49, 72, 76, 80, 80, 68, 85, + 76, 90, 76, 90, 0, 11, 31, 34, + 9, 13, 15 +}; + +static const char _hsh_http_eof_actions[] = { + 0, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0 +}; + +static const int hsh_http_start = 1; +static const int hsh_http_first_final = 90; +static const int hsh_http_error = 0; + +static const int hsh_http_en_chunk_end = 66; +static const int hsh_http_en_chunked_body = 74; +static const int hsh_http_en_small_body = 88; +static const int hsh_http_en_large_body = 89; +static const int hsh_http_en_main = 1; + + +#line 235 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + +void hsh_parser_init(struct hsh_parser_s* parser) { + memset(parser, 0, sizeof(struct hsh_parser_s)); + parser->state = hsh_http_start; +} + +struct hsh_token_s hsh_parser_exec(struct hsh_parser_s* parser, struct hsh_buffer_s* buffer, int max_buf_capacity) { + struct hsh_token_s none = {}; + none.type = HSH_TOK_NONE; + if (HTTP_FLAG_CHECK(parser->flags, HSH_P_FLAG_DONE) || parser->sequence_id == buffer->sequence_id) { + return none; + } + int cs = parser->state; + char* eof = NULL; + char *p = buffer->buf + buffer->index; + char *pe = buffer->buf + buffer->length; + +#line 373 "/Users/jeremywilliams/code/httpserver.h/build/src/parser.c" + { + int _klen; + unsigned int _trans; + const char *_acts; + unsigned int _nacts; + const char *_keys; + + if ( p == pe ) + goto _test_eof; + if ( cs == 0 ) + goto _out; +_resume: + _keys = _hsh_http_trans_keys + _hsh_http_key_offsets[cs]; + _trans = _hsh_http_index_offsets[cs]; + + _klen = _hsh_http_single_lengths[cs]; + if ( _klen > 0 ) { + const char *_lower = _keys; + const char *_mid; + const char *_upper = _keys + _klen - 1; + while (1) { + if ( _upper < _lower ) + break; + + _mid = _lower + ((_upper-_lower) >> 1); + if ( (*p) < *_mid ) + _upper = _mid - 1; + else if ( (*p) > *_mid ) + _lower = _mid + 1; + else { + _trans += (unsigned int)(_mid - _keys); + goto _match; + } + } + _keys += _klen; + _trans += _klen; + } + + _klen = _hsh_http_range_lengths[cs]; + if ( _klen > 0 ) { + const char *_lower = _keys; + const char *_mid; + const char *_upper = _keys + (_klen<<1) - 2; + while (1) { + if ( _upper < _lower ) + break; + + _mid = _lower + (((_upper-_lower) >> 1) & ~1); + if ( (*p) < _mid[0] ) + _upper = _mid - 2; + else if ( (*p) > _mid[1] ) + _lower = _mid + 2; + else { + _trans += (unsigned int)((_mid - _keys)>>1); + goto _match; + } + } + _trans += _klen; + } + +_match: + _trans = _hsh_http_indicies[_trans]; + cs = _hsh_http_trans_targs[_trans]; + + if ( _hsh_http_trans_actions[_trans] == 0 ) + goto _again; + + _acts = _hsh_http_actions + _hsh_http_trans_actions[_trans]; + _nacts = (unsigned int) *_acts++; + while ( _nacts-- > 0 ) + { + switch ( *_acts++ ) + { + case 0: +#line 23 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { HSH_ENTER_TOKEN(HSH_TOK_METHOD, 32) } + break; + case 1: +#line 24 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { HSH_ENTER_TOKEN(HSH_TOK_TARGET, 1024) } + break; + case 2: +#line 25 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { HSH_ENTER_TOKEN(HSH_TOK_VERSION, 16) } + break; + case 3: +#line 26 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { HSH_ENTER_TOKEN(HSH_TOK_HEADER_KEY, 256) } + break; + case 4: +#line 27 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { HSH_ENTER_TOKEN(HSH_TOK_HEADER_VALUE, 4096) } + break; + case 5: +#line 28 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + parser->token.type = HSH_TOK_BODY; + parser->token.flags = 0; + parser->token.index = p - buffer->buf; + } + break; + case 6: +#line 33 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + parser->token.len = p - (buffer->buf + parser->token.index); + // hsh_token_array_push(&parser->tokens, parser->token); + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY); + {p++; goto _out; } + } + break; + case 7: +#line 40 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + parser->content_length *= 10; + parser->content_length += (*p) - '0'; + } + break; + case 8: +#line 45 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_CHUNKED); + } + break; + case 9: +#line 49 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + parser->limit_count = 0; + parser->limit_max = 256; + } + break; + case 10: +#line 54 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + parser->limit_count++; + if (parser->limit_count > parser->limit_max) { + // parser->rc = (int8_t)HSH_PARSER_ERR; + {p++; goto _out; } + } + } + break; + case 11: +#line 62 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + buffer->after_headers_index = p - buffer->buf + 1; + parser->content_remaining = parser->content_length; + parser->token = (struct hsh_token_s){ }; + parser->token.type = HSH_TOK_HEADERS_DONE; + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY); + if (HTTP_FLAG_CHECK(parser->flags, HSH_P_FLAG_CHUNKED)) { + HTTP_FLAG_SET(parser->token.flags, HSH_TOK_FLAG_STREAMED_BODY); + cs = 74; + {p++; goto _out; } + } else if (parser->content_length == 0) { + HTTP_FLAG_SET(parser->token.flags, HSH_TOK_FLAG_NO_BODY); + {p++; goto _out; } + // The body won't fit into the buffer at maximum capacity. + } else if (parser->content_length > max_buf_capacity - buffer->after_headers_index) { + HTTP_FLAG_SET(parser->token.flags, HSH_TOK_FLAG_STREAMED_BODY); + cs = 89; + {p++; goto _out; } + } else { + // Resize the buffer to hold the full body + if (parser->content_length + buffer->after_headers_index > buffer->capacity) { + buffer->buf = (char*)realloc(buffer->buf, parser->content_length + buffer->after_headers_index); + buffer->capacity = parser->content_length + buffer->after_headers_index; + } + cs = 88; + {p++; goto _out; } + } + } + break; + case 12: +#line 91 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + parser->content_length = 0; + } + break; + case 13: +#line 95 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + if ((*p) >= 'A' && (*p) <= 'F') { + parser->content_length *= 0x10; + parser->content_length += (*p) - 55; + } else if ((*p) >= 'a' && (*p) <= 'f') { + parser->content_length *= 0x10; + parser->content_length += (*p) - 87; + } else if ((*p) >= '0' && (*p) <= '9') { + parser->content_length *= 0x10; + parser->content_length += (*p) - '0'; + } + } + break; + case 14: +#line 108 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + char* last_body_byte = buffer->buf + parser->token.index + parser->content_length - 1; + if (pe >= last_body_byte) { + p = last_body_byte; + parser->token.len = parser->content_length; + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY); + cs = 66; + {p++; goto _out; } + // The current chunk is at the end of the buffer and the buffer cannot be expanded. + // Move the remaining contents of the buffer to just after the headers to free up + // capacity in the buffer. + } else if (p - buffer->buf + parser->content_length > max_buf_capacity) { + memcpy(buffer->buf + buffer->after_headers_index, p, pe - p); + buffer->length = buffer->after_headers_index + pe - p; + p = buffer->buf + buffer->after_headers_index; + parser->token.index = buffer->after_headers_index; + parser->sequence_id = buffer->sequence_id; + p--; + {p++; goto _out; } + } + } + break; + case 15: +#line 130 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + // write 0 byte body to tokens + parser->token.type = HSH_TOK_BODY; + parser->token.index = 0; + parser->token.len = 0; + parser->token.flags = HSH_TOK_FLAG_BODY_FINAL; + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY); + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_DONE); + {p++; goto _out; } + } + break; + case 16: +#line 141 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + parser->token.index = buffer->after_headers_index; + parser->token.len = parser->content_length; + HTTP_FLAG_SET(parser->token.flags, HSH_TOK_FLAG_SMALL_BODY); + char* last_body_byte = buffer->buf + parser->token.index + parser->content_length - 1; + if (pe >= last_body_byte) { + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY); + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_DONE); + } + p = pe; + p--; + {p++; goto _out; } + } + break; + case 17: +#line 155 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + parser->token.index = buffer->after_headers_index; + char* last_body_byte = buffer->buf + buffer->after_headers_index + parser->content_remaining - 1; + if (pe >= last_body_byte) { + parser->token.flags = HSH_TOK_FLAG_BODY_FINAL; + parser->token.len = parser->content_remaining; + parser->content_remaining = 0; + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY); + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_DONE); + } else { + parser->token.len = pe - p; + parser->content_remaining -= parser->token.len; + HTTP_FLAG_SET(parser->flags, HSH_P_FLAG_TOKEN_READY); + p = buffer->buf + buffer->after_headers_index; + buffer->length = buffer->after_headers_index; + parser->sequence_id = buffer->sequence_id; + } + p--; + {p++; goto _out; } + } + break; + case 18: +#line 176 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + // parser->rc = (int8_t)HSH_PARSER_ERR; + {p++; goto _out; } + } + break; +#line 649 "/Users/jeremywilliams/code/httpserver.h/build/src/parser.c" + } + } + +_again: + if ( cs == 0 ) + goto _out; + if ( ++p != pe ) + goto _resume; + _test_eof: {} + if ( p == eof ) + { + const char *__acts = _hsh_http_actions + _hsh_http_eof_actions[cs]; + unsigned int __nacts = (unsigned int) *__acts++; + while ( __nacts-- > 0 ) { + switch ( *__acts++ ) { + case 18: +#line 176 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + { + // parser->rc = (int8_t)HSH_PARSER_ERR; + {p++; goto _out; } + } + break; +#line 672 "/Users/jeremywilliams/code/httpserver.h/build/src/parser.c" + } + } + } + + _out: {} + } + +#line 252 "/Users/jeremywilliams/code/httpserver.h/src/parser.rl" + parser->state = cs; + buffer->index = p - buffer->buf; + if (HTTP_FLAG_CHECK(parser->flags, HSH_P_FLAG_TOKEN_READY)) { + HTTP_FLAG_CLEAR(parser->flags, HSH_P_FLAG_TOKEN_READY); + return parser->token; + } else { + parser->sequence_id = buffer->sequence_id; + return none; + } +} + +#line 1 "read_socket.c" +#include <assert.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#ifndef HTTPSERVER_IMPL +#include "common.h" +#include "parser.h" +#include "read_socket.h" +#endif + +void _hs_token_array_push(struct hs_token_array_s *array, + struct hsh_token_s a) { + if (array->size == array->capacity) { + array->capacity *= 2; + array->buf = (struct hsh_token_s *)realloc( + array->buf, array->capacity * sizeof(struct hsh_token_s)); + assert(array->buf != NULL); + } + array->buf[array->size] = a; + array->size++; +} + +void _hs_buffer_init(struct hsh_buffer_s *buffer, int initial_capacity, + int64_t *memused) { + *buffer = (struct hsh_buffer_s){0}; + buffer->buf = (char *)calloc(1, initial_capacity); + *memused += initial_capacity; + assert(buffer->buf != NULL); + buffer->capacity = initial_capacity; +} + +int _hs_read_into_buffer(struct hsh_buffer_s *buffer, int request_socket, + int64_t *server_memused, + int64_t max_request_buf_capacity) { + int bytes; + do { + bytes = read(request_socket, buffer->buf + buffer->length, + buffer->capacity - buffer->length); + if (bytes > 0) + buffer->length += bytes; + + if (buffer->length == buffer->capacity && + buffer->capacity != max_request_buf_capacity) { + *server_memused -= buffer->capacity; + buffer->capacity *= 2; + if (buffer->capacity > max_request_buf_capacity) { + buffer->capacity = max_request_buf_capacity; + } + *server_memused += buffer->capacity; + buffer->buf = (char *)realloc(buffer->buf, buffer->capacity); + assert(buffer->buf != NULL); + } + } while (bytes > 0 && buffer->capacity < max_request_buf_capacity); + + buffer->sequence_id++; + + return bytes; +} + +int _hs_buffer_requires_read(struct hsh_buffer_s *buffer) { + return buffer->index >= buffer->length; +} + +void _hs_exec_callback(http_request_t *request, + void (*cb)(struct http_request_s *)) { + request->state = HTTP_SESSION_NOP; + cb(request); +} + +enum hs_read_rc_e +_hs_parse_buffer_and_exec_user_cb(http_request_t *request, + int max_request_buf_capacity) { + enum hs_read_rc_e rc = HS_READ_RC_SUCCESS; + + do { + struct hsh_token_s token = hsh_parser_exec( + &request->parser, &request->buffer, max_request_buf_capacity); + + switch (token.type) { + case HSH_TOK_HEADERS_DONE: + _hs_token_array_push(&request->tokens, token); + if (HTTP_FLAG_CHECK(token.flags, HSH_TOK_FLAG_STREAMED_BODY) || + HTTP_FLAG_CHECK(token.flags, HSH_TOK_FLAG_NO_BODY)) { + HTTP_FLAG_SET(request->flags, HTTP_FLG_STREAMED); + _hs_exec_callback(request, request->server->request_handler); + return rc; + } + break; + case HSH_TOK_BODY: + _hs_token_array_push(&request->tokens, token); + if (HTTP_FLAG_CHECK(token.flags, HSH_TOK_FLAG_SMALL_BODY)) { + _hs_exec_callback(request, request->server->request_handler); + } else { + if (HTTP_FLAG_CHECK(token.flags, HSH_TOK_FLAG_BODY_FINAL) && + token.len > 0) { + _hs_exec_callback(request, request->chunk_cb); + + // A zero length body is used to indicate to the user code that the + // body has finished streaming. This is natural when dealing with + // chunked request bodies but requires us to inject a zero length + // body for non-chunked requests. + struct hsh_token_s token = {}; + memset(&token, 0, sizeof(struct hsh_token_s)); + token.type = HSH_TOK_BODY; + _hs_token_array_push(&request->tokens, token); + _hs_exec_callback(request, request->chunk_cb); + } else { + _hs_exec_callback(request, request->chunk_cb); + } + } + return rc; + case HSH_TOK_ERR: + return HS_READ_RC_PARSE_ERR; + case HSH_TOK_NONE: + return rc; + default: + _hs_token_array_push(&request->tokens, token); + break; + } + } while (1); +} + +// Reads the request socket if required and parses HTTP in a non-blocking +// manner. +// +// It should be called when a new connection is established and when a read +// ready event occurs for the request socket. It parses the HTTP request and +// fills the tokens array of the request struct. It will also invoke the +// request_hander callback and the chunk_cb callback in the appropriate +// scenarios. +enum hs_read_rc_e hs_read_request_and_exec_user_cb(http_request_t *request, + struct hs_read_opts_s opts) { + request->state = HTTP_SESSION_READ; + request->timeout = HTTP_REQUEST_TIMEOUT; + + if (request->buffer.buf == NULL) { + _hs_buffer_init(&request->buffer, opts.initial_request_buf_capacity, + &request->server->memused); + hsh_parser_init(&request->parser); + } + + if (_hs_buffer_requires_read(&request->buffer)) { + int bytes = _hs_read_into_buffer(&request->buffer, request->socket, + &request->server->memused, + opts.max_request_buf_capacity); + + if (bytes == opts.eof_rc) { + return HS_READ_RC_SOCKET_ERR; + } + } + + return _hs_parse_buffer_and_exec_user_cb(request, + opts.max_request_buf_capacity); +} + +#line 1 "respond.c" +#include <assert.h> +#include <stdarg.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#ifndef HTTPSERVER_IMPL +#include "buffer_util.h" +#include "common.h" +#include "request_util.h" +#include "respond.h" +#endif + +char const *hs_status_text[] = { + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", + + // 100s + "Continue", "Switching Protocols", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", + + // 200s + "OK", "Created", "Accepted", "Non-Authoritative Information", "No Content", + "Reset Content", "Partial Content", "", "", "", + + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", + + // 300s + "Multiple Choices", "Moved Permanently", "Found", "See Other", + "Not Modified", "Use Proxy", "", "Temporary Redirect", "", "", + + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", + + // 400s + "Bad Request", "Unauthorized", "Payment Required", "Forbidden", "Not Found", + "Method Not Allowed", "Not Acceptable", "Proxy Authentication Required", + "Request Timeout", "Conflict", + + "Gone", "Length Required", "", "Payload Too Large", "", "", "", "", "", "", + + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", + + // 500s + "Internal Server Error", "Not Implemented", "Bad Gateway", + "Service Unavailable", "Gateway Timeout", "", "", "", "", "", + + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", ""}; +typedef struct { + char *buf; + int capacity; + int size; + int64_t *memused; +} grwprintf_t; + +void _grwprintf_init(grwprintf_t *ctx, int capacity, int64_t *memused) { + ctx->memused = memused; + ctx->size = 0; + ctx->buf = (char *)malloc(capacity); + *ctx->memused += capacity; + assert(ctx->buf != NULL); + ctx->capacity = capacity; +} + +void _grwmemcpy(grwprintf_t *ctx, char const *src, int size) { + if (ctx->size + size > ctx->capacity) { + *ctx->memused -= ctx->capacity; + ctx->capacity = ctx->size + size; + *ctx->memused += ctx->capacity; + ctx->buf = (char *)realloc(ctx->buf, ctx->capacity); + assert(ctx->buf != NULL); + } + memcpy(ctx->buf + ctx->size, src, size); + ctx->size += size; +} + +void _grwprintf(grwprintf_t *ctx, char const *fmt, ...) { + va_list args; + va_start(args, fmt); + + int bytes = + vsnprintf(ctx->buf + ctx->size, ctx->capacity - ctx->size, fmt, args); + if (bytes + ctx->size > ctx->capacity) { + *ctx->memused -= ctx->capacity; + while (bytes + ctx->size > ctx->capacity) + ctx->capacity *= 2; + *ctx->memused += ctx->capacity; + ctx->buf = (char *)realloc(ctx->buf, ctx->capacity); + assert(ctx->buf != NULL); + bytes += + vsnprintf(ctx->buf + ctx->size, ctx->capacity - ctx->size, fmt, args); + } + ctx->size += bytes; + + va_end(args); +} + +void _http_serialize_headers_list(http_response_t *response, + grwprintf_t *printctx) { + http_header_t *header = response->headers; + while (header) { + _grwprintf(printctx, "%s: %s\r\n", header->key, header->value); + header = header->next; + } + _grwprintf(printctx, "\r\n"); +} + +void _http_serialize_headers(http_request_t *request, http_response_t *response, + grwprintf_t *printctx) { + if (HTTP_FLAG_CHECK(request->flags, HTTP_AUTOMATIC)) { + hs_request_detect_keep_alive_flag(request); + } + if (HTTP_FLAG_CHECK(request->flags, HTTP_KEEP_ALIVE)) { + hs_response_set_header(response, "Connection", "keep-alive"); + } else { + hs_response_set_header(response, "Connection", "close"); + } + _grwprintf(printctx, "HTTP/1.1 %d %s\r\nDate: %s\r\n", response->status, + hs_status_text[response->status], request->server->date); + if (!HTTP_FLAG_CHECK(request->flags, HTTP_CHUNKED_RESPONSE)) { + _grwprintf(printctx, "Content-Length: %d\r\n", response->content_length); + } + _http_serialize_headers_list(response, printctx); +} + +void _http_perform_response(http_request_t *request, http_response_t *response, + grwprintf_t *printctx, hs_req_fn_t http_write) { + http_header_t *header = response->headers; + while (header) { + http_header_t *tmp = header; + header = tmp->next; + free(tmp); + } + _hs_buffer_free(&request->buffer, &request->server->memused); + free(response); + request->buffer.buf = printctx->buf; + request->buffer.length = printctx->size; + request->buffer.capacity = printctx->capacity; + request->bytes_written = 0; + request->state = HTTP_SESSION_WRITE; + http_write(request); +} + +// See api.h http_response_header +void hs_response_set_header(http_response_t *response, char const *key, + char const *value) { + http_header_t *header = (http_header_t *)malloc(sizeof(http_header_t)); + assert(header != NULL); + header->key = key; + header->value = value; + http_header_t *prev = response->headers; + header->next = prev; + response->headers = header; +} + +// Serializes the response into the request buffer and calls http_write. +// See api.h http_respond for more details +void hs_request_respond(http_request_t *request, http_response_t *response, + hs_req_fn_t http_write) { + grwprintf_t printctx; + _grwprintf_init(&printctx, HTTP_RESPONSE_BUF_SIZE, &request->server->memused); + _http_serialize_headers(request, response, &printctx); + if (response->body) { + _grwmemcpy(&printctx, response->body, response->content_length); + } + _http_perform_response(request, response, &printctx, http_write); +} + +// Serializes a chunk into the request buffer and calls http_write. +// See api.h http_respond_chunk for more details. +void hs_request_respond_chunk(http_request_t *request, + http_response_t *response, hs_req_fn_t cb, + hs_req_fn_t http_write) { + grwprintf_t printctx; + _grwprintf_init(&printctx, HTTP_RESPONSE_BUF_SIZE, &request->server->memused); + if (!HTTP_FLAG_CHECK(request->flags, HTTP_CHUNKED_RESPONSE)) { + HTTP_FLAG_SET(request->flags, HTTP_CHUNKED_RESPONSE); + hs_response_set_header(response, "Transfer-Encoding", "chunked"); + _http_serialize_headers(request, response, &printctx); + } + request->chunk_cb = cb; + _grwprintf(&printctx, "%X\r\n", response->content_length); + _grwmemcpy(&printctx, response->body, response->content_length); + _grwprintf(&printctx, "\r\n"); + _http_perform_response(request, response, &printctx, http_write); +} + +// Serializes the zero sized final chunk into the request buffer and calls +// http_write. See api.h http_respond_chunk_end for more details. +void hs_request_respond_chunk_end(http_request_t *request, + http_response_t *response, + hs_req_fn_t http_write) { + grwprintf_t printctx; + _grwprintf_init(&printctx, HTTP_RESPONSE_BUF_SIZE, &request->server->memused); + _grwprintf(&printctx, "0\r\n"); + _http_serialize_headers_list(response, &printctx); + _grwprintf(&printctx, "\r\n"); + HTTP_FLAG_CLEAR(request->flags, HTTP_CHUNKED_RESPONSE); + _http_perform_response(request, response, &printctx, http_write); +} + +// See api.h http_response_status +void hs_response_set_status(http_response_t *response, int status) { + response->status = status > 599 || status < 100 ? 500 : status; +} + +// See api.h http_response_body +void hs_response_set_body(http_response_t *response, char const *body, + int length) { + response->body = body; + response->content_length = length; +} + +// See api.h http_response_init +http_response_t *hs_response_init() { + http_response_t *response = + (http_response_t *)calloc(1, sizeof(http_response_t)); + assert(response != NULL); + response->status = 200; + return response; +} + +// Simple less flexible interface for responses, used for errors. +void hs_request_respond_error(http_request_t *request, int code, + char const *message, hs_req_fn_t http_write) { + struct http_response_s *response = hs_response_init(); + hs_response_set_status(response, code); + hs_response_set_header(response, "Content-Type", "text/plain"); + hs_response_set_body(response, message, strlen(message)); + hs_request_respond(request, response, http_write); + http_write(request); +} + +#line 1 "server.c" +#include <arpa/inet.h> +#include <assert.h> +#include <fcntl.h> +#include <netinet/in.h> +#include <signal.h> +#include <stdlib.h> +#include <sys/socket.h> +#include <time.h> + +#ifdef EPOLL +#include <sys/epoll.h> +#include <sys/timerfd.h> +#else +#include <sys/event.h> +#endif + +#ifndef HTTPSERVER_IMPL +#include "common.h" +#include "server.h" +#endif + +void _hs_bind_localhost(int s, struct sockaddr_in *addr, const char *ipaddr, + int port) { + addr->sin_family = AF_INET; + if (ipaddr == NULL) { + addr->sin_addr.s_addr = INADDR_ANY; + } else { + addr->sin_addr.s_addr = inet_addr(ipaddr); + } + addr->sin_port = htons(port); + int rc = bind(s, (struct sockaddr *)addr, sizeof(struct sockaddr_in)); + if (rc < 0) { + exit(1); + } +} + +#ifdef KQUEUE + +void _hs_add_server_sock_events(http_server_t *serv) { + struct kevent ev_set; + EV_SET(&ev_set, serv->socket, EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, serv); + kevent(serv->loop, &ev_set, 1, NULL, 0, NULL); +} + +void _hs_server_init_events(http_server_t *serv, hs_evt_cb_t unused) { + (void)unused; + + serv->loop = kqueue(); + struct kevent ev_set; + EV_SET(&ev_set, 1, EVFILT_TIMER, EV_ADD | EV_ENABLE, NOTE_SECONDS, 1, serv); + kevent(serv->loop, &ev_set, 1, NULL, 0, NULL); +} + +int hs_server_run_event_loop(http_server_t *serv, const char *ipaddr) { + hs_server_listen_on_addr(serv, ipaddr); + + struct kevent ev_list[1]; + + while (1) { + int nev = kevent(serv->loop, NULL, 0, ev_list, 1, NULL); + for (int i = 0; i < nev; i++) { + ev_cb_t *ev_cb = (ev_cb_t *)ev_list[i].udata; + ev_cb->handler(&ev_list[i]); + } + } + return 0; +} + +int hs_server_poll_events(http_server_t *serv) { + struct kevent ev; + struct timespec ts = {0, 0}; + int nev = kevent(serv->loop, NULL, 0, &ev, 1, &ts); + if (nev <= 0) + return nev; + ev_cb_t *ev_cb = (ev_cb_t *)ev.udata; + ev_cb->handler(&ev); + return nev; +} + +#else + +void _hs_server_init_events(http_server_t *serv, hs_evt_cb_t timer_cb) { + serv->loop = epoll_create1(0); + serv->timer_handler = timer_cb; + + int tfd = timerfd_create(CLOCK_MONOTONIC, 0); + struct itimerspec ts = {}; + ts.it_value.tv_sec = 1; + ts.it_interval.tv_sec = 1; + timerfd_settime(tfd, 0, &ts, NULL); + + struct epoll_event ev; + ev.events = EPOLLIN | EPOLLET; + ev.data.ptr = &serv->timer_handler; + epoll_ctl(serv->loop, EPOLL_CTL_ADD, tfd, &ev); + serv->timerfd = tfd; +} + +void _hs_add_server_sock_events(http_server_t *serv) { + struct epoll_event ev; + ev.events = EPOLLIN | EPOLLET; + ev.data.ptr = serv; + epoll_ctl(serv->loop, EPOLL_CTL_ADD, serv->socket, &ev); +} + +int hs_server_run_event_loop(http_server_t *serv, const char *ipaddr) { + hs_server_listen_on_addr(serv, ipaddr); + struct epoll_event ev_list[1]; + while (1) { + int nev = epoll_wait(serv->loop, ev_list, 1, -1); + for (int i = 0; i < nev; i++) { + ev_cb_t *ev_cb = (ev_cb_t *)ev_list[i].data.ptr; + ev_cb->handler(&ev_list[i]); + } + } + return 0; +} + +int hs_server_poll_events(http_server_t *serv) { + struct epoll_event ev; + int nev = epoll_wait(serv->loop, &ev, 1, 0); + if (nev <= 0) + return nev; + ev_cb_t *ev_cb = (ev_cb_t *)ev.data.ptr; + ev_cb->handler(&ev); + return nev; +} + +#endif + +void hs_server_listen_on_addr(http_server_t *serv, const char *ipaddr) { + // Ignore SIGPIPE. We handle these errors at the call site. + signal(SIGPIPE, SIG_IGN); + serv->socket = socket(AF_INET, SOCK_STREAM, 0); + int flag = 1; + setsockopt(serv->socket, SOL_SOCKET, SO_REUSEPORT, &flag, sizeof(flag)); + _hs_bind_localhost(serv->socket, &serv->addr, ipaddr, serv->port); + serv->len = sizeof(serv->addr); + int flags = fcntl(serv->socket, F_GETFL, 0); + fcntl(serv->socket, F_SETFL, flags | O_NONBLOCK); + listen(serv->socket, 128); + _hs_add_server_sock_events(serv); +} + +void hs_generate_date_time(char *datetime) { + time_t rawtime; + struct tm *timeinfo; + time(&rawtime); + timeinfo = gmtime(&rawtime); + strftime(datetime, 32, "%a, %d %b %Y %T GMT", timeinfo); +} + +http_server_t *hs_server_init(int port, void (*handler)(http_request_t *), + hs_evt_cb_t accept_cb, + hs_evt_cb_t epoll_timer_cb) { + http_server_t *serv = (http_server_t *)malloc(sizeof(http_server_t)); + assert(serv != NULL); + serv->port = port; + serv->memused = 0; + serv->handler = accept_cb; + _hs_server_init_events(serv, epoll_timer_cb); + hs_generate_date_time(serv->date); + serv->request_handler = handler; + return serv; +} + +#line 1 "write_socket.c" +#include <errno.h> +#include <unistd.h> + +#ifndef HTTPSERVER_IMPL +#include "common.h" +#include "write_socket.h" +#endif + +#ifdef DEBUG +#define write hs_test_write +ssize_t hs_test_write(int fd, char const *data, size_t size); +#endif + +// Writes response bytes from the buffer out to the socket. +// +// Runs when we get a socket ready to write event or when initiating an HTTP +// response and writing to the socket for the first time. If the response is +// chunked the chunk_cb callback will be invoked signalling to the user code +// that another chunk is ready to be written. +enum hs_write_rc_e hs_write_socket(http_request_t *request) { + int bytes = + write(request->socket, request->buffer.buf + request->bytes_written, + request->buffer.length - request->bytes_written); + if (bytes > 0) + request->bytes_written += bytes; + + enum hs_write_rc_e rc = HS_WRITE_RC_SUCCESS; + + if (errno == EPIPE) { + rc = HS_WRITE_RC_SOCKET_ERR; + } else { + if (request->bytes_written != request->buffer.length) { + // All bytes of the body were not written and we need to wait until the + // socket is writable again to complete the write + rc = HS_WRITE_RC_CONTINUE; + } else if (HTTP_FLAG_CHECK(request->flags, HTTP_CHUNKED_RESPONSE)) { + // All bytes of the chunk were written and we need to get the next chunk + // from the application. + rc = HS_WRITE_RC_SUCCESS_CHUNK; + } else { + if (HTTP_FLAG_CHECK(request->flags, HTTP_KEEP_ALIVE)) { + rc = HS_WRITE_RC_SUCCESS; + } else { + rc = HS_WRITE_RC_SUCCESS_CLOSE; + } + } + } + + return rc; +} + +#line 1 "connection.c" +#include <assert.h> +#include <fcntl.h> +#include <stdlib.h> +#include <sys/socket.h> +#include <unistd.h> + +#ifdef KQUEUE +#include <sys/event.h> +#else +#include <sys/epoll.h> +#include <sys/timerfd.h> +#include <time.h> +#endif + +#ifndef HTTPSERVER_IMPL +#include "buffer_util.h" +#include "common.h" +#include "connection.h" +#endif + +#ifdef KQUEUE + +void _hs_delete_events(http_request_t *request) { + struct kevent ev_set; + EV_SET(&ev_set, request->socket, EVFILT_TIMER, EV_DELETE, 0, 0, request); + kevent(request->server->loop, &ev_set, 1, NULL, 0, NULL); +} + +void _hs_add_timer_event(http_request_t *request, hs_io_cb_t unused) { + (void)unused; + + struct kevent ev_set; + EV_SET(&ev_set, request->socket, EVFILT_TIMER, EV_ADD | EV_ENABLE, 0, 1000, + request); + kevent(request->server->loop, &ev_set, 1, NULL, 0, NULL); +} + +#else + +void _hs_delete_events(http_request_t *request) { + epoll_ctl(request->server->loop, EPOLL_CTL_DEL, request->socket, NULL); + epoll_ctl(request->server->loop, EPOLL_CTL_DEL, request->timerfd, NULL); + close(request->timerfd); +} + +void _hs_add_timer_event(http_request_t *request, hs_io_cb_t timer_cb) { + request->timer_handler = timer_cb; + + // Watch for read events + struct epoll_event ev; + ev.events = EPOLLIN | EPOLLET; + ev.data.ptr = request; + epoll_ctl(request->server->loop, EPOLL_CTL_ADD, request->socket, &ev); + + // Add timer to timeout requests. + int tfd = timerfd_create(CLOCK_MONOTONIC, 0); + struct itimerspec ts = {}; + ts.it_value.tv_sec = 1; + ts.it_interval.tv_sec = 1; + timerfd_settime(tfd, 0, &ts, NULL); + + ev.events = EPOLLIN | EPOLLET; + ev.data.ptr = &request->timer_handler; + epoll_ctl(request->server->loop, EPOLL_CTL_ADD, tfd, &ev); + request->timerfd = tfd; +} + +#endif + +void hs_request_terminate_connection(http_request_t *request) { + _hs_delete_events(request); + close(request->socket); + _hs_buffer_free(&request->buffer, &request->server->memused); + free(request->tokens.buf); + request->tokens.buf = NULL; + free(request); +} + +void _hs_token_array_init(struct hs_token_array_s *array, int capacity) { + array->buf = + (struct hsh_token_s *)malloc(sizeof(struct hsh_token_s) * capacity); + assert(array->buf != NULL); + array->size = 0; + array->capacity = capacity; +} + +http_request_t *_hs_request_init(int sock, http_server_t *server, + hs_io_cb_t io_cb) { + http_request_t *request = (http_request_t *)calloc(1, sizeof(http_request_t)); + assert(request != NULL); + request->socket = sock; + request->server = server; + request->handler = io_cb; + request->timeout = HTTP_REQUEST_TIMEOUT; + request->flags = HTTP_AUTOMATIC; + request->parser = (struct hsh_parser_s){}; + request->buffer = (struct hsh_buffer_s){}; + request->tokens.buf = NULL; + _hs_token_array_init(&request->tokens, 32); + return request; +} + +http_request_t *hs_server_accept_connection(http_server_t *server, + hs_io_cb_t io_cb, + hs_io_cb_t epoll_timer_cb) { + http_request_t *request = NULL; + int sock = 0; + + sock = accept(server->socket, (struct sockaddr *)&server->addr, &server->len); + + if (sock > 0) { + int flags = fcntl(sock, F_GETFL, 0); + fcntl(sock, F_SETFL, flags | O_NONBLOCK); + + request = _hs_request_init(sock, server, io_cb); + _hs_add_timer_event(request, epoll_timer_cb); + } + return request; +} + +#line 1 "io_events.c" +#include <stdlib.h> + +#ifdef KQUEUE +#include <sys/event.h> +#else +#include <stdint.h> +#include <sys/epoll.h> +#include <unistd.h> +#endif + +#ifndef HTTPSERVER_IMPL +#include "buffer_util.h" +#include "common.h" +#include "connection.h" +#include "io_events.h" +#include "read_socket.h" +#include "respond.h" +#include "server.h" +#include "write_socket.h" +#endif + +void _hs_read_socket_and_handle_return_code(http_request_t *request) { + struct hs_read_opts_s opts; + opts.initial_request_buf_capacity = HTTP_REQUEST_BUF_SIZE; + opts.max_request_buf_capacity = HTTP_MAX_REQUEST_BUF_SIZE; + opts.eof_rc = 0; + + enum hs_read_rc_e rc = hs_read_request_and_exec_user_cb(request, opts); + switch (rc) { + case HS_READ_RC_PARSE_ERR: + hs_request_respond_error(request, 400, "Bad Request", + hs_request_begin_write); + break; + case HS_READ_RC_SOCKET_ERR: + hs_request_terminate_connection(request); + break; + case HS_READ_RC_SUCCESS: + break; + } +} + +void hs_request_begin_read(http_request_t *request); + +void _hs_write_socket_and_handle_return_code(http_request_t *request) { + enum hs_write_rc_e rc = hs_write_socket(request); + + request->timeout = rc == HS_WRITE_RC_SUCCESS ? HTTP_KEEP_ALIVE_TIMEOUT + : HTTP_REQUEST_TIMEOUT; + + if (rc != HS_WRITE_RC_CONTINUE) + _hs_buffer_free(&request->buffer, &request->server->memused); + + switch (rc) { + case HS_WRITE_RC_SUCCESS_CLOSE: + case HS_WRITE_RC_SOCKET_ERR: + // Error or response complete, connection: close + hs_request_terminate_connection(request); + break; + case HS_WRITE_RC_SUCCESS: + // Response complete, keep-alive connection + hs_request_begin_read(request); + break; + case HS_WRITE_RC_SUCCESS_CHUNK: + // Finished writing chunk, request next + request->state = HTTP_SESSION_NOP; + request->chunk_cb(request); + break; + case HS_WRITE_RC_CONTINUE: + break; + } +} + +void _hs_accept_and_begin_request_cycle(http_server_t *server, + hs_io_cb_t on_client_connection_cb, + hs_io_cb_t on_timer_event_cb) { + http_request_t *request = NULL; + while ((request = hs_server_accept_connection(server, on_client_connection_cb, + on_timer_event_cb))) { + if (server->memused > HTTP_MAX_TOTAL_EST_MEM_USAGE) { + hs_request_respond_error(request, 503, "Service Unavailable", + hs_request_begin_write); + } else { + hs_request_begin_read(request); + } + } +} + +#ifdef KQUEUE + +void _hs_on_kqueue_client_connection_event(struct kevent *ev) { + http_request_t *request = (http_request_t *)ev->udata; + if (ev->filter == EVFILT_TIMER) { + request->timeout -= 1; + if (request->timeout == 0) + hs_request_terminate_connection(request); + } else { + if (request->state == HTTP_SESSION_READ) { + _hs_read_socket_and_handle_return_code(request); + } else if (request->state == HTTP_SESSION_WRITE) { + _hs_write_socket_and_handle_return_code(request); + } + } +} + +void hs_on_kqueue_server_event(struct kevent *ev) { + http_server_t *server = (http_server_t *)ev->udata; + if (ev->filter == EVFILT_TIMER) { + hs_generate_date_time(server->date); + } else { + _hs_accept_and_begin_request_cycle( + server, _hs_on_kqueue_client_connection_event, NULL); + } +} + +#else + +void _hs_on_epoll_client_connection_event(struct epoll_event *ev) { + http_request_t *request = (http_request_t *)ev->data.ptr; + if (request->state == HTTP_SESSION_READ) { + _hs_read_socket_and_handle_return_code(request); + } else if (request->state == HTTP_SESSION_WRITE) { + _hs_write_socket_and_handle_return_code(request); + } +} + +void _hs_on_epoll_request_timer_event(struct epoll_event *ev) { + http_request_t *request = + (http_request_t *)((char *)ev->data.ptr - sizeof(epoll_cb_t)); + uint64_t res; + int bytes = read(request->timerfd, &res, sizeof(res)); + (void)bytes; // suppress warning + request->timeout -= 1; + if (request->timeout == 0) + hs_request_terminate_connection(request); +} + +void hs_on_epoll_server_connection_event(struct epoll_event *ev) { + _hs_accept_and_begin_request_cycle((http_server_t *)ev->data.ptr, + _hs_on_epoll_client_connection_event, + _hs_on_epoll_request_timer_event); +} + +void hs_on_epoll_server_timer_event(struct epoll_event *ev) { + http_server_t *server = + (http_server_t *)((char *)ev->data.ptr - sizeof(epoll_cb_t)); + uint64_t res; + int bytes = read(server->timerfd, &res, sizeof(res)); + (void)bytes; // suppress warning + hs_generate_date_time(server->date); +} + +#endif + +void _hs_add_write_event(http_request_t *request) { +#ifdef KQUEUE + struct kevent ev_set[2]; + EV_SET(&ev_set[0], request->socket, EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, + request); + EV_SET(&ev_set[1], request->socket, EVFILT_READ, EV_DISABLE, 0, 0, request); + kevent(request->server->loop, ev_set, 2, NULL, 0, NULL); +#else + struct epoll_event ev; + ev.events = EPOLLOUT | EPOLLET; + ev.data.ptr = request; + epoll_ctl(request->server->loop, EPOLL_CTL_MOD, request->socket, &ev); +#endif +} + +void hs_request_begin_write(http_request_t *request) { + request->state = HTTP_SESSION_WRITE; + _hs_add_write_event(request); + _hs_write_socket_and_handle_return_code(request); +} + +void _hs_add_read_event(http_request_t *request) { +#ifdef KQUEUE + // No action needed for kqueue since it's read event stays active. Should + // it be disabled during write? + struct kevent ev_set; + EV_SET(&ev_set, request->socket, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, + request); + kevent(request->server->loop, &ev_set, 1, NULL, 0, NULL); +#else + struct epoll_event ev; + ev.events = EPOLLIN | EPOLLET; + ev.data.ptr = request; + epoll_ctl(request->server->loop, EPOLL_CTL_MOD, request->socket, &ev); +#endif +} + +void hs_request_begin_read(http_request_t *request) { + request->state = HTTP_SESSION_READ; + _hs_add_read_event(request); + _hs_read_socket_and_handle_return_code(request); +} + +#endif +#endif +#endif |