#ifndef HTTPSERVER_H

#define HTTPSERVER_H

#ifdef __cplusplus

extern "C" {

struct http_string_s {

char const * buf;

int len;

};

struct http_server_s;

struct http_request_s;

struct http_response_s;

int http_server_loop(struct http_server_s* server);

struct http_server_s* http_server_init(int port, void (*handler)(struct http_request_s*));

int http_server_listen(struct http_server_s* server);

int http_server_listen_poll(struct http_server_s* server);

int http_server_poll(struct http_server_s* server);

struct http_string_s http_request_method(struct http_request_s* request);

struct http_string_s http_request_target(struct http_request_s* request);

struct http_string_s http_request_body(struct http_request_s* request);

struct http_string_s http_request_header(struct http_request_s* request, char const * key);

int http_request_iterate_headers(

);

void* http_request_userdata(struct http_request_s* request);

void http_request_set_userdata(struct http_request_s* request, void* data);

#define HTTP_KEEP_ALIVE 1

#define HTTP_CLOSE 0

void http_request_connection(struct http_request_s* request, int directive);

void http_request_free_buffer(struct http_request_s* request);

struct http_response_s* http_response_init();

void http_response_status(struct http_response_s* response, int status);

void http_response_header(struct http_response_s* response, char const * key, char const * value);

void http_response_body(struct http_response_s* response, char const * body, int length);

void http_respond(struct http_request_s* request, struct http_response_s* response);

void http_respond_chunk(

);

void http_respond_chunk_end(struct http_request_s* request, struct http_response_s* response);

void http_request_read_chunk(

struct http_request_s* request,

void (*chunk_cb)(struct http_request_s*)

);

struct http_string_s http_request_chunk(struct http_request_s* request);

#ifdef __cplusplus

}

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

}

#ifdef HTTPSERVER_IMPL

#ifndef HTTPSERVER_IMPL_ONCE

#define HTTPSERVER_IMPL_ONCE

#ifdef __linux__

#define EPOLL

#define _POSIX_C_SOURCE 199309L

#define KQUEUE

#include <time.h>

#include <stdlib.h>

#include <stdio.h>

#include <fcntl.h>

#include <errno.h>

#include <netdb.h>

#include <unistd.h>

#include <string.h>

#include <stdarg.h>

#include <signal.h>

#include <limits.h>

#include <assert.h>

#ifdef KQUEUE

#include <sys/event.h>

void http_server_listen_cb(struct kevent* ev);

void http_session_io_cb(struct kevent* ev);

#include <sys/epoll.h>

#include <sys/timerfd.h>

typedef void (*epoll_cb_t)(struct epoll_event*);

void http_server_listen_cb(struct epoll_event* ev);

void http_session_io_cb(struct epoll_event* ev);

void http_server_timer_cb(struct epoll_event* ev);

void http_request_timer_cb(struct epoll_event* ev);

#define HTTP_METHOD 0

#define HTTP_TARGET 1

#define HTTP_VERSION 2

#define HTTP_HEADER_KEY 3

#define HTTP_HEADER_VALUE 4

#define HTTP_NONE 6

#define HTTP_BODY 7

#define HTTP_CHUNK_SIZE 8

#define HTTP_CHUNK_EXTN 9

#define HTTP_CHUNK_BODY 10

#define HTTP_CHUNK_BODY_END 11

#define HTTP_CHUNK_BODY_PARTIAL 12

typedef struct {

int index;

int len;

int type;

} http_token_t;

typedef struct {

int content_length;

int len;

int token_start_index;

int start;

int body_start_index;

char content_length_i;

char transfer_encoding_i;

char flags;

char state;

char sub_state;

} http_parser_t;

typedef struct {

http_token_t* buf;

int capacity;

int size;

} http_token_dyn_t;

typedef struct http_ev_cb_s {

} ev_cb_t;

typedef struct http_request_s {

} http_request_t;

#define HS_PF_TRANSFER_ENCODING 0x1

#define HS_PF_CONTENT_LENGTH 0x2

#define HS_PF_CHUNKED 0x4

#define HTTP_LWS 2

#define HTTP_CR 3

#define HTTP_CRLF 4

#define HTTP_HEADER_END 5

#define CONTENT_LENGTH_LOW "content-length"

#define CONTENT_LENGTH_UP "CONTENT-LENGTH"

#define TRANSFER_ENCODING_LOW "transfer-encoding"

#define TRANSFER_ENCODING_UP "TRANSFER-ENCODING"

#define CHUNKED_LOW "chunked"

#define CHUNKED_UP "CHUNKED"

#define PAYLOAD_TOO_LARGE -1

#define HTTP_CHUNKED_LEN -1

#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 HS_P_MATCH_HEADER(up, low, i) \

if ((c == up[(int)i] || c == low[(int)i]) && i < (char)(sizeof(up) - 1)) i++;

http_token_t http_parse(http_parser_t* parser, char* input, int n) {

for (int i = parser->start; i < n; ++i, parser->start = i + 1, parser->len++) {

char c = input[i];

switch (parser->state) {

case HTTP_METHOD:

if (c == ' ') {

http_token_t token;

token.index = parser->token_start_index;

token.type = parser->state;

token.len = parser->len;

parser->state = HTTP_TARGET;

parser->len = 0;

parser->token_start_index = i + 1;

return token;

}

break;

case HTTP_TARGET:

if (c == ' ') {

http_token_t token;

token.index = parser->token_start_index;

token.type = parser->state;

token.len = parser->len;

parser->state = HTTP_VERSION;

parser->token_start_index = i + 1;

parser->len = 0;

return token;

}

break;

case HTTP_VERSION:

if (c == '\r') {

parser->sub_state = HTTP_CR;

http_token_t token;

token.index = parser->token_start_index;

token.type = HTTP_VERSION;

token.len = parser->len;

return token;

} else if (parser->sub_state == HTTP_CR && c == '\n') {

parser->sub_state = 0;

parser->len = 0;

parser->token_start_index = i + 1;

parser->state = HTTP_HEADER_KEY;

}

break;

case HTTP_HEADER_KEY:

if (c == ':') {

parser->state = HTTP_HEADER_VALUE;

parser->sub_state = HTTP_LWS;

if (parser->len == parser->content_length_i + 1) {

HTTP_FLAG_SET(parser->flags, HS_PF_CONTENT_LENGTH);

} else if (parser->len == parser->transfer_encoding_i + 1) {

HTTP_FLAG_SET(parser->flags, HS_PF_TRANSFER_ENCODING);

}

parser->content_length_i = 0;

parser->transfer_encoding_i = 0;

http_token_t token;

token.index = parser->token_start_index;

token.type = HTTP_HEADER_KEY;

token.len = parser->len - 1;

return token;

}

HS_P_MATCH_HEADER(CONTENT_LENGTH_UP, CONTENT_LENGTH_LOW, parser->content_length_i)

HS_P_MATCH_HEADER(TRANSFER_ENCODING_UP, TRANSFER_ENCODING_LOW, parser->transfer_encoding_i)

break;

case HTTP_HEADER_VALUE:

if (parser->sub_state == HTTP_LWS && (c == ' ' || c == '\t' || c == '\r' || c == '\n')) {

continue;

} else if (parser->sub_state == HTTP_LWS) {

parser->sub_state = 0;

parser->len = 0;

parser->token_start_index = i;

if (HTTP_FLAG_CHECK(parser->flags, HS_PF_CONTENT_LENGTH)) {

parser->content_length *= 10;

parser->content_length += c - '0';

} else if (HTTP_FLAG_CHECK(parser->flags, HS_PF_TRANSFER_ENCODING)) {

HS_P_MATCH_HEADER(CHUNKED_UP, CHUNKED_LOW, parser->transfer_encoding_i)

}

} else if (parser->sub_state != HTTP_LWS && c == '\r') {

parser->sub_state = HTTP_CR;

parser->state = HTTP_HEADER_END;

HTTP_FLAG_CLEAR(parser->flags, HS_PF_TRANSFER_ENCODING);

HTTP_FLAG_CLEAR(parser->flags, HS_PF_CONTENT_LENGTH);

if (parser->len == parser->transfer_encoding_i) {

HTTP_FLAG_SET(parser->flags, HS_PF_CHUNKED);

}

parser->transfer_encoding_i = 0;

http_token_t token;

token.index = parser->token_start_index;

token.type = HTTP_HEADER_VALUE;

token.len = parser->len;

return token;

} else if (

HTTP_FLAG_CHECK(parser->flags, HS_PF_CONTENT_LENGTH) &&

parser->content_length != PAYLOAD_TOO_LARGE

) {

int64_t new_content_length = parser->content_length * 10l;

new_content_length += c - '0';

if (new_content_length > INT_MAX) {

parser->content_length = PAYLOAD_TOO_LARGE;

} else {

parser->content_length = (int)new_content_length;

}

} else if (HTTP_FLAG_CHECK(parser->flags, HS_PF_TRANSFER_ENCODING)) {

HS_P_MATCH_HEADER(CHUNKED_UP, CHUNKED_LOW, parser->transfer_encoding_i)

}

break;

case HTTP_HEADER_END:

if (parser->sub_state == 0 && c == '\r') {

parser->sub_state = HTTP_CR;

} else if (parser->sub_state == HTTP_CR && c == '\n') {

parser->sub_state = HTTP_CRLF;

} else if (parser->sub_state == HTTP_CRLF && c == '\r') {

parser->sub_state = 0;

parser->state = HTTP_BODY;

http_token_t token;

token.index = i + 2;

parser->body_start_index = token.index;

token.type = HTTP_BODY;

if (HTTP_FLAG_CHECK(parser->flags, HS_PF_CHUNKED)) {

token.len = HTTP_CHUNKED_LEN;

} else {

token.len = parser->content_length;

}

parser->start++;

return token;

} else if (parser->sub_state == HTTP_CRLF && c != '\r') {

parser->sub_state = 0;

parser->len = 0;

parser->token_start_index = i;

i--;

parser->state = HTTP_HEADER_KEY;

}

break;

}

}

http_token_t token = { 0, 0, 0 };

token.type = HTTP_NONE;

return token;

}

http_token_t http_gen_body_token(http_parser_t* parser) {

http_token_t token;

token.index = parser->token_start_index;

token.type = HTTP_CHUNK_BODY;

token.len = parser->content_length;

parser->start = parser->token_start_index + parser->content_length;

parser->len = parser->content_length;

parser->state = HTTP_CHUNK_BODY_END;

return token;

}

http_token_t http_chunk_parse(http_request_t* request, char* input, int n) {

http_parser_t* parser = &request->parser;

for (int i = parser->start; i < n; ++i, parser->start = i + 1, parser->len++) {

char c = input[i];

int remaining = n - (i + 1);

switch (parser->state) {

case HTTP_CHUNK_SIZE:

if (c == ';') {

parser->state = HTTP_CHUNK_EXTN;

} else if (c == '\n') {

// Full chunk exists in buffer

parser->token_start_index = i + 1;

parser->len = 0;

if (remaining >= parser->content_length) {

return http_gen_body_token(parser);

}

parser->state = HTTP_CHUNK_BODY;

} else if (c == '\r') {

break;

} else if (c >= 'A' && c <= 'F') {

parser->content_length *= 0x10;

parser->content_length += c - 55;

} else if (c >= 'a' && c <= 'f') {

parser->content_length *= 0x10;

parser->content_length += c - 87;

} else if (c >= '0' && c <= '9') {

parser->content_length *= 0x10;

parser->content_length += c - '0';

}

break;

case HTTP_CHUNK_EXTN:

if (c == '\n') {

if (remaining >= parser->content_length) {

parser->token_start_index = i + 1;

return http_gen_body_token(parser);

}

parser->token_start_index = i + 1;

parser->state = HTTP_CHUNK_BODY;

}

break;

case HTTP_CHUNK_BODY:

if (remaining >= parser->content_length) {

return http_gen_body_token(parser);

}

break;

case HTTP_CHUNK_BODY_END:

if (c == '\n') {

parser->state = HTTP_CHUNK_SIZE;

parser->content_length = 0;

parser->len = 0;

parser->token_start_index = i + 1;

}

break;

}

}

// move bytes of partial token to start of buffer

if (parser->token_start_index != parser->body_start_index) {

parser->start = parser->body_start_index + parser->len - 1;

int tsi = parser->token_start_index;

parser->token_start_index = parser->body_start_index;

request->bytes = parser->start;

if (parser->len > 1) {

char* dst = input + parser->body_start_index;

char const* src = input + tsi;

memcpy(dst, src, n - tsi);

}

}

http_token_t token = { 0, 0, 0 };

token.type = HTTP_NONE;

return token;

}

void http_parse_start_chunk_mode(http_parser_t* parser) {

parser->token_start_index = parser->start;

parser->content_length = 0;

parser->state = HTTP_CHUNK_SIZE;

}

#define HTTP_RESPONSE_READY 0x4

#define HTTP_AUTOMATIC 0x8

#define HTTP_RESPONSE_PAUSED 0x10

#define HTTP_CHUNKED 0x20

#define HTTP_REQUEST_TIMEOUT 20

#define HTTP_KEEP_ALIVE_TIMEOUT 120

typedef struct http_server_s {

} http_server_t;

void http_token_dyn_push(http_token_dyn_t* dyn, http_token_t a) {

if (dyn->size == dyn->capacity) {

dyn->capacity *= 2;

dyn->buf = (http_token_t*)realloc(dyn->buf, dyn->capacity * sizeof(http_token_t));

assert(dyn->buf != NULL);

}

dyn->buf[dyn->size] = a;

dyn->size++;

}

void http_token_dyn_init(http_token_dyn_t* dyn, int capacity) {

dyn->buf = (http_token_t*)malloc(sizeof(http_token_t) * capacity);

assert(dyn->buf != NULL);

dyn->size = 0;

dyn->capacity = capacity;

}

#define HTTP_REQUEST_BUF_SIZE 1024

void bind_localhost(int s, struct sockaddr_in* addr, int port) {

addr->sin_family = AF_INET;

addr->sin_addr.s_addr = INADDR_ANY;

addr->sin_port = htons(port);

int rc = bind(s, (struct sockaddr *)addr, sizeof(struct sockaddr_in));;

if (rc < 0) {

exit(1);

}

}

int read_client_socket(http_request_t* session) {

if (!session->buf) {

session->buf = (char*)calloc(1, HTTP_REQUEST_BUF_SIZE);

assert(session->buf != NULL);

session->capacity = HTTP_REQUEST_BUF_SIZE;

http_token_dyn_init(&session->tokens, 32);

}

int bytes;

do {

bytes = read(

session->socket,

session->buf + session->bytes,

session->capacity - session->bytes

);

if (bytes > 0) session->bytes += bytes;

if (session->bytes == session->capacity) {

session->capacity *= 2;

session->buf = (char*)realloc(session->buf, session->capacity);

assert(session->buf != NULL);

}

} while (bytes > 0);

return bytes == 0 ? 0 : 1;

}

int write_client_socket(http_request_t* session) {

int bytes = write(

session->socket,

session->buf + session->bytes,

session->capacity - session->bytes

);

if (bytes > 0) session->bytes += bytes;

return errno == EPIPE ? 0 : 1;

}

void free_buffer(http_request_t* session) {

if (session->buf) {

free(session->buf);

session->buf = NULL;

free(session->tokens.buf);

session->tokens.buf = NULL;

}

}

void parse_tokens(http_request_t* session) {

http_token_t token;

int chunk_start = 0;

do {

token = http_parse(&session->parser, session->buf, session->bytes);

if (token.type != HTTP_NONE) {

session->token = token;

http_token_dyn_push(&session->tokens, token);

}

chunk_start = token.type == HTTP_BODY && token.len == HTTP_CHUNKED_LEN;

} while (token.type != HTTP_NONE && !chunk_start);

}

void init_session(http_request_t* session) {

session->flags = 0;

session->flags |= HTTP_AUTOMATIC;

session->parser = (http_parser_t){ };

session->bytes = 0;

session->buf = NULL;

session->token.len = 0;

session->token.index = 0;

session->token.type = HTTP_NONE;

}

int parsing_headers(http_request_t* request) {

return request->token.type != HTTP_BODY;

}

int reading_body(http_request_t* request) {

if (

request->token.type != HTTP_BODY ||

request->token.len == 0 ||

request->token.len == HTTP_CHUNKED_LEN

) {

return 0;

}

int size = request->token.index + request->token.len;

return request->bytes < size;

}

void end_session(http_request_t* session) {

#ifdef KQUEUE

struct kevent ev_set;

EV_SET(&ev_set, session->socket, EVFILT_TIMER, EV_DELETE, 0, 0, session);

kevent(session->server->loop, &ev_set, 1, NULL, 0, NULL);

epoll_ctl(session->server->loop, EPOLL_CTL_DEL, session->socket, NULL);

epoll_ctl(session->server->loop, EPOLL_CTL_DEL, session->timerfd, NULL);

close(session->timerfd);

close(session->socket);

free_buffer(session);

free(session);

}

#define HTTP_SESSION_INIT 0

#define HTTP_SESSION_READ_HEADERS 1

#define HTTP_SESSION_READ_BODY 2

#define HTTP_SESSION_WRITE 3

#define HTTP_SESSION_READ_CHUNK 4

#define HTTP_SESSION_NOP 5

void reset_timeout(http_request_t* request, int time) {

request->timeout = time;

}

void exec_response_handler(http_request_t* request, void (*handler)(http_request_t*));

void write_response(http_request_t* request) {

if (!write_client_socket(request)) { return end_session(request); }

if (request->bytes != request->capacity) {

#ifdef KQUEUE

struct kevent ev_set[2];

EV_SET(&ev_set[0], request->socket, EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, request);

kevent(request->server->loop, ev_set, 2, NULL, 0, NULL);

struct epoll_event ev;

ev.events = EPOLLOUT | EPOLLET;

ev.data.ptr = request;

epoll_ctl(request->server->loop, EPOLL_CTL_MOD, request->socket, &ev);

request->state = HTTP_SESSION_WRITE;

reset_timeout(request, HTTP_REQUEST_TIMEOUT);

} else if (HTTP_FLAG_CHECK(request->flags, HTTP_CHUNKED)) {

request->state = HTTP_SESSION_WRITE;

reset_timeout(request, HTTP_REQUEST_TIMEOUT);

free_buffer(request);

HTTP_FLAG_CLEAR(request->flags, HTTP_RESPONSE_READY);

exec_response_handler(request, request->chunk_cb);

} else if (HTTP_FLAG_CHECK(request->flags, HTTP_KEEP_ALIVE)) {

request->state = HTTP_SESSION_INIT;

free_buffer(request);

reset_timeout(request, HTTP_KEEP_ALIVE_TIMEOUT);

} else {

return end_session(request);

}

}

void exec_response_handler(http_request_t* request, void (*handler)(http_request_t*)) {

handler(request);

if (HTTP_FLAG_CHECK(request->flags, HTTP_RESPONSE_READY)) {

write_response(request);

} else {

HTTP_FLAG_SET(request->flags, HTTP_RESPONSE_PAUSED);

}

}

void error_response(http_request_t* request, int code, char const * message) {

struct http_response_s* response = http_response_init();

http_response_status(response, code);

http_response_header(response, "Content-Type", "text/plain");

http_response_body(response, message, strlen(message));

http_respond(request, response);

write_response(request);

}

void http_request_read_chunk(

struct http_request_s* request,

void (*chunk_cb)(struct http_request_s*)

) {

request->chunk_cb = chunk_cb;

http_token_t token = http_chunk_parse(request, request->buf, request->bytes);

if (token.type == HTTP_CHUNK_BODY) { //Next chunk exists in read buffer

request->token = token;

chunk_cb(request);

} else { //No buffered chunks, read again

if (!read_client_socket(request)) { return end_session(request); }

http_token_t token = http_chunk_parse(request, request->buf, request->bytes);

if (token.type == HTTP_CHUNK_BODY) {

request->token = token;

request->chunk_cb(request);

} else {

request->state = HTTP_SESSION_READ_CHUNK;

}

}

}

void http_session(http_request_t* request) {

http_token_t token;

switch (request->state) {

case HTTP_SESSION_INIT:

init_session(request);

request->state = HTTP_SESSION_READ_HEADERS;

// fallthrough

case HTTP_SESSION_READ_HEADERS:

if (!read_client_socket(request)) { return end_session(request); }

reset_timeout(request, HTTP_REQUEST_TIMEOUT);

parse_tokens(request);

if (!parsing_headers(request) && request->parser.content_length == PAYLOAD_TOO_LARGE) {

return error_response(request, 413, "Payload Too Large");

} else if (reading_body(request)) {

request->state = HTTP_SESSION_READ_BODY;

} else if (!parsing_headers(request)) {

if (request->parser.flags & HS_PF_CHUNKED) {

request->state = HTTP_SESSION_NOP;

http_parse_start_chunk_mode(&request->parser);

}

return exec_response_handler(request, request->server->request_handler);

}

break;

case HTTP_SESSION_READ_BODY:

if (!read_client_socket(request)) { return end_session(request); }

reset_timeout(request, HTTP_REQUEST_TIMEOUT);

if (!reading_body(request)) {

return exec_response_handler(request, request->server->request_handler);

}

break;

case HTTP_SESSION_READ_CHUNK:

if (!read_client_socket(request)) { return end_session(request); }

reset_timeout(request, HTTP_REQUEST_TIMEOUT);

token = http_chunk_parse(request, request->buf, request->bytes);

if (token.type == HTTP_CHUNK_BODY) {

request->token = token;

request->state = HTTP_SESSION_NOP;

request->chunk_cb(request);

}

break;

case HTTP_SESSION_WRITE:

write_response(request);

break;

}

}

void accept_connections(http_server_t* server) {

int sock = 0;

do {

sock = accept(server->socket, (struct sockaddr *)&server->addr, &server->len);

if (sock > 0) {

http_request_t* session = (http_request_t*)calloc(1, sizeof(http_request_t));

assert(session != NULL);

session->socket = sock;

session->server = server;

session->timeout = HTTP_REQUEST_TIMEOUT;

session->handler = http_session_io_cb;

int flags = fcntl(sock, F_GETFL, 0);

fcntl(sock, F_SETFL, flags | O_NONBLOCK);

#ifdef KQUEUE

struct kevent ev_set[2];

EV_SET(&ev_set[0], sock, EVFILT_READ, EV_ADD, 0, 0, session);

EV_SET(&ev_set[1], sock, EVFILT_TIMER, EV_ADD | EV_ENABLE, NOTE_SECONDS, 1, session);

kevent(server->loop, ev_set, 2, NULL, 0, NULL);

session->timer_handler = http_request_timer_cb;

struct epoll_event ev;

ev.events = EPOLLIN | EPOLLET;

ev.data.ptr = session;

epoll_ctl(server->loop, EPOLL_CTL_ADD, sock, &ev);

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 = &session->timer_handler;

epoll_ctl(server->loop, EPOLL_CTL_ADD, tfd, &ev);

session->timerfd = tfd;

http_session(session);

}

} while (sock > 0);

}

void generate_date_time(char** datetime) {

time_t rawtime;

struct tm * timeinfo;

time(&rawtime);

timeinfo = localtime(&rawtime);

*datetime = asctime(timeinfo);

}

#ifdef KQUEUE

void http_server_listen_cb(struct kevent* ev) {

http_server_t* server = (http_server_t*)ev->udata;

if (ev->filter == EVFILT_TIMER) {

generate_date_time(&server->date);

} else {

accept_connections(server);

}

}

void http_session_io_cb(struct kevent* ev) {

http_request_t* request = (http_request_t*)ev->udata;

if (ev->filter == EVFILT_TIMER) {

request->timeout -= 1;

if (request->timeout == 0) end_session(request);

} else {

http_session(request);

}

}