Passing only root location instead of the entire server

src/server/internalServer.cpp

@@ -587,7 +587,7 @@ std::unique_ptr<Response> InternalServer::handle_request(const RequestContext& r
 {
   try {
     if (! request.is_valid_url()) {
-      return UrlNotFoundResponse(*this, request);
+      return UrlNotFoundResponse(m_root, request);
     }
 
     if ( request.get_url() == "" ) {
@@ -643,11 +643,11 @@ std::unique_ptr<Response> InternalServer::handle_request(const RequestContext& r
     return Response::build_redirect(contentUrl + query);
   } catch (std::exception& e) {
     fprintf(stderr, "===== Unhandled error : %s\n", e.what());
-    return HTTP500Response(*this, request)
+    return HTTP500Response(m_root, request)
          + ParameterizedMessage("non-translated-text", {{"MSG", e.what()}});
   } catch (...) {
     fprintf(stderr, "===== Unhandled unknown error\n");
-    return HTTP500Response(*this, request)
+    return HTTP500Response(m_root, request)
          + nonParameterizedMessage("unknown-error");
   }
 }
@@ -661,7 +661,7 @@ MustacheData InternalServer::get_default_data() const
 
 std::unique_ptr<Response> InternalServer::build_homepage(const RequestContext& request)
 {
-  return ContentResponse::build(*this, m_indexTemplateString, get_default_data(), "text/html; charset=utf-8");
+  return ContentResponse::build(m_root, m_indexTemplateString, get_default_data(), "text/html; charset=utf-8");
 }
 
 /**
@@ -690,7 +690,7 @@ std::unique_ptr<Response> InternalServer::handle_suggest(const RequestContext& r
   }
 
   if ( startsWith(request.get_url(), "/suggest/") ) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   std::string bookName, bookId;
@@ -704,7 +704,7 @@ std::unique_ptr<Response> InternalServer::handle_suggest(const RequestContext& r
   }
 
   if (archive == nullptr) {
-    return HTTP404Response(*this, request)
+    return HTTP404Response(m_root, request)
            + noSuchBookErrorMsg(bookName);
   }
 
@@ -739,7 +739,7 @@ std::unique_ptr<Response> InternalServer::handle_suggest(const RequestContext& r
     results.addFTSearchSuggestion(request.get_user_language(), queryString);
   }
 
-  return ContentResponse::build(*this, results.getJSON(), "application/json; charset=utf-8");
+  return ContentResponse::build(m_root, results.getJSON(), "application/json; charset=utf-8");
 }
 
 std::unique_ptr<Response> InternalServer::handle_viewer_settings(const RequestContext& request)
@@ -754,7 +754,7 @@ std::unique_ptr<Response> InternalServer::handle_viewer_settings(const RequestCo
     {"enable_library_button", m_withLibraryButton ? "true" : "false" },
     {"default_user_language", request.get_user_language() }
   };
-  return ContentResponse::build(*this, RESOURCE::templates::viewer_settings_js, data, "application/javascript; charset=utf-8");
+  return ContentResponse::build(m_root, RESOURCE::templates::viewer_settings_js, data, "application/javascript; charset=utf-8");
 }
 
 std::string InternalServer::getNoJSDownloadPageHTML(const std::string& bookId, const std::string& userLang) const
@@ -809,14 +809,14 @@ std::unique_ptr<Response> InternalServer::handle_no_js(const RequestContext& req
       const auto bookId = mp_nameMapper->getIdForName(urlParts[2]);
       content = getNoJSDownloadPageHTML(bookId, userLang);
     } catch (const std::out_of_range&) {
-      return UrlNotFoundResponse(*this, request);
+      return UrlNotFoundResponse(m_root, request);
     }
   } else {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   return ContentResponse::build(
-             *this,
+             m_root,
              content,
              "text/html; charset=utf-8"
   );
@@ -857,13 +857,13 @@ std::unique_ptr<Response> InternalServer::handle_skin(const RequestContext& requ
   try {
     const auto accessType = staticResourceAccessType(request, resourceCacheId);
     auto response = ContentResponse::build(
-        *this,
+        m_root,
         getResource(resourceName),
         getMimeTypeForFile(resourceName));
     response->set_kind(accessType);
     return std::move(response);
   } catch (const ResourceNotFound& e) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 }
 
@@ -876,18 +876,18 @@ std::unique_ptr<Response> InternalServer::handle_search(const RequestContext& re
   if ( startsWith(request.get_url(), "/search/") ) {
     if (request.get_url() == "/search/searchdescription.xml") {
       return ContentResponse::build(
-        *this,
+        m_root,
         RESOURCE::ft_opensearchdescription_xml,
         get_default_data(),
         "application/opensearchdescription+xml");
     }
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   try {
     return handle_search_request(request);
   } catch (const Error& e) {
-    return HTTP400Response(*this, request)
+    return HTTP400Response(m_root, request)
       + e.message();
   }
 }
@@ -929,7 +929,7 @@ std::unique_ptr<Response> InternalServer::handle_search_request(const RequestCon
     // Searcher->search will throw a runtime error if there is no valid xapian database to do the search.
     // (in case of zim file not containing a index)
     const auto cssUrl = renderUrl(m_root, RESOURCE::templates::url_of_search_results_css);
-    HTTPErrorResponse response(*this, request, MHD_HTTP_NOT_FOUND,
+    HTTPErrorResponse response(m_root, request, MHD_HTTP_NOT_FOUND,
                                "fulltext-search-unavailable",
                                "404-page-heading",
                                cssUrl);
@@ -959,13 +959,13 @@ std::unique_ptr<Response> InternalServer::handle_search_request(const RequestCon
   renderer.setPageLength(pageLength);
   if (request.get_requested_format() == "xml") {
     return ContentResponse::build(
-      *this,
+      m_root,
       renderer.getXml(*mp_nameMapper, mp_library.get()),
       "application/rss+xml; charset=utf-8"
     );
   }
   auto response = ContentResponse::build(
-    *this,
+    m_root,
     renderer.getHtml(*mp_nameMapper, mp_library.get()),
     "text/html; charset=utf-8"
   );
@@ -988,7 +988,7 @@ std::unique_ptr<Response> InternalServer::handle_random(const RequestContext& re
   }
 
   if ( startsWith(request.get_url(), "/random/") ) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   std::string bookName;
@@ -1002,7 +1002,7 @@ std::unique_ptr<Response> InternalServer::handle_random(const RequestContext& re
   }
 
   if (archive == nullptr) {
-    return HTTP404Response(*this, request)
+    return HTTP404Response(m_root, request)
            + noSuchBookErrorMsg(bookName);
   }
 
@@ -1010,7 +1010,7 @@ std::unique_ptr<Response> InternalServer::handle_random(const RequestContext& re
     auto entry = archive->getRandomEntry();
     return build_redirect(bookName, getFinalItem(*archive, entry));
   } catch(zim::EntryNotFound& e) {
-    return HTTP404Response(*this, request)
+    return HTTP404Response(m_root, request)
            + nonParameterizedMessage("random-article-failure");
   }
 }
@@ -1023,12 +1023,12 @@ std::unique_ptr<Response> InternalServer::handle_captured_external(const Request
   } catch (const std::out_of_range& e) {}
 
   if (source.empty()) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   auto data = get_default_data();
   data.set("source", source);
-  return ContentResponse::build(*this, RESOURCE::templates::captured_external_html, data, "text/html; charset=utf-8");
+  return ContentResponse::build(m_root, RESOURCE::templates::captured_external_html, data, "text/html; charset=utf-8");
 }
 
 std::unique_ptr<Response> InternalServer::handle_catch(const RequestContext& request)
@@ -1041,7 +1041,7 @@ std::unique_ptr<Response> InternalServer::handle_catch(const RequestContext& req
     return handle_captured_external(request);
   }
 
-  return UrlNotFoundResponse(*this, request);
+  return UrlNotFoundResponse(m_root, request);
 }
 
 std::vector<std::string>
@@ -1125,7 +1125,7 @@ std::unique_ptr<Response> InternalServer::handle_content(const RequestContext& r
 
   if (archive == nullptr) {
     const std::string searchURL = m_root + "/search?pattern=" + kiwix::urlEncode(pattern);
-    return UrlNotFoundResponse(*this, request)
+    return UrlNotFoundResponse(m_root, request)
            + suggestSearchMsg(searchURL, kiwix::urlDecode(pattern));
   }
 
@@ -1151,7 +1151,7 @@ std::unique_ptr<Response> InternalServer::handle_content(const RequestContext& r
       //    '-' namespaces, in which case that resource is returned instead.
       return build_redirect(bookName, getFinalItem(*archive, entry));
     }
-    auto response = ItemResponse::build(*this, request, entry.getItem());
+    auto response = ItemResponse::build(m_root, request, entry.getItem());
     response->set_etag_body(archiveUuid);
 
     if ( !startsWith(entry.getItem().getMimetype(), "application/pdf") ) {
@@ -1172,7 +1172,7 @@ std::unique_ptr<Response> InternalServer::handle_content(const RequestContext& r
       printf("Failed to find %s\n", urlStr.c_str());
 
     std::string searchURL = m_root + "/search?content=" + bookName + "&pattern=" + kiwix::urlEncode(pattern);
-    return UrlNotFoundResponse(*this, request)
+    return UrlNotFoundResponse(m_root, request)
            + suggestSearchMsg(searchURL, kiwix::urlDecode(pattern));
   }
 }
@@ -1190,11 +1190,11 @@ std::unique_ptr<Response> InternalServer::handle_raw(const RequestContext& reque
      bookName = request.get_url_part(1);
      kind = request.get_url_part(2);
   } catch (const std::out_of_range& e) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   if (kind != "meta" && kind!= "content") {
-    return UrlNotFoundResponse(*this, request)
+    return UrlNotFoundResponse(m_root, request)
            + invalidRawAccessMsg(kind);
   }
 
@@ -1205,7 +1205,7 @@ std::unique_ptr<Response> InternalServer::handle_raw(const RequestContext& reque
   } catch (const std::out_of_range& e) {}
 
   if (archive == nullptr) {
-    return UrlNotFoundResponse(*this, request)
+    return UrlNotFoundResponse(m_root, request)
            + noSuchBookErrorMsg(bookName);
   }
 
@@ -1223,7 +1223,7 @@ std::unique_ptr<Response> InternalServer::handle_raw(const RequestContext& reque
   try {
     if (kind == "meta") {
       auto item = archive->getMetadataItem(itemPath);
-      auto response = ItemResponse::build(*this, request, item);
+      auto response = ItemResponse::build(m_root, request, item);
       response->set_etag_body(archiveUuid);
       return response;
     } else {
@@ -1231,7 +1231,7 @@ std::unique_ptr<Response> InternalServer::handle_raw(const RequestContext& reque
       if (entry.isRedirect()) {
         return build_redirect(bookName, entry.getItem(true));
       }
-      auto response = ItemResponse::build(*this, request, entry.getItem());
+      auto response = ItemResponse::build(m_root, request, entry.getItem());
       response->set_etag_body(archiveUuid);
       return response;
     }
@@ -1239,7 +1239,7 @@ std::unique_ptr<Response> InternalServer::handle_raw(const RequestContext& reque
     if (m_verbose.load()) {
       printf("Failed to find %s\n", itemPath.c_str());
     }
-    return UrlNotFoundResponse(*this, request)
+    return UrlNotFoundResponse(m_root, request)
            + rawEntryNotFoundMsg(kind, itemPath);
   }
 }
@@ -1267,7 +1267,7 @@ std::unique_ptr<Response> InternalServer::handle_locally_customized_resource(con
     return Response::build_416(resourceData.size());
   }
 
-  return ContentResponse::build(*this,
+  return ContentResponse::build(m_root,
                                 resourceData,
                                 crd.mimeType);
 }

src/server/internalServer.h

@@ -188,8 +188,6 @@ class InternalServer {
 
     class CustomizedResources;
     std::unique_ptr<CustomizedResources> m_customizedResources;
-
-    friend std::unique_ptr<ContentResponse> ContentResponse::build(const InternalServer& server, const std::string& content, const std::string& mimetype);
 };
 
 }

src/server/internalServer_catalog.cpp

@@ -63,7 +63,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog(const RequestContext& r
     host = request.get_header("Host");
     url  = request.get_url_part(1);
   } catch (const std::out_of_range&) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   if (url == "v2") {
@@ -71,11 +71,11 @@ std::unique_ptr<Response> InternalServer::handle_catalog(const RequestContext& r
   }
 
   if (url != "searchdescription.xml" && url != "root.xml" && url != "search") {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   if (url == "searchdescription.xml") {
-    auto response = ContentResponse::build(*this, RESOURCE::opensearchdescription_xml, get_default_data(), "application/opensearchdescription+xml");
+    auto response = ContentResponse::build(m_root, RESOURCE::opensearchdescription_xml, get_default_data(), "application/opensearchdescription+xml");
     return std::move(response);
   }
 
@@ -93,7 +93,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog(const RequestContext& r
   }
 
   auto response = ContentResponse::build(
-      *this,
+      m_root,
       opdsDumper.dumpOPDSFeed(bookIdsToDump, request.get_query()),
       opdsMimeType[OPDS_ACQUISITION_FEED]);
   return std::move(response);
@@ -109,14 +109,14 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2(const RequestContext
   try {
     url  = request.get_url_part(2);
   } catch (const std::out_of_range&) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   if (url == "root.xml") {
     return handle_catalog_v2_root(request);
   } else if (url == "searchdescription.xml") {
     const std::string endpoint_root = m_root + "/catalog/v2";
-    return ContentResponse::build(*this,
+    return ContentResponse::build(m_root,
         RESOURCE::catalog_v2_searchdescription_xml,
         kainjow::mustache::object({{"endpoint_root", endpoint_root}}),
         "application/opensearchdescription+xml"
@@ -135,7 +135,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2(const RequestContext
   } else if (url == "illustration") {
     return handle_catalog_v2_illustration(request);
   } else {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 }
 
@@ -143,7 +143,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2_root(const RequestCo
 {
   const std::string libraryId = getLibraryId();
   return ContentResponse::build(
-             *this,
+             m_root,
              RESOURCE::templates::catalog_v2_root_xml,
              kainjow::mustache::object{
                {"date", gen_date_str()},
@@ -166,7 +166,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2_entries(const Reques
   const auto bookIds = search_catalog(request, opdsDumper);
   const auto opdsFeed = opdsDumper.dumpOPDSFeedV2(bookIds, request.get_query(), partial);
   return ContentResponse::build(
-             *this,
+             m_root,
              opdsFeed,
              opdsMimeType[OPDS_ACQUISITION_FEED]
   );
@@ -177,7 +177,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2_complete_entry(const
   try {
     mp_library->getBookById(entryId);
   } catch (const std::out_of_range&) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 
   OPDSDumper opdsDumper(mp_library.get(), mp_nameMapper.get());
@@ -185,7 +185,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2_complete_entry(const
   opdsDumper.setLibraryId(getLibraryId());
   const auto opdsFeed = opdsDumper.dumpOPDSCompleteEntry(entryId);
   return ContentResponse::build(
-             *this,
+             m_root,
              opdsFeed,
              opdsMimeType[OPDS_ENTRY]
   );
@@ -197,7 +197,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2_categories(const Req
   opdsDumper.setRootLocation(m_root);
   opdsDumper.setLibraryId(getLibraryId());
   return ContentResponse::build(
-             *this,
+             m_root,
              opdsDumper.categoriesOPDSFeed(),
              opdsMimeType[OPDS_NAVIGATION_FEED]
   );
@@ -209,7 +209,7 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2_languages(const Requ
   opdsDumper.setRootLocation(m_root);
   opdsDumper.setLibraryId(getLibraryId());
   return ContentResponse::build(
-             *this,
+             m_root,
              opdsDumper.languagesOPDSFeed(),
              opdsMimeType[OPDS_NAVIGATION_FEED]
   );
@@ -223,12 +223,12 @@ std::unique_ptr<Response> InternalServer::handle_catalog_v2_illustration(const R
     auto size = request.get_argument<unsigned int>("size");
     auto illustration = book.getIllustration(size);
     return ContentResponse::build(
-               *this,
+               m_root,
                illustration->getData(),
                illustration->mimeType
     );
   } catch(...) {
-    return UrlNotFoundResponse(*this, request);
+    return UrlNotFoundResponse(m_root, request);
   }
 }
 

src/server/response.cpp

@@ -158,18 +158,18 @@ std::string ContentResponseBlueprint::getMessage(const std::string& msgId) const
 
 std::unique_ptr<ContentResponse> ContentResponseBlueprint::generateResponseObject() const
 {
-  auto r = ContentResponse::build(m_server, m_template, m_data, m_mimeType);
+  auto r = ContentResponse::build(m_root, m_template, m_data, m_mimeType);
   r->set_code(m_httpStatusCode);
   return r;
 }
 
-HTTPErrorResponse::HTTPErrorResponse(const InternalServer& server,
+HTTPErrorResponse::HTTPErrorResponse(const std::string& root,
                                      const RequestContext& request,
                                      int httpStatusCode,
                                      const std::string& pageTitleMsgId,
                                      const std::string& headingMsgId,
                                      const std::string& cssUrl)
-  : ContentResponseBlueprint(&server,
+  : ContentResponseBlueprint(root,
                              &request,
                              httpStatusCode,
                              request.get_requested_format() == "html" ? "text/html; charset=utf-8" : "application/xml; charset=utf-8",
@@ -184,9 +184,9 @@ HTTPErrorResponse::HTTPErrorResponse(const InternalServer& server,
   };
 }
 
-HTTP404Response::HTTP404Response(const InternalServer& server,
+HTTP404Response::HTTP404Response(const std::string& root,
                                  const RequestContext& request)
-  : HTTPErrorResponse(server,
+  : HTTPErrorResponse(root,
                       request,
                       MHD_HTTP_NOT_FOUND,
                       "404-page-title",
@@ -194,9 +194,9 @@ HTTP404Response::HTTP404Response(const InternalServer& server,
 {
 }
 
-UrlNotFoundResponse::UrlNotFoundResponse(const InternalServer& server,
+UrlNotFoundResponse::UrlNotFoundResponse(const std::string& root,
                                          const RequestContext& request)
-    : HTTP404Response(server, request)
+    : HTTP404Response(root, request)
 {
   const std::string requestUrl = urlDecode(m_request.get_full_url(), false);
   *this += ParameterizedMessage("url-not-found", {{"url", requestUrl}});
@@ -216,9 +216,9 @@ HTTPErrorResponse& HTTPErrorResponse::operator+=(const ParameterizedMessage& det
 }
 
 
-HTTP400Response::HTTP400Response(const InternalServer& server,
+HTTP400Response::HTTP400Response(const std::string& root,
                                  const RequestContext& request)
-  : HTTPErrorResponse(server,
+  : HTTPErrorResponse(root,
                       request,
                       MHD_HTTP_BAD_REQUEST,
                       "400-page-title",
@@ -232,9 +232,9 @@ HTTP400Response::HTTP400Response(const InternalServer& server,
   *this += ParameterizedMessage("invalid-request", {{"url", requestUrl}});
 }
 
-HTTP500Response::HTTP500Response(const InternalServer& server,
+HTTP500Response::HTTP500Response(const std::string& root,
                                  const RequestContext& request)
-  : HTTPErrorResponse(server,
+  : HTTPErrorResponse(root,
                       request,
                       MHD_HTTP_INTERNAL_SERVER_ERROR,
                       "500-page-title",
@@ -246,7 +246,7 @@ HTTP500Response::HTTP500Response(const InternalServer& server,
 std::unique_ptr<ContentResponse> HTTP500Response::generateResponseObject() const
 {
   const std::string mimeType = "text/html;charset=utf-8";
-  auto r = ContentResponse::build(m_server, m_template, m_data, mimeType);
+  auto r = ContentResponse::build(m_root, m_template, m_data, mimeType);
   r->set_code(m_httpStatusCode);
   return r;
 }
@@ -396,24 +396,24 @@ ContentResponse::ContentResponse(const std::string& root, const std::string& con
 }
 
 std::unique_ptr<ContentResponse> ContentResponse::build(
-  const InternalServer& server,
+  const std::string& root,
   const std::string& content,
   const std::string& mimetype)
 {
    return std::unique_ptr<ContentResponse>(new ContentResponse(
-        server.m_root,
+        root,
         content,
         mimetype));
 }
 
 std::unique_ptr<ContentResponse> ContentResponse::build(
-  const InternalServer& server,
+  const std::string& root,
   const std::string& template_str,
   kainjow::mustache::data data,
   const std::string& mimetype)
 {
   auto content = render_template(template_str, data);
-  return ContentResponse::build(server, content, mimetype);
+  return ContentResponse::build(root, content, mimetype);
 }
 
 ItemResponse::ItemResponse(const zim::Item& item, const std::string& mimetype, const ByteRange& byterange) :
@@ -426,14 +426,14 @@ ItemResponse::ItemResponse(const zim::Item& item, const std::string& mimetype, c
   add_header(MHD_HTTP_HEADER_CONTENT_TYPE, m_mimeType);
 }
 
-std::unique_ptr<Response> ItemResponse::build(const InternalServer& server, const RequestContext& request, const zim::Item& item)
+std::unique_ptr<Response> ItemResponse::build(const std::string& root, const RequestContext& request, const zim::Item& item)
 {
   const std::string mimetype = get_mime_type(item);
   auto byteRange = request.get_range().resolve(item.getSize());
   const bool noRange = byteRange.kind() == ByteRange::RESOLVED_FULL_CONTENT;
   if (noRange && is_compressible_mime_type(mimetype)) {
     // Return a contentResponse
-    auto response = ContentResponse::build(server, item.getData(), mimetype);
+    auto response = ContentResponse::build(root, item.getData(), mimetype);
     response->set_kind(Response::ZIM_CONTENT);
     response->m_byteRange = byteRange;
     return std::move(response);

src/server/response.h

@@ -41,7 +41,6 @@ class Archive;
 
 namespace kiwix {
 
-class InternalServer;
 class RequestContext;
 
 class Response {
@@ -95,12 +94,12 @@ class ContentResponse : public Response {
       const std::string& mimetype);
 
     static std::unique_ptr<ContentResponse> build(
-      const InternalServer& server,
+      const std::string& root,
       const std::string& content,
       const std::string& mimetype);
 
     static std::unique_ptr<ContentResponse> build(
-      const InternalServer& server,
+      const std::string& root,
       const std::string& template_str,
       kainjow::mustache::data data,
       const std::string& mimetype);
@@ -120,12 +119,12 @@ class ContentResponse : public Response {
 class ContentResponseBlueprint
 {
 public: // functions
-  ContentResponseBlueprint(const InternalServer* server,
+  ContentResponseBlueprint(const std::string& root,
                            const RequestContext* request,
                            int httpStatusCode,
                            const std::string& mimeType,
                            const std::string& templateStr)
-    : m_server(*server)
+    : m_root(root)
     , m_request(*request)
     , m_httpStatusCode(httpStatusCode)
     , m_mimeType(mimeType)
@@ -145,7 +144,7 @@ protected: // functions
   virtual std::unique_ptr<ContentResponse> generateResponseObject() const;
 
 public: //data
-  const InternalServer& m_server;
+  const std::string m_root;
   const RequestContext& m_request;
   const int m_httpStatusCode;
   const std::string m_mimeType;
@@ -155,7 +154,7 @@ public: //data
 
 struct HTTPErrorResponse : ContentResponseBlueprint
 {
-  HTTPErrorResponse(const InternalServer& server,
+  HTTPErrorResponse(const std::string& root,
                     const RequestContext& request,
                     int httpStatusCode,
                     const std::string& pageTitleMsgId,
@@ -168,25 +167,25 @@ struct HTTPErrorResponse : ContentResponseBlueprint
 
 struct HTTP404Response : HTTPErrorResponse
 {
-  HTTP404Response(const InternalServer& server,
+  HTTP404Response(const std::string& root,
                   const RequestContext& request);
 };
 
 struct UrlNotFoundResponse : HTTP404Response
 {
-  UrlNotFoundResponse(const InternalServer& server,
+  UrlNotFoundResponse(const std::string& root,
                       const RequestContext& request);
 };
 
 struct HTTP400Response : HTTPErrorResponse
 {
-  HTTP400Response(const InternalServer& server,
+  HTTP400Response(const std::string& root,
                   const RequestContext& request);
 };
 
 struct HTTP500Response : HTTPErrorResponse
 {
-  HTTP500Response(const InternalServer& server,
+  HTTP500Response(const std::string& root,
                   const RequestContext& request);
 
 private: // overrides
@@ -198,7 +197,7 @@ private: // overrides
 class ItemResponse : public Response {
   public:
     ItemResponse(const zim::Item& item, const std::string& mimetype, const ByteRange& byterange);
-    static std::unique_ptr<Response> build(const InternalServer& server, const RequestContext& request, const zim::Item& item);
+    static std::unique_ptr<Response> build(const std::string& root, const RequestContext& request, const zim::Item& item);
 
   private:
     MHD_Response* create_mhd_response(const RequestContext& request);