add support in http client to accept multi-range responses (#788)

* add support in http client to accept multi-range responses

6 files changed, 780 insertions, 245 deletions

diff --git a/src/zenhttp/clients/httpclientcommon.cpp b/src/zenhttp/clients/httpclientcommon.cpp
index 47425e014..312ca16d2 100644
--- a/src/zenhttp/clients/httpclientcommon.cpp
+++ b/src/zenhttp/clients/httpclientcommon.cpp
@@ -382,6 +382,178 @@ namespace detail {
 		return Result;
 	}
 
+	MultipartBoundaryParser::MultipartBoundaryParser() : BoundaryEndMatcher("--"), HeaderEndMatcher("\r\n\r\n") {}
+
+	bool MultipartBoundaryParser::Init(const std::string_view ContentTypeHeaderValue)
+	{
+		std::string LowerCaseValue = ToLower(ContentTypeHeaderValue);
+		if (LowerCaseValue.starts_with("multipart/byteranges"))
+		{
+			size_t BoundaryPos = LowerCaseValue.find("boundary=");
+			if (BoundaryPos != std::string::npos)
+			{
+				// Yes, we do a substring of the non-lowercase value string as we want the exact boundary string
+				std::string_view BoundaryName = std::string_view(ContentTypeHeaderValue).substr(BoundaryPos + 9);
+				if (!BoundaryName.empty())
+				{
+					size_t BoundaryEnd = std::string::npos;
+					while (BoundaryName[0] == ' ')
+					{
+						BoundaryName = BoundaryName.substr(1);
+					}
+					if (!BoundaryName.empty())
+					{
+						if (BoundaryName.size() > 2 && BoundaryName.front() == '"' && BoundaryName.back() == '"')
+						{
+							BoundaryEnd = BoundaryName.find('"', 1);
+							if (BoundaryEnd != std::string::npos)
+							{
+								BoundaryBeginMatcher.Init(fmt::format("\r\n--{}", BoundaryName.substr(1, BoundaryEnd - 1)));
+								return true;
+							}
+						}
+						else
+						{
+							BoundaryEnd = BoundaryName.find_first_of(" \r\n");
+							BoundaryBeginMatcher.Init(fmt::format("\r\n--{}", BoundaryName.substr(0, BoundaryEnd)));
+							return true;
+						}
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+	void MultipartBoundaryParser::InternalParseInput(std::string_view data)
+	{
+		size_t ScanPos = 0;
+		while (ScanPos < data.length())
+		{
+			const char ScanChar = data[ScanPos];
+			if (BoundaryBeginMatcher.MatchState == IncrementalStringMatcher::EMatchState::Complete)
+			{
+				if (PayloadOffset + ScanPos < (BoundaryBeginMatcher.GetMatchEndOffset() + BoundaryEndMatcher.GetMatchString().length()))
+				{
+					BoundaryEndMatcher.Match(PayloadOffset + ScanPos, ScanChar);
+					if (BoundaryEndMatcher.MatchState == IncrementalStringMatcher::EMatchState::Complete)
+					{
+						BoundaryBeginMatcher.Reset();
+						HeaderEndMatcher.Reset();
+						BoundaryEndMatcher.Reset();
+						BoundaryHeader.Reset();
+						break;
+					}
+				}
+
+				BoundaryHeader.Append(ScanChar);
+
+				HeaderEndMatcher.Match(PayloadOffset + ScanPos, ScanChar);
+
+				if (HeaderEndMatcher.MatchState == IncrementalStringMatcher::EMatchState::Complete)
+				{
+					const uint64_t	 HeaderStartOffset = BoundaryBeginMatcher.GetMatchEndOffset();
+					const uint64_t	 HeaderEndOffset   = HeaderEndMatcher.GetMatchStartOffset();
+					const uint64_t	 HeaderLength	   = HeaderEndOffset - HeaderStartOffset;
+					std::string_view HeaderText(BoundaryHeader.ToView().substr(0, HeaderLength));
+
+					uint64_t OffsetInPayload = PayloadOffset + ScanPos + 1;
+
+					uint64_t		RangeOffset = 0;
+					uint64_t		RangeLength = 0;
+					HttpContentType ContentType = HttpContentType::kBinary;
+
+					ForEachStrTok(HeaderText, "\r\n", [&](std::string_view Line) {
+						const std::pair<std::string_view, std::string_view> KeyAndValue = GetHeaderKeyAndValue(Line);
+						const std::string_view								Key			= KeyAndValue.first;
+						const std::string_view								Value		= KeyAndValue.second;
+						if (Key == "Content-Range")
+						{
+							std::pair<uint64_t, uint64_t> ContentRange = ParseContentRange(Value);
+							if (ContentRange.second != 0)
+							{
+								RangeOffset = ContentRange.first;
+								RangeLength = ContentRange.second;
+							}
+						}
+						else if (Key == "Content-Type")
+						{
+							ContentType = ParseContentType(Value);
+						}
+
+						return true;
+					});
+
+					if (RangeLength > 0)
+					{
+						Boundaries.push_back(HttpClient::Response::MultipartBoundary{.OffsetInPayload = OffsetInPayload,
+																					 .RangeOffset	  = RangeOffset,
+																					 .RangeLength	  = RangeLength,
+																					 .ContentType	  = ContentType});
+					}
+
+					BoundaryBeginMatcher.Reset();
+					HeaderEndMatcher.Reset();
+					BoundaryEndMatcher.Reset();
+					BoundaryHeader.Reset();
+				}
+			}
+			else
+			{
+				BoundaryBeginMatcher.Match(PayloadOffset + ScanPos, ScanChar);
+			}
+			ScanPos++;
+		}
+		PayloadOffset += data.length();
+	}
+
+	std::pair<std::string_view, std::string_view> GetHeaderKeyAndValue(std::string_view HeaderString)
+	{
+		size_t DelimiterPos = HeaderString.find(':');
+		if (DelimiterPos != std::string::npos)
+		{
+			std::string_view   Key = HeaderString.substr(0, DelimiterPos);
+			constexpr AsciiSet WhitespaceCharacters(" \v\f\t\r\n");
+			Key = AsciiSet::TrimSuffixWith(Key, WhitespaceCharacters);
+			Key = AsciiSet::TrimPrefixWith(Key, WhitespaceCharacters);
+
+			std::string_view Value = HeaderString.substr(DelimiterPos + 1);
+			Value				   = AsciiSet::TrimSuffixWith(Value, WhitespaceCharacters);
+			Value				   = AsciiSet::TrimPrefixWith(Value, WhitespaceCharacters);
+			return std::make_pair(Key, Value);
+		}
+		return std::make_pair(HeaderString, std::string_view{});
+	}
+
+	std::pair<uint64_t, uint64_t> ParseContentRange(std::string_view Value)
+	{
+		if (Value.starts_with("bytes "))
+		{
+			size_t RangeSplitPos = Value.find('-', 6);
+			if (RangeSplitPos != std::string::npos)
+			{
+				size_t RangeEndLength = Value.find('/', RangeSplitPos + 1);
+				if (RangeEndLength == std::string::npos)
+				{
+					RangeEndLength = Value.length() - (RangeSplitPos + 1);
+				}
+				else
+				{
+					RangeEndLength = RangeEndLength - (RangeSplitPos + 1);
+				}
+				std::optional<size_t> RequestedRangeStart = ParseInt<size_t>(Value.substr(6, RangeSplitPos - 6));
+				std::optional<size_t> RequestedRangeEnd	  = ParseInt<size_t>(Value.substr(RangeSplitPos + 1, RangeEndLength));
+				if (RequestedRangeStart.has_value() && RequestedRangeEnd.has_value())
+				{
+					uint64_t RangeOffset = RequestedRangeStart.value();
+					uint64_t RangeLength = RequestedRangeEnd.value() - RangeOffset + 1;
+					return std::make_pair(RangeOffset, RangeLength);
+				}
+			}
+		}
+		return {0, 0};
+	}
+
 }  // namespace detail
 
 }  // namespace zen
@@ -470,5 +642,148 @@ TEST_CASE("CompositeBufferReadStream")
 	CHECK_EQ(IoHash::HashBuffer(Data), testutil::HashComposite(Data));
 }
 
+TEST_CASE("MultipartBoundaryParser")
+{
+	uint64_t Range1Offset = 2638;
+	uint64_t Range1Length = (5111437 - Range1Offset) + 1;
+
+	uint64_t Range2Offset = 5118199;
+	uint64_t Range2Length = (9147741 - Range2Offset) + 1;
+
+	std::string_view ContentTypeHeaderValue1 = "multipart/byteranges; boundary=00000000000000019229";
+	std::string_view ContentTypeHeaderValue2 = "multipart/byteranges; boundary=\"00000000000000019229\"";
+
+	{
+		std::string_view Example1 =
+			"\r\n--00000000000000019229\r\n"
+			"Content-Type: application/x-ue-comp\r\n"
+			"Content-Range: bytes 2638-5111437/44369878\r\n"
+			"\r\n"
+			"datadatadatadata"
+			"\r\n--00000000000000019229\r\n"
+			"Content-Type: application/x-ue-comp\r\n"
+			"Content-Range: bytes 5118199-9147741/44369878\r\n"
+			"\r\n"
+			"ditaditadita"
+			"\r\n--00000000000000019229--";
+
+		detail::MultipartBoundaryParser ParserExample1;
+		ParserExample1.Init(ContentTypeHeaderValue1);
+
+		const size_t InputWindow = 7;
+		for (size_t Offset = 0; Offset < Example1.length(); Offset += InputWindow)
+		{
+			ParserExample1.ParseInput(Example1.substr(Offset, Min(Example1.length() - Offset, InputWindow)));
+		}
+
+		CHECK(ParserExample1.Boundaries.size() == 2);
+
+		CHECK(ParserExample1.Boundaries[0].RangeOffset == Range1Offset);
+		CHECK(ParserExample1.Boundaries[0].RangeLength == Range1Length);
+		CHECK(ParserExample1.Boundaries[1].RangeOffset == Range2Offset);
+		CHECK(ParserExample1.Boundaries[1].RangeLength == Range2Length);
+	}
+
+	{
+		std::string_view Example2 =
+			"\r\n--00000000000000019229\r\n"
+			"Content-Type: application/x-ue-comp\r\n"
+			"Content-Range: bytes 2638-5111437/*\r\n"
+			"\r\n"
+			"datadatadatadata"
+			"\r\n--00000000000000019229\r\n"
+			"Content-Type: application/x-ue-comp\r\n"
+			"Content-Range: bytes 5118199-9147741/44369878\r\n"
+			"\r\n"
+			"ditaditadita"
+			"\r\n--00000000000000019229--";
+
+		detail::MultipartBoundaryParser ParserExample2;
+		ParserExample2.Init(ContentTypeHeaderValue1);
+
+		const size_t InputWindow = 3;
+		for (size_t Offset = 0; Offset < Example2.length(); Offset += InputWindow)
+		{
+			std::string_view Window = Example2.substr(Offset, Min(Example2.length() - Offset, InputWindow));
+			ParserExample2.ParseInput(Window);
+		}
+
+		CHECK(ParserExample2.Boundaries.size() == 2);
+
+		CHECK(ParserExample2.Boundaries[0].RangeOffset == Range1Offset);
+		CHECK(ParserExample2.Boundaries[0].RangeLength == Range1Length);
+		CHECK(ParserExample2.Boundaries[1].RangeOffset == Range2Offset);
+		CHECK(ParserExample2.Boundaries[1].RangeLength == Range2Length);
+	}
+
+	{
+		std::string_view Example3 =
+			"\r\n--00000000000000019229\r\n"
+			"Content-Type: application/x-ue-comp\r\n"
+			"Content-Range: bytes 2638-5111437/*\r\n"
+			"\r\n"
+			"datadatadatadata"
+			"\r\n--00000000000000019229\r\n"
+			"Content-Type: application/x-ue-comp\r\n"
+			"Content-Range: bytes 5118199-9147741/44369878\r\n"
+			"\r\n"
+			"ditaditadita";
+
+		detail::MultipartBoundaryParser ParserExample3;
+		ParserExample3.Init(ContentTypeHeaderValue2);
+
+		const size_t InputWindow = 31;
+		for (size_t Offset = 0; Offset < Example3.length(); Offset += InputWindow)
+		{
+			ParserExample3.ParseInput(Example3.substr(Offset, Min(Example3.length() - Offset, InputWindow)));
+		}
+
+		CHECK(ParserExample3.Boundaries.size() == 2);
+
+		CHECK(ParserExample3.Boundaries[0].RangeOffset == Range1Offset);
+		CHECK(ParserExample3.Boundaries[0].RangeLength == Range1Length);
+		CHECK(ParserExample3.Boundaries[1].RangeOffset == Range2Offset);
+		CHECK(ParserExample3.Boundaries[1].RangeLength == Range2Length);
+	}
+
+	{
+		std::string_view Example4 =
+			"\r\n--00000000000000019229\r\n"
+			"Content-Type: application/x-ue-comp\r\n"
+			"Content-Range: bytes 2638-5111437/*\r\n"
+			"Not: really\r\n"
+			"\r\n"
+			"datadatadatadata"
+			"\r\n--000000000bait0019229\r\n"
+			"\r\n--00\r\n--000000000bait001922\r\n"
+			"\r\n\r\n\r\r\n--00000000000000019229\r\n"
+			"Content-Type: application/x-ue-comp\r\n"
+			"Content-Range: bytes 5118199-9147741/44369878\r\n"
+			"\r\n"
+			"ditaditadita"
+			"Content-Type: application/x-ue-comp\r\n"
+			"ditaditadita"
+			"Content-Range: bytes 5118199-9147741/44369878\r\n"
+			"\r\n---\r\n--00000000000000019229--";
+
+		detail::MultipartBoundaryParser ParserExample4;
+		ParserExample4.Init(ContentTypeHeaderValue1);
+
+		const size_t InputWindow = 3;
+		for (size_t Offset = 0; Offset < Example4.length(); Offset += InputWindow)
+		{
+			std::string_view Window = Example4.substr(Offset, Min(Example4.length() - Offset, InputWindow));
+			ParserExample4.ParseInput(Window);
+		}
+
+		CHECK(ParserExample4.Boundaries.size() == 2);
+
+		CHECK(ParserExample4.Boundaries[0].RangeOffset == Range1Offset);
+		CHECK(ParserExample4.Boundaries[0].RangeLength == Range1Length);
+		CHECK(ParserExample4.Boundaries[1].RangeOffset == Range2Offset);
+		CHECK(ParserExample4.Boundaries[1].RangeLength == Range2Length);
+	}
+}
+
 }  // namespace zen
 #endif
diff --git a/src/zenhttp/clients/httpclientcommon.h b/src/zenhttp/clients/httpclientcommon.h
index 1d0b7f9ea..8bb1e9268 100644
--- a/src/zenhttp/clients/httpclientcommon.h
+++ b/src/zenhttp/clients/httpclientcommon.h
@@ -3,6 +3,7 @@
 #pragma once
 
 #include <zencore/compositebuffer.h>
+#include <zencore/string.h>
 #include <zencore/trace.h>
 
 #include <zenhttp/httpclient.h>
@@ -87,7 +88,7 @@ namespace detail {
 		std::error_code Write(std::string_view DataString);
 		IoBuffer		DetachToIoBuffer();
 		IoBuffer		BorrowIoBuffer();
-		inline uint64_t GetSize() const { return m_WriteOffset; }
+		inline uint64_t GetSize() const { return m_WriteOffset + m_CacheBufferOffset; }
 		void			ResetWritePos(uint64_t WriteOffset);
 
 	private:
@@ -143,6 +144,112 @@ namespace detail {
 		uint64_t								m_BytesLeftInSegment;
 	};
 
+	class IncrementalStringMatcher
+	{
+	public:
+		enum class EMatchState
+		{
+			None,
+			Partial,
+			Complete
+		};
+
+		EMatchState MatchState = EMatchState::None;
+
+		IncrementalStringMatcher() {}
+
+		IncrementalStringMatcher(std::string&& InMatchString) : MatchString(std::move(InMatchString)) {}
+
+		void Init(std::string&& InMatchString) { MatchString = std::move(InMatchString); }
+
+		void Reset()
+		{
+			MatchLength		 = 0;
+			MatchStartOffset = 0;
+			MatchState		 = EMatchState::None;
+		}
+
+		inline uint64_t GetMatchEndOffset() const
+		{
+			if (MatchState == EMatchState::Complete)
+			{
+				return MatchStartOffset + MatchString.length();
+			}
+			return 0;
+		}
+
+		inline uint64_t GetMatchStartOffset() const
+		{
+			ZEN_ASSERT(MatchState == EMatchState::Complete);
+			return MatchStartOffset;
+		}
+
+		void Match(uint64_t Offset, char C)
+		{
+			ZEN_ASSERT_SLOW(!MatchString.empty());
+
+			if (MatchState == EMatchState::Complete)
+			{
+				Reset();
+			}
+			if (C == MatchString[MatchLength])
+			{
+				if (MatchLength == 0)
+				{
+					MatchStartOffset = Offset;
+				}
+				MatchLength++;
+				if (MatchLength == MatchString.length())
+				{
+					MatchState = EMatchState::Complete;
+				}
+				else
+				{
+					MatchState = EMatchState::Partial;
+				}
+			}
+			else if (MatchLength != 0)
+			{
+				Reset();
+				Match(Offset, C);
+			}
+			else
+			{
+				Reset();
+			}
+		}
+		inline const std::string& GetMatchString() const { return MatchString; }
+
+	private:
+		std::string MatchString;
+
+		uint64_t MatchLength	  = 0;
+		uint64_t MatchStartOffset = 0;
+	};
+
+	class MultipartBoundaryParser
+	{
+	public:
+		std::vector<HttpClient::Response::MultipartBoundary> Boundaries;
+
+		MultipartBoundaryParser();
+		bool		Init(const std::string_view ContentTypeHeaderValue);
+		inline void ParseInput(std::string_view data) { InternalParseInput(data); }
+
+	private:
+		IncrementalStringMatcher BoundaryBeginMatcher;
+		IncrementalStringMatcher BoundaryEndMatcher;
+		IncrementalStringMatcher HeaderEndMatcher;
+
+		ExtendableStringBuilder<64> BoundaryHeader;
+		uint64_t					PayloadOffset = 0;
+
+		void InternalParseInput(std::string_view data);
+	};
+
+	std::pair<std::string_view, std::string_view> GetHeaderKeyAndValue(std::string_view HeaderString);
+	std::pair<uint64_t, uint64_t>				  ParseContentRange(std::string_view Value);
+
 }  // namespace detail
 
 }  // namespace zen
diff --git a/src/zenhttp/clients/httpclientcpr.cpp b/src/zenhttp/clients/httpclientcpr.cpp
index 5d92b3b6b..6bc63db09 100644
--- a/src/zenhttp/clients/httpclientcpr.cpp
+++ b/src/zenhttp/clients/httpclientcpr.cpp
@@ -162,10 +162,11 @@ CprHttpClient::~CprHttpClient()
 }
 
 HttpClient::Response
-CprHttpClient::ResponseWithPayload(std::string_view		  SessionId,
-								   cpr::Response&&		  HttpResponse,
-								   const HttpResponseCode WorkResponseCode,
-								   IoBuffer&&			  Payload)
+CprHttpClient::ResponseWithPayload(std::string_view										  SessionId,
+								   cpr::Response&&										  HttpResponse,
+								   const HttpResponseCode								  WorkResponseCode,
+								   IoBuffer&&											  Payload,
+								   std::vector<HttpClient::Response::MultipartBoundary>&& BoundaryPositions)
 {
 	// This ends up doing a memcpy, would be good to get rid of it by streaming results
 	// into buffer directly
@@ -174,7 +175,6 @@ CprHttpClient::ResponseWithPayload(std::string_view		  SessionId,
 	if (auto It = HttpResponse.header.find("Content-Type"); It != HttpResponse.header.end())
 	{
 		const HttpContentType ContentType = ParseContentType(It->second);
-
 		ResponseBuffer.SetContentType(ContentType);
 	}
 
@@ -188,16 +188,26 @@ CprHttpClient::ResponseWithPayload(std::string_view		  SessionId,
 		}
 	}
 
+	std::sort(BoundaryPositions.begin(),
+			  BoundaryPositions.end(),
+			  [](const HttpClient::Response::MultipartBoundary& Lhs, const HttpClient::Response::MultipartBoundary& Rhs) {
+				  return Lhs.RangeOffset < Rhs.RangeOffset;
+			  });
+
 	return HttpClient::Response{.StatusCode		 = WorkResponseCode,
 								.ResponsePayload = std::move(ResponseBuffer),
 								.Header			 = HttpClient::KeyValueMap(HttpResponse.header.begin(), HttpResponse.header.end()),
 								.UploadedBytes	 = gsl::narrow<int64_t>(HttpResponse.uploaded_bytes),
 								.DownloadedBytes = gsl::narrow<int64_t>(HttpResponse.downloaded_bytes),
-								.ElapsedSeconds	 = HttpResponse.elapsed};
+								.ElapsedSeconds	 = HttpResponse.elapsed,
+								.Ranges			 = std::move(BoundaryPositions)};
 }
 
 HttpClient::Response
-CprHttpClient::CommonResponse(std::string_view SessionId, cpr::Response&& HttpResponse, IoBuffer&& Payload)
+CprHttpClient::CommonResponse(std::string_view										 SessionId,
+							  cpr::Response&&										 HttpResponse,
+							  IoBuffer&&											 Payload,
+							  std::vector<HttpClient::Response::MultipartBoundary>&& BoundaryPositions)
 {
 	const HttpResponseCode WorkResponseCode = HttpResponseCode(HttpResponse.status_code);
 	if (HttpResponse.error)
@@ -235,7 +245,7 @@ CprHttpClient::CommonResponse(std::string_view SessionId, cpr::Response&& HttpRe
 	}
 	else
 	{
-		return ResponseWithPayload(SessionId, std::move(HttpResponse), WorkResponseCode, std::move(Payload));
+		return ResponseWithPayload(SessionId, std::move(HttpResponse), WorkResponseCode, std::move(Payload), std::move(BoundaryPositions));
 	}
 }
 
@@ -896,236 +906,280 @@ CprHttpClient::Download(std::string_view Url, const std::filesystem::path& TempF
 
 	std::string								 PayloadString;
 	std::unique_ptr<detail::TempPayloadFile> PayloadFile;
-	cpr::Response							 Response = DoWithRetry(
-		   m_SessionId,
-		   [&]() {
-			   auto GetHeader = [&](std::string header) -> std::pair<std::string, std::string> {
-				   size_t DelimiterPos = header.find(':');
-				   if (DelimiterPos != std::string::npos)
-				   {
-					   std::string		  Key = header.substr(0, DelimiterPos);
-					   constexpr AsciiSet WhitespaceCharacters(" \v\f\t\r\n");
-					   Key = AsciiSet::TrimSuffixWith(Key, WhitespaceCharacters);
-					   Key = AsciiSet::TrimPrefixWith(Key, WhitespaceCharacters);
-
-					   std::string Value = header.substr(DelimiterPos + 1);
-					   Value			 = AsciiSet::TrimSuffixWith(Value, WhitespaceCharacters);
-					   Value			 = AsciiSet::TrimPrefixWith(Value, WhitespaceCharacters);
-
-					   return std::make_pair(Key, Value);
-				   }
-				   return std::make_pair(header, "");
-			   };
-
-			   auto DownloadCallback = [&](std::string data, intptr_t) {
-				   if (m_CheckIfAbortFunction && m_CheckIfAbortFunction())
-				   {
-					   return false;
-				   }
-				   if (PayloadFile)
-				   {
-					   ZEN_ASSERT(PayloadString.empty());
-					   std::error_code Ec = PayloadFile->Write(data);
-					   if (Ec)
-					   {
-						   ZEN_WARN("Failed to write to temp file in '{}' for HttpClient::Download. Reason: {}",
-									TempFolderPath.string(),
-									Ec.message());
-						   return false;
-					   }
-				   }
-				   else
-				   {
-					   PayloadString.append(data);
-				   }
-				   return true;
-			   };
-
-			   uint64_t RequestedContentLength = (uint64_t)-1;
-			   if (auto RangeIt = AdditionalHeader.Entries.find("Range"); RangeIt != AdditionalHeader.Entries.end())
-			   {
-				   if (RangeIt->second.starts_with("bytes"))
-				   {
-					   size_t RangeStartPos = RangeIt->second.find('=', 5);
-					   if (RangeStartPos != std::string::npos)
-					   {
-						   RangeStartPos++;
-						   size_t RangeSplitPos = RangeIt->second.find('-', RangeStartPos);
-						   if (RangeSplitPos != std::string::npos)
-						   {
-							   std::optional<size_t> RequestedRangeStart =
-								   ParseInt<size_t>(RangeIt->second.substr(RangeStartPos, RangeSplitPos - RangeStartPos));
-							   std::optional<size_t> RequestedRangeEnd = ParseInt<size_t>(RangeIt->second.substr(RangeStartPos + 1));
-							   if (RequestedRangeStart.has_value() && RequestedRangeEnd.has_value())
-							   {
-								   RequestedContentLength = RequestedRangeEnd.value() - 1;
-							   }
-						   }
-					   }
-				   }
-			   }
-
-			   cpr::Response Response;
-			   {
-				   std::vector<std::pair<std::string, std::string>> ReceivedHeaders;
-				   auto												HeaderCallback = [&](std::string header, intptr_t) {
-					   std::pair<std::string, std::string> Header = GetHeader(header);
-					   if (Header.first == "Content-Length"sv)
-					   {
-						   std::optional<size_t> ContentLength = ParseInt<size_t>(Header.second);
-						   if (ContentLength.has_value())
-						   {
-							   if (ContentLength.value() > m_ConnectionSettings.MaximumInMemoryDownloadSize)
-							   {
-								   PayloadFile = std::make_unique<detail::TempPayloadFile>();
-								   std::error_code Ec = PayloadFile->Open(TempFolderPath, ContentLength.value());
-								   if (Ec)
-								   {
-									   ZEN_WARN("Failed to create temp file in '{}' for HttpClient::Download. Reason: {}",
-												TempFolderPath.string(),
-												Ec.message());
-									   PayloadFile.reset();
-								   }
-							   }
-							   else
-							   {
-								   PayloadString.reserve(ContentLength.value());
-							   }
-						   }
-					   }
-					   if (!Header.first.empty())
-					   {
-						   ReceivedHeaders.emplace_back(std::move(Header));
-					   }
-					   return 1;
-				   };
-
-				   Session Sess = AllocSession(m_BaseUri, Url, m_ConnectionSettings, AdditionalHeader, {}, m_SessionId, GetAccessToken());
-				   Response = Sess.Download(cpr::WriteCallback{DownloadCallback}, cpr::HeaderCallback{HeaderCallback});
-				   for (const std::pair<std::string, std::string>& H : ReceivedHeaders)
-				   {
-					   Response.header.insert_or_assign(H.first, H.second);
-				   }
-			   }
-			   if (m_ConnectionSettings.AllowResume)
-			   {
-				   auto SupportsRanges = [](const cpr::Response& Response) -> bool {
-					   if (Response.header.find("Content-Range") != Response.header.end())
-					   {
-						   return true;
-					   }
-					   if (auto It = Response.header.find("Accept-Ranges"); It != Response.header.end())
-					   {
-						   return It->second == "bytes"sv;
-					   }
-					   return false;
-				   };
-
-				   auto ShouldResume = [&SupportsRanges](const cpr::Response& Response) -> bool {
-					   if (ShouldRetry(Response))
-					   {
-						   return SupportsRanges(Response);
-					   }
-					   return false;
-				   };
-
-				   if (ShouldResume(Response))
-				   {
-					   auto It = Response.header.find("Content-Length");
-					   if (It != Response.header.end())
-					   {
-						   uint64_t ContentLength = RequestedContentLength;
-						   if (ContentLength == uint64_t(-1))
-						   {
-							   if (auto ParsedContentLength = ParseInt<int64_t>(It->second); ParsedContentLength.has_value())
-							   {
-								   ContentLength = ParsedContentLength.value();
-							   }
-						   }
-
-						   std::vector<std::pair<std::string, std::string>> ReceivedHeaders;
-
-						   auto HeaderCallback = [&](std::string header, intptr_t) {
-							   std::pair<std::string, std::string> Header = GetHeader(header);
-							   if (!Header.first.empty())
-							   {
-								   ReceivedHeaders.emplace_back(std::move(Header));
-							   }
-
-							   if (Header.first == "Content-Range"sv)
-							   {
-								   if (Header.second.starts_with("bytes "sv))
-								   {
-									   size_t RangeStartEnd = Header.second.find('-', 6);
-									   if (RangeStartEnd != std::string::npos)
-									   {
-										   const auto Start = ParseInt<uint64_t>(Header.second.substr(6, RangeStartEnd - 6));
-										   if (Start)
-										   {
-											   uint64_t DownloadedSize = PayloadFile ? PayloadFile->GetSize() : PayloadString.length();
-											   if (Start.value() == DownloadedSize)
-											   {
-												   return 1;
-											   }
-											   else if (Start.value() > DownloadedSize)
-											   {
-												   return 0;
-											   }
-											   if (PayloadFile)
-											   {
-												   PayloadFile->ResetWritePos(Start.value());
-											   }
-											   else
-											   {
-												   PayloadString = PayloadString.substr(0, Start.value());
-											   }
-											   return 1;
-										   }
-									   }
-								   }
-								   return 0;
-							   }
-							   return 1;
-						   };
-
-						   KeyValueMap HeadersWithRange(AdditionalHeader);
-						   do
-						   {
-							   uint64_t DownloadedSize = PayloadFile ? PayloadFile->GetSize() : PayloadString.length();
-
-							   std::string Range = fmt::format("bytes={}-{}", DownloadedSize, DownloadedSize + ContentLength - 1);
-							   if (auto RangeIt = HeadersWithRange.Entries.find("Range"); RangeIt != HeadersWithRange.Entries.end())
-							   {
-								   if (RangeIt->second == Range)
-								   {
-									   // If we didn't make any progress, abort
-									   break;
-								   }
-							   }
-							   HeadersWithRange.Entries.insert_or_assign("Range", Range);
-
-							   Session Sess =
-								   AllocSession(m_BaseUri, Url, m_ConnectionSettings, HeadersWithRange, {}, m_SessionId, GetAccessToken());
-							   Response = Sess.Download(cpr::WriteCallback{DownloadCallback}, cpr::HeaderCallback{HeaderCallback});
-							   for (const std::pair<std::string, std::string>& H : ReceivedHeaders)
-							   {
-								   Response.header.insert_or_assign(H.first, H.second);
-							   }
-							   ReceivedHeaders.clear();
-						   } while (ShouldResume(Response));
-					   }
-				   }
-			   }
-
-			   if (!PayloadString.empty())
-			   {
-				   Response.text = std::move(PayloadString);
-			   }
-			   return Response;
-		   },
-		   PayloadFile);
-
-	return CommonResponse(m_SessionId, std::move(Response), PayloadFile ? PayloadFile->DetachToIoBuffer() : IoBuffer{});
+
+	HttpContentType					ContentType = HttpContentType::kUnknownContentType;
+	detail::MultipartBoundaryParser BoundaryParser;
+	bool							IsMultiRangeResponse = false;
+
+	cpr::Response Response = DoWithRetry(
+		m_SessionId,
+		[&]() {
+			auto DownloadCallback = [&](std::string data, intptr_t) {
+				if (m_CheckIfAbortFunction && m_CheckIfAbortFunction())
+				{
+					return false;
+				}
+
+				if (IsMultiRangeResponse)
+				{
+					BoundaryParser.ParseInput(data);
+				}
+
+				if (PayloadFile)
+				{
+					ZEN_ASSERT(PayloadString.empty());
+					std::error_code Ec = PayloadFile->Write(data);
+					if (Ec)
+					{
+						ZEN_WARN("Failed to write to temp file in '{}' for HttpClient::Download. Reason: {}",
+								 TempFolderPath.string(),
+								 Ec.message());
+						return false;
+					}
+				}
+				else
+				{
+					PayloadString.append(data);
+				}
+				return true;
+			};
+
+			uint64_t RequestedContentLength = (uint64_t)-1;
+			if (auto RangeIt = AdditionalHeader.Entries.find("Range"); RangeIt != AdditionalHeader.Entries.end())
+			{
+				if (RangeIt->second.starts_with("bytes"))
+				{
+					std::string_view RangeValue(RangeIt->second);
+					size_t			 RangeStartPos = RangeValue.find('=', 5);
+					if (RangeStartPos != std::string::npos)
+					{
+						RangeStartPos++;
+						while (RangeValue[RangeStartPos] == ' ')
+						{
+							RangeStartPos++;
+						}
+						RequestedContentLength = 0;
+
+						while (RangeStartPos < RangeValue.length())
+						{
+							size_t RangeEnd = RangeValue.find_first_of(", \r\n", RangeStartPos);
+							if (RangeEnd == std::string::npos)
+							{
+								RangeEnd = RangeValue.length();
+							}
+
+							std::string_view RangeString   = RangeValue.substr(RangeStartPos, RangeEnd - RangeStartPos);
+							size_t			 RangeSplitPos = RangeString.find('-');
+							if (RangeSplitPos != std::string::npos)
+							{
+								std::optional<size_t> RequestedRangeStart = ParseInt<size_t>(RangeString.substr(0, RangeSplitPos));
+								std::optional<size_t> RequestedRangeEnd	  = ParseInt<size_t>(RangeString.substr(RangeSplitPos + 1));
+								if (RequestedRangeStart.has_value() && RequestedRangeEnd.has_value())
+								{
+									RequestedContentLength += RequestedRangeEnd.value() - 1;
+								}
+							}
+							RangeStartPos = RangeEnd;
+							while (RangeStartPos != RangeValue.length() &&
+								   (RangeValue[RangeStartPos] == ',' || RangeValue[RangeStartPos] == ' '))
+							{
+								RangeStartPos++;
+							}
+						}
+					}
+				}
+			}
+
+			cpr::Response Response;
+			{
+				std::vector<std::pair<std::string, std::string>> ReceivedHeaders;
+				auto											 HeaderCallback = [&](std::string header, intptr_t) {
+					const std::pair<std::string_view, std::string_view> Header = detail::GetHeaderKeyAndValue(header);
+					if (Header.first == "Content-Length"sv)
+					{
+						std::optional<size_t> ContentLength = ParseInt<size_t>(Header.second);
+						if (ContentLength.has_value())
+						{
+							if (ContentLength.value() > m_ConnectionSettings.MaximumInMemoryDownloadSize)
+							{
+								PayloadFile = std::make_unique<detail::TempPayloadFile>();
+								std::error_code Ec = PayloadFile->Open(TempFolderPath, ContentLength.value());
+								if (Ec)
+								{
+									ZEN_WARN("Failed to create temp file in '{}' for HttpClient::Download. Reason: {}",
+											 TempFolderPath.string(),
+											 Ec.message());
+									PayloadFile.reset();
+								}
+							}
+							else
+							{
+								PayloadString.reserve(ContentLength.value());
+							}
+						}
+					}
+					else if (Header.first == "Content-Type")
+					{
+						IsMultiRangeResponse = BoundaryParser.Init(Header.second);
+						if (!IsMultiRangeResponse)
+						{
+							ContentType = ParseContentType(Header.second);
+						}
+					}
+					else if (Header.first == "Content-Range")
+					{
+						if (!IsMultiRangeResponse)
+						{
+							std::pair<uint64_t, uint64_t> Range = detail::ParseContentRange(Header.second);
+							if (Range.second != 0)
+							{
+								BoundaryParser.Boundaries.push_back(HttpClient::Response::MultipartBoundary{.OffsetInPayload = 0,
+																																						.RangeOffset = Range.first,
+																																						.RangeLength = Range.second,
+																																						.ContentType = ContentType});
+							}
+						}
+					}
+					if (!Header.first.empty())
+					{
+						ReceivedHeaders.emplace_back(std::move(Header));
+					}
+					return 1;
+				};
+
+				Session Sess = AllocSession(m_BaseUri, Url, m_ConnectionSettings, AdditionalHeader, {}, m_SessionId, GetAccessToken());
+				Response	 = Sess.Download(cpr::WriteCallback{DownloadCallback}, cpr::HeaderCallback{HeaderCallback});
+				for (const std::pair<std::string, std::string>& H : ReceivedHeaders)
+				{
+					Response.header.insert_or_assign(H.first, H.second);
+				}
+			}
+			if (m_ConnectionSettings.AllowResume)
+			{
+				auto SupportsRanges = [](const cpr::Response& Response) -> bool {
+					if (Response.header.find("Content-Range") != Response.header.end())
+					{
+						return true;
+					}
+					if (auto It = Response.header.find("Accept-Ranges"); It != Response.header.end())
+					{
+						return It->second == "bytes"sv;
+					}
+					return false;
+				};
+
+				auto ShouldResume = [&SupportsRanges, &IsMultiRangeResponse](const cpr::Response& Response) -> bool {
+					if (IsMultiRangeResponse)
+					{
+						return false;
+					}
+					if (ShouldRetry(Response))
+					{
+						return SupportsRanges(Response);
+					}
+					return false;
+				};
+
+				if (ShouldResume(Response))
+				{
+					auto It = Response.header.find("Content-Length");
+					if (It != Response.header.end())
+					{
+						uint64_t ContentLength = RequestedContentLength;
+						if (ContentLength == uint64_t(-1))
+						{
+							if (auto ParsedContentLength = ParseInt<int64_t>(It->second); ParsedContentLength.has_value())
+							{
+								ContentLength = ParsedContentLength.value();
+							}
+						}
+
+						std::vector<std::pair<std::string, std::string>> ReceivedHeaders;
+
+						auto HeaderCallback = [&](std::string header, intptr_t) {
+							const std::pair<std::string_view, std::string_view> Header = detail::GetHeaderKeyAndValue(header);
+							if (!Header.first.empty())
+							{
+								ReceivedHeaders.emplace_back(std::move(Header));
+							}
+
+							if (Header.first == "Content-Range"sv)
+							{
+								if (Header.second.starts_with("bytes "sv))
+								{
+									size_t RangeStartEnd = Header.second.find('-', 6);
+									if (RangeStartEnd != std::string::npos)
+									{
+										const auto Start = ParseInt<uint64_t>(Header.second.substr(6, RangeStartEnd - 6));
+										if (Start)
+										{
+											uint64_t DownloadedSize = PayloadFile ? PayloadFile->GetSize() : PayloadString.length();
+											if (Start.value() == DownloadedSize)
+											{
+												return 1;
+											}
+											else if (Start.value() > DownloadedSize)
+											{
+												return 0;
+											}
+											if (PayloadFile)
+											{
+												PayloadFile->ResetWritePos(Start.value());
+											}
+											else
+											{
+												PayloadString = PayloadString.substr(0, Start.value());
+											}
+											return 1;
+										}
+									}
+								}
+								return 0;
+							}
+							return 1;
+						};
+
+						KeyValueMap HeadersWithRange(AdditionalHeader);
+						do
+						{
+							uint64_t DownloadedSize = PayloadFile ? PayloadFile->GetSize() : PayloadString.length();
+
+							std::string Range = fmt::format("bytes={}-{}", DownloadedSize, DownloadedSize + ContentLength - 1);
+							if (auto RangeIt = HeadersWithRange.Entries.find("Range"); RangeIt != HeadersWithRange.Entries.end())
+							{
+								if (RangeIt->second == Range)
+								{
+									// If we didn't make any progress, abort
+									break;
+								}
+							}
+							HeadersWithRange.Entries.insert_or_assign("Range", Range);
+
+							Session Sess =
+								AllocSession(m_BaseUri, Url, m_ConnectionSettings, HeadersWithRange, {}, m_SessionId, GetAccessToken());
+							Response = Sess.Download(cpr::WriteCallback{DownloadCallback}, cpr::HeaderCallback{HeaderCallback});
+							for (const std::pair<std::string, std::string>& H : ReceivedHeaders)
+							{
+								Response.header.insert_or_assign(H.first, H.second);
+							}
+							ReceivedHeaders.clear();
+						} while (ShouldResume(Response));
+					}
+				}
+			}
+
+			if (!PayloadString.empty())
+			{
+				Response.text = std::move(PayloadString);
+			}
+			return Response;
+		},
+		PayloadFile);
+
+	return CommonResponse(m_SessionId,
+						  std::move(Response),
+						  PayloadFile ? PayloadFile->DetachToIoBuffer() : IoBuffer{},
+						  std::move(BoundaryParser.Boundaries));
 }
 
 }  // namespace zen
diff --git a/src/zenhttp/clients/httpclientcpr.h b/src/zenhttp/clients/httpclientcpr.h
index 40af53b5d..cf2d3bd14 100644
--- a/src/zenhttp/clients/httpclientcpr.h
+++ b/src/zenhttp/clients/httpclientcpr.h
@@ -157,12 +157,16 @@ private:
 
 	bool ValidatePayload(cpr::Response& Response, std::unique_ptr<detail::TempPayloadFile>& PayloadFile);
 
-	HttpClient::Response CommonResponse(std::string_view SessionId, cpr::Response&& HttpResponse, IoBuffer&& Payload);
-
-	HttpClient::Response ResponseWithPayload(std::string_view		SessionId,
-											 cpr::Response&&		HttpResponse,
-											 const HttpResponseCode WorkResponseCode,
-											 IoBuffer&&				Payload);
+	HttpClient::Response CommonResponse(std::string_view									   SessionId,
+										cpr::Response&&										   HttpResponse,
+										IoBuffer&&											   Payload,
+										std::vector<HttpClient::Response::MultipartBoundary>&& BoundaryPositions = {});
+
+	HttpClient::Response ResponseWithPayload(std::string_view										SessionId,
+											 cpr::Response&&										HttpResponse,
+											 const HttpResponseCode									WorkResponseCode,
+											 IoBuffer&&												Payload,
+											 std::vector<HttpClient::Response::MultipartBoundary>&& BoundaryPositions);
 };
 
 }  // namespace zen
diff --git a/src/zenhttp/httpclient.cpp b/src/zenhttp/httpclient.cpp
index 078e27b34..998eb27ea 100644
--- a/src/zenhttp/httpclient.cpp
+++ b/src/zenhttp/httpclient.cpp
@@ -104,6 +104,47 @@ HttpClientBase::GetAccessToken()
 
 //////////////////////////////////////////////////////////////////////////
 
+std::vector<std::pair<uint64_t, uint64_t>>
+HttpClient::Response::GetRanges(std::span<const std::pair<uint64_t, uint64_t>> OffsetAndLengthPairs) const
+{
+	std::vector<std::pair<uint64_t, uint64_t>> Result;
+	Result.reserve(OffsetAndLengthPairs.size());
+	if (Ranges.empty())
+	{
+		for (const std::pair<uint64_t, uint64_t>& Range : OffsetAndLengthPairs)
+		{
+			Result.emplace_back(std::make_pair(Range.first, Range.second));
+		}
+		return Result;
+	}
+
+	auto BoundaryIt			   = Ranges.begin();
+	auto OffsetAndLengthPairIt = OffsetAndLengthPairs.begin();
+	while (OffsetAndLengthPairIt != OffsetAndLengthPairs.end())
+	{
+		uint64_t Offset = OffsetAndLengthPairIt->first;
+		uint64_t Length = OffsetAndLengthPairIt->second;
+		while (Offset >= BoundaryIt->RangeOffset + BoundaryIt->RangeLength)
+		{
+			BoundaryIt++;
+			if (BoundaryIt == Ranges.end())
+			{
+				throw std::runtime_error("HttpClient::Response can not fulfill requested range");
+			}
+		}
+		if (Offset + Length > BoundaryIt->RangeOffset + BoundaryIt->RangeLength || Offset < BoundaryIt->RangeOffset)
+		{
+			throw std::runtime_error("HttpClient::Response can not fulfill requested range");
+		}
+		uint64_t OffsetIntoRange	= Offset - BoundaryIt->RangeOffset;
+		uint64_t RangePayloadOffset = BoundaryIt->OffsetInPayload + OffsetIntoRange;
+		Result.emplace_back(std::make_pair(RangePayloadOffset, Length));
+
+		OffsetAndLengthPairIt++;
+	}
+	return Result;
+}
+
 CbObject
 HttpClient::Response::AsObject() const
 {
diff --git a/src/zenhttp/include/zenhttp/httpclient.h b/src/zenhttp/include/zenhttp/httpclient.h
index 336a3deee..41a7ce621 100644
--- a/src/zenhttp/include/zenhttp/httpclient.h
+++ b/src/zenhttp/include/zenhttp/httpclient.h
@@ -179,6 +179,20 @@ public:
 		// The elapsed time in seconds for the request to execute
 		double ElapsedSeconds;
 
+		struct MultipartBoundary
+		{
+			uint64_t		OffsetInPayload;
+			uint64_t		RangeOffset;
+			uint64_t		RangeLength;
+			HttpContentType ContentType;
+		};
+
+		// Ranges will map out all recevied ranges, both single and multi-range responses
+		// If no range was requested Ranges will be empty
+		std::vector<MultipartBoundary> Ranges;
+
+		std::vector<std::pair<uint64_t, uint64_t>> GetRanges(std::span<const std::pair<uint64_t, uint64_t>> OffsetAndLengthPairs) const;
+
 		// This contains any errors from the HTTP stack. It won't contain information on
 		// why the server responded with a non-success HTTP status, that may be gleaned
 		// from the response payload itself depending on what the server provides.