HTTP range responses (RFC 7233) - httpobjectstore (#928)

- Improvement: HTTP range responses (RFC 7233) are now fully compliant across the object store and build store
  - 206 Partial Content responses now include a `Content-Range` header; previously absent for single-range requests, which broke `HttpClient::GetRanges()`
  - 416 Range Not Satisfiable responses now include `Content-Range: bytes */N` as required by RFC 7233
  - Out-of-bounds range requests return 416 Range Not Satisfiable (was 400 Bad Request)
  - Single-byte ranges (`bytes=N-N`) are now correctly accepted (were previously rejected)
  - Range byte positions widened from 32-bit to 64-bit; RFC 7233 imposes no size limit on byte range values
  - Build store binary GET requests with a Range header now return 206 Partial Content with `Content-Range` (previously returned 200 OK without it)

6 files changed, 191 insertions, 12 deletions

diff --git a/src/zenhttp/httpserver.cpp b/src/zenhttp/httpserver.cpp
index 38021be16..3668e1e8f 100644
--- a/src/zenhttp/httpserver.cpp
+++ b/src/zenhttp/httpserver.cpp
@@ -266,10 +266,10 @@ TryParseHttpRangeHeader(std::string_view RangeHeader, HttpRanges& Ranges)
 			return false;
 		}
 
-		const auto Start = ParseInt<uint32_t>(Token.substr(0, Delim));
-		const auto End	 = ParseInt<uint32_t>(Token.substr(Delim + 1));
+		const auto Start = ParseInt<uint64_t>(Token.substr(0, Delim));
+		const auto End	 = ParseInt<uint64_t>(Token.substr(Delim + 1));
 
-		if (Start.has_value() && End.has_value() && End.value() > Start.value())
+		if (Start.has_value() && End.has_value() && End.value() >= Start.value())
 		{
 			Ranges.push_back({.Start = Start.value(), .End = End.value()});
 		}
@@ -286,6 +286,45 @@ TryParseHttpRangeHeader(std::string_view RangeHeader, HttpRanges& Ranges)
 	return Count != Ranges.size();
 }
 
+MultipartByteRangesResult
+BuildMultipartByteRanges(const IoBuffer& Data, const HttpRanges& Ranges)
+{
+	Oid::String_t BoundaryStr;
+	Oid::NewOid().ToString(BoundaryStr);
+	std::string_view Boundary(BoundaryStr, Oid::StringLength);
+
+	const uint64_t TotalSize = Data.GetSize();
+
+	std::vector<IoBuffer> Parts;
+	Parts.reserve(Ranges.size() * 2 + 1);
+
+	for (const HttpRange& Range : Ranges)
+	{
+		uint64_t RangeEnd = (Range.End != ~uint64_t(0)) ? Range.End : TotalSize - 1;
+		if (RangeEnd >= TotalSize || Range.Start > RangeEnd)
+		{
+			return {};
+		}
+
+		uint64_t RangeSize = 1 + (RangeEnd - Range.Start);
+
+		std::string PartHeader = fmt::format("\r\n--{}\r\nContent-Type: application/octet-stream\r\nContent-Range: bytes {}-{}/{}\r\n\r\n",
+											 Boundary,
+											 Range.Start,
+											 RangeEnd,
+											 TotalSize);
+		Parts.push_back(IoBufferBuilder::MakeCloneFromMemory(PartHeader.data(), PartHeader.size()));
+
+		IoBuffer RangeData(Data, Range.Start, RangeSize);
+		Parts.push_back(RangeData);
+	}
+
+	std::string ClosingBoundary = fmt::format("\r\n--{}--", Boundary);
+	Parts.push_back(IoBufferBuilder::MakeCloneFromMemory(ClosingBoundary.data(), ClosingBoundary.size()));
+
+	return {.Parts = std::move(Parts), .ContentType = fmt::format("multipart/byteranges; boundary={}", Boundary)};
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 const std::string_view
@@ -564,6 +603,56 @@ HttpServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType
 }
 
 void
+HttpServerRequest::WriteResponse(HttpContentType ContentType, const IoBuffer& Data, const HttpRanges& Ranges)
+{
+	if (Ranges.empty())
+	{
+		WriteResponse(HttpResponseCode::OK, ContentType, IoBuffer(Data));
+		return;
+	}
+
+	if (Ranges.size() == 1)
+	{
+		const HttpRange& Range	   = Ranges[0];
+		const uint64_t	 TotalSize = Data.GetSize();
+		// ~uint64_t(0) is the sentinel meaning "end of file" (suffix range).
+		const uint64_t RangeEnd = (Range.End != ~uint64_t(0)) ? Range.End : TotalSize - 1;
+
+		if (RangeEnd >= TotalSize || Range.Start > RangeEnd)
+		{
+			m_ContentRangeHeader = fmt::format("bytes */{}", TotalSize);
+			WriteResponse(HttpResponseCode::RangeNotSatisfiable);
+			return;
+		}
+
+		const uint64_t RangeSize = 1 + (RangeEnd - Range.Start);
+		IoBuffer	   RangeBuf(Data, Range.Start, RangeSize);
+
+		m_ContentRangeHeader = fmt::format("bytes {}-{}/{}", Range.Start, RangeEnd, TotalSize);
+		WriteResponse(HttpResponseCode::PartialContent, ContentType, std::move(RangeBuf));
+		return;
+	}
+
+	// Multi-range
+	MultipartByteRangesResult MultipartResult = BuildMultipartByteRanges(Data, Ranges);
+	if (MultipartResult.Parts.empty())
+	{
+		m_ContentRangeHeader = fmt::format("bytes */{}", Data.GetSize());
+		WriteResponse(HttpResponseCode::RangeNotSatisfiable);
+		return;
+	}
+	WriteResponse(HttpResponseCode::PartialContent, std::move(MultipartResult.ContentType), std::span<IoBuffer>(MultipartResult.Parts));
+}
+
+void
+HttpServerRequest::WriteResponse(HttpResponseCode ResponseCode, const std::string& CustomContentType, std::span<IoBuffer> Blobs)
+{
+	ZEN_ASSERT(ParseContentType(CustomContentType) == HttpContentType::kUnknownContentType);
+	m_ContentTypeOverride = CustomContentType;
+	WriteResponse(ResponseCode, HttpContentType::kBinary, Blobs);
+}
+
+void
 HttpServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, CompositeBuffer& Payload)
 {
 	std::span<const SharedBuffer> Segments = Payload.GetSegments();
diff --git a/src/zenhttp/include/zenhttp/httpcommon.h b/src/zenhttp/include/zenhttp/httpcommon.h
index f9a99f3cc..1d921600d 100644
--- a/src/zenhttp/include/zenhttp/httpcommon.h
+++ b/src/zenhttp/include/zenhttp/httpcommon.h
@@ -19,8 +19,8 @@ class StringBuilderBase;
 
 struct HttpRange
 {
-	uint32_t Start = ~uint32_t(0);
-	uint32_t End   = ~uint32_t(0);
+	uint64_t Start = ~uint64_t(0);
+	uint64_t End   = ~uint64_t(0);
 };
 
 using HttpRanges = std::vector<HttpRange>;
@@ -30,6 +30,16 @@ extern HttpContentType (*ParseContentType)(const std::string_view& ContentTypeSt
 std::string_view ReasonStringForHttpResultCode(int HttpCode);
 bool			 TryParseHttpRangeHeader(std::string_view RangeHeader, HttpRanges& Ranges);
 
+struct MultipartByteRangesResult
+{
+	std::vector<IoBuffer> Parts;
+	std::string			  ContentType;
+};
+
+// Build a multipart/byteranges response body from the given data and ranges.
+// Generates a unique boundary per call. Returns empty Parts if any range is out of bounds.
+MultipartByteRangesResult BuildMultipartByteRanges(const IoBuffer& Data, const HttpRanges& Ranges);
+
 enum class HttpVerb : uint8_t
 {
 	kGet	 = 1 << 0,
diff --git a/src/zenhttp/include/zenhttp/httpserver.h b/src/zenhttp/include/zenhttp/httpserver.h
index e8bfcfd4d..136304426 100644
--- a/src/zenhttp/include/zenhttp/httpserver.h
+++ b/src/zenhttp/include/zenhttp/httpserver.h
@@ -122,11 +122,13 @@ public:
 	virtual void WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::u8string_view ResponseString) = 0;
 	virtual void WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, CompositeBuffer& Payload);
 
+	void WriteResponse(HttpResponseCode ResponseCode, const std::string& CustomContentType, std::span<IoBuffer> Blobs);
 	void WriteResponse(HttpResponseCode ResponseCode, CbObject Data);
 	void WriteResponse(HttpResponseCode ResponseCode, CbArray Array);
 	void WriteResponse(HttpResponseCode ResponseCode, CbPackage Package);
 	void WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::string_view ResponseString);
 	void WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, IoBuffer Blob);
+	void WriteResponse(HttpContentType ContentType, const IoBuffer& Data, const HttpRanges& Ranges);
 
 	virtual void WriteResponseAsync(std::function<void(HttpServerRequest&)>&& ContinuationHandler) = 0;
 
@@ -152,6 +154,8 @@ protected:
 	std::string_view m_QueryString;
 	mutable uint32_t m_RequestId = ~uint32_t(0);
 	mutable Oid		 m_SessionId = Oid::Zero;
+	std::string		 m_ContentTypeOverride;
+	std::string		 m_ContentRangeHeader;
 
 	inline void SetIsHandled() { m_Flags |= kIsHandled; }
 
diff --git a/src/zenhttp/servers/httpasio.cpp b/src/zenhttp/servers/httpasio.cpp
index 6cda84875..cfba3c95f 100644
--- a/src/zenhttp/servers/httpasio.cpp
+++ b/src/zenhttp/servers/httpasio.cpp
@@ -625,6 +625,8 @@ public:
 
 	void SetAllowZeroCopyFileSend(bool Allow) { m_AllowZeroCopyFileSend = Allow; }
 	void SetKeepAlive(bool KeepAlive) { m_IsKeepAlive = KeepAlive; }
+	void SetContentTypeOverride(std::string Override) { m_ContentTypeOverride = std::move(Override); }
+	void SetContentRangeHeader(std::string V) { m_ContentRangeHeader = std::move(V); }
 
 	/**
 	 * Initialize the response for sending a payload made up of multiple blobs
@@ -768,10 +770,18 @@ public:
 	{
 		ZEN_MEMSCOPE(GetHttpasioTag());
 
+		std::string_view ContentTypeStr =
+			m_ContentTypeOverride.empty() ? MapContentTypeToString(m_ContentType) : std::string_view(m_ContentTypeOverride);
+
 		m_Headers << "HTTP/1.1 " << ResponseCode() << " " << ReasonStringForHttpResultCode(ResponseCode()) << "\r\n"
-				  << "Content-Type: " << MapContentTypeToString(m_ContentType) << "\r\n"
+				  << "Content-Type: " << ContentTypeStr << "\r\n"
 				  << "Content-Length: " << ContentLength() << "\r\n"sv;
 
+		if (!m_ContentRangeHeader.empty())
+		{
+			m_Headers << "Content-Range: " << m_ContentRangeHeader << "\r\n"sv;
+		}
+
 		if (!m_IsKeepAlive)
 		{
 			m_Headers << "Connection: close\r\n"sv;
@@ -898,7 +908,9 @@ private:
 	bool							 m_AllowZeroCopyFileSend = true;
 	State							 m_State				 = State::kUninitialized;
 	HttpContentType					 m_ContentType			 = HttpContentType::kBinary;
-	uint64_t						 m_ContentLength		 = 0;
+	std::string						 m_ContentTypeOverride;
+	std::string						 m_ContentRangeHeader;
+	uint64_t						 m_ContentLength = 0;
 	eastl::fixed_vector<IoBuffer, 8> m_DataBuffers;	 // This is here to keep the IoBuffer buffers/handles alive
 	ExtendableStringBuilder<160>	 m_Headers;
 
@@ -2131,6 +2143,10 @@ HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 	m_Response.reset(new HttpResponse(HttpContentType::kBinary, m_RequestNumber));
 	m_Response->SetAllowZeroCopyFileSend(m_AllowZeroCopyFileSend);
 	m_Response->SetKeepAlive(m_Request.IsKeepAlive());
+	if (!m_ContentRangeHeader.empty())
+	{
+		m_Response->SetContentRangeHeader(std::move(m_ContentRangeHeader));
+	}
 	std::array<IoBuffer, 0> Empty;
 
 	m_Response->InitializeForPayload((uint16_t)ResponseCode, Empty);
@@ -2146,6 +2162,14 @@ HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentT
 	m_Response.reset(new HttpResponse(ContentType, m_RequestNumber));
 	m_Response->SetAllowZeroCopyFileSend(m_AllowZeroCopyFileSend);
 	m_Response->SetKeepAlive(m_Request.IsKeepAlive());
+	if (!m_ContentTypeOverride.empty())
+	{
+		m_Response->SetContentTypeOverride(std::move(m_ContentTypeOverride));
+	}
+	if (!m_ContentRangeHeader.empty())
+	{
+		m_Response->SetContentRangeHeader(std::move(m_ContentRangeHeader));
+	}
 	m_Response->InitializeForPayload((uint16_t)ResponseCode, Blobs);
 }
 
diff --git a/src/zenhttp/servers/httpplugin.cpp b/src/zenhttp/servers/httpplugin.cpp
index 31b0315d4..b0fb020e0 100644
--- a/src/zenhttp/servers/httpplugin.cpp
+++ b/src/zenhttp/servers/httpplugin.cpp
@@ -185,13 +185,17 @@ public:
 
 	const std::vector<IoBuffer>& ResponseBuffers() const { return m_ResponseBuffers; }
 	void						 SuppressPayload() { m_ResponseBuffers.resize(1); }
+	void						 SetContentTypeOverride(std::string Override) { m_ContentTypeOverride = std::move(Override); }
+	void						 SetContentRangeHeader(std::string V) { m_ContentRangeHeader = std::move(V); }
 
 	std::string_view GetHeaders();
 
 private:
-	uint16_t					 m_ResponseCode	 = 0;
-	bool						 m_IsKeepAlive	 = true;
-	HttpContentType				 m_ContentType	 = HttpContentType::kBinary;
+	uint16_t					 m_ResponseCode = 0;
+	bool						 m_IsKeepAlive	= true;
+	HttpContentType				 m_ContentType	= HttpContentType::kBinary;
+	std::string					 m_ContentTypeOverride;
+	std::string					 m_ContentRangeHeader;
 	uint64_t					 m_ContentLength = 0;
 	std::vector<IoBuffer>		 m_ResponseBuffers;
 	ExtendableStringBuilder<160> m_Headers;
@@ -246,10 +250,18 @@ HttpPluginResponse::GetHeaders()
 
 	if (m_Headers.Size() == 0)
 	{
+		std::string_view ContentTypeStr =
+			m_ContentTypeOverride.empty() ? MapContentTypeToString(m_ContentType) : std::string_view(m_ContentTypeOverride);
+
 		m_Headers << "HTTP/1.1 " << ResponseCode() << " " << ReasonStringForHttpResultCode(ResponseCode()) << "\r\n"
-				  << "Content-Type: " << MapContentTypeToString(m_ContentType) << "\r\n"
+				  << "Content-Type: " << ContentTypeStr << "\r\n"
 				  << "Content-Length: " << ContentLength() << "\r\n"sv;
 
+		if (!m_ContentRangeHeader.empty())
+		{
+			m_Headers << "Content-Range: " << m_ContentRangeHeader << "\r\n"sv;
+		}
+
 		if (!m_IsKeepAlive)
 		{
 			m_Headers << "Connection: close\r\n"sv;
@@ -669,6 +681,10 @@ HttpPluginServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 	ZEN_MEMSCOPE(GetHttppluginTag());
 
 	m_Response.reset(new HttpPluginResponse(HttpContentType::kBinary));
+	if (!m_ContentRangeHeader.empty())
+	{
+		m_Response->SetContentRangeHeader(std::move(m_ContentRangeHeader));
+	}
 	std::array<IoBuffer, 0> Empty;
 
 	m_Response->InitializeForPayload((uint16_t)ResponseCode, Empty);
@@ -681,6 +697,14 @@ HttpPluginServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpConten
 	ZEN_MEMSCOPE(GetHttppluginTag());
 
 	m_Response.reset(new HttpPluginResponse(ContentType));
+	if (!m_ContentTypeOverride.empty())
+	{
+		m_Response->SetContentTypeOverride(std::move(m_ContentTypeOverride));
+	}
+	if (!m_ContentRangeHeader.empty())
+	{
+		m_Response->SetContentRangeHeader(std::move(m_ContentRangeHeader));
+	}
 	m_Response->InitializeForPayload((uint16_t)ResponseCode, Blobs);
 }
 
diff --git a/src/zenhttp/servers/httpsys.cpp b/src/zenhttp/servers/httpsys.cpp
index 1b722940d..d45804c50 100644
--- a/src/zenhttp/servers/httpsys.cpp
+++ b/src/zenhttp/servers/httpsys.cpp
@@ -464,6 +464,8 @@ public:
 	inline int64_t	GetResponseBodySize() const { return m_TotalDataSize; }
 
 	void SetLocationHeader(std::string_view Location) { m_LocationHeader = Location; }
+	void SetContentTypeOverride(std::string Override) { m_ContentTypeOverride = std::move(Override); }
+	void SetContentRangeHeader(std::string V) { m_ContentRangeHeader = std::move(V); }
 
 private:
 	eastl::fixed_vector<HTTP_DATA_CHUNK, 16> m_HttpDataChunks;
@@ -473,6 +475,8 @@ private:
 	uint32_t								 m_RemainingChunkCount = 0;	 // Backlog for multi-call sends
 	bool									 m_IsInitialResponse   = true;
 	HttpContentType							 m_ContentType		   = HttpContentType::kBinary;
+	std::string								 m_ContentTypeOverride;
+	std::string								 m_ContentRangeHeader;
 	eastl::fixed_vector<IoBuffer, 16>		 m_DataBuffers;
 	std::string								 m_LocationHeader;
 
@@ -725,7 +729,8 @@ HttpMessageResponseRequest::IssueRequest(std::error_code& ErrorCode)
 
 		PHTTP_KNOWN_HEADER ContentTypeHeader = &HttpResponse.Headers.KnownHeaders[HttpHeaderContentType];
 
-		std::string_view ContentTypeString = MapContentTypeToString(m_ContentType);
+		std::string_view ContentTypeString =
+			m_ContentTypeOverride.empty() ? MapContentTypeToString(m_ContentType) : std::string_view(m_ContentTypeOverride);
 
 		ContentTypeHeader->pRawValue	  = ContentTypeString.data();
 		ContentTypeHeader->RawValueLength = (USHORT)ContentTypeString.size();
@@ -739,6 +744,15 @@ HttpMessageResponseRequest::IssueRequest(std::error_code& ErrorCode)
 			LocationHeader->RawValueLength	  = (USHORT)m_LocationHeader.size();
 		}
 
+		// Content-Range header (for 206 Partial Content single-range responses)
+
+		if (!m_ContentRangeHeader.empty())
+		{
+			PHTTP_KNOWN_HEADER ContentRangeHeader = &HttpResponse.Headers.KnownHeaders[HttpHeaderContentRange];
+			ContentRangeHeader->pRawValue		  = m_ContentRangeHeader.data();
+			ContentRangeHeader->RawValueLength	  = (USHORT)m_ContentRangeHeader.size();
+		}
+
 		std::string_view ReasonString = ReasonStringForHttpResultCode(m_ResponseCode);
 
 		HttpResponse.StatusCode	  = m_ResponseCode;
@@ -2279,6 +2293,11 @@ HttpSysServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 
 	HttpMessageResponseRequest* Response = new HttpMessageResponseRequest(m_HttpTx, (uint16_t)ResponseCode);
 
+	if (!m_ContentRangeHeader.empty())
+	{
+		Response->SetContentRangeHeader(std::move(m_ContentRangeHeader));
+	}
+
 	if (SuppressBody())
 	{
 		Response->SuppressResponseBody();
@@ -2307,6 +2326,15 @@ HttpSysServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentTy
 
 	HttpMessageResponseRequest* Response = new HttpMessageResponseRequest(m_HttpTx, (uint16_t)ResponseCode, ContentType, Blobs);
 
+	if (!m_ContentTypeOverride.empty())
+	{
+		Response->SetContentTypeOverride(std::move(m_ContentTypeOverride));
+	}
+	if (!m_ContentRangeHeader.empty())
+	{
+		Response->SetContentRangeHeader(std::move(m_ContentRangeHeader));
+	}
+
 	if (SuppressBody())
 	{
 		Response->SuppressResponseBody();