Add m-esr52 at 52.6.0

1 files changed, 1121 insertions, 0 deletions

diff --git a/netwerk/streamconv/converters/nsMultiMixedConv.cpp b/netwerk/streamconv/converters/nsMultiMixedConv.cpp
new file mode 100644
index 000000000..4ebd61d9c
--- /dev/null
+++ b/netwerk/streamconv/converters/nsMultiMixedConv.cpp
@@ -0,0 +1,1121 @@
+/* -*- Mode: C++; tab-width: 2; 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/. */
+
+#include "nsMultiMixedConv.h"
+#include "plstr.h"
+#include "nsIHttpChannel.h"
+#include "nsNetCID.h"
+#include "nsMimeTypes.h"
+#include "nsIStringStream.h"
+#include "nsCRT.h"
+#include "nsIHttpChannelInternal.h"
+#include "nsURLHelper.h"
+#include "nsIStreamConverterService.h"
+#include "nsICacheInfoChannel.h"
+#include <algorithm>
+#include "nsContentSecurityManager.h"
+#include "nsHttp.h"
+#include "nsNetUtil.h"
+#include "nsIURI.h"
+#include "nsHttpHeaderArray.h"
+
+//
+// Helper function for determining the length of data bytes up to
+// the next multipart token.  A token is usually preceded by a LF
+// or CRLF delimiter.
+// 
+static uint32_t
+LengthToToken(const char *cursor, const char *token)
+{
+    uint32_t len = token - cursor;
+    // Trim off any LF or CRLF preceding the token
+    if (len && *(token-1) == '\n') {
+        --len;
+        if (len && *(token-2) == '\r')
+            --len;
+    }
+    return len;
+}
+
+nsPartChannel::nsPartChannel(nsIChannel *aMultipartChannel, uint32_t aPartID,
+                             nsIStreamListener* aListener) :
+  mMultipartChannel(aMultipartChannel),
+  mListener(aListener),
+  mStatus(NS_OK),
+  mContentLength(UINT64_MAX),
+  mIsByteRangeRequest(false),
+  mByteRangeStart(0),
+  mByteRangeEnd(0),
+  mPartID(aPartID),
+  mIsLastPart(false)
+{
+    // Inherit the load flags from the original channel...
+    mMultipartChannel->GetLoadFlags(&mLoadFlags);
+
+    mMultipartChannel->GetLoadGroup(getter_AddRefs(mLoadGroup));
+}
+
+nsPartChannel::~nsPartChannel()
+{
+}
+
+void nsPartChannel::InitializeByteRange(int64_t aStart, int64_t aEnd)
+{
+    mIsByteRangeRequest = true;
+    
+    mByteRangeStart = aStart;
+    mByteRangeEnd   = aEnd;
+}
+
+nsresult nsPartChannel::SendOnStartRequest(nsISupports* aContext)
+{
+    return mListener->OnStartRequest(this, aContext);
+}
+
+nsresult nsPartChannel::SendOnDataAvailable(nsISupports* aContext,
+                                            nsIInputStream* aStream,
+                                            uint64_t aOffset, uint32_t aLen)
+{
+    return mListener->OnDataAvailable(this, aContext, aStream, aOffset, aLen);
+}
+
+nsresult nsPartChannel::SendOnStopRequest(nsISupports* aContext,
+                                          nsresult aStatus)
+{
+    // Drop the listener
+    nsCOMPtr<nsIStreamListener> listener;
+    listener.swap(mListener);
+    return listener->OnStopRequest(this, aContext, aStatus);
+}
+
+void nsPartChannel::SetContentDisposition(const nsACString& aContentDispositionHeader)
+{
+    mContentDispositionHeader = aContentDispositionHeader;
+    nsCOMPtr<nsIURI> uri;
+    GetURI(getter_AddRefs(uri));
+    NS_GetFilenameFromDisposition(mContentDispositionFilename,
+                                  mContentDispositionHeader, uri);
+    mContentDisposition = NS_GetContentDispositionFromHeader(mContentDispositionHeader, this);
+}
+
+//
+// nsISupports implementation...
+//
+
+NS_IMPL_ADDREF(nsPartChannel)
+NS_IMPL_RELEASE(nsPartChannel)
+
+NS_INTERFACE_MAP_BEGIN(nsPartChannel)
+    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIChannel)
+    NS_INTERFACE_MAP_ENTRY(nsIRequest)
+    NS_INTERFACE_MAP_ENTRY(nsIChannel)
+    NS_INTERFACE_MAP_ENTRY(nsIByteRangeRequest)
+    NS_INTERFACE_MAP_ENTRY(nsIMultiPartChannel)
+NS_INTERFACE_MAP_END
+
+//
+// nsIRequest implementation...
+//
+
+NS_IMETHODIMP
+nsPartChannel::GetName(nsACString &aResult)
+{
+    return mMultipartChannel->GetName(aResult);
+}
+
+NS_IMETHODIMP
+nsPartChannel::IsPending(bool *aResult)
+{
+    // For now, consider the active lifetime of each part the same as
+    // the underlying multipart channel...  This is not exactly right,
+    // but it is good enough :-)
+    return mMultipartChannel->IsPending(aResult);
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetStatus(nsresult *aResult)
+{
+    nsresult rv = NS_OK;
+
+    if (NS_FAILED(mStatus)) {
+        *aResult = mStatus;
+    } else {
+        rv = mMultipartChannel->GetStatus(aResult);
+    }
+
+    return rv;
+}
+
+NS_IMETHODIMP
+nsPartChannel::Cancel(nsresult aStatus)
+{
+    // Cancelling an individual part must not cancel the underlying
+    // multipart channel...
+    // XXX but we should stop sending data for _this_ part channel!
+    mStatus = aStatus;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::Suspend(void)
+{
+    // Suspending an individual part must not suspend the underlying
+    // multipart channel...
+    // XXX why not?
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::Resume(void)
+{
+    // Resuming an individual part must not resume the underlying
+    // multipart channel...
+    // XXX why not?
+    return NS_OK;
+}
+
+//
+// nsIChannel implementation
+//
+
+NS_IMETHODIMP
+nsPartChannel::GetOriginalURI(nsIURI * *aURI)
+{
+    return mMultipartChannel->GetOriginalURI(aURI);
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetOriginalURI(nsIURI *aURI)
+{
+    return mMultipartChannel->SetOriginalURI(aURI);
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetURI(nsIURI * *aURI)
+{
+    return mMultipartChannel->GetURI(aURI);
+}
+
+NS_IMETHODIMP
+nsPartChannel::Open(nsIInputStream **result)
+{
+    // This channel cannot be opened!
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsPartChannel::Open2(nsIInputStream** aStream)
+{
+    nsCOMPtr<nsIStreamListener> listener;
+    nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return Open(aStream);
+}
+
+NS_IMETHODIMP
+nsPartChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
+{
+    // This channel cannot be opened!
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsPartChannel::AsyncOpen2(nsIStreamListener *aListener)
+{
+  nsCOMPtr<nsIStreamListener> listener = aListener;
+  nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return AsyncOpen(listener, nullptr);
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetLoadFlags(nsLoadFlags *aLoadFlags)
+{
+    *aLoadFlags = mLoadFlags;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetLoadFlags(nsLoadFlags aLoadFlags)
+{
+    mLoadFlags = aLoadFlags;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
+{
+    *aLoadGroup = mLoadGroup;
+    NS_IF_ADDREF(*aLoadGroup);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
+{
+    mLoadGroup = aLoadGroup;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetOwner(nsISupports* *aOwner)
+{
+    return mMultipartChannel->GetOwner(aOwner);
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetOwner(nsISupports* aOwner)
+{
+    return mMultipartChannel->SetOwner(aOwner);
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetLoadInfo(nsILoadInfo* *aLoadInfo)
+{
+    return mMultipartChannel->GetLoadInfo(aLoadInfo);
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetLoadInfo(nsILoadInfo* aLoadInfo)
+{
+    return mMultipartChannel->SetLoadInfo(aLoadInfo);
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aCallbacks)
+{
+    return mMultipartChannel->GetNotificationCallbacks(aCallbacks);
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aCallbacks)
+{
+    return mMultipartChannel->SetNotificationCallbacks(aCallbacks);
+}
+
+NS_IMETHODIMP 
+nsPartChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
+{
+    return mMultipartChannel->GetSecurityInfo(aSecurityInfo);
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetContentType(nsACString &aContentType)
+{
+    aContentType = mContentType;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetContentType(const nsACString &aContentType)
+{
+    bool dummy;
+    net_ParseContentType(aContentType, mContentType, mContentCharset, &dummy);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetContentCharset(nsACString &aContentCharset)
+{
+    aContentCharset = mContentCharset;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetContentCharset(const nsACString &aContentCharset)
+{
+    mContentCharset = aContentCharset;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetContentLength(int64_t *aContentLength)
+{
+    *aContentLength = mContentLength;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetContentLength(int64_t aContentLength)
+{
+    mContentLength = aContentLength;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetContentDisposition(uint32_t *aContentDisposition)
+{
+    if (mContentDispositionHeader.IsEmpty())
+        return NS_ERROR_NOT_AVAILABLE;
+
+    *aContentDisposition = mContentDisposition;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetContentDisposition(uint32_t aContentDisposition)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetContentDispositionFilename(nsAString &aContentDispositionFilename)
+{
+    if (mContentDispositionFilename.IsEmpty())
+        return NS_ERROR_NOT_AVAILABLE;
+
+    aContentDispositionFilename = mContentDispositionFilename;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::SetContentDispositionFilename(const nsAString &aContentDispositionFilename)
+{
+    return NS_ERROR_NOT_AVAILABLE;
+}
+
+
+NS_IMETHODIMP
+nsPartChannel::GetContentDispositionHeader(nsACString &aContentDispositionHeader)
+{
+    if (mContentDispositionHeader.IsEmpty())
+        return NS_ERROR_NOT_AVAILABLE;
+
+    aContentDispositionHeader = mContentDispositionHeader;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetPartID(uint32_t *aPartID)
+{
+    *aPartID = mPartID;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetIsLastPart(bool *aIsLastPart)
+{
+    *aIsLastPart = mIsLastPart;
+    return NS_OK;
+}
+
+//
+// nsIByteRangeRequest implementation...
+//
+
+NS_IMETHODIMP 
+nsPartChannel::GetIsByteRangeRequest(bool *aIsByteRangeRequest)
+{
+    *aIsByteRangeRequest = mIsByteRangeRequest;
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP 
+nsPartChannel::GetStartRange(int64_t *aStartRange)
+{
+    *aStartRange = mByteRangeStart;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsPartChannel::GetEndRange(int64_t *aEndRange)
+{
+    *aEndRange = mByteRangeEnd;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPartChannel::GetBaseChannel(nsIChannel ** aReturn)
+{
+    NS_ENSURE_ARG_POINTER(aReturn);
+
+    *aReturn = mMultipartChannel;
+    NS_IF_ADDREF(*aReturn);
+    return NS_OK;
+}
+
+// nsISupports implementation
+NS_IMPL_ISUPPORTS(nsMultiMixedConv,
+                  nsIStreamConverter,
+                  nsIStreamListener,
+                  nsIRequestObserver)
+
+
+// nsIStreamConverter implementation
+
+// No syncronous conversion at this time.
+NS_IMETHODIMP
+nsMultiMixedConv::Convert(nsIInputStream *aFromStream,
+                          const char *aFromType,
+                          const char *aToType,
+                          nsISupports *aCtxt, nsIInputStream **_retval) {
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+// Stream converter service calls this to initialize the actual stream converter (us).
+NS_IMETHODIMP
+nsMultiMixedConv::AsyncConvertData(const char *aFromType, const char *aToType,
+                                   nsIStreamListener *aListener, nsISupports *aCtxt) {
+    NS_ASSERTION(aListener && aFromType && aToType, "null pointer passed into multi mixed converter");
+
+    // hook up our final listener. this guy gets the various On*() calls we want to throw
+    // at him.
+    //
+    // WARNING: this listener must be able to handle multiple OnStartRequest, OnDataAvail()
+    //  and OnStopRequest() call combinations. We call of series of these for each sub-part
+    //  in the raw stream.
+    mFinalListener = aListener;
+
+    return NS_OK;
+}
+
+// AutoFree implementation to prevent memory leaks
+class AutoFree
+{
+public:
+  AutoFree() : mBuffer(nullptr) {}
+
+  explicit AutoFree(char *buffer) : mBuffer(buffer) {}
+
+  ~AutoFree() {
+    free(mBuffer);
+  }
+
+  AutoFree& operator=(char *buffer) {
+    mBuffer = buffer;
+    return *this;
+  }
+
+  operator char*() const {
+    return mBuffer;
+  }
+private:
+  char *mBuffer;
+};
+
+// nsIStreamListener implementation
+NS_IMETHODIMP
+nsMultiMixedConv::OnDataAvailable(nsIRequest *request, nsISupports *context,
+                                  nsIInputStream *inStr, uint64_t sourceOffset,
+                                  uint32_t count) {
+    nsresult rv = NS_OK;
+    AutoFree buffer(nullptr);
+    uint32_t bufLen = 0, read = 0;
+
+    NS_ASSERTION(request, "multimixed converter needs a request");
+
+    nsCOMPtr<nsIChannel> channel = do_QueryInterface(request, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    // fill buffer
+    {
+        bufLen = count + mBufLen;
+        NS_ENSURE_TRUE((bufLen >= count) && (bufLen >= mBufLen),
+                       NS_ERROR_FAILURE);
+        buffer = (char *) malloc(bufLen);
+        if (!buffer)
+            return NS_ERROR_OUT_OF_MEMORY;
+
+        if (mBufLen) {
+            // incorporate any buffered data into the parsing
+            memcpy(buffer, mBuffer, mBufLen);
+            free(mBuffer);
+            mBuffer = 0;
+            mBufLen = 0;
+        }
+        
+        rv = inStr->Read(buffer + (bufLen - count), count, &read);
+
+        if (NS_FAILED(rv) || read == 0) return rv;
+        NS_ASSERTION(read == count, "poor data size assumption");
+    }
+
+    char *cursor = buffer;
+
+    if (mFirstOnData) {
+        // this is the first OnData() for this request. some servers
+        // don't bother sending a token in the first "part." This is
+        // illegal, but we'll handle the case anyway by shoving the
+        // boundary token in for the server.
+        mFirstOnData = false;
+        NS_ASSERTION(!mBufLen, "this is our first time through, we can't have buffered data");
+        const char * token = mToken.get();
+
+        PushOverLine(cursor, bufLen);
+
+        bool needMoreChars = bufLen < mTokenLen + 2;
+        nsAutoCString firstBuffer(buffer, bufLen);
+        int32_t posCR = firstBuffer.Find("\r");
+
+        if (needMoreChars || (posCR == kNotFound)) {
+            // we don't have enough data yet to make this comparison.
+            // skip this check, and try again the next time OnData()
+            // is called.
+            mFirstOnData = true;
+        } else if (!PL_strnstr(cursor, token, mTokenLen + 2)) {
+            char *newBuffer = (char *) realloc(buffer, bufLen + mTokenLen + 1);
+            if (!newBuffer)
+                return NS_ERROR_OUT_OF_MEMORY;
+            buffer = newBuffer;
+
+            memmove(buffer + mTokenLen + 1, buffer, bufLen);
+            memcpy(buffer, token, mTokenLen);
+            buffer[mTokenLen] = '\n';
+
+            bufLen += (mTokenLen + 1);
+
+            // need to reset cursor to the buffer again (bug 100595)
+            cursor = buffer;
+        }
+    }
+
+    char *token = nullptr;
+
+    if (mProcessingHeaders) {
+        // we were not able to process all the headers
+        // for this "part" given the previous buffer given to 
+        // us in the previous OnDataAvailable callback.
+        bool done = false;
+        rv = ParseHeaders(channel, cursor, bufLen, &done);
+        if (NS_FAILED(rv)) return rv;
+
+        if (done) {
+            mProcessingHeaders = false;
+            rv = SendStart(channel);
+            if (NS_FAILED(rv)) return rv;
+        }
+    }
+
+    int32_t tokenLinefeed = 1;
+    while ( (token = FindToken(cursor, bufLen)) ) {
+
+        if (((token + mTokenLen + 1) < (cursor + bufLen)) &&
+            (*(token + mTokenLen + 1) == '-')) {
+            // This was the last delimiter so we can stop processing
+            rv = SendData(cursor, LengthToToken(cursor, token));
+            if (NS_FAILED(rv)) return rv;
+            if (mPartChannel) {
+                mPartChannel->SetIsLastPart();
+            }
+            return SendStop(NS_OK);
+        }
+
+        if (!mNewPart && token > cursor) {
+            // headers are processed, we're pushing data now.
+            NS_ASSERTION(!mProcessingHeaders, "we should be pushing raw data");
+            rv = SendData(cursor, LengthToToken(cursor, token));
+            bufLen -= token - cursor;
+            if (NS_FAILED(rv)) return rv;
+        }
+        // XXX else NS_ASSERTION(token == cursor, "?");
+        token += mTokenLen;
+        bufLen -= mTokenLen;
+        tokenLinefeed = PushOverLine(token, bufLen);
+
+        if (mNewPart) {
+            // parse headers
+            mNewPart = false;
+            cursor = token;
+            bool done = false;
+            rv = ParseHeaders(channel, cursor, bufLen, &done);
+            if (NS_FAILED(rv)) return rv;
+
+            if (done) {
+                rv = SendStart(channel);
+                if (NS_FAILED(rv)) return rv;
+            }
+            else {
+                // we haven't finished processing header info.
+                // we'll break out and try to process later.
+                mProcessingHeaders = true;
+                break;
+            }
+        }
+        else {
+            mNewPart = true;
+            // Reset state so we don't carry it over from part to part
+            mContentType.Truncate();
+            mContentLength = UINT64_MAX;
+            mContentDisposition.Truncate();
+            mIsByteRangeRequest = false;
+            mByteRangeStart = 0;
+            mByteRangeEnd = 0;
+            
+            rv = SendStop(NS_OK);
+            if (NS_FAILED(rv)) return rv;
+            // reset the token to front. this allows us to treat
+            // the token as a starting token.
+            token -= mTokenLen + tokenLinefeed;
+            bufLen += mTokenLen + tokenLinefeed;
+            cursor = token;
+        }
+    }
+
+    // at this point, we want to buffer up whatever amount (bufLen)
+    // we have leftover. However, we *always* want to ensure that
+    // we buffer enough data to handle a broken token.
+
+    // carry over
+    uint32_t bufAmt = 0;
+    if (mProcessingHeaders)
+        bufAmt = bufLen;
+    else if (bufLen) {
+        // if the data ends in a linefeed, and we're in the middle
+        // of a "part" (ie. mPartChannel exists) don't bother
+        // buffering, go ahead and send the data we have. Otherwise
+        // if we don't have a channel already, then we don't even
+        // have enough info to start a part, go ahead and buffer
+        // enough to collect a boundary token.
+        if (!mPartChannel || !(cursor[bufLen-1] == nsCRT::LF) )
+            bufAmt = std::min(mTokenLen - 1, bufLen);
+    }
+
+    if (bufAmt) {
+        rv = BufferData(cursor + (bufLen - bufAmt), bufAmt);
+        if (NS_FAILED(rv)) return rv;
+        bufLen -= bufAmt;
+    }
+
+    if (bufLen) {
+        rv = SendData(cursor, bufLen);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    return rv;
+}
+
+
+// nsIRequestObserver implementation
+NS_IMETHODIMP
+nsMultiMixedConv::OnStartRequest(nsIRequest *request, nsISupports *ctxt) {
+    // we're assuming the content-type is available at this stage
+    NS_ASSERTION(mToken.IsEmpty(), "a second on start???");
+    const char *bndry = nullptr;
+    nsAutoCString delimiter;
+    nsresult rv = NS_OK;
+    mContext = ctxt;
+
+    mFirstOnData = true;
+    mTotalSent   = 0;
+
+    nsCOMPtr<nsIChannel> channel = do_QueryInterface(request, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    // ask the HTTP channel for the content-type and extract the boundary from it.
+    nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(channel, &rv);
+    if (NS_SUCCEEDED(rv)) {
+        rv = httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("content-type"), delimiter);
+        if (NS_FAILED(rv)) {
+            return rv;
+        }
+    } else {
+        // try asking the channel directly
+        rv = channel->GetContentType(delimiter);
+        if (NS_FAILED(rv)) {
+            return NS_ERROR_FAILURE;
+        }
+    }
+
+    bndry = strstr(delimiter.BeginWriting(), "boundary");
+
+    if (!bndry) {
+        return NS_ERROR_FAILURE;
+    }
+
+    bndry = strchr(bndry, '=');
+    if (!bndry) return NS_ERROR_FAILURE;
+
+    bndry++; // move past the equals sign
+
+    char *attrib = (char *) strchr(bndry, ';');
+    if (attrib) *attrib = '\0';
+
+    nsAutoCString boundaryString(bndry);
+    if (attrib) *attrib = ';';
+
+    boundaryString.Trim(" \"");
+
+    mToken = boundaryString;
+    mTokenLen = boundaryString.Length();
+
+    if (mTokenLen == 0) {
+        return NS_ERROR_FAILURE;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMultiMixedConv::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
+                                nsresult aStatus)
+{
+    if (mToken.IsEmpty()) { // no token, no love.
+        return NS_ERROR_FAILURE;
+    }
+
+    if (mPartChannel) {
+        mPartChannel->SetIsLastPart();
+
+        // we've already called SendStart() (which sets up the mPartChannel,
+        // and fires an OnStart()) send any data left over, and then fire the stop.
+        if (mBufLen > 0 && mBuffer) {
+            (void) SendData(mBuffer, mBufLen);
+            // don't bother checking the return value here, if the send failed
+            // we're done anyway as we're in the OnStop() callback.
+            free(mBuffer);
+            mBuffer = nullptr;
+            mBufLen = 0;
+        }
+        (void) SendStop(aStatus);
+    } else if (NS_FAILED(aStatus)) {
+        // underlying data production problem. we should not be in
+        // the middle of sending data. if we were, mPartChannel,
+        // above, would have been true.
+
+        // if we send the start, the URI Loader's m_targetStreamListener, may
+        // be pointing at us causing a nice stack overflow.  So, don't call 
+        // OnStartRequest!  -  This breaks necko's semantecs. 
+        //(void) mFinalListener->OnStartRequest(request, ctxt);
+
+        (void) mFinalListener->OnStopRequest(request, ctxt, aStatus);
+    }
+
+    return NS_OK;
+}
+
+
+// nsMultiMixedConv methods
+nsMultiMixedConv::nsMultiMixedConv() :
+  mCurrentPartID(0)
+{
+    mTokenLen           = 0;
+    mNewPart            = true;
+    mContentLength      = UINT64_MAX;
+    mBuffer             = nullptr;
+    mBufLen             = 0;
+    mProcessingHeaders  = false;
+    mByteRangeStart     = 0;
+    mByteRangeEnd       = 0;
+    mTotalSent          = 0;
+    mIsByteRangeRequest = false;
+}
+
+nsMultiMixedConv::~nsMultiMixedConv() {
+    NS_ASSERTION(!mBuffer, "all buffered data should be gone");
+    if (mBuffer) {
+        free(mBuffer);
+        mBuffer = nullptr;
+    }
+}
+
+nsresult
+nsMultiMixedConv::BufferData(char *aData, uint32_t aLen) {
+    NS_ASSERTION(!mBuffer, "trying to over-write buffer");
+
+    char *buffer = (char *) malloc(aLen);
+    if (!buffer) return NS_ERROR_OUT_OF_MEMORY;
+
+    memcpy(buffer, aData, aLen);
+    mBuffer = buffer;
+    mBufLen = aLen;
+    return NS_OK;
+}
+
+
+nsresult
+nsMultiMixedConv::SendStart(nsIChannel *aChannel) {
+    nsresult rv = NS_OK;
+
+    nsCOMPtr<nsIStreamListener> partListener(mFinalListener);
+    if (mContentType.IsEmpty()) {
+        mContentType.AssignLiteral(UNKNOWN_CONTENT_TYPE);
+        nsCOMPtr<nsIStreamConverterService> serv =
+            do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv);
+        if (NS_SUCCEEDED(rv)) {
+            nsCOMPtr<nsIStreamListener> converter;
+            rv = serv->AsyncConvertData(UNKNOWN_CONTENT_TYPE,
+                                        "*/*",
+                                        mFinalListener,
+                                        mContext,
+                                        getter_AddRefs(converter));
+            if (NS_SUCCEEDED(rv)) {
+                partListener = converter;
+            }
+        }
+    }
+
+    // if we already have an mPartChannel, that means we never sent a Stop()
+    // before starting up another "part." that would be bad.
+    NS_ASSERTION(!mPartChannel, "tisk tisk, shouldn't be overwriting a channel");
+
+    nsPartChannel *newChannel;
+    newChannel = new nsPartChannel(aChannel, mCurrentPartID++, partListener);
+    if (!newChannel)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    if (mIsByteRangeRequest) {
+        newChannel->InitializeByteRange(mByteRangeStart, mByteRangeEnd);
+    }
+
+    mTotalSent = 0;
+
+    // Set up the new part channel...
+    mPartChannel = newChannel;
+
+    rv = mPartChannel->SetContentType(mContentType);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = mPartChannel->SetContentLength(mContentLength);
+    if (NS_FAILED(rv)) return rv;
+
+    mPartChannel->SetContentDisposition(mContentDisposition);
+
+    nsLoadFlags loadFlags = 0;
+    mPartChannel->GetLoadFlags(&loadFlags);
+    loadFlags |= nsIChannel::LOAD_REPLACE;
+    mPartChannel->SetLoadFlags(loadFlags);
+
+    nsCOMPtr<nsILoadGroup> loadGroup;
+    (void)mPartChannel->GetLoadGroup(getter_AddRefs(loadGroup));
+
+    // Add the new channel to the load group (if any)
+    if (loadGroup) {
+        rv = loadGroup->AddRequest(mPartChannel, nullptr);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    // Let's start off the load. NOTE: we don't forward on the channel passed
+    // into our OnDataAvailable() as it's the root channel for the raw stream.
+    return mPartChannel->SendOnStartRequest(mContext);
+}
+
+
+nsresult
+nsMultiMixedConv::SendStop(nsresult aStatus) {
+    
+    nsresult rv = NS_OK;
+    if (mPartChannel) {
+        rv = mPartChannel->SendOnStopRequest(mContext, aStatus);
+        // don't check for failure here, we need to remove the channel from 
+        // the loadgroup.
+
+        // Remove the channel from its load group (if any)
+        nsCOMPtr<nsILoadGroup> loadGroup;
+        (void) mPartChannel->GetLoadGroup(getter_AddRefs(loadGroup));
+        if (loadGroup) 
+            (void) loadGroup->RemoveRequest(mPartChannel, mContext, aStatus);
+    }
+
+    mPartChannel = nullptr;
+    return rv;
+}
+
+nsresult
+nsMultiMixedConv::SendData(char *aBuffer, uint32_t aLen) {
+
+    nsresult rv = NS_OK;
+    
+    if (!mPartChannel) return NS_ERROR_FAILURE; // something went wrong w/ processing
+
+    if (mContentLength != UINT64_MAX) {
+        // make sure that we don't send more than the mContentLength
+        // XXX why? perhaps the Content-Length header was actually wrong!!
+        if ((uint64_t(aLen) + mTotalSent) > mContentLength)
+            aLen = static_cast<uint32_t>(mContentLength - mTotalSent);
+
+        if (aLen == 0)
+            return NS_OK;
+    }
+
+    uint64_t offset = mTotalSent;
+    mTotalSent += aLen;
+
+    nsCOMPtr<nsIStringInputStream> ss(
+            do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv));
+    if (NS_FAILED(rv))
+        return rv;
+
+    rv = ss->ShareData(aBuffer, aLen);
+    if (NS_FAILED(rv))
+        return rv;
+
+    nsCOMPtr<nsIInputStream> inStream(do_QueryInterface(ss, &rv));
+    if (NS_FAILED(rv)) return rv;
+
+    return mPartChannel->SendOnDataAvailable(mContext, inStream, offset, aLen);
+}
+
+int32_t
+nsMultiMixedConv::PushOverLine(char *&aPtr, uint32_t &aLen) {
+    int32_t chars = 0;
+    if ((aLen > 0) && (*aPtr == nsCRT::CR || *aPtr == nsCRT::LF)) {
+        if ((aLen > 1) && (aPtr[1] == nsCRT::LF))
+            chars++;
+        chars++;
+        aPtr += chars;
+        aLen -= chars;
+    }
+    return chars;
+}
+
+nsresult
+nsMultiMixedConv::ParseHeaders(nsIChannel *aChannel, char *&aPtr, 
+                               uint32_t &aLen, bool *_retval) {
+    // NOTE: this data must be ascii.
+    // NOTE: aPtr is NOT null terminated!
+    nsresult rv = NS_OK;
+    char *cursor = aPtr, *newLine = nullptr;
+    uint32_t cursorLen = aLen;
+    bool done = false;
+    uint32_t lineFeedIncrement = 1;
+
+    mContentLength = UINT64_MAX; // XXX what if we were already called?
+    while (cursorLen && (newLine = (char *) memchr(cursor, nsCRT::LF, cursorLen))) {
+        // adjust for linefeeds
+        if ((newLine > cursor) && (newLine[-1] == nsCRT::CR) ) { // CRLF
+            lineFeedIncrement = 2;
+            newLine--;
+        }
+        else
+            lineFeedIncrement = 1; // reset
+
+        if (newLine == cursor) {
+            // move the newLine beyond the linefeed marker
+            NS_ASSERTION(cursorLen >= lineFeedIncrement, "oops!");
+
+            cursor += lineFeedIncrement;
+            cursorLen -= lineFeedIncrement;
+
+            done = true;
+            break;
+        }
+
+        char tmpChar = *newLine;
+        *newLine = '\0'; // cursor is now null terminated
+
+        char *colon = (char *) strchr(cursor, ':');
+        if (colon) {
+            *colon = '\0';
+            nsAutoCString headerStr(cursor);
+            headerStr.CompressWhitespace();
+            *colon = ':';
+
+            nsAutoCString headerVal(colon + 1);
+            headerVal.CompressWhitespace();
+
+            // examine header
+            if (headerStr.LowerCaseEqualsLiteral("content-type")) {
+                mContentType = headerVal;
+            } else if (headerStr.LowerCaseEqualsLiteral("content-length")) {
+                mContentLength = nsCRT::atoll(headerVal.get());
+            } else if (headerStr.LowerCaseEqualsLiteral("content-disposition")) {
+                mContentDisposition = headerVal;
+            } else if (headerStr.LowerCaseEqualsLiteral("set-cookie")) {
+                nsCOMPtr<nsIHttpChannelInternal> httpInternal =
+                    do_QueryInterface(aChannel);
+                if (httpInternal) {
+                    httpInternal->SetCookie(headerVal.get());
+                }
+            } else if (headerStr.LowerCaseEqualsLiteral("content-range") || 
+                       headerStr.LowerCaseEqualsLiteral("range") ) {
+                // something like: Content-range: bytes 7000-7999/8000
+                char* tmpPtr;
+
+                tmpPtr = (char *) strchr(colon + 1, '/');
+                if (tmpPtr) 
+                    *tmpPtr = '\0';
+
+                // pass the bytes-unit and the SP
+                char *range = (char *) strchr(colon + 2, ' ');
+                if (!range)
+                    return NS_ERROR_FAILURE;
+
+                do {
+                    range++;
+                } while (*range == ' ');
+
+                if (range[0] == '*'){
+                    mByteRangeStart = mByteRangeEnd = 0;
+                }
+                else {
+                    tmpPtr = (char *) strchr(range, '-');
+                    if (!tmpPtr)
+                        return NS_ERROR_FAILURE;
+                    
+                    tmpPtr[0] = '\0';
+                    
+                    mByteRangeStart = nsCRT::atoll(range);
+                    tmpPtr++;
+                    mByteRangeEnd = nsCRT::atoll(tmpPtr);
+                }
+
+                mIsByteRangeRequest = true;
+                if (mContentLength == UINT64_MAX)
+                    mContentLength = uint64_t(mByteRangeEnd - mByteRangeStart + 1);
+            }
+        }
+        *newLine = tmpChar;
+        newLine += lineFeedIncrement;
+        cursorLen -= (newLine - cursor);
+        cursor = newLine;
+    }
+
+    aPtr = cursor;
+    aLen = cursorLen;
+
+    *_retval = done;
+    return rv;
+}
+
+char *
+nsMultiMixedConv::FindToken(char *aCursor, uint32_t aLen) {
+    // strnstr without looking for null termination
+    const char *token = mToken.get();
+    char *cur = aCursor;
+
+    if (!(token && aCursor && *token)) {
+        NS_WARNING("bad data");
+        return nullptr;
+    }
+
+    for (; aLen >= mTokenLen; aCursor++, aLen--) {
+        if (!memcmp(aCursor, token, mTokenLen) ) {
+            if ((aCursor - cur) >= 2) {
+                // back the cursor up over a double dash for backwards compat.
+                if ((*(aCursor-1) == '-') && (*(aCursor-2) == '-')) {
+                    aCursor -= 2;
+                    aLen += 2;
+
+                    // we're playing w/ double dash tokens, adjust.
+                    mToken.Assign(aCursor, mTokenLen + 2);
+                    mTokenLen = mToken.Length();
+                }
+            }
+            return aCursor;
+        }
+    }
+
+    return nullptr;
+}
+
+nsresult
+NS_NewMultiMixedConv(nsMultiMixedConv** aMultiMixedConv)
+{
+    NS_PRECONDITION(aMultiMixedConv != nullptr, "null ptr");
+    if (! aMultiMixedConv)
+        return NS_ERROR_NULL_POINTER;
+
+    *aMultiMixedConv = new nsMultiMixedConv();
+    if (! *aMultiMixedConv)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aMultiMixedConv);
+    return NS_OK;
+}