Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// HttpLog.h should generally be included first
#include "HttpLog.h"
#include <errno.h>
#include "nsHttpChunkedDecoder.h"
#include <algorithm>
#include "plstr.h"
#include "mozilla/Unused.h"
namespace mozilla {
namespace net {
//-----------------------------------------------------------------------------
// nsHttpChunkedDecoder <public>
//-----------------------------------------------------------------------------
nsresult nsHttpChunkedDecoder::HandleChunkedContent(
char* buf, uint32_t count, uint32_t* contentRead,
uint32_t* contentRemaining) {
LOG(("nsHttpChunkedDecoder::HandleChunkedContent [count=%u]\n", count));
*contentRead = 0;
// from RFC2616 section 3.6.1, the chunked transfer coding is defined as:
//
// Chunked-Body = *chunk
// last-chunk
// trailer
// CRLF
// chunk = chunk-size [ chunk-extension ] CRLF
// chunk-data CRLF
// chunk-size = 1*HEX
// last-chunk = 1*("0") [ chunk-extension ] CRLF
//
// chunk-extension = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
// chunk-ext-name = token
// chunk-ext-val = token | quoted-string
// chunk-data = chunk-size(OCTET)
// trailer = *(entity-header CRLF)
//
// the chunk-size field is a string of hex digits indicating the size of the
// chunk. the chunked encoding is ended by any chunk whose size is zero,
// followed by the trailer, which is terminated by an empty line.
while (count) {
if (mChunkRemaining) {
uint32_t amt = std::min(mChunkRemaining, count);
count -= amt;
mChunkRemaining -= amt;
*contentRead += amt;
buf += amt;
} else if (mReachedEOF)
break; // done
else {
uint32_t bytesConsumed = 0;
nsresult rv = ParseChunkRemaining(buf, count, &bytesConsumed);
if (NS_FAILED(rv)) return rv;
count -= bytesConsumed;
if (count) {
// shift buf by bytesConsumed
memmove(buf, buf + bytesConsumed, count);
}
}
}
*contentRemaining = count;
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsHttpChunkedDecoder <private>
//-----------------------------------------------------------------------------
nsresult nsHttpChunkedDecoder::ParseChunkRemaining(char* buf, uint32_t count,
uint32_t* bytesConsumed) {
MOZ_ASSERT(mChunkRemaining == 0, "chunk remaining should be zero");
MOZ_ASSERT(count, "unexpected");
*bytesConsumed = 0;
char* p = static_cast<char*>(memchr(buf, '\n', count));
if (p) {
*p = 0;
count = p - buf; // new length
*bytesConsumed = count + 1; // length + newline
if ((p > buf) && (*(p - 1) == '\r')) { // eliminate a preceding CR
*(p - 1) = 0;
count--;
}
// make buf point to the full line buffer to parse
if (!mLineBuf.IsEmpty()) {
mLineBuf.Append(buf, count);
buf = (char*)mLineBuf.get();
count = mLineBuf.Length();
}
if (mWaitEOF) {
if (*buf) {
LOG(("got trailer: %s\n", buf));
// allocate a header array for the trailers on demand
if (!mTrailers) {
mTrailers = MakeUnique<nsHttpHeaderArray>();
}
nsHttpAtom hdr;
nsAutoCString headerNameOriginal;
nsAutoCString val;
if (NS_SUCCEEDED(
mTrailers->ParseHeaderLine(nsDependentCSubstring(buf, count),
&hdr, &headerNameOriginal, &val))) {
if (hdr == nsHttp::Server_Timing) {
Unused << mTrailers->SetHeaderFromNet(hdr, headerNameOriginal, val,
true);
}
}
} else {
mWaitEOF = false;
mReachedEOF = true;
LOG(("reached end of chunked-body\n"));
}
} else if (*buf) {
char* endptr;
unsigned long parsedval; // could be 64 bit, could be 32
// ignore any chunk-extensions
if ((p = PL_strchr(buf, ';')) != nullptr) *p = 0;
// mChunkRemaining is an uint32_t!
parsedval = strtoul(buf, &endptr, 16);
mChunkRemaining = (uint32_t)parsedval;
if ((endptr == buf) || ((errno == ERANGE) && (parsedval == ULONG_MAX)) ||
(parsedval != mChunkRemaining)) {
LOG(("failed parsing hex on string [%s]\n", buf));
return NS_ERROR_UNEXPECTED;
}
// we've discovered the last chunk
if (mChunkRemaining == 0) mWaitEOF = true;
}
// ensure that the line buffer is clear
mLineBuf.Truncate();
} else {
// save the partial line; wait for more data
*bytesConsumed = count;
// ignore a trailing CR
if (buf[count - 1] == '\r') count--;
mLineBuf.Append(buf, count);
}
return NS_OK;
}
} // namespace net
} // namespace mozilla