Merge pull request #143 from etr/lazy_request_building

Lazy request building

Author: etr

README.md

@@ -542,23 +542,23 @@ The `http_request` class has a set of methods you will have access to when imple
 * _**const std::vector\<std::string\>&** get_path_pieces() **const**:_ Returns the components of the path requested by the HTTP client (each piece of the path split by `'/'`.
 * _**const std::string&** get_path_piece(int index) **const**:_ Returns one piece of the path requested by the HTTP client. The piece is selected through the `index` parameter (0-indexed). 
 * _**const std::string&** get_method() **const**:_ Returns the method requested by the HTTP client.
-* _**const std::string&** get_header(**const std::string&** key) **const**:_ Returns the header with name equal to `key` if present in the HTTP request. Returns an `empty string` otherwise.
-* _**const std::string&** get_cookie(**const std::string&** key) **const**:_ Returns the cookie with name equal to `key` if present in the HTTP request. Returns an `empty string` otherwise.
-* _**const std::string&** get_footer(**const std::string&** key) **const**:_ Returns the footer with name equal to `key` if present in the HTTP request (only for http 1.1 chunked encodings). Returns an `empty string` otherwise.
-* _**const std::string&** get_arg(**const std::string&** key) **const**:_ Returns the argument with name equal to `key` if present in the HTTP request. Arguments can be (1) querystring parameters, (2) path argument (in case of parametric endpoint, (3) parameters parsed from the HTTP request body if the body is in `application/x-www-form-urlencoded` or `multipart/form-data` formats and the postprocessor is enabled in the webserver (enabled by default).
-* _**const std::map<std::string, std::string, http::header_comparator>&** get_headers() **const**:_ Returns a map containing all the headers present in the HTTP request.
-* _**const std::map<std::string, std::string, http::header_comparator>&** get_cookies() **const**:_ Returns a map containing all the cookies present in the HTTP request.
-* _**const std::map<std::string, std::string, http::header_comparator>&** get_footers() **const**:_ Returns a map containing all the footers present in the HTTP request (only for http 1.1 chunked encodings).
-* _**const std::map<std::string, std::string, http::arg_comparator>&** get_args() **const**:_ Returns all the arguments present in the HTTP request. Arguments can be (1) querystring parameters, (2) path argument (in case of parametric endpoint, (3) parameters parsed from the HTTP request body if the body is in `application/x-www-form-urlencoded` or `multipart/form-data` formats and the postprocessor is enabled in the webserver (enabled by default).
+* _**const std::string** get_header(**const std::string&** key) **const**:_ Returns the header with name equal to `key` if present in the HTTP request. Returns an `empty string` otherwise.
+* _**const std::string** get_cookie(**const std::string&** key) **const**:_ Returns the cookie with name equal to `key` if present in the HTTP request. Returns an `empty string` otherwise.
+* _**const std::string** get_footer(**const std::string&** key) **const**:_ Returns the footer with name equal to `key` if present in the HTTP request (only for http 1.1 chunked encodings). Returns an `empty string` otherwise.
+* _**const std::string** get_arg(**const std::string&** key) **const**:_ Returns the argument with name equal to `key` if present in the HTTP request. Arguments can be (1) querystring parameters, (2) path argument (in case of parametric endpoint, (3) parameters parsed from the HTTP request body if the body is in `application/x-www-form-urlencoded` or `multipart/form-data` formats and the postprocessor is enabled in the webserver (enabled by default).
+* _**const std::map<std::string, std::string, http::header_comparator>** get_headers() **const**:_ Returns a map containing all the headers present in the HTTP request.
+* _**const std::map<std::string, std::string, http::header_comparator>** get_cookies() **const**:_ Returns a map containing all the cookies present in the HTTP request.
+* _**const std::map<std::string, std::string, http::header_comparator>** get_footers() **const**:_ Returns a map containing all the footers present in the HTTP request (only for http 1.1 chunked encodings).
+* _**const std::map<std::string, std::string, http::arg_comparator>** get_args() **const**:_ Returns all the arguments present in the HTTP request. Arguments can be (1) querystring parameters, (2) path argument (in case of parametric endpoint, (3) parameters parsed from the HTTP request body if the body is in `application/x-www-form-urlencoded` or `multipart/form-data` formats and the postprocessor is enabled in the webserver (enabled by default).
 * _**const std::string&** get_content() **const**:_ Returns the body of the HTTP request.
 * _**bool**  content_too_large() **const**:_ Returns `true` if the body length of the HTTP request sent by the client is longer than the max allowed on the server.
-* _**const std::string&** get_querystring() **const**:_ Returns the `querystring` of the HTTP request.
+* _**const std::string** get_querystring() **const**:_ Returns the `querystring` of the HTTP request.
 * _**const std::string&** get_version() **const**:_ Returns the HTTP version of the client request.
-* _**const std::string&** get_requestor() **const**:_ Returns the IP from which the client is sending the request.
+* _**const std::string** get_requestor() **const**:_ Returns the IP from which the client is sending the request.
 * _**unsigned  short**  get_requestor_port() **const**:_ Returns the port from which the client is sending the request.
-* _**const std::string&** get_user() **const**:_ Returns the `user` as self-identified through basic authentication. The content of the user header will be parsed only if basic authentication is enabled on the server (enabled by default).
-* _**const std::string&** get_pass() **const**:_ Returns the `password` as self-identified through basic authentication. The content of the password header will be parsed only if basic authentication is enabled on the server (enabled by default).
-* _**const std::string&** get_digested_user() **const**:_ Returns the `digested user` as self-identified through digest authentication. The content of the user header will be parsed only if digest authentication is enabled on the server (enabled by default).
+* _**const std::string** get_user() **const**:_ Returns the `user` as self-identified through basic authentication. The content of the user header will be parsed only if basic authentication is enabled on the server (enabled by default).
+* _**const std::string** get_pass() **const**:_ Returns the `password` as self-identified through basic authentication. The content of the password header will be parsed only if basic authentication is enabled on the server (enabled by default).
+* _**const std::string** get_digested_user() **const**:_ Returns the `digested user` as self-identified through digest authentication. The content of the user header will be parsed only if digest authentication is enabled on the server (enabled by default).
 * _**bool** check_digest_auth(**const std::string&** realm, **const std::string&** password, **int** nonce_timeout, **bool&** reload_nonce) **const**:_ Allows to check the validity of the authentication token sent through digest authentication (if the provided values in the WWW-Authenticate header are valid and sound according to RFC2716). Takes in input the `realm` of validity of the authentication, the `password` as known to the server to compare against, the `nonce_timeout` to indicate how long the nonce is valid and `reload_nonce` a boolean that will be set by the method to indicate a nonce being reloaded. The method returns `true` if the authentication is valid, `false` otherwise.
 
 #### Example of handler reading arguments from a request

src/http_request.cpp

@@ -31,6 +31,12 @@ namespace httpserver
 
 const std::string http_request::EMPTY = "";
 
+struct arguments_accumulator
+{
+    unescaper_ptr unescaper;
+    std::map<std::string, std::string, http::arg_comparator>* arguments;
+};
+
 void http_request::set_method(const std::string& method)
 {
     this->method = string_utilities::to_upper_copy(method);
@@ -43,6 +49,8 @@ bool http_request::check_digest_auth(
         bool& reload_nonce
 ) const
 {
+    std::string digested_user = get_digested_user();
+
     int val = MHD_digest_auth_check(
             underlying_connection,
             realm.c_str(),
@@ -65,21 +73,242 @@ bool http_request::check_digest_auth(
     return true;
 }
 
+const std::string http_request::get_connection_value(const std::string& key, enum MHD_ValueKind kind) const
+{
+    const char* header_c = MHD_lookup_connection_value(
+        this->underlying_connection,
+        kind,
+        key.c_str()
+    );
+
+    if (header_c == NULL) return EMPTY;
+
+    return header_c;
+}
+
+int http_request::build_request_header(
+        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;
+}
+
+const std::map<std::string, std::string, http::header_comparator> http_request::get_headerlike_values(enum MHD_ValueKind kind) const
+{
+    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;
+}
+
+const std::string http_request::get_header(const std::string& key) const
+{
+    return get_connection_value(key, MHD_HEADER_KIND);
+}
+
+const std::map<std::string, std::string, http::header_comparator> http_request::get_headers() const
+{
+    return get_headerlike_values(MHD_HEADER_KIND);
+}
+
+const std::string http_request::get_footer(const std::string& key) const
+{
+    return get_connection_value(key, MHD_FOOTER_KIND);
+}
+
+const std::map<std::string, std::string, http::header_comparator> http_request::get_footers() const
+{
+    return get_headerlike_values(MHD_FOOTER_KIND);
+}
+
+const std::string http_request::get_cookie(const std::string& key) const
+{
+    return get_connection_value(key, MHD_COOKIE_KIND);
+}
+
+const std::map<std::string, std::string, http::header_comparator> http_request::get_cookies() const
+{
+    return get_headerlike_values(MHD_COOKIE_KIND);
+}
+
+const std::string http_request::get_arg(const std::string& key) const
+{
+    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);
+}
+
+const std::map<std::string, std::string, http::arg_comparator> http_request::get_args() const
+{
+    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;
+}
+
+const std::string http_request::get_querystring() const
+{
+    std::string querystring = "";
+
+    MHD_get_connection_values(
+        this->underlying_connection,
+        MHD_GET_ARGUMENT_KIND,
+        &build_request_querystring,
+        (void*) &querystring
+    );
+
+    return querystring;
+}
+
+int http_request::build_request_args(
+        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;
+}
+
+int http_request::build_request_querystring(
+        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;
+}
+
+const std::string http_request::get_user() const
+{
+    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;
+}
+
+const std::string http_request::get_pass() const
+{
+    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;
+}
+
+const std::string http_request::get_digested_user() const
+{
+    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 std::string http_request::get_requestor() const
+{
+    const MHD_ConnectionInfo * conninfo = MHD_get_connection_info(
+            underlying_connection,
+            MHD_CONNECTION_INFO_CLIENT_ADDRESS
+    );
+
+    return http::get_ip_str(conninfo->client_addr);
+}
+
+unsigned short http_request::get_requestor_port() const
+{
+    const MHD_ConnectionInfo * conninfo = MHD_get_connection_info(
+            underlying_connection,
+            MHD_CONNECTION_INFO_CLIENT_ADDRESS
+    );
+
+    return http::get_port(conninfo->client_addr);
+}
+
 std::ostream &operator<< (std::ostream &os, const http_request &r)
 {
-    os << r.method << " Request [user:\"" << r.user << "\" pass:\"" << r.pass << "\"] path:\""
-       << r.path << "\"" << std::endl;
+    os << r.get_method() << " Request [user:\"" << r.get_user() << "\" pass:\"" << r.get_pass() << "\"] path:\""
+       << r.get_path() << "\"" << std::endl;
 
-    http::dump_header_map(os,"Headers",r.headers);
-    http::dump_header_map(os,"Footers",r.footers);
-    http::dump_header_map(os,"Cookies",r.cookies);
-    http::dump_arg_map(os,"Query Args",r.args);
+    http::dump_header_map(os,"Headers",r.get_headers());
+    http::dump_header_map(os,"Footers",r.get_footers());
+    http::dump_header_map(os,"Cookies",r.get_cookies());
+    http::dump_arg_map(os,"Query Args",r.get_args());
 
-    os << "    Version [ " << r.version << " ] Requestor [ " << r.requestor
-       << " ] Port [ " << r.requestor_port << " ]" << std::endl;
+    os << "    Version [ " << r.get_version() << " ] Requestor [ " << r.get_requestor()
+       << " ] Port [ " << r.get_requestor_port() << " ]" << std::endl;
 
     return os;
 }
 
-
 }

src/http_utils.cpp

@@ -593,6 +593,18 @@ void dump_arg_map(std::ostream &os, const std::string &prefix,
     }
 }
 
+size_t base_unescaper(std::string& s, unescaper_ptr unescaper)
+{
+    if(s[0] == 0) return 0;
+
+    if(unescaper != 0x0)
+    {
+        unescaper(s);
+        return s.size();
+    }
+
+    return http_unescape(s);
+}
 
 };
 };

src/httpserver/create_webserver.hpp

@@ -39,7 +39,6 @@ class http_request;
 
 typedef const std::shared_ptr<http_response>(*render_ptr)(const http_request&);
 typedef bool(*validator_ptr)(const std::string&);
-typedef void(*unescaper_ptr)(std::string&);
 typedef void(*log_access_ptr)(const std::string&);
 typedef void(*log_error_ptr)(const std::string&);