diff options
Diffstat (limited to 'netwerk/protocol/http/ObliviousHttpChannel.cpp')
| -rw-r--r-- | netwerk/protocol/http/ObliviousHttpChannel.cpp | 849 |
1 files changed, 849 insertions, 0 deletions
diff --git a/netwerk/protocol/http/ObliviousHttpChannel.cpp b/netwerk/protocol/http/ObliviousHttpChannel.cpp new file mode 100644 index 0000000000..3629b642ae --- /dev/null +++ b/netwerk/protocol/http/ObliviousHttpChannel.cpp @@ -0,0 +1,849 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=8 et tw=80 : */ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// HttpLog.h should generally be included first +#include "HttpLog.h" + +#include "ObliviousHttpChannel.h" + +#include "BinaryHttpRequest.h" +#include "nsIHttpHeaderVisitor.h" +#include "nsStringStream.h" + +namespace mozilla::net { + +NS_IMPL_ISUPPORTS(ObliviousHttpChannel, nsIChannel, nsIHttpChannel, + nsIHttpChannelInternal, nsIIdentChannel, nsIRequest, + nsIRequestObserver, nsIStreamListener, nsIUploadChannel2, + nsITimedChannel) + +ObliviousHttpChannel::ObliviousHttpChannel( + nsIURI* targetURI, const nsTArray<uint8_t>& encodedConfig, + nsIHttpChannel* innerChannel) + : mTargetURI(targetURI), + mEncodedConfig(encodedConfig.Clone()), + mInnerChannel(innerChannel), + mInnerChannelInternal(do_QueryInterface(innerChannel)), + mInnerChannelTimed(do_QueryInterface(innerChannel)) { + LOG(("ObliviousHttpChannel ctor [this=%p]", this)); + MOZ_ASSERT(mInnerChannel); + MOZ_ASSERT(mInnerChannelInternal); + MOZ_ASSERT(mInnerChannelTimed); +} + +ObliviousHttpChannel::~ObliviousHttpChannel() { + LOG(("ObliviousHttpChannel dtor [this=%p]", this)); +} + +//----------------------------------------------------------------------------- +// ObliviousHttpChannel::nsIHttpChannel +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +ObliviousHttpChannel::GetTopLevelContentWindowId(uint64_t* aWindowId) { + return mInnerChannel->GetTopLevelContentWindowId(aWindowId); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetTopLevelContentWindowId(uint64_t aWindowId) { + return mInnerChannel->SetTopLevelContentWindowId(aWindowId); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetBrowserId(uint64_t* aWindowId) { + return mInnerChannel->GetBrowserId(aWindowId); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetBrowserId(uint64_t aId) { + return mInnerChannel->SetBrowserId(aId); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetTransferSize(uint64_t* aTransferSize) { + return mInnerChannel->GetTransferSize(aTransferSize); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetRequestSize(uint64_t* aRequestSize) { + return mInnerChannel->GetRequestSize(aRequestSize); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetDecodedBodySize(uint64_t* aDecodedBodySize) { + return mInnerChannel->GetDecodedBodySize(aDecodedBodySize); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetRequestMethod(nsACString& aRequestMethod) { + aRequestMethod.Assign(mMethod); + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetRequestMethod(const nsACString& aRequestMethod) { + mMethod.Assign(aRequestMethod); + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetReferrerInfo(nsIReferrerInfo** aReferrerInfo) { + return mInnerChannel->GetReferrerInfo(aReferrerInfo); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetReferrerInfo(nsIReferrerInfo* aReferrerInfo) { + return mInnerChannel->SetReferrerInfo(aReferrerInfo); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetReferrerInfoWithoutClone( + nsIReferrerInfo* aReferrerInfo) { + return mInnerChannel->SetReferrerInfoWithoutClone(aReferrerInfo); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetRequestHeader(const nsACString& aHeader, + nsACString& _retval) { + _retval.Truncate(); + auto value = mHeaders.Lookup(aHeader); + if (!value) { + return NS_ERROR_NOT_AVAILABLE; + } + _retval.Assign(*value); + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetRequestHeader(const nsACString& aHeader, + const nsACString& aValue, bool aMerge) { + mHeaders.WithEntryHandle(aHeader, [&aValue, aMerge](auto&& entry) { + if (!entry) { + entry.Insert(aValue); + return; + } + if (!aMerge) { + entry.Update(aValue); + return; + } + nsAutoCString newValue(*entry); + newValue.AppendLiteral(", "); + newValue.Append(aValue); + entry.Update(newValue); + }); + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetNewReferrerInfo( + const nsACString& aUrl, nsIReferrerInfo::ReferrerPolicyIDL aPolicy, + bool aSendReferrer) { + return mInnerChannel->SetNewReferrerInfo(aUrl, aPolicy, aSendReferrer); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetEmptyRequestHeader(const nsACString& aHeader) { + return SetRequestHeader(aHeader, EmptyCString(), false); +} + +NS_IMETHODIMP +ObliviousHttpChannel::VisitRequestHeaders(nsIHttpHeaderVisitor* aVisitor) { + for (auto iter = mHeaders.ConstIter(); !iter.Done(); iter.Next()) { + nsresult rv = aVisitor->VisitHeader(iter.Key(), iter.Data()); + if (NS_FAILED(rv)) { + return rv; + } + } + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::VisitNonDefaultRequestHeaders( + nsIHttpHeaderVisitor* aVisitor) { + return mInnerChannel->VisitNonDefaultRequestHeaders(aVisitor); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetAllowSTS(bool* aAllowSTS) { + return mInnerChannel->GetAllowSTS(aAllowSTS); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetAllowSTS(bool aAllowSTS) { + return mInnerChannel->SetAllowSTS(aAllowSTS); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetRedirectionLimit(uint32_t* aRedirectionLimit) { + return mInnerChannel->GetRedirectionLimit(aRedirectionLimit); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetRedirectionLimit(uint32_t aRedirectionLimit) { + return mInnerChannel->SetRedirectionLimit(aRedirectionLimit); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetResponseStatus(uint32_t* aResponseStatus) { + if (!mBinaryHttpResponse) { + return NS_ERROR_NOT_AVAILABLE; + } + uint16_t responseStatus; + nsresult rv = mBinaryHttpResponse->GetStatus(&responseStatus); + if (NS_FAILED(rv)) { + return rv; + } + *aResponseStatus = responseStatus; + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetResponseStatusText(nsACString& aResponseStatusText) { + LOG(("ObliviousHttpChannel::GetResponseStatusText NOT IMPLEMENTED [this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetRequestSucceeded(bool* aRequestSucceeded) { + uint32_t responseStatus; + nsresult rv = GetResponseStatus(&responseStatus); + if (NS_FAILED(rv)) { + return rv; + } + *aRequestSucceeded = (responseStatus / 100) == 2; + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetIsMainDocumentChannel(bool* aValue) { + return mInnerChannel->GetIsMainDocumentChannel(aValue); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetIsMainDocumentChannel(bool aValue) { + return mInnerChannel->SetIsMainDocumentChannel(aValue); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetResponseHeader(const nsACString& header, + nsACString& _retval) { + if (!mBinaryHttpResponse) { + return NS_ERROR_NOT_AVAILABLE; + } + nsTArray<nsCString> responseHeaderNames; + nsTArray<nsCString> responseHeaderValues; + nsresult rv = mBinaryHttpResponse->GetHeaderNames(responseHeaderNames); + if (NS_FAILED(rv)) { + return rv; + } + rv = mBinaryHttpResponse->GetHeaderValues(responseHeaderValues); + if (NS_FAILED(rv)) { + return rv; + } + for (size_t i = 0; + i < responseHeaderNames.Length() && i < responseHeaderValues.Length(); + i++) { + if (responseHeaderNames[i].EqualsIgnoreCase(header)) { + _retval.Assign(responseHeaderValues[i]); + return NS_OK; + } + } + return NS_ERROR_NOT_AVAILABLE; +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetResponseHeader(const nsACString& header, + const nsACString& value, bool merge) { + LOG(("ObliviousHttpChannel::SetResponseHeader NOT IMPLEMENTED [this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::VisitResponseHeaders(nsIHttpHeaderVisitor* aVisitor) { + if (!mBinaryHttpResponse) { + return NS_ERROR_NOT_AVAILABLE; + } + nsTArray<nsCString> responseHeaderNames; + nsTArray<nsCString> responseHeaderValues; + nsresult rv = mBinaryHttpResponse->GetHeaderNames(responseHeaderNames); + if (NS_FAILED(rv)) { + return rv; + } + rv = mBinaryHttpResponse->GetHeaderValues(responseHeaderValues); + if (NS_FAILED(rv)) { + return rv; + } + for (size_t i = 0; + i < responseHeaderNames.Length() && i < responseHeaderValues.Length(); + i++) { + rv = aVisitor->VisitHeader(responseHeaderNames[i], responseHeaderValues[i]); + if (NS_FAILED(rv)) { + return rv; + } + } + return rv; +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetOriginalResponseHeader( + const nsACString& header, nsIHttpHeaderVisitor* aVisitor) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::VisitOriginalResponseHeaders( + nsIHttpHeaderVisitor* aVisitor) { + LOG( + ("ObliviousHttpChannel::VisitOriginalResponseHeaders NOT IMPLEMENTED " + "[this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::ShouldStripRequestBodyHeader(const nsACString& aMethod, + bool* aResult) { + LOG( + ("ObliviousHttpChannel::ShouldStripRequestBodyHeader NOT IMPLEMENTED " + "[this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::IsNoStoreResponse(bool* _retval) { + LOG(("ObliviousHttpChannel::IsNoStoreResponse NOT IMPLEMENTED [this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::IsNoCacheResponse(bool* _retval) { + LOG(("ObliviousHttpChannel::IsNoCacheResponse NOT IMPLEMENTED [this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::IsPrivateResponse(bool* _retval) { + LOG(("ObliviousHttpChannel::IsPrivateResponse NOT IMPLEMENTED [this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::RedirectTo(nsIURI* aNewURI) { + LOG(("ObliviousHttpChannel::RedirectTo NOT IMPLEMENTED [this=%p]", this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::UpgradeToSecure() { + LOG(("ObliviousHttpChannel::UpgradeToSecure NOT IMPLEMENTED [this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetRequestContextID(uint64_t* _retval) { + return mInnerChannel->GetRequestContextID(_retval); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetRequestContextID(uint64_t rcID) { + return mInnerChannel->SetRequestContextID(rcID); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetProtocolVersion(nsACString& aProtocolVersion) { + return mInnerChannel->GetProtocolVersion(aProtocolVersion); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetEncodedBodySize(uint64_t* aEncodedBodySize) { + LOG(("ObliviousHttpChannel::GetEncodedBodySize NOT IMPLEMENTED [this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::LogBlockedCORSRequest(const nsAString& aMessage, + const nsACString& aCategory, + bool aIsWarning) { + return mInnerChannel->LogBlockedCORSRequest(aMessage, aCategory, aIsWarning); +} + +NS_IMETHODIMP +ObliviousHttpChannel::LogMimeTypeMismatch(const nsACString& aMessageName, + bool aWarning, const nsAString& aURL, + const nsAString& aContentType) { + return mInnerChannel->LogMimeTypeMismatch(aMessageName, aWarning, aURL, + aContentType); +} + +void ObliviousHttpChannel::SetSource( + mozilla::UniquePtr<mozilla::ProfileChunkedBuffer> aSource) { + LOG(("ObliviousHttpChannel::SetSource NOT IMPLEMENTED [this=%p]", this)); + // NS_ERROR_NOT_IMPLEMENTED +} + +void ObliviousHttpChannel::SetConnectionInfo(nsHttpConnectionInfo* aCi) { + if (mInnerChannelInternal) { + mInnerChannelInternal->SetConnectionInfo(aCi); + } +} + +void ObliviousHttpChannel::DoDiagnosticAssertWhenOnStopNotCalledOnDestroy() { + if (mInnerChannelInternal) { + mInnerChannelInternal->DoDiagnosticAssertWhenOnStopNotCalledOnDestroy(); + } +} + +void ObliviousHttpChannel::DisableAltDataCache() { + if (mInnerChannelInternal) { + mInnerChannelInternal->DisableAltDataCache(); + } +} + +void ObliviousHttpChannel::SetAltDataForChild(bool aIsForChild) { + if (mInnerChannelInternal) { + mInnerChannelInternal->SetAltDataForChild(aIsForChild); + } +} + +void ObliviousHttpChannel::SetCorsPreflightParameters( + nsTArray<nsTString<char>> const& aUnsafeHeaders, + bool aShouldStripRequestBodyHeader) { + if (mInnerChannelInternal) { + mInnerChannelInternal->SetCorsPreflightParameters( + aUnsafeHeaders, aShouldStripRequestBodyHeader); + } +} + +//----------------------------------------------------------------------------- +// ObliviousHttpChannel::nsIChannel +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +ObliviousHttpChannel::GetOriginalURI(nsIURI** aOriginalURI) { + return mInnerChannel->GetOriginalURI(aOriginalURI); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetOriginalURI(nsIURI* aOriginalURI) { + return mInnerChannel->SetOriginalURI(aOriginalURI); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetURI(nsIURI** aURI) { + *aURI = do_AddRef(mTargetURI).take(); + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetOwner(nsISupports** aOwner) { + return mInnerChannel->GetOwner(aOwner); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetOwner(nsISupports* aOwner) { + return mInnerChannel->SetOwner(aOwner); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetNotificationCallbacks( + nsIInterfaceRequestor** aNotificationCallbacks) { + return mInnerChannel->GetNotificationCallbacks(aNotificationCallbacks); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetNotificationCallbacks( + nsIInterfaceRequestor* aNotificationCallbacks) { + return mInnerChannel->SetNotificationCallbacks(aNotificationCallbacks); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetSecurityInfo( + nsITransportSecurityInfo** aSecurityInfo) { + return mInnerChannel->GetSecurityInfo(aSecurityInfo); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetContentType(nsACString& aContentType) { + return GetResponseHeader("content-type"_ns, aContentType); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetContentType(const nsACString& aContentType) { + mContentType = aContentType; + return NS_OK; +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetContentCharset(nsACString& aContentCharset) { + return mInnerChannel->GetContentCharset(aContentCharset); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetContentCharset(const nsACString& aContentCharset) { + return mInnerChannel->SetContentCharset(aContentCharset); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetContentLength(int64_t* aContentLength) { + return mInnerChannel->GetContentLength(aContentLength); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetContentLength(int64_t aContentLength) { + return mInnerChannel->SetContentLength(aContentLength); +} + +NS_IMETHODIMP +ObliviousHttpChannel::Open(nsIInputStream** aStream) { + LOG(("ObliviousHttpChannel::Open NOT IMPLEMENTED [this=%p]", this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +ObliviousHttpChannel::AsyncOpen(nsIStreamListener* aListener) { + LOG(("ObliviousHttpChannel::AsyncOpen [this=%p, listener=%p]", this, + aListener)); + mStreamListener = aListener; + nsresult rv = mInnerChannel->SetRequestMethod("POST"_ns); + if (NS_FAILED(rv)) { + return rv; + } + rv = mInnerChannel->SetRequestHeader("Content-Type"_ns, + "message/ohttp-req"_ns, false); + if (NS_FAILED(rv)) { + return rv; + } + nsAutoCString scheme; + if (!mTargetURI) { + return NS_ERROR_NULL_POINTER; + } + rv = mTargetURI->GetScheme(scheme); + if (NS_FAILED(rv)) { + return rv; + } + nsAutoCString authority; + rv = mTargetURI->GetHostPort(authority); + if (NS_FAILED(rv)) { + return rv; + } + nsAutoCString path; + rv = mTargetURI->GetPathQueryRef(path); + if (NS_FAILED(rv)) { + return rv; + } + nsTArray<nsCString> headerNames; + nsTArray<nsCString> headerValues; + for (auto iter = mHeaders.ConstIter(); !iter.Done(); iter.Next()) { + headerNames.AppendElement(iter.Key()); + headerValues.AppendElement(iter.Data()); + } + if (!mContentType.IsEmpty() && !headerNames.Contains("Content-Type")) { + headerNames.AppendElement("Content-Type"_ns); + headerValues.AppendElement(mContentType); + } + nsCOMPtr<nsIBinaryHttp> bhttp( + do_GetService("@mozilla.org/network/binary-http;1")); + nsCOMPtr<nsIBinaryHttpRequest> bhttpRequest(new BinaryHttpRequest( + mMethod, scheme, authority, path, std::move(headerNames), + std::move(headerValues), std::move(mContent))); + nsTArray<uint8_t> encodedRequest; + rv = bhttp->EncodeRequest(bhttpRequest, encodedRequest); + if (NS_FAILED(rv)) { + return rv; + } + nsCOMPtr<nsIObliviousHttp> obliviousHttp( + do_GetService("@mozilla.org/network/oblivious-http;1")); + if (!obliviousHttp) { + return NS_ERROR_FAILURE; + } + rv = obliviousHttp->EncapsulateRequest(mEncodedConfig, encodedRequest, + getter_AddRefs(mEncapsulatedRequest)); + if (NS_FAILED(rv)) { + return rv; + } + nsTArray<uint8_t> encRequest; + rv = mEncapsulatedRequest->GetEncRequest(encRequest); + if (NS_FAILED(rv)) { + return rv; + } + nsCOMPtr<nsIUploadChannel2> uploadChannel(do_QueryInterface(mInnerChannel)); + if (!uploadChannel) { + return NS_ERROR_UNEXPECTED; + } + nsCOMPtr<nsIInputStream> uploadStream; + uint32_t streamLength = encRequest.Length(); + rv = NS_NewByteInputStream(getter_AddRefs(uploadStream), + std::move(encRequest)); + if (NS_FAILED(rv)) { + return rv; + } + rv = uploadChannel->ExplicitSetUploadStream( + uploadStream, "message/ohttp-req"_ns, streamLength, "POST"_ns, false); + if (NS_FAILED(rv)) { + return rv; + } + return mInnerChannel->AsyncOpen(this); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetCanceled(bool* aCanceled) { + return mInnerChannel->GetCanceled(aCanceled); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetContentDisposition(uint32_t* aContentDisposition) { + return mInnerChannel->GetContentDisposition(aContentDisposition); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetContentDisposition(uint32_t aContentDisposition) { + return mInnerChannel->SetContentDisposition(aContentDisposition); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetContentDispositionFilename( + nsAString& aContentDispositionFilename) { + return mInnerChannel->GetContentDispositionFilename( + aContentDispositionFilename); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetContentDispositionFilename( + const nsAString& aContentDispositionFilename) { + return mInnerChannel->SetContentDispositionFilename( + aContentDispositionFilename); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetContentDispositionHeader( + nsACString& aContentDispositionHeader) { + return mInnerChannel->GetContentDispositionHeader(aContentDispositionHeader); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetLoadInfo(nsILoadInfo** aLoadInfo) { + return mInnerChannel->GetLoadInfo(aLoadInfo); +} + +NS_IMETHODIMP +ObliviousHttpChannel::SetLoadInfo(nsILoadInfo* aLoadInfo) { + return mInnerChannel->SetLoadInfo(aLoadInfo); +} + +NS_IMETHODIMP +ObliviousHttpChannel::GetIsDocument(bool* aIsDocument) { + return mInnerChannel->GetIsDocument(aIsDocument); +} + +//----------------------------------------------------------------------------- +// ObliviousHttpChannel::nsIStreamListener +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +ObliviousHttpChannel::OnDataAvailable(nsIRequest* aRequest, + nsIInputStream* aStream, uint64_t aOffset, + uint32_t aCount) { + LOG( + ("ObliviousHttpChannel::OnDataAvailable [this=%p, request=%p, stream=%p, " + "offset=%" PRIu64 ", count=%u]", + this, aRequest, aStream, aOffset, aCount)); + if (aOffset != 0) { + return NS_ERROR_INVALID_ARG; + } + size_t oldLength = mRawResponse.Length(); + size_t newLength = oldLength + aCount; + if (newLength < oldLength) { // i.e., overflow + return NS_ERROR_FAILURE; + } + mRawResponse.SetCapacity(newLength); + mRawResponse.SetLengthAndRetainStorage(newLength); + void* dest = mRawResponse.Elements() + oldLength; + uint64_t written = 0; + nsresult rv = NS_ReadInputStreamToBuffer(aStream, &dest, aCount, &written); + if (NS_FAILED(rv)) { + return rv; + } + if (written != aCount) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +//----------------------------------------------------------------------------- +// ObliviousHttpChannel::nsIRequestObserver +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +ObliviousHttpChannel::OnStartRequest(nsIRequest* aRequest) { + LOG(("ObliviousHttpChannel::OnStartRequest [this=%p, request=%p]", this, + aRequest)); + return NS_OK; +} + +nsresult ObliviousHttpChannel::ProcessOnStopRequest() { + if (mRawResponse.IsEmpty()) { + return NS_OK; + } + nsCOMPtr<nsIObliviousHttp> obliviousHttp( + do_GetService("@mozilla.org/network/oblivious-http;1")); + if (!obliviousHttp) { + return NS_ERROR_FAILURE; + } + nsCOMPtr<nsIObliviousHttpClientResponse> response; + nsresult rv = mEncapsulatedRequest->GetResponse(getter_AddRefs(response)); + if (NS_FAILED(rv)) { + return rv; + } + nsTArray<uint8_t> decapsulated; + rv = response->Decapsulate(mRawResponse, decapsulated); + if (NS_FAILED(rv)) { + return rv; + } + nsCOMPtr<nsIBinaryHttp> bhttp( + do_GetService("@mozilla.org/network/binary-http;1")); + if (!bhttp) { + return NS_ERROR_FAILURE; + } + return bhttp->DecodeResponse(decapsulated, + getter_AddRefs(mBinaryHttpResponse)); +} + +void ObliviousHttpChannel::EmitOnDataAvailable() { + if (!mBinaryHttpResponse) { + return; + } + nsTArray<uint8_t> content; + nsresult rv = mBinaryHttpResponse->GetContent(content); + if (NS_FAILED(rv)) { + return; + } + if (content.IsEmpty()) { + return; + } + if (content.Length() > std::numeric_limits<uint32_t>::max()) { + return; + } + uint32_t contentLength = (uint32_t)content.Length(); + nsCOMPtr<nsIInputStream> contentStream; + rv = NS_NewByteInputStream(getter_AddRefs(contentStream), std::move(content)); + if (NS_FAILED(rv)) { + return; + } + rv = mStreamListener->OnDataAvailable(this, contentStream, 0, contentLength); + Unused << rv; +} + +NS_IMETHODIMP +ObliviousHttpChannel::OnStopRequest(nsIRequest* aRequest, + nsresult aStatusCode) { + LOG(("ObliviousHttpChannel::OnStopRequest [this=%p, request=%p, status=%u]", + this, aRequest, (uint32_t)aStatusCode)); + + auto releaseStreamListener = MakeScopeExit( + [self = RefPtr{this}]() mutable { self->mStreamListener = nullptr; }); + + if (NS_SUCCEEDED(aStatusCode)) { + bool requestSucceeded; + nsresult rv = mInnerChannel->GetRequestSucceeded(&requestSucceeded); + if (NS_SUCCEEDED(rv) && requestSucceeded) { + aStatusCode = ProcessOnStopRequest(); + } + } + Unused << mStreamListener->OnStartRequest(this); + if (NS_SUCCEEDED(aStatusCode)) { + EmitOnDataAvailable(); + } + Unused << mStreamListener->OnStopRequest(this, aStatusCode); + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// ObliviousHttpChannel::nsIUploadChannel2 +//----------------------------------------------------------------------------- + +NS_IMETHODIMP ObliviousHttpChannel::ExplicitSetUploadStream( + nsIInputStream* aStream, const nsACString& aContentType, + int64_t aContentLength, const nsACString& aMethod, bool aStreamHasHeaders) { + // This function should only be called before AsyncOpen. + if (mStreamListener) { + return NS_ERROR_IN_PROGRESS; + } + if (aMethod != "POST"_ns || aStreamHasHeaders) { + return NS_ERROR_INVALID_ARG; + } + mMethod.Assign(aMethod); + uint64_t available; + if (aContentLength < 0) { + nsresult rv = aStream->Available(&available); + if (NS_FAILED(rv)) { + return rv; + } + } else { + available = aContentLength; + } + if (available > std::numeric_limits<int64_t>::max()) { + return NS_ERROR_FAILURE; + } + mContent.SetCapacity(available); + mContent.SetLengthAndRetainStorage(available); + void* dest = mContent.Elements(); + uint64_t written = 0; + nsresult rv = + NS_ReadInputStreamToBuffer(aStream, &dest, (int64_t)available, &written); + if (NS_FAILED(rv)) { + return rv; + } + if (written != available) { + return NS_ERROR_FAILURE; + } + mContentType = aContentType; + return NS_OK; +} + +NS_IMETHODIMP ObliviousHttpChannel::GetUploadStreamHasHeaders( + bool* aUploadStreamHasHeaders) { + *aUploadStreamHasHeaders = false; + return NS_OK; +} + +NS_IMETHODIMP ObliviousHttpChannel::CloneUploadStream( + int64_t* aContentLength, nsIInputStream** _retval) { + LOG(("ObliviousHttpChannel::CloneUploadStream NOT IMPLEMENTED [this=%p]", + this)); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP ObliviousHttpChannel::SetClassicScriptHintCharset( + const nsAString& aClassicScriptHintCharset) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP ObliviousHttpChannel::GetClassicScriptHintCharset( + nsAString& aClassicScriptHintCharset) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP ObliviousHttpChannel::SetDocumentCharacterSet( + const nsAString& aDocumentCharacterSet) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP ObliviousHttpChannel::GetDocumentCharacterSet( + nsAString& aDocumenharacterSet) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +} // namespace mozilla::net |