{

unescaper_ptr unescaper;

std::map<std::string, std::string, http::arg_comparator>* arguments;

const std::string& realm,

const std::string& password,

int nonce_timeout,

bool& reload_nonce

) const

{

std::string digested_user = get_digested_user();

int val = MHD_digest_auth_check(

underlying_connection,

realm.c_str(),

digested_user.c_str(),

password.c_str(),

nonce_timeout

);

if(val == MHD_INVALID_NONCE)

{

reload_nonce = true;

return false;

}

else if(val == MHD_NO)

{

reload_nonce = false;

return false;

}

reload_nonce = false;

return true;

{

const char* header_c = MHD_lookup_connection_value(

this->underlying_connection,

kind,

key.c_str()

);

if (header_c == NULL) return EMPTY;

return header_c;

void *cls,

enum MHD_ValueKind kind,

const char *key,

const char *value

)

{

std::map<std::string, std::string, http::header_comparator>* dhr = static_cast<std::map<std::string, std::string, http::header_comparator>*>(cls);

(*dhr)[key] = value;

return MHD_YES;

{

std::map<std::string, std::string, http::header_comparator> headers;

MHD_get_connection_values(

this->underlying_connection,

kind,

&build_request_header,

(void*) &headers

);

return headers;

{

std::map<std::string, std::string>::const_iterator it = this->args.find(key);

if(it != this->args.end())

{

return it->second;

}

return get_connection_value(key, MHD_GET_ARGUMENT_KIND);

{

std::map<std::string, std::string, http::arg_comparator> arguments;

arguments.insert(this->args.begin(), this->args.end());

arguments_accumulator aa;

aa.unescaper = this->unescaper;

aa.arguments = &arguments;

MHD_get_connection_values(

this->underlying_connection,

MHD_GET_ARGUMENT_KIND,

&build_request_args,

(void*) &aa

);

return arguments;

{

std::string querystring = "";

MHD_get_connection_values(

this->underlying_connection,

MHD_GET_ARGUMENT_KIND,

&build_request_querystring,

(void*) &querystring

);

return querystring;

void *cls,

enum MHD_ValueKind kind,

const char *key,

const char *arg_value

)

{

arguments_accumulator* aa = static_cast<arguments_accumulator*>(cls);

std::string value = ((arg_value == NULL) ? "" : arg_value);

http::base_unescaper(value, aa->unescaper);

(*aa->arguments)[key] = value;

return MHD_YES;

void *cls,

enum MHD_ValueKind kind,

const char *key,

const char *arg_value

)

{

std::string* querystring = static_cast<std::string*>(cls);

std::string value = ((arg_value == NULL) ? "" : arg_value);

{

char buf[std::string(key).size() + value.size() + 3];

if(*querystring == "")

{

snprintf(buf, sizeof buf, "?%s=%s", key, value.c_str());

*querystring = buf;

}

else

{

snprintf(buf, sizeof buf, "&%s=%s", key, value.c_str());

*querystring += string(buf);

}

}

return MHD_YES;

{

char* username = 0x0;

char* password = 0x0;

username = MHD_basic_auth_get_username_password(underlying_connection, &password);

if (password != 0x0) free(password);

std::string user;

if (username != 0x0) user = username;

free(username);

return user;

{

char* username = 0x0;

char* password = 0x0;

username = MHD_basic_auth_get_username_password(underlying_connection, &password);

if (username != 0x0) free(username);

std::string pass;

if (password != 0x0) pass = password;

free(password);

return pass;

{

char* digested_user_c = 0x0;

digested_user_c = MHD_digest_auth_get_username(underlying_connection);

std::string digested_user = EMPTY;

if (digested_user_c != 0x0)

{

digested_user = digested_user_c;

free(digested_user_c);

}

return digested_user;

{

const MHD_ConnectionInfo * conninfo = MHD_get_connection_info(

underlying_connection,

MHD_CONNECTION_INFO_CLIENT_ADDRESS

);

return http::get_ip_str(conninfo->client_addr);

{

const MHD_ConnectionInfo * conninfo = MHD_get_connection_info(

underlying_connection,

MHD_CONNECTION_INFO_CLIENT_ADDRESS

);

return http::get_port(conninfo->client_addr);