Translation of error pages

src/server/i18n.cpp

@@ -112,8 +112,12 @@ std::string expandParameterizedString(const std::string& lang,
                                       const std::string& key,
                                       const Parameters& params)
 {
+  kainjow::mustache::object mustacheParams;
+  for( const auto& kv : params ) {
+    mustacheParams[kv.first] = kv.second;
+  }
   const std::string tmpl = getTranslatedString(lang, key);
-  return render_template(tmpl, params);
+  return render_template(tmpl, mustacheParams);
 }
 
 } // namespace i18n

src/server/i18n.h

@@ -20,6 +20,7 @@
 #ifndef KIWIX_SERVER_I18N
 #define KIWIX_SERVER_I18N
 
+#include <map>
 #include <string>
 #include <mustache.hpp>
 
@@ -44,7 +45,7 @@ std::string getTranslatedString(const std::string& lang, const std::string& key)
 namespace i18n
 {
 
-typedef kainjow::mustache::object Parameters;
+typedef std::map<std::string, std::string> Parameters;
 
 std::string expandParameterizedString(const std::string& lang,
                                       const std::string& key,
@@ -93,10 +94,10 @@ class GetTranslatedStringWithMsgId
 
 } // namespace i18n
 
-struct ParameterizedMessage
+class ParameterizedMessage
 {
 public: // types
-  typedef kainjow::mustache::object Parameters;
+  typedef i18n::Parameters Parameters;
 
 public: // functions
   ParameterizedMessage(const std::string& msgId, const Parameters& params)
@@ -106,6 +107,9 @@ struct ParameterizedMessage
 
   std::string getText(const std::string& lang) const;
 
+  const std::string& getMsgId()  const { return msgId; }
+  const Parameters&  getParams() const { return params; }
+
 private: // data
   const std::string msgId;
   const Parameters  params;

src/server/internalServer.cpp

@@ -513,6 +513,19 @@ static MHD_Result staticHandlerCallback(void* cls,
                                 cont_cls);
 }
 
+namespace
+{
+
+MHD_Result add_name_value_pair(void *nvp, enum MHD_ValueKind kind,
+                               const char *key, const char *value)
+{
+  auto& nameValuePairs = *reinterpret_cast<RequestContext::NameValuePairs*>(nvp);
+  nameValuePairs.push_back({key, value});
+  return MHD_YES;
+}
+
+} // unnamed namespace
+
 MHD_Result InternalServer::handlerCallback(struct MHD_Connection* connection,
                                            const char* fullUrl,
                                            const char* method,
@@ -529,7 +542,10 @@ MHD_Result InternalServer::handlerCallback(struct MHD_Connection* connection,
   }
 
   const auto url = fullURL2LocalURL(fullUrl, m_rootPrefixOfDecodedURL);
-  RequestContext request(connection, m_root, url, method, version);
+  RequestContext::NameValuePairs headers, queryArgs;
+  MHD_get_connection_values(connection, MHD_HEADER_KIND, add_name_value_pair, &headers);
+  MHD_get_connection_values(connection, MHD_GET_ARGUMENT_KIND, add_name_value_pair, &queryArgs);
+  RequestContext request(m_root, url, method, version, headers, queryArgs);
 
   if (m_verbose.load() ) {
     request.print_debug_info();
@@ -926,7 +942,8 @@ std::unique_ptr<Response> InternalServer::handle_search_request(const RequestCon
     HTTPErrorResponse response(request, MHD_HTTP_NOT_FOUND,
                                "fulltext-search-unavailable",
                                "404-page-heading",
-                               cssUrl);
+                               cssUrl,
+                               /*includeKiwixResponseData=*/true);
     response += nonParameterizedMessage("no-search-results");
     // XXX: Now this has to be handled by the iframe-based viewer which
     // XXX: has to resolve if the book selection resulted in a single book.

src/server/request_context.cpp

@@ -51,11 +51,12 @@ RequestMethod str2RequestMethod(const std::string& method) {
 
 } // unnamed namespace
 
-RequestContext::RequestContext(struct MHD_Connection* connection,
-                               const std::string& _rootLocation, // URI-encoded
+RequestContext::RequestContext(const std::string& _rootLocation, // URI-encoded
                                const std::string& unrootedUrl,   // URI-decoded
                                const std::string& _method,
-                               const std::string& version) :
+                               const std::string& version,
+                               const NameValuePairs& headers,
+                               const NameValuePairs& queryArgs) :
   rootLocation(_rootLocation),
   url(unrootedUrl),
   method(str2RequestMethod(_method)),
@@ -64,9 +65,13 @@ RequestContext::RequestContext(struct MHD_Connection* connection,
   acceptEncodingGzip(false),
   byteRange_()
 {
-  MHD_get_connection_values(connection, MHD_HEADER_KIND, &RequestContext::fill_header, this);
-  MHD_get_connection_values(connection, MHD_GET_ARGUMENT_KIND, &RequestContext::fill_argument, this);
-  MHD_get_connection_values(connection, MHD_COOKIE_KIND, &RequestContext::fill_cookie, this);
+  for ( const auto& kv : headers ) {
+    add_header(kv.first, kv.second);
+  }
+
+  for ( const auto& kv : queryArgs ) {
+    add_argument(kv.first, kv.second);
+  }
 
   try {
     acceptEncodingGzip =
@@ -83,18 +88,14 @@ RequestContext::RequestContext(struct MHD_Connection* connection,
 RequestContext::~RequestContext()
 {}
 
-MHD_Result RequestContext::fill_header(void *__this, enum MHD_ValueKind kind,
-                                       const char *key, const char *value)
+void RequestContext::add_header(const char *key, const char *value)
 {
-  RequestContext *_this = static_cast<RequestContext*>(__this);
-  _this->headers[lcAll(key)] = value;
-  return MHD_YES;
+  this->headers[lcAll(key)] = value;
 }
 
-MHD_Result RequestContext::fill_argument(void *__this, enum MHD_ValueKind kind,
-                                         const char *key, const char* value)
+void RequestContext::add_argument(const char *key, const char* value)
 {
-  RequestContext *_this = static_cast<RequestContext*>(__this);
+  RequestContext *_this = this;
   _this->arguments[key].push_back(value == nullptr ? "" : value);
   if ( ! _this->queryString.empty() ) {
     _this->queryString += "&";
@@ -104,15 +105,6 @@ MHD_Result RequestContext::fill_argument(void *__this, enum MHD_ValueKind kind,
     _this->queryString += "=";
     _this->queryString += urlEncode(value);
   }
-  return MHD_YES;
-}
-
-MHD_Result RequestContext::fill_cookie(void *__this, enum MHD_ValueKind kind,
-                                         const char *key, const char* value)
-{
-  RequestContext *_this = static_cast<RequestContext*>(__this);
-  _this->cookies[key] = value == nullptr ? "" : value;
-  return MHD_YES;
 }
 
 void RequestContext::print_debug_info() const {

src/server/request_context.h

@@ -29,7 +29,7 @@
 #include <stdexcept>
 
 #include "byte_range.h"
-#include "tools/stringTools.h"
+#include "../tools/stringTools.h"
 
 extern "C" {
 #include "microhttpd_wrapper.h"
@@ -55,12 +55,17 @@ class IndexError: public std::runtime_error {};
 
 
 class RequestContext {
+  public: // types
+    typedef std::vector<std::pair<const char*, const char*>> NameValuePairs;
+
   public: // functions
-    RequestContext(struct MHD_Connection* connection,
-                   const std::string& rootLocation, // URI-encoded
+    RequestContext(const std::string& rootLocation, // URI-encoded
                    const std::string& unrootedUrl,  // URI-decoded
                    const std::string& method,
-                   const std::string& version);
+                   const std::string& version,
+                   const NameValuePairs& headers,
+                   const NameValuePairs& queryArgs);
+
     ~RequestContext();
 
     void print_debug_info() const;
@@ -145,16 +150,14 @@ class RequestContext {
     ByteRange byteRange_;
     std::map<std::string, std::string> headers;
     std::map<std::string, std::vector<std::string>> arguments;
-    std::map<std::string, std::string> cookies;
     std::string queryString;
     UserLanguage userlang;
 
   private: // functions
     UserLanguage determine_user_language() const;
 
-    static MHD_Result fill_header(void *, enum MHD_ValueKind, const char*, const char*);
-    static MHD_Result fill_cookie(void *, enum MHD_ValueKind, const char*, const char*);
-    static MHD_Result fill_argument(void *, enum MHD_ValueKind, const char*, const char*);
+    void add_header(const char* name, const char* value);
+    void add_argument(const char* name, const char* value);
 };
 
 template<> std::string RequestContext::get_argument(const std::string& name) const;