mirror of https://github.com/kiwix/libkiwix.git
658 lines
20 KiB
C++
658 lines
20 KiB
C++
/*
|
||
* Copyright 2019 Matthieu Gautier <mgautier@kymeria.fr>
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 3 of the License, or
|
||
* any later version.
|
||
*
|
||
* This program 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 General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with this program; if not, write to the Free Software
|
||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||
* MA 02110-1301, USA.
|
||
*/
|
||
|
||
#include "response.h"
|
||
#include "request_context.h"
|
||
#include "internalServer.h"
|
||
#include "libkiwix-resources.h"
|
||
|
||
#include "tools/regexTools.h"
|
||
#include "tools/stringTools.h"
|
||
#include "tools/otherTools.h"
|
||
#include "tools/archiveTools.h"
|
||
|
||
#include "string.h"
|
||
#include <mustache.hpp>
|
||
#include <zlib.h>
|
||
|
||
#include <array>
|
||
#include <list>
|
||
#include <map>
|
||
|
||
// This is somehow a magic value.
|
||
// If this value is too small, we will compress (and lost cpu time) too much
|
||
// content.
|
||
// If this value is too big, we will not compress enough content and send too
|
||
// much data.
|
||
// If we assume that MTU is 1500 Bytes it is useless to compress
|
||
// content smaller as the content will be sent in one packet anyway.
|
||
// 1400 Bytes seems to be a common accepted limit.
|
||
#define KIWIX_MIN_CONTENT_SIZE_TO_COMPRESS 1400
|
||
|
||
namespace kiwix {
|
||
|
||
namespace
|
||
{
|
||
typedef kainjow::mustache::data MustacheData;
|
||
|
||
// some utilities
|
||
|
||
std::string get_mime_type(const zim::Item& item)
|
||
{
|
||
try {
|
||
return item.getMimetype();
|
||
} catch (std::exception& e) {
|
||
return "application/octet-stream";
|
||
}
|
||
}
|
||
|
||
bool is_compressible_mime_type(const std::string& mimeType)
|
||
{
|
||
return mimeType.find("text/") != std::string::npos
|
||
|| mimeType.find("application/javascript") != std::string::npos
|
||
|| mimeType.find("application/atom") != std::string::npos
|
||
|| mimeType.find("application/opensearchdescription") != std::string::npos
|
||
|| mimeType.find("application/json") != std::string::npos
|
||
|
||
// Web fonts
|
||
|| mimeType.find("application/font-") != std::string::npos
|
||
|| mimeType.find("application/x-font-") != std::string::npos
|
||
|| mimeType.find("application/vnd.ms-fontobject") != std::string::npos
|
||
|| mimeType.find("font/") != std::string::npos;
|
||
}
|
||
|
||
bool compress(std::string &content) {
|
||
z_stream strm;
|
||
strm.zalloc = Z_NULL;
|
||
strm.zfree = Z_NULL;
|
||
strm.opaque = Z_NULL;
|
||
|
||
auto ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8,
|
||
Z_DEFAULT_STRATEGY);
|
||
if (ret != Z_OK) { return false; }
|
||
|
||
strm.avail_in = static_cast<decltype(strm.avail_in)>(content.size());
|
||
strm.next_in =
|
||
const_cast<Bytef *>(reinterpret_cast<const Bytef *>(content.data()));
|
||
|
||
std::string compressed;
|
||
|
||
std::array<char, 16384> buff{};
|
||
do {
|
||
strm.avail_out = buff.size();
|
||
strm.next_out = reinterpret_cast<Bytef *>(buff.data());
|
||
ret = deflate(&strm, Z_FINISH);
|
||
assert(ret != Z_STREAM_ERROR);
|
||
compressed.append(buff.data(), buff.size() - strm.avail_out);
|
||
} while (strm.avail_out == 0);
|
||
|
||
assert(ret == Z_STREAM_END);
|
||
assert(strm.avail_in == 0);
|
||
|
||
content.swap(compressed);
|
||
|
||
deflateEnd(&strm);
|
||
return true;
|
||
}
|
||
|
||
|
||
const char* getCacheControlHeader(Response::Kind k)
|
||
{
|
||
switch(k) {
|
||
case Response::STATIC_RESOURCE: return "max-age=31536000, immutable";
|
||
case Response::ZIM_CONTENT: return "max-age=3600, must-revalidate";
|
||
default: return "max-age=0, must-revalidate";
|
||
}
|
||
}
|
||
|
||
} // unnamed namespace
|
||
|
||
Response::Response()
|
||
: m_returnCode(MHD_HTTP_OK)
|
||
{
|
||
add_header(MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN, "*");
|
||
}
|
||
|
||
void Response::set_kind(Kind k)
|
||
{
|
||
m_kind = k;
|
||
if ( k == ZIM_CONTENT )
|
||
m_etag.set_option(ETag::ZIM_CONTENT);
|
||
}
|
||
|
||
std::unique_ptr<Response> Response::build()
|
||
{
|
||
return std::make_unique<Response>();
|
||
}
|
||
|
||
std::unique_ptr<Response> Response::build_304(const ETag& etag)
|
||
{
|
||
auto response = Response::build();
|
||
response->set_code(MHD_HTTP_NOT_MODIFIED);
|
||
response->m_etag = etag;
|
||
if ( etag.get_option(ETag::ZIM_CONTENT) ) {
|
||
response->set_kind(Response::ZIM_CONTENT);
|
||
}
|
||
if ( etag.get_option(ETag::COMPRESSED_CONTENT) ) {
|
||
response->add_header(MHD_HTTP_HEADER_VARY, "Accept-Encoding");
|
||
}
|
||
return response;
|
||
}
|
||
|
||
|
||
namespace
|
||
{
|
||
|
||
// This class was introduced in order to work around the missing support
|
||
// for std::variant (and std::optional) under some of the current build
|
||
// platforms.
|
||
template<class T>
|
||
class Optional
|
||
{
|
||
public: // functions
|
||
Optional() {}
|
||
Optional(const T& t) : ptr(new T(t)) {}
|
||
Optional(const Optional& o) : ptr(o.has_value() ? new T(*o) : nullptr) {}
|
||
Optional(Optional&& o) : ptr(std::move(o.ptr)) {}
|
||
|
||
Optional& operator=(const Optional& o)
|
||
{
|
||
*this = Optional(o);
|
||
return *this;
|
||
}
|
||
|
||
Optional& operator=(Optional&& o)
|
||
{
|
||
ptr = std::move(o.ptr);
|
||
return *this;
|
||
}
|
||
|
||
bool has_value() const { return ptr.get() != nullptr; }
|
||
const T& operator*() const { return *ptr; }
|
||
T& operator*() { return *ptr; }
|
||
|
||
private: // data
|
||
std::unique_ptr<T> ptr;
|
||
};
|
||
|
||
} // unnamed namespace
|
||
|
||
class ContentResponseBlueprint::Data
|
||
{
|
||
public:
|
||
typedef std::list<Data> List;
|
||
typedef std::map<std::string, Data> Object;
|
||
|
||
private:
|
||
// std::variant<std::string, bool, List, Object> data;
|
||
// XXX: libkiwix is compiled on platforms where std::variant
|
||
// XXX: is not yet supported. Hence this hack. Only one
|
||
// XXX: of the below data members is expected to contain a value.
|
||
Optional<std::string> m_stringValue;
|
||
Optional<bool> m_boolValue;
|
||
Optional<List> m_listValue;
|
||
Optional<Object> m_objectValue;
|
||
|
||
public:
|
||
Data() {}
|
||
Data(const std::string& s) : m_stringValue(s) {}
|
||
Data(bool b) : m_boolValue(b) {}
|
||
Data(const List& l) : m_listValue(l) {}
|
||
Data(const Object& o) : m_objectValue(o) {}
|
||
|
||
MustacheData toMustache(const std::string& lang) const;
|
||
|
||
Data& operator[](const std::string& key)
|
||
{
|
||
return (*m_objectValue)[key];
|
||
}
|
||
|
||
void push_back(const Data& d) { (*m_listValue).push_back(d); }
|
||
|
||
static Data onlyAsNonEmptyValue(const std::string& s)
|
||
{
|
||
return s.empty() ? Data(false) : Data(s);
|
||
}
|
||
|
||
static Data from(const ParameterizedMessage& pmsg)
|
||
{
|
||
Object obj;
|
||
for(const auto& kv : pmsg.getParams()) {
|
||
obj[kv.first] = kv.second;
|
||
}
|
||
return Object{
|
||
{ "msgid", pmsg.getMsgId() },
|
||
{ "params", Data(obj) }
|
||
};
|
||
}
|
||
|
||
std::string asJSON() const;
|
||
void dumpJSON(std::ostream& os) const;
|
||
|
||
private:
|
||
bool isString() const { return m_stringValue.has_value(); }
|
||
bool isList() const { return m_listValue.has_value(); }
|
||
bool isObject() const { return m_objectValue.has_value(); }
|
||
|
||
const std::string& stringValue() const { return *m_stringValue; }
|
||
bool boolValue() const { return *m_boolValue; }
|
||
const List& listValue() const { return *m_listValue; }
|
||
const Object& objectValue() const { return *m_objectValue; }
|
||
|
||
const Data* get(const std::string& key) const
|
||
{
|
||
if ( !isObject() )
|
||
return nullptr;
|
||
|
||
const auto& obj = objectValue();
|
||
const auto it = obj.find(key);
|
||
return it != obj.end() ? &it->second : nullptr;
|
||
}
|
||
};
|
||
|
||
MustacheData ContentResponseBlueprint::Data::toMustache(const std::string& lang) const
|
||
{
|
||
if ( this->isList() ) {
|
||
kainjow::mustache::list l;
|
||
for ( const auto& x : this->listValue() ) {
|
||
l.push_back(x.toMustache(lang));
|
||
}
|
||
return l;
|
||
} else if ( this->isObject() ) {
|
||
const Data* msgId = this->get("msgid");
|
||
const Data* msgParams = this->get("params");
|
||
if ( msgId && msgId->isString() && msgParams && msgParams->isObject() ) {
|
||
std::map<std::string, std::string> params;
|
||
for(const auto& kv : msgParams->objectValue()) {
|
||
params[kv.first] = kv.second.stringValue();
|
||
}
|
||
const ParameterizedMessage msg(msgId->stringValue(), ParameterizedMessage::Parameters(params));
|
||
return msg.getText(lang);
|
||
} else {
|
||
kainjow::mustache::object o;
|
||
for ( const auto& kv : this->objectValue() ) {
|
||
o[kv.first] = kv.second.toMustache(lang);
|
||
}
|
||
return o;
|
||
}
|
||
} else if ( this->isString() ) {
|
||
return this->stringValue();
|
||
} else {
|
||
return this->boolValue();
|
||
}
|
||
}
|
||
|
||
void ContentResponseBlueprint::Data::dumpJSON(std::ostream& os) const
|
||
{
|
||
if ( this->isString() ) {
|
||
os << '"' << escapeForJSON(this->stringValue()) << '"';
|
||
} else if ( this->isList() ) {
|
||
const char * sep = " ";
|
||
os << "[";
|
||
|
||
for ( const auto& x : this->listValue() ) {
|
||
os << sep;
|
||
x.dumpJSON(os);
|
||
sep = ", ";
|
||
}
|
||
os << " ]";
|
||
} else if ( this->isObject() ) {
|
||
const char * sep = " ";
|
||
os << "{";
|
||
for ( const auto& kv : this->objectValue() ) {
|
||
os << sep << '"' << kv.first << "\" : ";
|
||
kv.second.dumpJSON(os);
|
||
sep = ", ";
|
||
}
|
||
os << " }";
|
||
} else {
|
||
os << (this->boolValue() ? "true" : "false");
|
||
}
|
||
}
|
||
|
||
std::string ContentResponseBlueprint::Data::asJSON() const
|
||
{
|
||
std::ostringstream oss;
|
||
this->dumpJSON(oss);
|
||
return oss.str();
|
||
}
|
||
|
||
ContentResponseBlueprint::ContentResponseBlueprint(const RequestContext* request,
|
||
int httpStatusCode,
|
||
const std::string& mimeType,
|
||
const std::string& templateStr,
|
||
bool includeKiwixResponseData)
|
||
: m_request(*request)
|
||
, m_httpStatusCode(httpStatusCode)
|
||
, m_mimeType(mimeType)
|
||
, m_template(templateStr)
|
||
, m_includeKiwixResponseData(includeKiwixResponseData)
|
||
, m_data(new Data)
|
||
{}
|
||
|
||
ContentResponseBlueprint::~ContentResponseBlueprint() = default;
|
||
|
||
std::unique_ptr<ContentResponse> ContentResponseBlueprint::generateResponseObject() const
|
||
{
|
||
kainjow::mustache::data d = m_data->toMustache(m_request.get_user_language());
|
||
if ( m_includeKiwixResponseData ) {
|
||
d.set("KIWIX_RESPONSE_TEMPLATE", escapeForJSON(m_template, false));
|
||
d.set("KIWIX_RESPONSE_DATA", m_data->asJSON());
|
||
}
|
||
auto r = ContentResponse::build(m_template, d, m_mimeType);
|
||
r->set_code(m_httpStatusCode);
|
||
return r;
|
||
}
|
||
|
||
HTTPErrorResponse::HTTPErrorResponse(const RequestContext& request,
|
||
int httpStatusCode,
|
||
const std::string& pageTitleMsgId,
|
||
const std::string& headingMsgId,
|
||
const std::string& cssUrl,
|
||
bool includeKiwixResponseData)
|
||
: ContentResponseBlueprint(&request,
|
||
httpStatusCode,
|
||
request.get_requested_format() == "html" ? "text/html; charset=utf-8" : "application/xml; charset=utf-8",
|
||
request.get_requested_format() == "html" ? RESOURCE::templates::error_html : RESOURCE::templates::error_xml,
|
||
includeKiwixResponseData)
|
||
{
|
||
Data::List emptyList;
|
||
*this->m_data = Data(Data::Object{
|
||
{"CSS_URL", Data::onlyAsNonEmptyValue(cssUrl) },
|
||
{"PAGE_TITLE", Data::from(nonParameterizedMessage(pageTitleMsgId))},
|
||
{"PAGE_HEADING", Data::from(nonParameterizedMessage(headingMsgId))},
|
||
{"details", emptyList}
|
||
});
|
||
}
|
||
|
||
HTTP404Response::HTTP404Response(const RequestContext& request,
|
||
bool includeKiwixResponseData)
|
||
: HTTPErrorResponse(request,
|
||
MHD_HTTP_NOT_FOUND,
|
||
"404-page-title",
|
||
"404-page-heading",
|
||
std::string(),
|
||
includeKiwixResponseData)
|
||
{
|
||
}
|
||
|
||
UrlNotFoundResponse::UrlNotFoundResponse(const RequestContext& request,
|
||
bool includeKiwixResponseData)
|
||
: HTTP404Response(request, includeKiwixResponseData)
|
||
{
|
||
const std::string requestUrl = urlDecode(m_request.get_full_url(), false);
|
||
*this += ParameterizedMessage("url-not-found", {{"url", requestUrl}});
|
||
}
|
||
|
||
HTTPErrorResponse& HTTPErrorResponse::operator+(const ParameterizedMessage& details)
|
||
{
|
||
(*m_data)["details"].push_back(Data::Object{{"p", Data::from(details)}});
|
||
return *this;
|
||
}
|
||
|
||
HTTPErrorResponse& HTTPErrorResponse::operator+=(const ParameterizedMessage& details)
|
||
{
|
||
// operator+() is already a state-modifying operator (akin to operator+=)
|
||
return *this + details;
|
||
}
|
||
|
||
|
||
HTTP400Response::HTTP400Response(const RequestContext& request)
|
||
: HTTPErrorResponse(request,
|
||
MHD_HTTP_BAD_REQUEST,
|
||
"400-page-title",
|
||
"400-page-heading")
|
||
{
|
||
std::string requestUrl = urlDecode(m_request.get_full_url(), false);
|
||
const auto query = m_request.get_query();
|
||
if (!query.empty()) {
|
||
requestUrl += "?" + encodeDiples(query);
|
||
}
|
||
*this += ParameterizedMessage("invalid-request", {{"url", requestUrl}});
|
||
}
|
||
|
||
HTTP500Response::HTTP500Response(const RequestContext& request)
|
||
: HTTPErrorResponse(request,
|
||
MHD_HTTP_INTERNAL_SERVER_ERROR,
|
||
"500-page-title",
|
||
"500-page-heading",
|
||
std::string(),
|
||
/*includeKiwixResponseData=*/true)
|
||
{
|
||
*this += nonParameterizedMessage("500-page-text");
|
||
}
|
||
|
||
std::unique_ptr<Response> Response::build_416(size_t resourceLength)
|
||
{
|
||
auto response = Response::build();
|
||
// [FIXME] (compile with recent enough version of libmicrohttpd)
|
||
// response->set_code(MHD_HTTP_RANGE_NOT_SATISFIABLE);
|
||
response->set_code(416);
|
||
std::ostringstream oss;
|
||
oss << "bytes */" << resourceLength;
|
||
response->add_header(MHD_HTTP_HEADER_CONTENT_RANGE, oss.str());
|
||
|
||
return response;
|
||
}
|
||
|
||
|
||
std::unique_ptr<Response> Response::build_redirect(const std::string& redirectUrl)
|
||
{
|
||
auto response = Response::build();
|
||
response->m_returnCode = MHD_HTTP_FOUND;
|
||
response->add_header(MHD_HTTP_HEADER_LOCATION, redirectUrl);
|
||
return response;
|
||
}
|
||
|
||
static MHD_Result print_key_value (void *cls, enum MHD_ValueKind kind,
|
||
const char *key, const char *value)
|
||
{
|
||
printf (" - %s: '%s'\n", key, value);
|
||
return MHD_YES;
|
||
}
|
||
|
||
|
||
struct RunningResponse {
|
||
zim::Item item;
|
||
int range_start;
|
||
|
||
RunningResponse(zim::Item item,
|
||
int range_start) :
|
||
item(item),
|
||
range_start(range_start)
|
||
{}
|
||
};
|
||
|
||
static ssize_t callback_reader_from_item(void* cls,
|
||
uint64_t pos,
|
||
char* buf,
|
||
size_t max)
|
||
{
|
||
RunningResponse* response = static_cast<RunningResponse*>(cls);
|
||
|
||
size_t max_size_to_set = std::min<size_t>(
|
||
max,
|
||
response->item.getSize() - pos - response->range_start);
|
||
|
||
if (max_size_to_set <= 0) {
|
||
return MHD_CONTENT_READER_END_WITH_ERROR;
|
||
}
|
||
|
||
zim::Blob blob = response->item.getData(response->range_start+pos, max_size_to_set);
|
||
memcpy(buf, blob.data(), max_size_to_set);
|
||
return max_size_to_set;
|
||
}
|
||
|
||
static void callback_free_response(void* cls)
|
||
{
|
||
RunningResponse* response = static_cast<RunningResponse*>(cls);
|
||
delete response;
|
||
}
|
||
|
||
|
||
|
||
void print_response_info(int retCode, MHD_Response* response)
|
||
{
|
||
printf("Response :\n");
|
||
printf("httpResponseCode : %d\n", retCode);
|
||
printf("headers :\n");
|
||
MHD_get_response_headers(response, print_key_value, nullptr);
|
||
}
|
||
|
||
|
||
bool
|
||
ContentResponse::can_compress(const RequestContext& request) const
|
||
{
|
||
return request.can_compress()
|
||
&& is_compressible_mime_type(m_mimeType)
|
||
&& (m_content.size() > KIWIX_MIN_CONTENT_SIZE_TO_COMPRESS);
|
||
}
|
||
|
||
MHD_Response*
|
||
Response::create_mhd_response(const RequestContext& request)
|
||
{
|
||
MHD_Response* response = MHD_create_response_from_buffer(0, nullptr, MHD_RESPMEM_PERSISTENT);
|
||
return response;
|
||
}
|
||
|
||
MHD_Response*
|
||
ContentResponse::create_mhd_response(const RequestContext& request)
|
||
{
|
||
const bool isCompressed = can_compress(request) && compress(m_content);
|
||
|
||
MHD_Response* response = MHD_create_response_from_buffer(
|
||
m_content.size(), const_cast<char*>(m_content.data()), MHD_RESPMEM_MUST_COPY);
|
||
|
||
if (isCompressed) {
|
||
m_etag.set_option(ETag::COMPRESSED_CONTENT);
|
||
MHD_add_response_header(
|
||
response, MHD_HTTP_HEADER_VARY, "Accept-Encoding");
|
||
MHD_add_response_header(
|
||
response, MHD_HTTP_HEADER_CONTENT_ENCODING, "gzip");
|
||
}
|
||
return response;
|
||
}
|
||
|
||
MHD_Result Response::send(const RequestContext& request, bool verbose, MHD_Connection* connection)
|
||
{
|
||
MHD_Response* response = create_mhd_response(request);
|
||
|
||
MHD_add_response_header(response, MHD_HTTP_HEADER_CACHE_CONTROL,
|
||
getCacheControlHeader(m_kind));
|
||
const std::string etag = m_etag.get_etag();
|
||
if ( ! etag.empty() )
|
||
MHD_add_response_header(response, MHD_HTTP_HEADER_ETAG, etag.c_str());
|
||
for(auto& p: m_customHeaders) {
|
||
MHD_add_response_header(response, p.first.c_str(), p.second.c_str());
|
||
}
|
||
|
||
if (m_returnCode == MHD_HTTP_OK && m_byteRange.kind() == ByteRange::RESOLVED_PARTIAL_CONTENT)
|
||
m_returnCode = MHD_HTTP_PARTIAL_CONTENT;
|
||
|
||
if (verbose)
|
||
print_response_info(m_returnCode, response);
|
||
|
||
auto ret = MHD_queue_response(connection, m_returnCode, response);
|
||
MHD_destroy_response(response);
|
||
return ret;
|
||
}
|
||
|
||
ContentResponse::ContentResponse(const std::string& content, const std::string& mimetype) :
|
||
Response(),
|
||
m_content(content),
|
||
m_mimeType(mimetype)
|
||
{
|
||
add_header(MHD_HTTP_HEADER_CONTENT_TYPE, m_mimeType);
|
||
}
|
||
|
||
std::unique_ptr<ContentResponse> ContentResponse::build(
|
||
const std::string& content,
|
||
const std::string& mimetype)
|
||
{
|
||
return std::make_unique<ContentResponse>(content, mimetype);
|
||
}
|
||
|
||
std::unique_ptr<ContentResponse> ContentResponse::build(
|
||
const std::string& template_str,
|
||
kainjow::mustache::data data,
|
||
const std::string& mimetype)
|
||
{
|
||
auto content = render_template(template_str, data);
|
||
return ContentResponse::build(content, mimetype);
|
||
}
|
||
|
||
ItemResponse::ItemResponse(const zim::Item& item, const std::string& mimetype, const ByteRange& byterange) :
|
||
Response(),
|
||
m_item(item),
|
||
m_mimeType(mimetype)
|
||
{
|
||
m_byteRange = byterange;
|
||
set_kind(Response::ZIM_CONTENT);
|
||
add_header(MHD_HTTP_HEADER_CONTENT_TYPE, m_mimeType);
|
||
}
|
||
|
||
std::unique_ptr<Response> ItemResponse::build(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(item.getData(), mimetype);
|
||
response->set_kind(Response::ZIM_CONTENT);
|
||
response->m_byteRange = byteRange;
|
||
return std::move(response);
|
||
}
|
||
|
||
if (byteRange.kind() == ByteRange::RESOLVED_UNSATISFIABLE) {
|
||
auto response = Response::build_416(item.getSize());
|
||
response->set_kind(Response::ZIM_CONTENT);
|
||
return response;
|
||
}
|
||
|
||
return std::make_unique<ItemResponse>(item, mimetype, byteRange);
|
||
}
|
||
|
||
MHD_Response*
|
||
ItemResponse::create_mhd_response(const RequestContext& request)
|
||
{
|
||
const auto content_length = m_byteRange.length();
|
||
MHD_Response* response = MHD_create_response_from_callback(content_length,
|
||
16384,
|
||
callback_reader_from_item,
|
||
new RunningResponse(m_item, m_byteRange.first()),
|
||
callback_free_response);
|
||
MHD_add_response_header(response, MHD_HTTP_HEADER_ACCEPT_RANGES, "bytes");
|
||
if ( m_byteRange.kind() == ByteRange::RESOLVED_PARTIAL_CONTENT ) {
|
||
std::ostringstream oss;
|
||
oss << "bytes " << m_byteRange.first() << "-" << m_byteRange.last()
|
||
<< "/" << m_item.getSize();
|
||
|
||
MHD_add_response_header(response,
|
||
MHD_HTTP_HEADER_CONTENT_RANGE, oss.str().c_str());
|
||
}
|
||
|
||
MHD_add_response_header(response,
|
||
MHD_HTTP_HEADER_CONTENT_LENGTH, kiwix::to_string(content_length).c_str());
|
||
return response;
|
||
}
|
||
|
||
|
||
}
|