1 // Written by James Turner
3 // Copyright (C) 2013 James Turner <zakalawe@mac.com>
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Library General Public
7 // License as published by the Free Software Foundation; either
8 // version 2 of the License, or (at your option) any later version.
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Library General Public License for more details.
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 #include "HTTPContentDecode.hxx"
23 #include <cstdlib> // rand()
24 #include <cstring> // for memset, memcpy
26 #include <simgear/debug/logstream.hxx>
27 #include <simgear/structure/exception.hxx>
28 #include <simgear/io/lowlevel.hxx> // for sgEndian stuff
36 const int ZLIB_DECOMPRESS_BUFFER_SIZE = 32 * 1024;
37 const int ZLIB_INFLATE_WINDOW_BITS = -MAX_WBITS;
39 // see http://www.ietf.org/rfc/rfc1952.txt for these values and
40 // detailed description of the logic
41 const int GZIP_HEADER_ID1 = 31;
42 const int GZIP_HEADER_ID2 = 139;
43 const int GZIP_HEADER_METHOD_DEFLATE = 8;
44 const unsigned int GZIP_HEADER_SIZE = 10;
45 const int GZIP_HEADER_FEXTRA = 1 << 2;
46 const int GZIP_HEADER_FNAME = 1 << 3;
47 const int GZIP_HEADER_COMMENT = 1 << 4;
48 const int GZIP_HEADER_CRC = 1 << 1;
50 ContentDecoder::ContentDecoder() :
59 ContentDecoder::~ContentDecoder()
66 void ContentDecoder::setEncoding(const std::string& encoding)
68 if (encoding == "gzip") {
69 _contentDeflate = true;
70 _needGZipHeader = true;
71 } else if (encoding == "deflate") {
72 _contentDeflate = true;
73 _needGZipHeader = false;
74 } else if (encoding != "identity") {
75 SG_LOG(SG_IO, SG_WARN, "unsupported content encoding:" << encoding);
79 void ContentDecoder::reset()
82 _contentDeflate = false;
83 _needGZipHeader = false;
87 void ContentDecoder::initWithRequest(Request_ptr req)
90 if (!_contentDeflate) {
95 _zlib = (z_stream*) malloc(sizeof(z_stream));
98 memset(_zlib, 0, sizeof(z_stream));
100 _output = (unsigned char*) malloc(ZLIB_DECOMPRESS_BUFFER_SIZE);
104 // NULLs means we'll get default alloc+free methods
105 // which is absolutely fine
106 _zlib->avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
107 _zlib->next_out = _output;
108 if (inflateInit2(_zlib, ZLIB_INFLATE_WINDOW_BITS) != Z_OK) {
109 SG_LOG(SG_IO, SG_WARN, "inflateInit2 failed");
113 void ContentDecoder::finish()
115 if (_contentDeflate) {
121 void ContentDecoder::receivedBytes(const char* n, size_t s)
123 if (!_contentDeflate) {
124 _request->processBodyBytes(n, s);
128 // allocate more space if needed (this will only happen rarely once the
129 // buffer has hit something proportionate to the server's compression
131 size_t requiredSize = _inputSize + s;
132 if (requiredSize > _inputAllocated) {
133 reallocateInputBuffer(requiredSize);
136 // copy newly recieved bytes into the buffer
137 memcpy(_input + _inputSize, n, s);
140 if (_needGZipHeader && !consumeGZipHeader()) {
141 // still waiting on the full GZIP header, so done
148 void ContentDecoder::consumeBytes(size_t consumed)
150 assert(_inputSize >= consumed);
151 // move existing (consumed) bytes down
153 size_t newSize = _inputSize - consumed;
154 memmove(_input, _input + consumed, newSize);
155 _inputSize = newSize;
159 void ContentDecoder::reallocateInputBuffer(size_t newSize)
161 _input = (unsigned char*) realloc(_input, newSize);
162 _inputAllocated = newSize;
165 void ContentDecoder::runDecoder()
167 _zlib->next_in = (unsigned char*) _input;
168 _zlib->avail_in = _inputSize;
171 // loop, running zlib() inflate and sending output bytes to
172 // our request body handler. Keep calling inflate until no bytes are
173 // written, and ZLIB has consumed all available input
175 _zlib->next_out = _output;
176 _zlib->avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
177 int result = inflate(_zlib, Z_NO_FLUSH);
178 if (result == Z_OK || result == Z_STREAM_END) {
180 } else if (result == Z_BUF_ERROR) {
181 // transient error, fall through
187 writtenSize = ZLIB_DECOMPRESS_BUFFER_SIZE - _zlib->avail_out;
188 if (writtenSize > 0) {
189 _request->processBodyBytes((char*) _output, writtenSize);
192 if (result == Z_STREAM_END) {
195 } while ((_zlib->avail_in > 0) || (writtenSize > 0));
197 // update input buffers based on what we consumed
198 consumeBytes(_inputSize - _zlib->avail_in);
201 bool ContentDecoder::consumeGZipHeader()
203 size_t avail = _inputSize;
204 if (avail < GZIP_HEADER_SIZE) {
205 return false; // need more header bytes
208 if ((_input[0] != GZIP_HEADER_ID1) ||
209 (_input[1] != GZIP_HEADER_ID2) ||
210 (_input[2] != GZIP_HEADER_METHOD_DEFLATE))
212 return false; // invalid GZip header
215 char flags = _input[3];
216 unsigned int gzipHeaderSize = GZIP_HEADER_SIZE;
217 if (flags & GZIP_HEADER_FEXTRA) {
219 if (avail < gzipHeaderSize) {
220 return false; // need more header bytes
223 unsigned short extraHeaderBytes = *(reinterpret_cast<unsigned short*>(_input + GZIP_HEADER_FEXTRA));
224 if ( sgIsBigEndian() ) {
225 sgEndianSwap( &extraHeaderBytes );
228 gzipHeaderSize += extraHeaderBytes;
229 if (avail < gzipHeaderSize) {
230 return false; // need more header bytes
235 if (flags & GZIP_HEADER_FNAME) {
237 while (gzipHeaderSize <= avail) {
238 if (_input[gzipHeaderSize-1] == 0) {
239 break; // found terminating NULL character
244 if (flags & GZIP_HEADER_COMMENT) {
246 while (gzipHeaderSize <= avail) {
247 if (_input[gzipHeaderSize-1] == 0) {
248 break; // found terminating NULL character
254 if (flags & GZIP_HEADER_CRC) {
258 if (avail < gzipHeaderSize) {
259 return false; // need more header bytes
262 consumeBytes(gzipHeaderSize);
263 _needGZipHeader = false;
267 } // of namespace HTTP
269 } // of namespace simgear