#ifndef HTTPSERVER_H

#define HTTPSERVER_H

#line 1 "api.h"

#ifndef HS_API_H

#define HS_API_H

#ifdef __cplusplus

extern "C" {

struct http_string_s;

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_addr(struct http_server_s *server, const char *ipaddr);

int http_server_listen(struct http_server_s *server);

int http_server_listen_addr_poll(struct http_server_s *server,

const char *ipaddr);

int http_server_listen_poll(struct http_server_s *server);

int http_server_poll(struct http_server_s *server);

int http_request_has_flag(struct http_request_s *request, int flag);

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(struct http_request_s *request,

struct http_string_s *key,

struct http_string_s *val, int *iter);

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

void *http_request_userdata(struct http_request_s *request);

void http_server_set_userdata(struct http_server_s *server, void *data);

void *http_request_server_userdata(struct http_request_s *request);

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

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(struct http_request_s *request,

struct http_response_s *response,

void (*notify_done)(struct http_request_s *));

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

#define http_request_read_body http_request_read_chunk

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

}

#line 1 "common.h"

#ifndef HS_COMMON_H

#define HS_COMMON_H

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

#include <sys/epoll.h>

#ifdef EPOLL

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

typedef struct http_ev_cb_s {

} ev_cb_t;

struct hsh_buffer_s {

};

enum hsh_token_e {

};

struct hsh_token_s {

};

struct hsh_parser_s {

};

struct hs_token_array_s {

};

typedef struct http_request_s {

} http_request_t;

typedef struct http_server_s {

} http_server_t;

#line 1 "buffer_util.h"

#ifndef HS_BUFFER_UTIL_H

#define HS_BUFFER_UTIL_H

#include <stdlib.h>

#ifndef HTTPSERVER_IMPL

#include "common.h"

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;

}

}

#line 1 "request_util.h"

#ifndef HS_REQUEST_UTIL_H

#define HS_REQUEST_UTIL_H

#ifndef HTTPSERVER_IMPL

#include "common.h"

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

#line 1 "parser.h"

#ifndef HTTP_PARSER_H

#define HTTP_PARSER_H

#define HSH_TOK_FLAG_NO_BODY 0x1

#define HSH_TOK_FLAG_STREAMED_BODY 0x2

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

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

enum hs_read_rc_e {

};

struct hs_read_opts_s {

};

enum hs_read_rc_e

hs_read_request_and_exec_user_cb(struct http_request_s *request,

struct hs_read_opts_s opts);

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

typedef struct http_header_s {

} http_header_t;

typedef struct http_response_s {

} http_response_t;

http_response_t *hs_response_init(void);

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

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

struct epoll_event;

typedef void (*hs_evt_cb_t)(struct epoll_event *ev);

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

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

enum hs_write_rc_e {

};

enum hs_write_rc_e hs_write_socket(struct http_request_s *request);

#line 1 "connection.h"

#ifndef HS_CONNECTION_H

#define HS_CONNECTION_H

struct http_request_s;

struct http_server_s;

#ifdef KQUEUE

struct kevent;

typedef void (*hs_io_cb_t)(struct kevent *ev);

struct epoll_event;

typedef void (*hs_io_cb_t)(struct epoll_event *ev);

void hs_request_terminate_connection(struct http_request_s *request);

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

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

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

#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"

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

return hs_server_init(port, handler, hs_on_epoll_server_connection_event,

hs_on_epoll_server_timer_event);

}

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(void) { return hs_response_init(); }

void http_response_header(http_response_t *response, char const *key,

char const *value) {

hs_response_set_header(response, key, value);

}

void http_response_status(http_response_t *response, int status) {

hs_response_set_status(response, status);

}