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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/* -*- 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 <string.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 = 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
|
