summaryrefslogtreecommitdiffstats
path: root/netwerk/base/nsMIMEInputStream.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /netwerk/base/nsMIMEInputStream.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'netwerk/base/nsMIMEInputStream.cpp')
-rw-r--r--netwerk/base/nsMIMEInputStream.cpp390
1 files changed, 390 insertions, 0 deletions
diff --git a/netwerk/base/nsMIMEInputStream.cpp b/netwerk/base/nsMIMEInputStream.cpp
new file mode 100644
index 000000000..ce1188ea0
--- /dev/null
+++ b/netwerk/base/nsMIMEInputStream.cpp
@@ -0,0 +1,390 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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/. */
+
+/**
+ * The MIME stream separates headers and a datastream. It also allows
+ * automatic creation of the content-length header.
+ */
+
+#include "ipc/IPCMessageUtils.h"
+
+#include "nsCOMPtr.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIMultiplexInputStream.h"
+#include "nsIMIMEInputStream.h"
+#include "nsISeekableStream.h"
+#include "nsIStringStream.h"
+#include "nsString.h"
+#include "nsMIMEInputStream.h"
+#include "nsIClassInfoImpl.h"
+#include "nsIIPCSerializableInputStream.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+
+using namespace mozilla::ipc;
+using mozilla::Maybe;
+
+class nsMIMEInputStream : public nsIMIMEInputStream,
+ public nsISeekableStream,
+ public nsIIPCSerializableInputStream
+{
+ virtual ~nsMIMEInputStream();
+
+public:
+ nsMIMEInputStream();
+
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIINPUTSTREAM
+ NS_DECL_NSIMIMEINPUTSTREAM
+ NS_DECL_NSISEEKABLESTREAM
+ NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM
+
+ nsresult Init();
+
+private:
+
+ void InitStreams();
+
+ struct MOZ_STACK_CLASS ReadSegmentsState {
+ nsCOMPtr<nsIInputStream> mThisStream;
+ nsWriteSegmentFun mWriter;
+ void* mClosure;
+ };
+ static nsresult ReadSegCb(nsIInputStream* aIn, void* aClosure,
+ const char* aFromRawSegment, uint32_t aToOffset,
+ uint32_t aCount, uint32_t *aWriteCount);
+
+ nsCString mHeaders;
+ nsCOMPtr<nsIStringInputStream> mHeaderStream;
+
+ nsCString mContentLength;
+ nsCOMPtr<nsIStringInputStream> mCLStream;
+
+ nsCOMPtr<nsIInputStream> mData;
+ nsCOMPtr<nsIMultiplexInputStream> mStream;
+ bool mAddContentLength;
+ bool mStartedReading;
+};
+
+NS_IMPL_ADDREF(nsMIMEInputStream)
+NS_IMPL_RELEASE(nsMIMEInputStream)
+
+NS_IMPL_CLASSINFO(nsMIMEInputStream, nullptr, nsIClassInfo::THREADSAFE,
+ NS_MIMEINPUTSTREAM_CID)
+
+NS_IMPL_QUERY_INTERFACE_CI(nsMIMEInputStream,
+ nsIMIMEInputStream,
+ nsIInputStream,
+ nsISeekableStream,
+ nsIIPCSerializableInputStream)
+NS_IMPL_CI_INTERFACE_GETTER(nsMIMEInputStream,
+ nsIMIMEInputStream,
+ nsIInputStream,
+ nsISeekableStream)
+
+nsMIMEInputStream::nsMIMEInputStream() : mAddContentLength(false),
+ mStartedReading(false)
+{
+}
+
+nsMIMEInputStream::~nsMIMEInputStream()
+{
+}
+
+nsresult nsMIMEInputStream::Init()
+{
+ nsresult rv = NS_OK;
+ mStream = do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1",
+ &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mHeaderStream = do_CreateInstance("@mozilla.org/io/string-input-stream;1",
+ &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mCLStream = do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = mStream->AppendStream(mHeaderStream);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = mStream->AppendStream(mCLStream);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMIMEInputStream::GetAddContentLength(bool *aAddContentLength)
+{
+ *aAddContentLength = mAddContentLength;
+ return NS_OK;
+}
+NS_IMETHODIMP
+nsMIMEInputStream::SetAddContentLength(bool aAddContentLength)
+{
+ NS_ENSURE_FALSE(mStartedReading, NS_ERROR_FAILURE);
+ mAddContentLength = aAddContentLength;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMIMEInputStream::AddHeader(const char *aName, const char *aValue)
+{
+ NS_ENSURE_FALSE(mStartedReading, NS_ERROR_FAILURE);
+ mHeaders.Append(aName);
+ mHeaders.AppendLiteral(": ");
+ mHeaders.Append(aValue);
+ mHeaders.AppendLiteral("\r\n");
+
+ // Just in case someone somehow uses our stream, lets at least
+ // let the stream have a valid pointer. The stream will be properly
+ // initialized in nsMIMEInputStream::InitStreams
+ mHeaderStream->ShareData(mHeaders.get(), 0);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMIMEInputStream::SetData(nsIInputStream *aStream)
+{
+ NS_ENSURE_FALSE(mStartedReading, NS_ERROR_FAILURE);
+ // Remove the old stream if there is one
+ if (mData)
+ mStream->RemoveStream(2);
+
+ mData = aStream;
+ if (aStream)
+ mStream->AppendStream(mData);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMIMEInputStream::GetData(nsIInputStream **aStream)
+{
+ NS_ENSURE_ARG_POINTER(aStream);
+ *aStream = mData;
+ NS_IF_ADDREF(*aStream);
+ return NS_OK;
+}
+
+// set up the internal streams
+void nsMIMEInputStream::InitStreams()
+{
+ NS_ASSERTION(!mStartedReading,
+ "Don't call initStreams twice without rewinding");
+
+ mStartedReading = true;
+
+ // We'll use the content-length stream to add the final \r\n
+ if (mAddContentLength) {
+ uint64_t cl = 0;
+ if (mData) {
+ mData->Available(&cl);
+ }
+ mContentLength.AssignLiteral("Content-Length: ");
+ mContentLength.AppendInt(cl);
+ mContentLength.AppendLiteral("\r\n\r\n");
+ }
+ else {
+ mContentLength.AssignLiteral("\r\n");
+ }
+ mCLStream->ShareData(mContentLength.get(), -1);
+ mHeaderStream->ShareData(mHeaders.get(), -1);
+}
+
+
+
+#define INITSTREAMS \
+if (!mStartedReading) { \
+ InitStreams(); \
+}
+
+// Reset mStartedReading when Seek-ing to start
+NS_IMETHODIMP
+nsMIMEInputStream::Seek(int32_t whence, int64_t offset)
+{
+ nsresult rv;
+ nsCOMPtr<nsISeekableStream> stream = do_QueryInterface(mStream);
+ if (whence == NS_SEEK_SET && offset == 0) {
+ rv = stream->Seek(whence, offset);
+ if (NS_SUCCEEDED(rv))
+ mStartedReading = false;
+ }
+ else {
+ INITSTREAMS;
+ rv = stream->Seek(whence, offset);
+ }
+
+ return rv;
+}
+
+// Proxy ReadSegments since we need to be a good little nsIInputStream
+NS_IMETHODIMP nsMIMEInputStream::ReadSegments(nsWriteSegmentFun aWriter,
+ void *aClosure, uint32_t aCount,
+ uint32_t *_retval)
+{
+ INITSTREAMS;
+ ReadSegmentsState state;
+ state.mThisStream = this;
+ state.mWriter = aWriter;
+ state.mClosure = aClosure;
+ return mStream->ReadSegments(ReadSegCb, &state, aCount, _retval);
+}
+
+nsresult
+nsMIMEInputStream::ReadSegCb(nsIInputStream* aIn, void* aClosure,
+ const char* aFromRawSegment,
+ uint32_t aToOffset, uint32_t aCount,
+ uint32_t *aWriteCount)
+{
+ ReadSegmentsState* state = (ReadSegmentsState*)aClosure;
+ return (state->mWriter)(state->mThisStream,
+ state->mClosure,
+ aFromRawSegment,
+ aToOffset,
+ aCount,
+ aWriteCount);
+}
+
+/**
+ * Forward everything else to the mStream after calling InitStreams()
+ */
+
+// nsIInputStream
+NS_IMETHODIMP nsMIMEInputStream::Close(void) { INITSTREAMS; return mStream->Close(); }
+NS_IMETHODIMP nsMIMEInputStream::Available(uint64_t *_retval) { INITSTREAMS; return mStream->Available(_retval); }
+NS_IMETHODIMP nsMIMEInputStream::Read(char * buf, uint32_t count, uint32_t *_retval) { INITSTREAMS; return mStream->Read(buf, count, _retval); }
+NS_IMETHODIMP nsMIMEInputStream::IsNonBlocking(bool *aNonBlocking) { INITSTREAMS; return mStream->IsNonBlocking(aNonBlocking); }
+
+// nsISeekableStream
+NS_IMETHODIMP nsMIMEInputStream::Tell(int64_t *_retval)
+{
+ INITSTREAMS;
+ nsCOMPtr<nsISeekableStream> stream = do_QueryInterface(mStream);
+ return stream->Tell(_retval);
+}
+NS_IMETHODIMP nsMIMEInputStream::SetEOF(void) {
+ INITSTREAMS;
+ nsCOMPtr<nsISeekableStream> stream = do_QueryInterface(mStream);
+ return stream->SetEOF();
+}
+
+
+/**
+ * Factory method used by do_CreateInstance
+ */
+
+nsresult
+nsMIMEInputStreamConstructor(nsISupports *outer, REFNSIID iid, void **result)
+{
+ *result = nullptr;
+
+ if (outer)
+ return NS_ERROR_NO_AGGREGATION;
+
+ nsMIMEInputStream *inst = new nsMIMEInputStream();
+ if (!inst)
+ return NS_ERROR_OUT_OF_MEMORY;
+
+ NS_ADDREF(inst);
+
+ nsresult rv = inst->Init();
+ if (NS_FAILED(rv)) {
+ NS_RELEASE(inst);
+ return rv;
+ }
+
+ rv = inst->QueryInterface(iid, result);
+ NS_RELEASE(inst);
+
+ return rv;
+}
+
+void
+nsMIMEInputStream::Serialize(InputStreamParams& aParams,
+ FileDescriptorArray& aFileDescriptors)
+{
+ MIMEInputStreamParams params;
+
+ if (mData) {
+ nsCOMPtr<nsIInputStream> stream = do_QueryInterface(mData);
+ MOZ_ASSERT(stream);
+
+ InputStreamParams wrappedParams;
+ SerializeInputStream(stream, wrappedParams, aFileDescriptors);
+
+ NS_ASSERTION(wrappedParams.type() != InputStreamParams::T__None,
+ "Wrapped stream failed to serialize!");
+
+ params.optionalStream() = wrappedParams;
+ }
+ else {
+ params.optionalStream() = mozilla::void_t();
+ }
+
+ params.headers() = mHeaders;
+ params.contentLength() = mContentLength;
+ params.startedReading() = mStartedReading;
+ params.addContentLength() = mAddContentLength;
+
+ aParams = params;
+}
+
+bool
+nsMIMEInputStream::Deserialize(const InputStreamParams& aParams,
+ const FileDescriptorArray& aFileDescriptors)
+{
+ if (aParams.type() != InputStreamParams::TMIMEInputStreamParams) {
+ NS_ERROR("Received unknown parameters from the other process!");
+ return false;
+ }
+
+ const MIMEInputStreamParams& params =
+ aParams.get_MIMEInputStreamParams();
+ const OptionalInputStreamParams& wrappedParams = params.optionalStream();
+
+ mHeaders = params.headers();
+ mContentLength = params.contentLength();
+ mStartedReading = params.startedReading();
+
+ // nsMIMEInputStream::Init() already appended mHeaderStream & mCLStream
+ mHeaderStream->ShareData(mHeaders.get(),
+ mStartedReading ? mHeaders.Length() : 0);
+ mCLStream->ShareData(mContentLength.get(),
+ mStartedReading ? mContentLength.Length() : 0);
+
+ nsCOMPtr<nsIInputStream> stream;
+ if (wrappedParams.type() == OptionalInputStreamParams::TInputStreamParams) {
+ stream = DeserializeInputStream(wrappedParams.get_InputStreamParams(),
+ aFileDescriptors);
+ if (!stream) {
+ NS_WARNING("Failed to deserialize wrapped stream!");
+ return false;
+ }
+
+ mData = stream;
+
+ if (NS_FAILED(mStream->AppendStream(mData))) {
+ NS_WARNING("Failed to append stream!");
+ return false;
+ }
+ }
+ else {
+ NS_ASSERTION(wrappedParams.type() == OptionalInputStreamParams::Tvoid_t,
+ "Unknown type for OptionalInputStreamParams!");
+ }
+
+ mAddContentLength = params.addContentLength();
+
+ return true;
+}
+
+Maybe<uint64_t>
+nsMIMEInputStream::ExpectedSerializedLength()
+{
+ nsCOMPtr<nsIIPCSerializableInputStream> serializable = do_QueryInterface(mStream);
+ return serializable ? serializable->ExpectedSerializedLength() : Nothing();
+}
+