1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/* -*- 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/. */
// HttpLog.h should generally be included first
#include "HttpLog.h"
#include "nsHttpChunkedDecoder.h"
#include "nsHttp.h"
#include <algorithm>
//-----------------------------------------------------------------------------
// 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 RFC2617 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)
{
NS_PRECONDITION(mChunkRemaining == 0, "chunk remaining should be zero");
NS_PRECONDITION(count, "unexpected");
*bytesConsumed = 0;
char *p = static_cast<char *>(memchr(buf, '\n', count));
if (p) {
*p = 0;
if ((p > buf) && (*(p-1) == '\r')) // eliminate a preceding CR
*(p-1) = 0;
*bytesConsumed = p - buf + 1;
// make buf point to the full line buffer to parse
if (!mLineBuf.IsEmpty()) {
mLineBuf.Append(buf);
buf = (char *) mLineBuf.get();
}
if (mWaitEOF) {
if (*buf) {
LOG(("got trailer: %s\n", buf));
// allocate a header array for the trailers on demand
if (!mTrailers) {
mTrailers = new nsHttpHeaderArray();
}
mTrailers->ParseHeaderLine(buf);
}
else {
mWaitEOF = false;
mReachedEOF = true;
LOG(("reached end of chunked-body\n"));
}
}
else if (*buf) {
// ignore any chunk-extensions
if ((p = PL_strchr(buf, ';')) != nullptr)
*p = 0;
if (!sscanf(buf, "%x", &mChunkRemaining)) {
LOG(("sscanf 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;
}
|
