bool operator() (const std::pair<int, int>& left, const std::pair<int, int>& right) const {

return left.second < right.second;

}

#if !defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)

struct sigaction oldsig;

struct sigaction sig;

sig.sa_handler = &catcher;

sigemptyset(&sig.sa_mask);

#ifdef SA_INTERRUPT

sig.sa_flags = SA_INTERRUPT; /* SunOS */

#else // SA_INTERRUPT

sig.sa_flags = SA_RESTART;

#endif // SA_INTERRUPTT

if (0 != sigaction(SIGPIPE, &sig, &oldsig)) {

fprintf(stderr, "Failed to install SIGPIPE handler: %s\n", strerror(errno));

}

#endif

port(params._port),

start_method(params._start_method),

max_threads(params._max_threads),

max_connections(params._max_connections),

memory_limit(params._memory_limit),

content_size_limit(params._content_size_limit),

connection_timeout(params._connection_timeout),

per_IP_connection_limit(params._per_IP_connection_limit),

log_access(params._log_access),

log_error(params._log_error),

validator(params._validator),

unescaper(params._unescaper),

bind_address(params._bind_address),

bind_socket(params._bind_socket),

max_thread_stack_size(params._max_thread_stack_size),

use_ssl(params._use_ssl),

use_ipv6(params._use_ipv6),

use_dual_stack(params._use_dual_stack),

debug(params._debug),

pedantic(params._pedantic),

https_mem_key(params._https_mem_key),

https_mem_cert(params._https_mem_cert),

https_mem_trust(params._https_mem_trust),

https_priorities(params._https_priorities),

cred_type(params._cred_type),

digest_auth_random(params._digest_auth_random),

nonce_nc_size(params._nonce_nc_size),

running(false),

default_policy(params._default_policy),

basic_auth_enabled(params._basic_auth_enabled),

digest_auth_enabled(params._digest_auth_enabled),

regex_checking(params._regex_checking),

ban_system_enabled(params._ban_system_enabled),

post_process_enabled(params._post_process_enabled),

deferred_enabled(params._deferred_enabled),

single_resource(params._single_resource),

tcp_nodelay(params._tcp_nodelay),

not_found_resource(params._not_found_resource),

method_not_allowed_resource(params._method_not_allowed_resource),

internal_error_resource(params._internal_error_resource) {

ignore_sigpipe();

pthread_mutex_init(&mutexwait, NULL);

pthread_cond_init(&mutexcond, NULL);

// These parameters are passed to respect the MHD interface, but are not needed here.

std::ignore = cls;

std::ignore = connection;

std::ignore = toe;

details::modded_request* mr = static_cast<details::modded_request*>(*con_cls);

if (mr == 0x0) return;

delete mr;

mr = 0x0;

if (single_resource && ((resource != "" && resource != "/") || !family)) {

throw std::invalid_argument("The resource should be '' or '/' and be marked as family when using a single_resource server");

}

details::http_endpoint idx(resource, family, true, regex_checking);

pair<map<details::http_endpoint, http_resource*>::iterator, bool> result = registered_resources.insert(map<details::http_endpoint, http_resource*>::value_type(idx, hrm));

if (result.second) {

registered_resources_str.insert(pair<string, http_resource*>(idx.get_url_complete(), result.first->second));

}

return result.second;

struct {

MHD_OptionItem operator ()(enum MHD_OPTION opt, intptr_t val, void *ptr = 0) {

MHD_OptionItem x = {opt, val, ptr};

return x;

}

} gen;

vector<struct MHD_OptionItem> iov;

iov.push_back(gen(MHD_OPTION_NOTIFY_COMPLETED, (intptr_t) &request_completed, NULL));

iov.push_back(gen(MHD_OPTION_URI_LOG_CALLBACK, (intptr_t) &uri_log, this));

iov.push_back(gen(MHD_OPTION_EXTERNAL_LOGGER, (intptr_t) &error_log, this));

iov.push_back(gen(MHD_OPTION_UNESCAPE_CALLBACK, (intptr_t) &unescaper_func, this));

iov.push_back(gen(MHD_OPTION_CONNECTION_TIMEOUT, connection_timeout));

if (bind_socket != 0) {

iov.push_back(gen(MHD_OPTION_LISTEN_SOCKET, bind_socket));

}

if (start_method == http_utils::THREAD_PER_CONNECTION && (max_threads != 0 || max_thread_stack_size != 0)) {

throw std::invalid_argument("Cannot specify maximum number of threads when using a thread per connection");

}

if (max_threads != 0) {

iov.push_back(gen(MHD_OPTION_THREAD_POOL_SIZE, max_threads));

}

if (max_connections != 0) {

iov.push_back(gen(MHD_OPTION_CONNECTION_LIMIT, max_connections));

}

if (memory_limit != 0) {

iov.push_back(gen(MHD_OPTION_CONNECTION_MEMORY_LIMIT, memory_limit));

}

if (per_IP_connection_limit != 0) {

iov.push_back(gen(MHD_OPTION_PER_IP_CONNECTION_LIMIT, per_IP_connection_limit));

}

if (max_thread_stack_size != 0) {

iov.push_back(gen(MHD_OPTION_THREAD_STACK_SIZE, max_thread_stack_size));

}

if (nonce_nc_size != 0) {

iov.push_back(gen(MHD_OPTION_NONCE_NC_SIZE, nonce_nc_size));

}

if (use_ssl) {

// Need for const_cast to respect MHD interface that needs a void*

iov.push_back(gen(MHD_OPTION_HTTPS_MEM_KEY, 0, reinterpret_cast<void*>(const_cast<char*>(https_mem_key.c_str()))));

}

if (use_ssl) {

// Need for const_cast to respect MHD interface that needs a void*

iov.push_back(gen(MHD_OPTION_HTTPS_MEM_CERT, 0, reinterpret_cast<void*>(const_cast<char*>(https_mem_cert.c_str()))));

}

if (https_mem_trust != "" && use_ssl) {

// Need for const_cast to respect MHD interface that needs a void*

iov.push_back(gen(MHD_OPTION_HTTPS_MEM_TRUST, 0, reinterpret_cast<void*>(const_cast<char*>(https_mem_trust.c_str()))));

}

if (https_priorities != "" && use_ssl) {

// Need for const_cast to respect MHD interface that needs a void*

iov.push_back(gen(MHD_OPTION_HTTPS_PRIORITIES, 0, reinterpret_cast<void*>(const_cast<char*>(https_priorities.c_str()))));

}

if (digest_auth_random != "") {

// Need for const_cast to respect MHD interface that needs a char*

iov.push_back(gen(MHD_OPTION_DIGEST_AUTH_RANDOM, digest_auth_random.size(), const_cast<char*>(digest_auth_random.c_str())));

}

#ifdef HAVE_GNUTLS

if (cred_type != http_utils::NONE) {

iov.push_back(gen(MHD_OPTION_HTTPS_CRED_TYPE, cred_type));

}

#endif // HAVE_GNUTLS

iov.push_back(gen(MHD_OPTION_END, 0, NULL));

int start_conf = start_method;

if (use_ssl) {

start_conf |= MHD_USE_SSL;

}

if (use_ipv6) {

start_conf |= MHD_USE_IPv6;

}

if (use_dual_stack) {

start_conf |= MHD_USE_DUAL_STACK;

}

if (debug) {

start_conf |= MHD_USE_DEBUG;

}

if (pedantic) {

start_conf |= MHD_USE_PEDANTIC_CHECKS;

}

if (deferred_enabled) {

start_conf |= MHD_USE_SUSPEND_RESUME;

}

start_conf |= MHD_USE_ERROR_LOG;

start_conf |= MHD_ALLOW_UPGRADE;

#ifdef USE_FASTOPEN

start_conf |= MHD_USE_TCP_FASTOPEN;

#endif

daemon = NULL;

if (bind_address == 0x0) {

daemon = MHD_start_daemon(start_conf, port, &policy_callback, this,

&answer_to_connection, this, MHD_OPTION_ARRAY,

&iov[0], MHD_OPTION_END);

} else {

daemon = MHD_start_daemon(start_conf, 1, &policy_callback, this,

&answer_to_connection, this, MHD_OPTION_ARRAY,

&iov[0], MHD_OPTION_SOCK_ADDR, bind_address, MHD_OPTION_END);

}

if (daemon == NULL) {

throw std::invalid_argument("Unable to connect daemon to port: " + std::to_string(port));

}

bool value_onclose = false;

running = true;

if (blocking) {

pthread_mutex_lock(&mutexwait);

while (blocking && running) {

pthread_cond_wait(&mutexcond, &mutexwait);

}

pthread_mutex_unlock(&mutexwait);

value_onclose = true;

}

return value_onclose;

if (!running) return false;

pthread_mutex_lock(&mutexwait);

running = false;

pthread_cond_signal(&mutexcond);

pthread_mutex_unlock(&mutexwait);

MHD_stop_daemon(daemon);

shutdown(bind_socket, 2);

return true;

// family does not matter - it just checks the url_normalized anyhow

details::http_endpoint he(resource, false, true, regex_checking);

registered_resources.erase(he);

registered_resources.erase(he.get_url_complete());

registered_resources_str.erase(he.get_url_complete());

ip_representation t_ip(ip);

set<ip_representation>::iterator it = bans.find(t_ip);

if (it != bans.end() && (t_ip.weight() < (*it).weight())) {

bans.erase(it);

bans.insert(t_ip);

} else {

bans.insert(t_ip);

}

ip_representation t_ip(ip);

set<ip_representation>::iterator it = allowances.find(t_ip);

if (it != allowances.end() && (t_ip.weight() < (*it).weight())) {

allowances.erase(it);

allowances.insert(t_ip);

} else {

allowances.insert(t_ip);

}

// Parameter needed to respect MHD interface, but not needed here.

std::ignore = addrlen;

if (!(static_cast<webserver*>(cls))->ban_system_enabled) return MHD_YES;

if ((((static_cast<webserver*>(cls))->default_policy == http_utils::ACCEPT) &&

((static_cast<webserver*>(cls))->bans.count(ip_representation(addr))) &&

(!(static_cast<webserver*>(cls))->allowances.count(ip_representation(addr)))) ||

(((static_cast<webserver*>(cls))->default_policy == http_utils::REJECT) &&

((!(static_cast<webserver*>(cls))->allowances.count(ip_representation(addr))) ||

((static_cast<webserver*>(cls))->bans.count(ip_representation(addr)))))) {

return MHD_NO;

}

return MHD_YES;

// Parameter needed to respect MHD interface, but not needed here.

std::ignore = ap;

webserver* dws = static_cast<webserver*>(cls);

if (dws->log_error != 0x0) dws->log_error(fmt);

// Parameter needed to respect MHD interface, but not needed here.

std::ignore = cls;

std::ignore = c;

// THIS IS USED TO AVOID AN UNESCAPING OF URL BEFORE THE ANSWER.

// IT IS DUE TO A BOGUS ON libmicrohttpd (V0.99) THAT PRODUCING A

// STRING CONTAINING '\0' AFTER AN UNESCAPING, IS UNABLE TO PARSE

// ARGS WITH get_connection_values FUNC OR lookup FUNC.

return std::string(s).size();

const char *key, const char *filename, const char *content_type,

const char *transfer_encoding, const char *data, uint64_t off, size_t size) {

// Parameter needed to respect MHD interface, but not needed here.

std::ignore = kind;

std::ignore = filename;

std::ignore = content_type;

std::ignore = transfer_encoding;

std::ignore = off;

struct details::modded_request* mr = (struct details::modded_request*) cls;

mr->dhr->set_arg(key, mr->dhr->get_arg(key) + std::string(data, size));

return MHD_YES;

if (not_found_resource != 0x0) {

return not_found_resource(*mr->dhr);

} else {

return std::shared_ptr<http_response>(new string_response(NOT_FOUND_ERROR, http_utils::http_not_found));

}

if (method_not_allowed_resource != 0x0) {

return method_not_allowed_resource(*mr->dhr);

} else {

return std::shared_ptr<http_response>(new string_response(METHOD_ERROR, http_utils::http_method_not_allowed));

}

if (internal_error_resource != 0x0 && !force_our) {

return internal_error_resource(*mr->dhr);

} else {

return std::shared_ptr<http_response>(new string_response(GENERIC_ERROR, http_utils::http_internal_server_error, "text/plain"));

}

mr->second = true;

mr->dhr = new http_request(connection, unescaper);

if (!mr->has_body) {

return MHD_YES;

}

mr->dhr->set_content_size_limit(content_size_limit);

const char *encoding = MHD_lookup_connection_value(connection, MHD_HEADER_KIND, http_utils::http_header_content_type);

if (post_process_enabled &&

(0x0 != encoding &&

((0 == strncasecmp(http_utils::http_post_encoding_form_urlencoded, encoding, strlen(http_utils::http_post_encoding_form_urlencoded))) ||

(0 == strncasecmp(http_utils::http_post_encoding_multipart_formdata, encoding, strlen(http_utils::http_post_encoding_multipart_formdata)))))) {

const size_t post_memory_limit(32 * 1024); // Same as #MHD_POOL_SIZE_DEFAULT

mr->pp = MHD_create_post_processor(connection, post_memory_limit, &post_iterator, mr);

} else {

mr->pp = NULL;

}

return MHD_YES;

const char* version, const char* upload_data,

size_t* upload_data_size, struct details::modded_request* mr) {

if (0 == *upload_data_size) return complete_request(connection, mr, version, method);

if (mr->has_body) {

#ifdef DEBUG

std::cout << "Writing content: " << upload_data << std::endl;

#endif // DEBUG

mr->dhr->grow_content(upload_data, *upload_data_size);

if (mr->pp != NULL) MHD_post_process(mr->pp, upload_data, *upload_data_size);

}

*upload_data_size = 0;

return MHD_YES;

{

#if defined(MHD_POSIX_SOCKETS)

int flags;

flags = fcntl (fd, F_GETFL);

if (-1 == flags)

return;

if ((flags & ~O_NONBLOCK) != flags)

if (-1 == fcntl (fd, F_SETFL, flags & ~O_NONBLOCK))

abort ();

#elif defined(MHD_WINSOCK_SOCKETS)

unsigned long flags = 0;

ioctlsocket (fd, FIONBIO, &flags);

#endif /* MHD_WINSOCK_SOCKETS */

char* buf,

size_t buf_len)

{

size_t buf_offset = 0;

while (buf_offset < buf_len)

{

size_t new_offset = 0;

char *frame_data = NULL;

size_t frame_len = 0;

int status = MHD_websocket_decode (cu->ws,

buf + buf_offset,

buf_len - buf_offset,

&new_offset,

&frame_data,

&frame_len);

if (0 > status)

{

/* an error occurred and the connection must be closed */

if (NULL != frame_data)

{

/* depending on the WebSocket flag */

/* MHD_WEBSOCKET_FLAG_GENERATE_CLOSE_FRAMES_ON_ERROR */

/* close frames might be generated on errors */

cu->send_raw(frame_data, frame_len);

MHD_websocket_free (cu->ws, frame_data);

}

return 1;

}

else

{

buf_offset += new_offset;

if (0 < status)

{

/* the frame is complete */

switch (status)

{

case MHD_WEBSOCKET_STATUS_TEXT_FRAME:

case MHD_WEBSOCKET_STATUS_BINARY_FRAME:

/**

cu->insert_into_receive_queue(std::string(frame_data, frame_len));

MHD_websocket_free (cu->ws,

frame_data);

return 0;

case MHD_WEBSOCKET_STATUS_CLOSE_FRAME:

/* if we receive a close frame, we will respond with one */

MHD_websocket_free (cu->ws,

frame_data);

{

char*result = NULL;

size_t result_len = 0;

int er = MHD_websocket_encode_close (cu->ws,

MHD_WEBSOCKET_CLOSEREASON_REGULAR,

NULL,

0,

&result,

&result_len);

if (MHD_WEBSOCKET_STATUS_OK == er)

{

cu->send_raw(result, result_len);

MHD_websocket_free (cu->ws, result);

}

}

return 1;

case MHD_WEBSOCKET_STATUS_PING_FRAME:

/* if we receive a ping frame, we will respond */

/* with the corresponding pong frame */

std::cerr << "ping not yet implemented" << std::endl;

return 0;

case MHD_WEBSOCKET_STATUS_PONG_FRAME:

/* if we receive a pong frame, */

/* we will check whether we requested this frame and */

/* whether it is the last requested pong */

std::cerr << "pong not yet implemented" << std::endl;

return 0;

default:

/* This case should really never happen, */

/* because there are only five types of (finished) websocket frames. */

/* If it is ever reached, it means that there is memory corruption. */

MHD_websocket_free (cu->ws,

frame_data);

return 1;

}

}

}

}

return 0;

struct MHD_Connection *connection,

void *con_cls,

const char *extra_in,

size_t extra_in_size,

MHD_socket fd,

struct MHD_UpgradeResponseHandle *urh)

{

pthread_t pt;

(void) connection; /* Unused. Silent compiler warning. */

(void) con_cls; /* Unused. Silent compiler warning. */

/* This callback must return as soon as possible. */

/* allocate new connected user */

websocket* cu = new websocket();

if (0 != extra_in_size)

{

cu->extra_in = (char*)malloc (extra_in_size);

if (NULL == cu->extra_in)

abort ();

memcpy (cu->extra_in,

extra_in,

extra_in_size);

}

cu->extra_in_size = extra_in_size;

cu->fd = fd;

cu->urh = urh;

cu->ws_handler = (websocket_handler*)cls;

/* create thread for the new connected user */

if (0 != pthread_create (&pt,

NULL,

&connecteduser_receive_messages,

cu))

abort ();

pthread_detach (pt);

websocket_handler* ws_handler,

MHD_Connection *connection)

{

/**

MHD_Result ret;

/* check whether a websocket upgrade is requested */

const char*value = MHD_lookup_connection_value (connection,

MHD_HEADER_KIND,

MHD_HTTP_HEADER_UPGRADE);

if ((0 == value) || (0 != strcasecmp (value, "websocket")))

{

struct MHD_Response*response = MHD_create_response_from_buffer (strlen (

PAGE_INVALID_WEBSOCKET_REQUEST),

(void*)PAGE_INVALID_WEBSOCKET_REQUEST,

MHD_RESPMEM_PERSISTENT);

ret = MHD_queue_response (connection,

MHD_HTTP_BAD_REQUEST,

response);

MHD_destroy_response (response);

return ret;

}

/* check the protocol version */

value = MHD_lookup_connection_value (connection,

MHD_HEADER_KIND,

MHD_HTTP_HEADER_SEC_WEBSOCKET_VERSION);

if ((0 == value) || (0 != strcasecmp (value, "13")))

{

struct MHD_Response*response = MHD_create_response_from_buffer (strlen (

PAGE_INVALID_WEBSOCKET_REQUEST),

(void*)PAGE_INVALID_WEBSOCKET_REQUEST,

MHD_RESPMEM_PERSISTENT);

ret = MHD_queue_response (connection,

MHD_HTTP_BAD_REQUEST,

response);

MHD_destroy_response (response);

return ret;

}

/* read the websocket key (required for the response) */

value = MHD_lookup_connection_value (connection, MHD_HEADER_KIND,

MHD_HTTP_HEADER_SEC_WEBSOCKET_KEY);

if (0 == value)

{

struct MHD_Response*response = MHD_create_response_from_buffer (strlen (

PAGE_INVALID_WEBSOCKET_REQUEST),

(void*)PAGE_INVALID_WEBSOCKET_REQUEST,

MHD_RESPMEM_PERSISTENT);

ret = MHD_queue_response (connection,

MHD_HTTP_BAD_REQUEST,

response);

MHD_destroy_response (response);

return ret;

}

/* generate the response accept header */

char sec_websocket_accept[29];

if (0 != MHD_websocket_create_accept (value, sec_websocket_accept))

{

struct MHD_Response*response = MHD_create_response_from_buffer (strlen (

PAGE_INVALID_WEBSOCKET_REQUEST),

(void*)PAGE_INVALID_WEBSOCKET_REQUEST,

MHD_RESPMEM_PERSISTENT);

ret = MHD_queue_response (connection,

MHD_HTTP_BAD_REQUEST,

response);

MHD_destroy_response (response);

return ret;

}

/* create the response for upgrade */

MHD_Response* response = MHD_create_response_for_upgrade(

&upgrade_handler, ws_handler);

/**

MHD_add_response_header (response,

MHD_HTTP_HEADER_CONNECTION,

"Upgrade");

MHD_add_response_header (response,

MHD_HTTP_HEADER_UPGRADE,

"websocket");

MHD_add_response_header (response,

MHD_HTTP_HEADER_SEC_WEBSOCKET_ACCEPT,

sec_websocket_accept);

ret = MHD_queue_response (connection,

MHD_HTTP_SWITCHING_PROTOCOLS,

response);

MHD_destroy_response (response);

return ret;

int to_ret = MHD_NO;

map<string, http_resource*>::iterator fe;

http_resource* hrm;