/*

This file is part of libhttpserver

Copyright (C) 2011 Sebastiano Merlino

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301

USA

*/

#include <stdint.h>

#include <inttypes.h>

#include <iostream>

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <unistd.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <netinet/ip.h>

#include <signal.h>

#include <fcntl.h>

#include <algorithm>

#include <microhttpd.h>

#include "gettext.h"

#include "http_utils.hpp"

#include "http_resource.hpp"

#include "http_response.hpp"

#include "http_request.hpp"

#include "http_endpoint.hpp"

#include "string_utilities.hpp"

#include "webserver.hpp"

#define _REENTRANT 1

using namespace std;

namespace httpserver

{

namespace details

{

struct daemon_item

{

webserver* ws;

struct MHD_Daemon* daemon;

daemon_item(webserver* ws, struct MHD_Daemon* daemon):

ws(ws),

daemon(daemon)

{

}

~daemon_item()

{

MHD_stop_daemon (this->daemon);

}

};

struct http_response_ptr

{

public:

http_response_ptr():

res(0x0),

num_references(0x0)

{

num_references = new int(0);

}

http_response_ptr(http_response* res):

res(res),

num_references(0x0)

{

num_references = new int(0);

}

http_response_ptr(const http_response_ptr& b):

res(b.res),

num_references(b.num_references)

{

(*num_references)++;

}

~http_response_ptr()

{

if(num_references)

{

if((*num_references) == 0)

{

if(res && res->autodelete)

{

delete res;

res = 0x0;

}

delete num_references;

}

else

(*num_references)--;

}

}

http_response& operator* ()

{

return *res;

}

http_response* operator-> ()

{

return res;

}

http_response* ptr()

{

return res;

}

http_response_ptr& operator= (const http_response_ptr& b)

{

if( this != &b)

{

if(num_references)

{

if((*num_references) == 0)

{

if(res && res->autodelete)

{

delete res;

res = 0x0;

}

delete num_references;

}

else

(*num_references)--;

}

res = b.res;

num_references = b.num_references;

(*num_references)++;

}

return *this;

}

private:

http_response* res;

int* num_references;

friend class ::httpserver::webserver;

};

struct modded_request

{

struct MHD_PostProcessor *pp;

std::string* complete_uri;

webserver* ws;

const binders::functor_two<

const http_request&, http_response**, void

> http_resource_mirror::*callback;

http_request* dhr;

http_response_ptr dhrs;

bool second;

modded_request():

pp(0x0),

complete_uri(0x0),

ws(0x0),

dhr(0x0),

dhrs(0x0),

second(false)

{

}

~modded_request()

{

if (NULL != pp)

{

MHD_destroy_post_processor (pp);

}

if(second)

delete dhr; //TODO: verify. It could be an error

delete complete_uri;

}

};

void empty_render(const http_request& r, http_response** res)

{

*res = new http_string_response("", 200);

}

void empty_not_acceptable_render(const http_request& r, http_response** res)

{

*res = new http_string_response(NOT_METHOD_ERROR, 200);

}

bool empty_is_allowed(const std::string& method)

{

return true;

}

}

struct pthread_t_comparator

{

bool operator()(const pthread_t& t1, const pthread_t& t2) const

{

return pthread_equal(t1, t2);

}

};

struct cache_entry

{

long ts;

int validity;

details::http_response_ptr response;

pthread_rwlock_t elem_guard;

pthread_mutex_t lock_guard;

set<pthread_t, pthread_t_comparator> lockers;

cache_entry():

ts(-1),

validity(-1)

{

pthread_rwlock_init(&elem_guard, NULL);

pthread_mutex_init(&lock_guard, NULL);

}

~cache_entry()

{

pthread_rwlock_destroy(&elem_guard);

pthread_mutex_destroy(&lock_guard);

}

cache_entry(const cache_entry& b):

ts(b.ts),

validity(b.validity),

response(b.response),

elem_guard(b.elem_guard),

lock_guard(b.lock_guard)

{

}

void operator= (const cache_entry& b)

{

ts = b.ts;

validity = b.validity;

response = b.response;

pthread_rwlock_destroy(&elem_guard);

pthread_mutex_destroy(&lock_guard);

elem_guard = b.elem_guard;

}

cache_entry(

details::http_response_ptr response,

long ts = -1,

int validity = -1

):

ts(ts),

validity(validity),

response(response)

{

pthread_rwlock_init(&elem_guard, NULL);

pthread_mutex_init(&lock_guard, NULL);

}

void lock(bool write = false)

{

pthread_mutex_lock(&lock_guard);

pthread_t tid = pthread_self();

if(!lockers.count(tid))

{

if(write)

{

lockers.insert(tid);

pthread_mutex_unlock(&lock_guard);

pthread_rwlock_wrlock(&elem_guard);

}

else

{

lockers.insert(tid);

pthread_mutex_unlock(&lock_guard);

pthread_rwlock_rdlock(&elem_guard);

}

}

else

pthread_mutex_unlock(&lock_guard);

}

void unlock()

{

pthread_mutex_lock(&lock_guard);

{

pthread_t tid = pthread_self();

if(lockers.count(tid))

{

lockers.erase(tid);

pthread_rwlock_unlock(&elem_guard);

}

}

pthread_mutex_unlock(&lock_guard);

}

};

using namespace http;

int policy_callback (void *, const struct sockaddr*, socklen_t);

void error_log(void*, const char*, va_list);

void* uri_log(void*, const char*);

void access_log(webserver*, string);

size_t unescaper_func(void*, struct MHD_Connection*, char*);

size_t internal_unescaper(void*, char*);

struct compare_value

{

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

const std::pair<int, int>& right

) const

{

return left.second < right.second;

}

};

static void catcher (int sig)

{

}

static void ignore_sigpipe ()

{

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,

gettext("Failed to install SIGPIPE handler: %s\n"),

strerror (errno)

);

}

//WEBSERVER CREATOR

create_webserver& create_webserver::https_mem_key(

const std::string& https_mem_key

)

{

char* _https_mem_key_pt = http::load_file(https_mem_key.c_str());

_https_mem_key = _https_mem_key_pt;

free(_https_mem_key_pt);

return *this;

}

create_webserver& create_webserver::https_mem_cert(

const std::string& https_mem_cert

)

{

char* _https_mem_cert_pt = http::load_file(https_mem_cert.c_str());

_https_mem_cert = _https_mem_cert_pt;

free(_https_mem_cert_pt);

return *this;

}

create_webserver& create_webserver::https_mem_trust(

const std::string& https_mem_trust

)

{

char* _https_mem_trust_pt = http::load_file(https_mem_trust.c_str());

_https_mem_trust = _https_mem_trust_pt;

free(_https_mem_trust_pt);

return *this;

}

//WEBSERVER

webserver::webserver

(

int port,

const http_utils::start_method_T& start_method,

int max_threads,

int max_connections,

int memory_limit,

int connection_timeout,

int per_IP_connection_limit,

log_access_ptr log_access,

log_error_ptr log_error,

validator_ptr validator,

unescaper_ptr unescaper,

const struct sockaddr* bind_address,

int bind_socket,

int max_thread_stack_size,

bool use_ssl,

bool use_ipv6,

bool debug,

bool pedantic,

const string& https_mem_key,

const string& https_mem_cert,

const string& https_mem_trust,

const string& https_priorities,

const http_utils::cred_type_T& cred_type,

const string digest_auth_random,

int nonce_nc_size,

const http_utils::policy_T& default_policy,

bool basic_auth_enabled,

bool digest_auth_enabled,

bool regex_checking,

bool ban_system_enabled,

bool post_process_enabled,

render_ptr single_resource,

render_ptr not_found_resource,

render_ptr method_not_allowed_resource,

render_ptr method_not_acceptable_resource,

render_ptr internal_error_resource

) :

port(port),

start_method(start_method),

max_threads(max_threads),

max_connections(max_connections),

memory_limit(memory_limit),

connection_timeout(connection_timeout),

per_IP_connection_limit(per_IP_connection_limit),

log_access(log_access),

log_error(log_error),

validator(validator),

unescaper(unescaper),

bind_address(bind_address),

bind_socket(bind_socket),

max_thread_stack_size(max_thread_stack_size),

use_ssl(use_ssl),

use_ipv6(use_ipv6),

debug(debug),

pedantic(pedantic),

https_mem_key(https_mem_key),

https_mem_cert(https_mem_cert),

https_mem_trust(https_mem_trust),

https_priorities(https_priorities),

cred_type(cred_type),

digest_auth_random(digest_auth_random),

nonce_nc_size(nonce_nc_size),

running(false),

default_policy(default_policy),

basic_auth_enabled(basic_auth_enabled),

digest_auth_enabled(digest_auth_enabled),

regex_checking(regex_checking),

ban_system_enabled(ban_system_enabled),

post_process_enabled(post_process_enabled),

not_found_resource(not_found_resource),

method_not_allowed_resource(method_not_allowed_resource),

method_not_acceptable_resource(method_not_acceptable_resource),

internal_error_resource(internal_error_resource),

next_to_choose(0)

{

init(single_resource);

}

webserver::webserver(const create_webserver& params):

port(params._port),

start_method(params._start_method),

max_threads(params._max_threads),

max_connections(params._max_connections),

memory_limit(params._memory_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),

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

not_found_resource(params._not_found_resource),

method_not_allowed_resource(params._method_not_allowed_resource),

method_not_acceptable_resource(params._method_not_acceptable_resource),

internal_error_resource(params._internal_error_resource),

next_to_choose(0)

{

init(params._single_resource);

}

void webserver::init(render_ptr single_resource)

{

if(single_resource != 0x0)

this->single_resource = true;

else

this->single_resource = false;

ignore_sigpipe();

pthread_mutex_init(&mutexwait, NULL);

pthread_rwlock_init(&runguard, NULL);

pthread_cond_init(&mutexcond, NULL);

pthread_rwlock_init(&cache_guard, NULL);

pthread_rwlock_init(&comet_guard, NULL);

pthread_mutex_init(&cleanmux, NULL);

pthread_cond_init(&cleancond, NULL);

}

webserver::~webserver()

{

this->stop();

pthread_mutex_destroy(&mutexwait);

pthread_rwlock_destroy(&runguard);

pthread_rwlock_destroy(&cache_guard);

pthread_cond_destroy(&mutexcond);

pthread_rwlock_destroy(&comet_guard);

pthread_mutex_destroy(&cleanmux);

pthread_cond_destroy(&cleancond);

}

void webserver::sweet_kill()

{

this->stop();

}

void webserver::request_completed (

void *cls,

struct MHD_Connection *connection,

void **con_cls,

enum MHD_RequestTerminationCode toe

)

{

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

pthread_rwlock_wrlock(&mr->ws->comet_guard);

mr->ws->q_messages.erase(mr->dhrs->connection_id);

mr->ws->q_blocks.erase(mr->dhrs->connection_id);

mr->ws->q_signal.erase(mr->dhrs->connection_id);

mr->ws->q_keepalives.erase(mr->dhrs->connection_id);

typedef std::map<string, std::set<httpserver_ska> >::iterator conn_it;

for(conn_it it = mr->ws->q_waitings.begin(); it != mr->ws->q_waitings.end(); ++it)

{

it->second.erase(mr->dhrs->connection_id);

}

pthread_rwlock_unlock(&mr->ws->comet_guard);

if (0x0 == mr)

{

if(mr->dhrs.res != 0x0 && mr->dhrs->ca != 0x0)

mr->dhrs->ca(mr->dhrs->closure_data);

delete mr;

}

}

void webserver::register_resource(

const std::string& resource,

details::http_resource_mirror hrm,

bool family

)

{

if(method_not_acceptable_resource)

hrm.method_not_acceptable_resource = method_not_acceptable_resource;

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

registered_resources.insert(

pair<details::http_endpoint, details::http_resource_mirror>(idx,hrm)

);

registered_resources_str[idx.url_complete] = &registered_resources[idx];

}

void* webserver::select(void* self)

{

fd_set rs;

fd_set ws;

fd_set es;

struct timeval timeout_value;

details::daemon_item* di = static_cast<details::daemon_item*>(self);

int max;

while (di->ws->is_running())

{

max = 0;

FD_ZERO (&rs);

FD_ZERO (&ws);

FD_ZERO (&es);

if (MHD_YES != MHD_get_fdset (di->daemon, &rs, &ws, &es, &max))

abort(); /* fatal internal error */

unsigned MHD_LONG_LONG timeout_microsecs = 0;

unsigned MHD_LONG_LONG timeout_secs = 0;

if (!(MHD_get_timeout (di->daemon, &timeout_microsecs) == MHD_YES))

{

timeout_secs = 1;

timeout_microsecs = 0;

}

else

{

if(timeout_microsecs < 1000)

{

timeout_microsecs = timeout_microsecs * 1000;

timeout_secs = 0;

}

}

// SUPPLIERS MANAGEMENT

{

std::map<std::string, details::event_tuple>::const_iterator it;

pthread_rwlock_rdlock(&di->ws->runguard);

for(it = di->ws->event_suppliers.begin();

it != di->ws->event_suppliers.end();

++it

)

{

int local_max;

(*it).second.supply_events(&rs, &ws, &es, &local_max);

if(local_max > max)

max = local_max;

struct timeval t = (*it).second.get_timeout();

if((unsigned MHD_LONG_LONG) t.tv_sec < timeout_secs ||

((unsigned MHD_LONG_LONG) t.tv_sec == timeout_secs

&& (unsigned MHD_LONG_LONG) t.tv_usec < timeout_microsecs

)

)

{

timeout_secs = t.tv_sec;

timeout_microsecs = t.tv_usec;

}

}

pthread_rwlock_unlock(&di->ws->runguard);

}

// COMET CONNECTIONS MANAGEMENT

pthread_rwlock_wrlock(&di->ws->comet_guard);

for(std::map<httpserver_ska, long>::iterator it = di->ws->q_keepalives.begin();

it != di->ws->q_keepalives.end();

++it

)

{

struct timeval curtime;

gettimeofday(&curtime, NULL);

int waited_time = curtime.tv_sec - (*it).second;

if(waited_time >= di->ws->q_keepalives_mem[(*it).first].first)

di->ws->send_message_to_consumer(

(*it).first,

di->ws->q_keepalives_mem[(*it).first].second

);

else

{

unsigned MHD_LONG_LONG to_wait_time =

di->ws->q_keepalives_mem[(*it).first].first - waited_time;

if(to_wait_time < timeout_secs)

{

timeout_secs = to_wait_time;

timeout_microsecs = 0;

}

}

}

pthread_rwlock_unlock(&di->ws->comet_guard);

timeout_value.tv_sec = timeout_secs;

timeout_value.tv_usec = timeout_microsecs;

::select (max + 1, &rs, &ws, &es, &timeout_value);

MHD_run (di->daemon);

//EVENT SUPPLIERS DISPATCHING

{

std::map<std::string, details::event_tuple>::const_iterator it;

pthread_rwlock_rdlock(&di->ws->runguard);

for(it = di->ws->event_suppliers.begin();

it != di->ws->event_suppliers.end();

++it

)

(*it).second.dispatch_events();

}

}

return 0x0;

}

int create_socket (int domain, int type, int protocol)

{

int sock_cloexec = SOCK_CLOEXEC;

int ctype = SOCK_STREAM | sock_cloexec;

int fd;

/* use SOCK_STREAM rather than ai_socktype: some getaddrinfo

* implementations do not set ai_socktype, e.g. RHL6.2. */

fd = socket(domain, ctype, protocol);

if ( (-1 == fd) && (EINVAL == errno) && (0 != sock_cloexec) )

{

sock_cloexec = 0;

fd = socket(domain, type, protocol);

}

if (-1 == fd)

return -1;

return fd;

}

bool webserver::start(bool blocking)

{

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_address != 0x0)

iov.push_back(gen(MHD_OPTION_SOCK_ADDR, (intptr_t) bind_address));

if(bind_socket != 0)

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

if(! (start_method == http_utils::INTERNAL_SELECT))

{

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)

iov.push_back(gen(MHD_OPTION_HTTPS_MEM_KEY,

0,

(void*)https_mem_key.c_str())

);

if(use_ssl)

iov.push_back(gen(MHD_OPTION_HTTPS_MEM_CERT,

0,

(void*)https_mem_cert.c_str())

);

if(https_mem_trust != "" && use_ssl)

iov.push_back(gen(MHD_OPTION_HTTPS_MEM_TRUST,

0,

(void*)https_mem_trust.c_str())

);

if(https_priorities != "" && use_ssl)

iov.push_back(gen(MHD_OPTION_HTTPS_PRIORITIES,

0,

(void*)https_priorities.c_str())

);

if(digest_auth_random != "")

iov.push_back(gen(MHD_OPTION_DIGEST_AUTH_RANDOM,

digest_auth_random.size(),

(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

if(start_method == http_utils::INTERNAL_SELECT)

{

int on = 1;

bool bind_settled = true;

if(!bind_socket)

{

bind_settled = false;

struct sockaddr_in servaddr4;

#if HAVE_INET6

struct sockaddr_in6 servaddr6;

#endif

const struct sockaddr *servaddr = NULL;

socklen_t addrlen;

#if HAVE_INET6

if (0 != (options & MHD_USE_IPv6))

addrlen = sizeof (struct sockaddr_in6);

else

#endif

addrlen = sizeof (struct ::sockaddr_in);

#if HAVE_INET6

if (0 != (options & MHD_USE_IPv6))

{

memset (&servaddr6, 0, sizeof (struct sockaddr_in6));

servaddr6.sin6_family = AF_INET6;

servaddr6.sin6_port = htons (port);

#if HAVE_SOCKADDR_IN_SIN_LEN

servaddr6.sin6_len = sizeof (struct sockaddr_in6);

#endif

servaddr = (struct sockaddr *) &servaddr6;

}

else

#endif

{

memset (&servaddr4, 0, sizeof (struct ::sockaddr_in));

servaddr4.sin_family = AF_INET;

servaddr4.sin_port = htons (port);

#if HAVE_SOCKADDR_IN_SIN_LEN

servaddr4.sin_len = sizeof (struct ::sockaddr_in);

#endif

servaddr = (struct sockaddr *) &servaddr4;

}

if (use_ipv6)

bind_socket = create_socket (PF_INET6, SOCK_STREAM, 0);

else

bind_socket = create_socket (PF_INET, SOCK_STREAM, 0);

setsockopt (bind_socket,

SOL_SOCKET,

SO_REUSEADDR,

&on, sizeof (on));

if(use_ipv6)

{

#ifdef IPPROTO_IPV6

#ifdef IPV6_V6ONLY

setsockopt (bind_socket,

IPPROTO_IPV6, IPV6_V6ONLY,

&on, sizeof (on)

);

#endif

#endif

}

bind(bind_socket, servaddr, addrlen);

}

int flags = fcntl (bind_socket, F_GETFL);

flags |= O_NONBLOCK;

fcntl (bind_socket, F_SETFL, flags);

if(!bind_settled)

listen(bind_socket, 1);

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

}

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

struct MHD_OptionItem ops[iov.size()];

for(unsigned int i = 0; i < iov.size(); i++)

{

ops[i] = iov[i];

}

int start_conf = start_method;

if(use_ssl)

start_conf |= MHD_USE_SSL;

if(use_ipv6)

start_conf |= MHD_USE_IPv6;

if(debug)

start_conf |= MHD_USE_DEBUG;

if(pedantic)

start_conf |= MHD_USE_PEDANTIC_CHECKS;

int num_threads = 1;

if(max_threads > num_threads)

num_threads = max_threads;

if(start_method == http_utils::INTERNAL_SELECT)

{

for(int i = 0; i < num_threads; i++)

{

struct MHD_Daemon* daemon = MHD_start_daemon

(

start_conf, this->port, &policy_callback, this,

&answer_to_connection, this, MHD_OPTION_ARRAY,

ops, MHD_OPTION_END

);

if(NULL == daemon)

{

cout << gettext("Unable to connect daemon to port: ") <<

this->port << endl;

abort();

}

details::daemon_item* di = new details::daemon_item(this, daemon);

daemons.push_back(di);

//RUN SELECT THREADS

pthread_t t;

threads.push_back(t);

if(pthread_create(

&threads[i],

NULL,

&webserver::select,

static_cast<void*>(di)

))

{

abort();

}

}

}

else

{

struct MHD_Daemon* daemon = MHD_start_daemon

(

start_conf, this->port, &policy_callback, this,

&answer_to_connection, this, MHD_OPTION_ARRAY,

ops, MHD_OPTION_END

);

if(NULL == daemon)

{

cout << gettext("Unable to connect daemon to port: ") <<

this->port << endl;

abort();

}

details::daemon_item* di = new details::daemon_item(this, daemon);

daemons.push_back(di);

}

this->running = true;

bool value_onclose = false;

if(blocking)

{

pthread_mutex_lock(&mutexwait);

while(blocking && running)

pthread_cond_wait(&mutexcond, &mutexwait);

pthread_mutex_unlock(&mutexwait);

value_onclose = true;

}

return value_onclose;

}

bool webserver::is_running()

{

return this->running;

}

bool webserver::stop()

{

if(this->running)

{

pthread_mutex_lock(&mutexwait);

this->running = false;

pthread_cond_signal(&mutexcond);

pthread_mutex_unlock(&mutexwait);

for(unsigned int i = 0; i < threads.size(); ++i)

{

void* t_res;

pthread_join(threads[i], &t_res);

free(t_res);

}

threads.clear();

typedef vector<details::daemon_item*>::const_iterator daemon_item_it;

for(daemon_item_it it = daemons.begin(); it != daemons.end(); ++it)

delete *it;

daemons.clear();

return true;

}

else

{

return false;

}

}

void webserver::unregister_resource(const string& resource)

{

details::http_endpoint he(resource);

this->registered_resources.erase(he);

this->registered_resources.erase(he.url_complete);

}

void webserver::ban_ip(const string& ip)

{

ip_representation t_ip(ip);

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

if(it != this->bans.end() && (t_ip.weight() < (*it).weight()))

{

this->bans.erase(it);

this->bans.insert(t_ip);

}

else