1122 lines
31 KiB
C++
1122 lines
31 KiB
C++
/* -*- 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;
|
|
}
|