From 9768733eb7d34fff6f7cdf2e6a8049d4ffb954bb Mon Sep 17 00:00:00 2001 From: wolfbeast Date: Thu, 14 Nov 2019 09:46:28 +0100 Subject: Issue #1288 - Part 1b: Rewrite nsHTTPCompressConv. This also includes formatting changes. --- .../streamconv/converters/nsHTTPCompressConv.cpp | 735 +++++++++++---------- netwerk/streamconv/converters/nsHTTPCompressConv.h | 136 ++-- 2 files changed, 466 insertions(+), 405 deletions(-) (limited to 'netwerk/streamconv/converters') diff --git a/netwerk/streamconv/converters/nsHTTPCompressConv.cpp b/netwerk/streamconv/converters/nsHTTPCompressConv.cpp index 37b4b28b0..c35b0dcac 100644 --- a/netwerk/streamconv/converters/nsHTTPCompressConv.cpp +++ b/netwerk/streamconv/converters/nsHTTPCompressConv.cpp @@ -20,7 +20,7 @@ // brotli headers #include "state.h" -#include "decode.h" +#include "brotli/decode.h" namespace mozilla { namespace net { @@ -33,7 +33,8 @@ NS_IMPL_ISUPPORTS(nsHTTPCompressConv, nsIStreamConverter, nsIStreamListener, nsIRequestObserver, - nsICompressConvStats) + nsICompressConvStats, + nsIThreadRetargetableStreamListener) // nsFTPDirListingConv methods nsHTTPCompressConv::nsHTTPCompressConv() @@ -45,11 +46,14 @@ nsHTTPCompressConv::nsHTTPCompressConv() , mCheckHeaderDone(false) , mStreamEnded(false) , mStreamInitialized(false) + , mDummyStreamInitialised(false) + , d_stream{} , mLen(0) , hMode(0) , mSkipCount(0) , mFlags(0) , mDecodedDataLength(0) + , mMutex("nsHTTPCompressConv") { LOG(("nsHttpCompresssConv %p ctor\n", this)); if (NS_IsMainThread()) { @@ -60,8 +64,7 @@ nsHTTPCompressConv::nsHTTPCompressConv() } } -nsHTTPCompressConv::~nsHTTPCompressConv() -{ +nsHTTPCompressConv::~nsHTTPCompressConv() { LOG(("nsHttpCompresssConv %p dtor\n", this)); if (mInpBuffer) { free(mInpBuffer); @@ -74,63 +77,64 @@ nsHTTPCompressConv::~nsHTTPCompressConv() // For some reason we are not getting Z_STREAM_END. But this was also seen // for mozilla bug 198133. Need to handle this case. if (mStreamInitialized && !mStreamEnded) { - inflateEnd (&d_stream); + inflateEnd(&d_stream); } } NS_IMETHODIMP -nsHTTPCompressConv::GetDecodedDataLength(uint64_t *aDecodedDataLength) -{ - *aDecodedDataLength = mDecodedDataLength; - return NS_OK; +nsHTTPCompressConv::GetDecodedDataLength(uint64_t* aDecodedDataLength) { + *aDecodedDataLength = mDecodedDataLength; + return NS_OK; } NS_IMETHODIMP -nsHTTPCompressConv::AsyncConvertData(const char *aFromType, - const char *aToType, - nsIStreamListener *aListener, - nsISupports *aCtxt) -{ - if (!PL_strncasecmp(aFromType, HTTP_COMPRESS_TYPE, sizeof(HTTP_COMPRESS_TYPE)-1) || - !PL_strncasecmp(aFromType, HTTP_X_COMPRESS_TYPE, sizeof(HTTP_X_COMPRESS_TYPE)-1)) { +nsHTTPCompressConv::AsyncConvertData(const char* aFromType, const char* aToType, + nsIStreamListener* aListener, + nsISupports* aCtxt) { + if (!PL_strncasecmp(aFromType, HTTP_COMPRESS_TYPE, sizeof(HTTP_COMPRESS_TYPE) - 1) || + !PL_strncasecmp(aFromType, HTTP_X_COMPRESS_TYPE, sizeof(HTTP_X_COMPRESS_TYPE) - 1)) { mMode = HTTP_COMPRESS_COMPRESS; - } else if (!PL_strncasecmp(aFromType, HTTP_GZIP_TYPE, sizeof(HTTP_GZIP_TYPE)-1) || - !PL_strncasecmp(aFromType, HTTP_X_GZIP_TYPE, sizeof(HTTP_X_GZIP_TYPE)-1)) { + } else if (!PL_strncasecmp(aFromType, HTTP_GZIP_TYPE, sizeof(HTTP_GZIP_TYPE) - 1) || + !PL_strncasecmp(aFromType, HTTP_X_GZIP_TYPE, sizeof(HTTP_X_GZIP_TYPE) - 1)) { mMode = HTTP_COMPRESS_GZIP; - } else if (!PL_strncasecmp(aFromType, HTTP_DEFLATE_TYPE, sizeof(HTTP_DEFLATE_TYPE)-1)) { + } else if (!PL_strncasecmp(aFromType, HTTP_DEFLATE_TYPE, sizeof(HTTP_DEFLATE_TYPE) - 1)) { mMode = HTTP_COMPRESS_DEFLATE; - } else if (!PL_strncasecmp(aFromType, HTTP_BROTLI_TYPE, sizeof(HTTP_BROTLI_TYPE)-1)) { + } else if (!PL_strncasecmp(aFromType, HTTP_BROTLI_TYPE, sizeof(HTTP_BROTLI_TYPE) - 1)) { mMode = HTTP_COMPRESS_BROTLI; } - LOG(("nsHttpCompresssConv %p AsyncConvertData %s %s mode %d\n", - this, aFromType, aToType, mMode)); + LOG(("nsHttpCompresssConv %p AsyncConvertData %s %s mode %d\n", this, + aFromType, aToType, (CompressMode)mMode)); + MutexAutoLock lock(mMutex); // hook ourself up with the receiving listener. mListener = aListener; - mAsyncConvContext = aCtxt; return NS_OK; } NS_IMETHODIMP -nsHTTPCompressConv::OnStartRequest(nsIRequest* request, nsISupports *aContext) -{ +nsHTTPCompressConv::OnStartRequest(nsIRequest* request, nsISupports* aContext) { LOG(("nsHttpCompresssConv %p onstart\n", this)); - return mListener->OnStartRequest(request, aContext); + nsCOMPtr listener; + { + MutexAutoLock lock(mMutex); + listener = mListener; + } + return listener->OnStartRequest(request, aContext); } NS_IMETHODIMP -nsHTTPCompressConv::OnStopRequest(nsIRequest* request, nsISupports *aContext, - nsresult aStatus) -{ +nsHTTPCompressConv::OnStopRequest(nsIRequest* request, nsISupports* aContext, + nsresult aStatus) { nsresult status = aStatus; - LOG(("nsHttpCompresssConv %p onstop %x\n", this, aStatus)); - + LOG(("nsHttpCompresssConv %p onstop %" PRIx32 "\n", this, + static_cast(aStatus))); + // Framing integrity is enforced for content-encoding: gzip, but not for // content-encoding: deflate. Note that gzip vs deflate is NOT determined // by content sniffing but only via header. if (!mStreamEnded && NS_SUCCEEDED(status) && - (mFailUncleanStops && (mMode == HTTP_COMPRESS_GZIP)) ) { + (mFailUncleanStops && (mMode == HTTP_COMPRESS_GZIP))) { // This is not a clean end of gzip stream: the transfer is incomplete. status = NS_ERROR_NET_PARTIAL_TRANSFER; LOG(("nsHttpCompresssConv %p onstop partial gzip\n", this)); @@ -144,31 +148,40 @@ nsHTTPCompressConv::OnStopRequest(nsIRequest* request, nsISupports *aContext, if (fpChannel && !isPending) { fpChannel->ForcePending(true); } - if (mBrotli && (mBrotli->mTotalOut == 0) && !BrotliStateIsStreamEnd(&mBrotli->mState)) { + if (mBrotli && (mBrotli->mTotalOut == 0) && !mBrotli->mBrotliStateIsStreamEnd) { status = NS_ERROR_INVALID_CONTENT_ENCODING; } - LOG(("nsHttpCompresssConv %p onstop brotlihandler rv %x\n", this, status)); + LOG(("nsHttpCompresssConv %p onstop brotlihandler rv %" PRIx32 "\n", this, + static_cast(status))); if (fpChannel && !isPending) { fpChannel->ForcePending(false); } } - return mListener->OnStopRequest(request, aContext, status); -} + nsCOMPtr listener; + { + MutexAutoLock lock(mMutex); + listener = mListener; + } + return listener->OnStopRequest(request, aContext, status); +} -/* static */ nsresult -nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const char *dataIn, - uint32_t, uint32_t aAvail, uint32_t *countRead) -{ +/* static */ +nsresult nsHTTPCompressConv::BrotliHandler(nsIInputStream* stream, + void* closure, + const char* dataIn, + uint32_t, + uint32_t aAvail, + uint32_t* countRead) { MOZ_ASSERT(stream); - nsHTTPCompressConv *self = static_cast(closure); + nsHTTPCompressConv* self = static_cast(closure); *countRead = 0; - const size_t kOutSize = 128 * 1024; // just a chunk size, we call in a loop - uint8_t *outPtr; + const size_t kOutSize = 128 * 1024; // just a chunk size, we call in a loop + uint8_t* outPtr; size_t outSize; size_t avail = aAvail; - BrotliResult res; + BrotliDecoderResult res; if (!self->mBrotli) { *countRead = aAvail; @@ -186,15 +199,21 @@ nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const c outPtr = outBuffer.get(); // brotli api is documented in brotli/dec/decode.h and brotli/dec/decode.c - LOG(("nsHttpCompresssConv %p brotlihandler decompress %d\n", self, avail)); - res = ::BrotliDecompressStream( - &avail, reinterpret_cast(&dataIn), - &outSize, &outPtr, &self->mBrotli->mTotalOut, &self->mBrotli->mState); + LOG(("nsHttpCompresssConv %p brotlihandler decompress %zu\n", self, avail)); + size_t totalOut = self->mBrotli->mTotalOut; + res = ::BrotliDecoderDecompressStream( + &self->mBrotli->mState, &avail, + reinterpret_cast(&dataIn), &outSize, &outPtr, + &totalOut); outSize = kOutSize - outSize; - LOG(("nsHttpCompresssConv %p brotlihandler decompress rv=%x out=%d\n", - self, res, outSize)); - - if (res == BROTLI_RESULT_ERROR) { + self->mBrotli->mTotalOut = totalOut; + self->mBrotli->mBrotliStateIsStreamEnd = + BrotliDecoderIsFinished(&self->mBrotli->mState); + LOG(("nsHttpCompresssConv %p brotlihandler decompress rv=%" PRIx32 + " out=%zu\n", + self, static_cast(res), outSize)); + + if (res == BROTLI_DECODER_RESULT_ERROR) { LOG(("nsHttpCompressConv %p marking invalid encoding", self)); self->mBrotli->mStatus = NS_ERROR_INVALID_CONTENT_ENCODING; return self->mBrotli->mStatus; @@ -202,7 +221,7 @@ nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const c // in 'the current implementation' brotli must consume everything before // asking for more input - if (res == BROTLI_RESULT_NEEDS_MORE_INPUT) { + if (res == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) { MOZ_ASSERT(!avail); if (avail) { LOG(("nsHttpCompressConv %p did not consume all input", self)); @@ -214,22 +233,23 @@ nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const c nsresult rv = self->do_OnDataAvailable(self->mBrotli->mRequest, self->mBrotli->mContext, self->mBrotli->mSourceOffset, - reinterpret_cast(outBuffer.get()), + reinterpret_cast(outBuffer.get()), outSize); - LOG(("nsHttpCompressConv %p BrotliHandler ODA rv=%x", self, rv)); + LOG(("nsHttpCompressConv %p BrotliHandler ODA rv=%" PRIx32, self, + static_cast(rv))); if (NS_FAILED(rv)) { self->mBrotli->mStatus = rv; return self->mBrotli->mStatus; } } - if (res == BROTLI_RESULT_SUCCESS || - res == BROTLI_RESULT_NEEDS_MORE_INPUT) { + if (res == BROTLI_DECODER_RESULT_SUCCESS || + res == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) { *countRead = aAvail; return NS_OK; } - MOZ_ASSERT (res == BROTLI_RESULT_NEEDS_MORE_OUTPUT); - } while (res == BROTLI_RESULT_NEEDS_MORE_OUTPUT); + MOZ_ASSERT(res == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT); + } while (res == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT); self->mBrotli->mStatus = NS_ERROR_UNEXPECTED; return self->mBrotli->mStatus; @@ -237,11 +257,10 @@ nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const c NS_IMETHODIMP nsHTTPCompressConv::OnDataAvailable(nsIRequest* request, - nsISupports *aContext, - nsIInputStream *iStr, + nsISupports* aContext, + nsIInputStream* iStr, uint64_t aSourceOffset, - uint32_t aCount) -{ + uint32_t aCount) { nsresult rv = NS_ERROR_INVALID_CONTENT_ENCODING; uint32_t streamLen = aCount; LOG(("nsHttpCompressConv %p OnDataAvailable %d", this, aCount)); @@ -260,206 +279,216 @@ nsHTTPCompressConv::OnDataAvailable(nsIRequest* request, } switch (mMode) { - case HTTP_COMPRESS_GZIP: - streamLen = check_header(iStr, streamLen, &rv); + case HTTP_COMPRESS_GZIP: + streamLen = check_header(iStr, streamLen, &rv); - if (rv != NS_OK) { - return rv; - } + if (rv != NS_OK) { + return rv; + } - if (streamLen == 0) { - return NS_OK; - } + if (streamLen == 0) { + return NS_OK; + } - MOZ_FALLTHROUGH; + MOZ_FALLTHROUGH; - case HTTP_COMPRESS_DEFLATE: + case HTTP_COMPRESS_DEFLATE: - if (mInpBuffer != nullptr && streamLen > mInpBufferLen) { - mInpBuffer = (unsigned char *) realloc(mInpBuffer, mInpBufferLen = streamLen); + if (mInpBuffer != nullptr && streamLen > mInpBufferLen) { + unsigned char* originalInpBuffer = mInpBuffer; + if (!(mInpBuffer = (unsigned char*)realloc(originalInpBuffer, mInpBufferLen = streamLen))) { + free(originalInpBuffer); + } + + if (mOutBufferLen < streamLen * 2) { + unsigned char* originalOutBuffer = mOutBuffer; + if (!(mOutBuffer = (unsigned char*)realloc(mOutBuffer, mOutBufferLen = streamLen * 3))) { + free(originalOutBuffer); + } + } - if (mOutBufferLen < streamLen * 2) { - mOutBuffer = (unsigned char *) realloc(mOutBuffer, mOutBufferLen = streamLen * 3); + if (mInpBuffer == nullptr || mOutBuffer == nullptr) { + return NS_ERROR_OUT_OF_MEMORY; + } } - if (mInpBuffer == nullptr || mOutBuffer == nullptr) { - return NS_ERROR_OUT_OF_MEMORY; + if (mInpBuffer == nullptr) { + mInpBuffer = (unsigned char*)malloc(mInpBufferLen = streamLen); } - } - if (mInpBuffer == nullptr) { - mInpBuffer = (unsigned char *) malloc(mInpBufferLen = streamLen); - } + if (mOutBuffer == nullptr) { + mOutBuffer = (unsigned char*)malloc(mOutBufferLen = streamLen * 3); + } - if (mOutBuffer == nullptr) { - mOutBuffer = (unsigned char *) malloc(mOutBufferLen = streamLen * 3); - } + if (mInpBuffer == nullptr || mOutBuffer == nullptr) { + return NS_ERROR_OUT_OF_MEMORY; + } - if (mInpBuffer == nullptr || mOutBuffer == nullptr) { - return NS_ERROR_OUT_OF_MEMORY; - } + uint32_t unused; + iStr->Read((char*)mInpBuffer, streamLen, &unused); - uint32_t unused; - iStr->Read((char *)mInpBuffer, streamLen, &unused); + if (mMode == HTTP_COMPRESS_DEFLATE) { + if (!mStreamInitialized) { + memset(&d_stream, 0, sizeof(d_stream)); - if (mMode == HTTP_COMPRESS_DEFLATE) { - if (!mStreamInitialized) { - memset(&d_stream, 0, sizeof (d_stream)); + if (inflateInit(&d_stream) != Z_OK) { + return NS_ERROR_FAILURE; + } - if (inflateInit(&d_stream) != Z_OK) { - return NS_ERROR_FAILURE; + mStreamInitialized = true; } - - mStreamInitialized = true; - } - d_stream.next_in = mInpBuffer; - d_stream.avail_in = (uInt)streamLen; - - mDummyStreamInitialised = false; - for (;;) { - d_stream.next_out = mOutBuffer; - d_stream.avail_out = (uInt)mOutBufferLen; - - int code = inflate(&d_stream, Z_NO_FLUSH); - unsigned bytesWritten = (uInt)mOutBufferLen - d_stream.avail_out; - - if (code == Z_STREAM_END) { - if (bytesWritten) { - rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char *)mOutBuffer, bytesWritten); - if (NS_FAILED (rv)) { - return rv; + d_stream.next_in = mInpBuffer; + d_stream.avail_in = (uInt)streamLen; + + mDummyStreamInitialised = false; + for (;;) { + d_stream.next_out = mOutBuffer; + d_stream.avail_out = (uInt)mOutBufferLen; + + int code = inflate(&d_stream, Z_NO_FLUSH); + unsigned bytesWritten = (uInt)mOutBufferLen - d_stream.avail_out; + + if (code == Z_STREAM_END) { + if (bytesWritten) { + rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char*)mOutBuffer, bytesWritten); + if (NS_FAILED(rv)) { + return rv; + } } - } - inflateEnd(&d_stream); - mStreamEnded = true; - break; - } else if (code == Z_OK) { - if (bytesWritten) { - rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char *)mOutBuffer, bytesWritten); - if (NS_FAILED (rv)) { - return rv; + inflateEnd(&d_stream); + mStreamEnded = true; + break; + } else if (code == Z_OK) { + if (bytesWritten) { + rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char*)mOutBuffer, bytesWritten); + if (NS_FAILED(rv)) { + return rv; + } } - } - } else if (code == Z_BUF_ERROR) { - if (bytesWritten) { - rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char *)mOutBuffer, bytesWritten); - if (NS_FAILED (rv)) { - return rv; + } else if (code == Z_BUF_ERROR) { + if (bytesWritten) { + rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char*)mOutBuffer, bytesWritten); + if (NS_FAILED(rv)) { + return rv; + } } - } - break; - } else if (code == Z_DATA_ERROR) { - // some servers (notably Apache with mod_deflate) don't generate zlib headers - // insert a dummy header and try again - static char dummy_head[2] = - { - 0x8 + 0x7 * 0x10, - (((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF, + break; + } else if (code == Z_DATA_ERROR) { + // some servers (notably Apache with mod_deflate) don't generate + // zlib headers insert a dummy header and try again + static char dummy_head[2] = { + 0x8 + 0x7 * 0x10, + (((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF, }; - inflateReset(&d_stream); - d_stream.next_in = (Bytef*) dummy_head; - d_stream.avail_in = sizeof(dummy_head); + inflateReset(&d_stream); + d_stream.next_in = (Bytef*)dummy_head; + d_stream.avail_in = sizeof(dummy_head); - code = inflate(&d_stream, Z_NO_FLUSH); - if (code != Z_OK) { - return NS_ERROR_FAILURE; - } + code = inflate(&d_stream, Z_NO_FLUSH); + if (code != Z_OK) { + return NS_ERROR_FAILURE; + } - // stop an endless loop caused by non-deflate data being labelled as deflate - if (mDummyStreamInitialised) { - NS_WARNING("endless loop detected" - " - invalid deflate"); + // stop an endless loop caused by non-deflate data being labelled as + // deflate + if (mDummyStreamInitialised) { + NS_WARNING( + "endless loop detected" + " - invalid deflate"); + return NS_ERROR_INVALID_CONTENT_ENCODING; + } + mDummyStreamInitialised = true; + // reset stream pointers to our original data + d_stream.next_in = mInpBuffer; + d_stream.avail_in = (uInt)streamLen; + } else { return NS_ERROR_INVALID_CONTENT_ENCODING; } - mDummyStreamInitialised = true; - // reset stream pointers to our original data - d_stream.next_in = mInpBuffer; - d_stream.avail_in = (uInt)streamLen; - } else { - return NS_ERROR_INVALID_CONTENT_ENCODING; - } - } /* for */ - } else { - if (!mStreamInitialized) { - memset(&d_stream, 0, sizeof (d_stream)); + } /* for */ + } else { + if (!mStreamInitialized) { + memset(&d_stream, 0, sizeof(d_stream)); - if (inflateInit2(&d_stream, -MAX_WBITS) != Z_OK) { - return NS_ERROR_FAILURE; - } + if (inflateInit2(&d_stream, -MAX_WBITS) != Z_OK) { + return NS_ERROR_FAILURE; + } - mStreamInitialized = true; - } + mStreamInitialized = true; + } - d_stream.next_in = mInpBuffer; - d_stream.avail_in = (uInt)streamLen; + d_stream.next_in = mInpBuffer; + d_stream.avail_in = (uInt)streamLen; - for (;;) { - d_stream.next_out = mOutBuffer; - d_stream.avail_out = (uInt)mOutBufferLen; + for (;;) { + d_stream.next_out = mOutBuffer; + d_stream.avail_out = (uInt)mOutBufferLen; - int code = inflate (&d_stream, Z_NO_FLUSH); - unsigned bytesWritten = (uInt)mOutBufferLen - d_stream.avail_out; + int code = inflate(&d_stream, Z_NO_FLUSH); + unsigned bytesWritten = (uInt)mOutBufferLen - d_stream.avail_out; - if (code == Z_STREAM_END) { - if (bytesWritten) { - rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char *)mOutBuffer, bytesWritten); - if (NS_FAILED (rv)) { - return rv; + if (code == Z_STREAM_END) { + if (bytesWritten) { + rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char*)mOutBuffer, bytesWritten); + if (NS_FAILED(rv)) { + return rv; + } } - } - inflateEnd(&d_stream); - mStreamEnded = true; - break; - } else if (code == Z_OK) { - if (bytesWritten) { - rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char *)mOutBuffer, bytesWritten); - if (NS_FAILED (rv)) { - return rv; + inflateEnd(&d_stream); + mStreamEnded = true; + break; + } else if (code == Z_OK) { + if (bytesWritten) { + rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char*)mOutBuffer, bytesWritten); + if (NS_FAILED(rv)) { + return rv; + } } - } - } else if (code == Z_BUF_ERROR) { - if (bytesWritten) { - rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char *)mOutBuffer, bytesWritten); - if (NS_FAILED (rv)) { - return rv; + } else if (code == Z_BUF_ERROR) { + if (bytesWritten) { + rv = do_OnDataAvailable(request, aContext, aSourceOffset, (char*)mOutBuffer, bytesWritten); + if (NS_FAILED(rv)) { + return rv; + } } + break; + } else { + return NS_ERROR_INVALID_CONTENT_ENCODING; } - break; - } else { - return NS_ERROR_INVALID_CONTENT_ENCODING; - } - } /* for */ - } /* gzip */ - break; + } /* for */ + } /* gzip */ + break; - case HTTP_COMPRESS_BROTLI: - { - if (!mBrotli) { - mBrotli = new BrotliWrapper(); - } + case HTTP_COMPRESS_BROTLI: { + if (!mBrotli) { + mBrotli = new BrotliWrapper(); + } - mBrotli->mRequest = request; - mBrotli->mContext = aContext; - mBrotli->mSourceOffset = aSourceOffset; + mBrotli->mRequest = request; + mBrotli->mContext = nullptr; + mBrotli->mSourceOffset = aSourceOffset; - uint32_t countRead; - rv = iStr->ReadSegments(BrotliHandler, this, streamLen, &countRead); - if (NS_SUCCEEDED(rv)) { - rv = mBrotli->mStatus; - } - if (NS_FAILED(rv)) { - return rv; - } - } - break; + uint32_t countRead; + rv = iStr->ReadSegments(BrotliHandler, this, streamLen, &countRead); + if (NS_SUCCEEDED(rv)) { + rv = mBrotli->mStatus; + } + if (NS_FAILED(rv)) { + return rv; + } + } break; - default: - rv = mListener->OnDataAvailable(request, aContext, iStr, aSourceOffset, aCount); - if (NS_FAILED (rv)) { - return rv; - } + default: + nsCOMPtr listener; + { + MutexAutoLock lock(mMutex); + listener = mListener; + } + rv = listener->OnDataAvailable(request, aContext, iStr, aSourceOffset, aCount); + if (NS_FAILED(rv)) { + return rv; + } } /* switch */ return NS_OK; @@ -468,20 +497,19 @@ nsHTTPCompressConv::OnDataAvailable(nsIRequest* request, // XXX/ruslan: need to implement this too NS_IMETHODIMP -nsHTTPCompressConv::Convert(nsIInputStream *aFromStream, - const char *aFromType, - const char *aToType, - nsISupports *aCtxt, - nsIInputStream **_retval) -{ +nsHTTPCompressConv::Convert(nsIInputStream* aFromStream, + const char* aFromType, + const char* aToType, + nsISupports* aCtxt, + nsIInputStream** _retval) { return NS_ERROR_NOT_IMPLEMENTED; } -nsresult -nsHTTPCompressConv::do_OnDataAvailable(nsIRequest* request, - nsISupports *context, uint64_t offset, - const char *buffer, uint32_t count) -{ +nsresult nsHTTPCompressConv::do_OnDataAvailable(nsIRequest* request, + nsISupports* context, + uint64_t offset, + const char* buffer, + uint32_t count) { if (!mStream) { mStream = do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID); NS_ENSURE_STATE(mStream); @@ -489,8 +517,12 @@ nsHTTPCompressConv::do_OnDataAvailable(nsIRequest* request, mStream->ShareData(buffer, count); - nsresult rv = mListener->OnDataAvailable(request, context, mStream, - offset, count); + nsCOMPtr listener; + { + MutexAutoLock lock(mMutex); + listener = mListener; + } + nsresult rv = listener->OnDataAvailable(request, context, mStream, offset, count); // Make sure the stream no longer references |buffer| in case our listener // is crazy enough to try to read from |mStream| after ODA. @@ -500,19 +532,27 @@ nsHTTPCompressConv::do_OnDataAvailable(nsIRequest* request, return rv; } -#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ -#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */ -#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ -#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ -#define COMMENT 0x10 /* bit 4 set: file comment present */ -#define RESERVED 0xE0 /* bits 5..7: reserved */ +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ +#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */ +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define COMMENT 0x10 /* bit 4 set: file comment present */ +#define RESERVED 0xE0 /* bits 5..7: reserved */ static unsigned gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */ -uint32_t -nsHTTPCompressConv::check_header(nsIInputStream *iStr, uint32_t streamLen, nsresult *rs) -{ - enum { GZIP_INIT = 0, GZIP_OS, GZIP_EXTRA0, GZIP_EXTRA1, GZIP_EXTRA2, GZIP_ORIG, GZIP_COMMENT, GZIP_CRC }; +uint32_t nsHTTPCompressConv::check_header(nsIInputStream* iStr, + uint32_t streamLen, nsresult* rs) { + enum { + GZIP_INIT = 0, + GZIP_OS, + GZIP_EXTRA0, + GZIP_EXTRA1, + GZIP_EXTRA2, + GZIP_ORIG, + GZIP_COMMENT, + GZIP_CRC + }; char c; *rs = NS_OK; @@ -523,134 +563,147 @@ nsHTTPCompressConv::check_header(nsIInputStream *iStr, uint32_t streamLen, nsres while (streamLen) { switch (hMode) { - case GZIP_INIT: - uint32_t unused; - iStr->Read(&c, 1, &unused); - streamLen--; - - if (mSkipCount == 0 && ((unsigned)c & 0377) != gz_magic[0]) { - *rs = NS_ERROR_INVALID_CONTENT_ENCODING; - return 0; - } - - if (mSkipCount == 1 && ((unsigned)c & 0377) != gz_magic[1]) { - *rs = NS_ERROR_INVALID_CONTENT_ENCODING; - return 0; - } + case GZIP_INIT: + uint32_t unused; + iStr->Read(&c, 1, &unused); + streamLen--; - if (mSkipCount == 2 && ((unsigned)c & 0377) != Z_DEFLATED) { - *rs = NS_ERROR_INVALID_CONTENT_ENCODING; - return 0; - } + if (mSkipCount == 0 && ((unsigned)c & 0377) != gz_magic[0]) { + *rs = NS_ERROR_INVALID_CONTENT_ENCODING; + return 0; + } - mSkipCount++; - if (mSkipCount == 4) { - mFlags = (unsigned) c & 0377; - if (mFlags & RESERVED) { + if (mSkipCount == 1 && ((unsigned)c & 0377) != gz_magic[1]) { *rs = NS_ERROR_INVALID_CONTENT_ENCODING; return 0; } - hMode = GZIP_OS; - mSkipCount = 0; - } - break; - case GZIP_OS: - iStr->Read(&c, 1, &unused); - streamLen--; - mSkipCount++; + if (mSkipCount == 2 && ((unsigned)c & 0377) != Z_DEFLATED) { + *rs = NS_ERROR_INVALID_CONTENT_ENCODING; + return 0; + } - if (mSkipCount == 6) { - hMode = GZIP_EXTRA0; - } - break; + mSkipCount++; + if (mSkipCount == 4) { + mFlags = (unsigned)c & 0377; + if (mFlags & RESERVED) { + *rs = NS_ERROR_INVALID_CONTENT_ENCODING; + return 0; + } + hMode = GZIP_OS; + mSkipCount = 0; + } + break; - case GZIP_EXTRA0: - if (mFlags & EXTRA_FIELD) { + case GZIP_OS: iStr->Read(&c, 1, &unused); streamLen--; - mLen = (uInt) c & 0377; - hMode = GZIP_EXTRA1; - } else { - hMode = GZIP_ORIG; - } - break; + mSkipCount++; - case GZIP_EXTRA1: - iStr->Read(&c, 1, &unused); - streamLen--; - mLen |= ((uInt) c & 0377) << 8; - mSkipCount = 0; - hMode = GZIP_EXTRA2; - break; + if (mSkipCount == 6) { + hMode = GZIP_EXTRA0; + } + break; + + case GZIP_EXTRA0: + if (mFlags & EXTRA_FIELD) { + iStr->Read(&c, 1, &unused); + streamLen--; + mLen = (uInt)c & 0377; + hMode = GZIP_EXTRA1; + } else { + hMode = GZIP_ORIG; + } + break; - case GZIP_EXTRA2: - if (mSkipCount == mLen) { - hMode = GZIP_ORIG; - } else { + case GZIP_EXTRA1: iStr->Read(&c, 1, &unused); streamLen--; - mSkipCount++; - } - break; + mLen |= ((uInt)c & 0377) << 8; + mSkipCount = 0; + hMode = GZIP_EXTRA2; + break; - case GZIP_ORIG: - if (mFlags & ORIG_NAME) { - iStr->Read(&c, 1, &unused); - streamLen--; - if (c == 0) - hMode = GZIP_COMMENT; - } else { - hMode = GZIP_COMMENT; - } - break; + case GZIP_EXTRA2: + if (mSkipCount == mLen) { + hMode = GZIP_ORIG; + } else { + iStr->Read(&c, 1, &unused); + streamLen--; + mSkipCount++; + } + break; - case GZIP_COMMENT: - if (mFlags & COMMENT) { - iStr->Read(&c, 1, &unused); - streamLen--; - if (c == 0) { + case GZIP_ORIG: + if (mFlags & ORIG_NAME) { + iStr->Read(&c, 1, &unused); + streamLen--; + if (c == 0) hMode = GZIP_COMMENT; + } else { + hMode = GZIP_COMMENT; + } + break; + + case GZIP_COMMENT: + if (mFlags & COMMENT) { + iStr->Read(&c, 1, &unused); + streamLen--; + if (c == 0) { + hMode = GZIP_CRC; + mSkipCount = 0; + } + } else { hMode = GZIP_CRC; mSkipCount = 0; } - } else { - hMode = GZIP_CRC; - mSkipCount = 0; - } - break; - - case GZIP_CRC: - if (mFlags & HEAD_CRC) { - iStr->Read(&c, 1, &unused); - streamLen--; - mSkipCount++; - if (mSkipCount == 2) { + break; + + case GZIP_CRC: + if (mFlags & HEAD_CRC) { + iStr->Read(&c, 1, &unused); + streamLen--; + mSkipCount++; + if (mSkipCount == 2) { + mCheckHeaderDone = true; + return streamLen; + } + } else { mCheckHeaderDone = true; return streamLen; } - } else { - mCheckHeaderDone = true; - return streamLen; - } - break; + break; } } return streamLen; } -} // namespace net -} // namespace mozilla +NS_IMETHODIMP +nsHTTPCompressConv::CheckListenerChain() { + nsCOMPtr listener; + { + MutexAutoLock lock(mMutex); + listener = do_QueryInterface(mListener); + } -nsresult -NS_NewHTTPCompressConv(mozilla::net::nsHTTPCompressConv **aHTTPCompressConv) -{ - NS_PRECONDITION(aHTTPCompressConv != nullptr, "null ptr"); + if (!listener) { + return NS_ERROR_NO_INTERFACE; + } + + return listener->CheckListenerChain(); +} + +} // namespace net +} // namespace mozilla + +nsresult NS_NewHTTPCompressConv( + mozilla::net::nsHTTPCompressConv** aHTTPCompressConv) { + MOZ_ASSERT(aHTTPCompressConv != nullptr, "null ptr"); if (!aHTTPCompressConv) { return NS_ERROR_NULL_POINTER; } RefPtr outVal = - new mozilla::net::nsHTTPCompressConv(); + new mozilla::net::nsHTTPCompressConv(); if (!outVal) { return NS_ERROR_OUT_OF_MEMORY; } diff --git a/netwerk/streamconv/converters/nsHTTPCompressConv.h b/netwerk/streamconv/converters/nsHTTPCompressConv.h index 38889a8f7..6721a1e34 100644 --- a/netwerk/streamconv/converters/nsHTTPCompressConv.h +++ b/netwerk/streamconv/converters/nsHTTPCompressConv.h @@ -4,13 +4,16 @@ * 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/. */ -#if !defined (__nsHTTPCompressConv__h__) -#define __nsHTTPCompressConv__h__ 1 +#if !defined(__nsHTTPCompressConv__h__) +#define __nsHTTPCompressConv__h__ 1 #include "nsIStreamConverter.h" #include "nsICompressConvStats.h" +#include "nsIThreadRetargetableStreamListener.h" #include "nsCOMPtr.h" #include "nsAutoPtr.h" +#include "mozilla/Atomics.h" +#include "mozilla/Mutex.h" #include "zlib.h" @@ -30,20 +33,19 @@ class nsIStringInputStream; {0xab, 0xf4, 0x07, 0x98, 0x61, 0x51, 0x02, 0x2d} \ } - -#define HTTP_DEFLATE_TYPE "deflate" -#define HTTP_GZIP_TYPE "gzip" -#define HTTP_X_GZIP_TYPE "x-gzip" -#define HTTP_COMPRESS_TYPE "compress" -#define HTTP_X_COMPRESS_TYPE "x-compress" -#define HTTP_BROTLI_TYPE "br" -#define HTTP_IDENTITY_TYPE "identity" -#define HTTP_UNCOMPRESSED_TYPE "uncompressed" +#define HTTP_DEFLATE_TYPE "deflate" +#define HTTP_GZIP_TYPE "gzip" +#define HTTP_X_GZIP_TYPE "x-gzip" +#define HTTP_COMPRESS_TYPE "compress" +#define HTTP_X_COMPRESS_TYPE "x-compress" +#define HTTP_BROTLI_TYPE "br" +#define HTTP_IDENTITY_TYPE "identity" +#define HTTP_UNCOMPRESSED_TYPE "uncompressed" namespace mozilla { namespace net { -typedef enum { +typedef enum { HTTP_COMPRESS_GZIP, HTTP_COMPRESS_DEFLATE, HTTP_COMPRESS_COMPRESS, @@ -51,82 +53,88 @@ typedef enum { HTTP_COMPRESS_IDENTITY } CompressMode; -class BrotliWrapper -{ +class BrotliWrapper { public: BrotliWrapper() - : mTotalOut(0) - , mStatus(NS_OK) - { - BrotliStateInit(&mState); - } - ~BrotliWrapper() - { - BrotliStateCleanup(&mState); + : mTotalOut(0), + mStatus(NS_OK), + mBrotliStateIsStreamEnd(false), + mRequest(nullptr), + mContext(nullptr), + mSourceOffset(0) { + BrotliDecoderStateInit(&mState, 0, 0, 0); } + ~BrotliWrapper() { BrotliDecoderStateCleanup(&mState); } - BrotliState mState; - size_t mTotalOut; - nsresult mStatus; + BrotliDecoderState mState; + Atomic mTotalOut; + nsresult mStatus; + Atomic mBrotliStateIsStreamEnd; - nsIRequest *mRequest; - nsISupports *mContext; - uint64_t mSourceOffset; + nsIRequest* mRequest; + nsISupports* mContext; + uint64_t mSourceOffset; }; -class nsHTTPCompressConv - : public nsIStreamConverter - , public nsICompressConvStats -{ - public: +class nsHTTPCompressConv : public nsIStreamConverter, + public nsICompressConvStats, + public nsIThreadRetargetableStreamListener { +public: // nsISupports methods - NS_DECL_THREADSAFE_ISUPPORTS - NS_DECL_NSIREQUESTOBSERVER - NS_DECL_NSISTREAMLISTENER - NS_DECL_NSICOMPRESSCONVSTATS + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSICOMPRESSCONVSTATS + NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER // nsIStreamConverter methods - NS_DECL_NSISTREAMCONVERTER + NS_DECL_NSISTREAMCONVERTER - nsHTTPCompressConv (); + nsHTTPCompressConv(); private: - virtual ~nsHTTPCompressConv (); + virtual ~nsHTTPCompressConv(); + + nsCOMPtr mListener; // this guy gets the converted data via his OnDataAvailable () + Atomic mMode; - nsCOMPtr mListener; // this guy gets the converted data via his OnDataAvailable () - CompressMode mMode; + unsigned char* mOutBuffer; + unsigned char* mInpBuffer; - unsigned char *mOutBuffer; - unsigned char *mInpBuffer; + uint32_t mOutBufferLen; + uint32_t mInpBufferLen; - uint32_t mOutBufferLen; - uint32_t mInpBufferLen; + nsAutoPtr mBrotli; - nsAutoPtr mBrotli; + nsCOMPtr mStream; - nsCOMPtr mAsyncConvContext; - nsCOMPtr mStream; + static nsresult BrotliHandler(nsIInputStream* stream, + void* closure, + const char* dataIn, + uint32_t, + uint32_t avail, + uint32_t* countRead); - static nsresult - BrotliHandler(nsIInputStream *stream, void *closure, const char *dataIn, - uint32_t, uint32_t avail, uint32_t *countRead); + nsresult do_OnDataAvailable(nsIRequest* request, + nsISupports* aContext, + uint64_t aSourceOffset, + const char* buffer, + uint32_t aCount); - nsresult do_OnDataAvailable (nsIRequest *request, nsISupports *aContext, - uint64_t aSourceOffset, const char *buffer, - uint32_t aCount); + bool mCheckHeaderDone; + Atomic mStreamEnded; + bool mStreamInitialized; + bool mDummyStreamInitialised; + bool mFailUncleanStops; - bool mCheckHeaderDone; - bool mStreamEnded; - bool mStreamInitialized; - bool mDummyStreamInitialised; - bool mFailUncleanStops; + z_stream d_stream; + unsigned mLen, hMode, mSkipCount, mFlags; - z_stream d_stream; - unsigned mLen, hMode, mSkipCount, mFlags; + uint32_t check_header(nsIInputStream* iStr, uint32_t streamLen, nsresult* rv); - uint32_t check_header (nsIInputStream *iStr, uint32_t streamLen, nsresult *rv); + Atomic mDecodedDataLength; - uint32_t mDecodedDataLength; + mutable mozilla::Mutex mMutex; }; } // namespace net -- cgit v1.2.3