QNAM - fix poor performance of HEAD request with authentication
[qt:qt.git] / src / network / access / qhttpnetworkreply.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4 ** All rights reserved.
5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 **
7 ** This file is part of the QtNetwork module of the Qt Toolkit.
8 **
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** GNU Lesser General Public License Usage
11 ** This file may be used under the terms of the GNU Lesser General Public
12 ** License version 2.1 as published by the Free Software Foundation and
13 ** appearing in the file LICENSE.LGPL included in the packaging of this
14 ** file. Please review the following information to ensure the GNU Lesser
15 ** General Public License version 2.1 requirements will be met:
16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
17 **
18 ** In addition, as a special exception, Nokia gives you certain additional
19 ** rights. These rights are described in the Nokia Qt LGPL Exception
20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
21 **
22 ** GNU General Public License Usage
23 ** Alternatively, this file may be used under the terms of the GNU General
24 ** Public License version 3.0 as published by the Free Software Foundation
25 ** and appearing in the file LICENSE.GPL included in the packaging of this
26 ** file. Please review the following information to ensure the GNU General
27 ** Public License version 3.0 requirements will be met:
28 ** http://www.gnu.org/copyleft/gpl.html.
29 **
30 ** Other Usage
31 ** Alternatively, this file may be used in accordance with the terms and
32 ** conditions contained in a signed written agreement between you and Nokia.
33 **
34 **
35 **
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include "qhttpnetworkreply_p.h"
43 #include "qhttpnetworkconnection_p.h"
44
45 #include <qbytearraymatcher.h>
46
47 #ifndef QT_NO_HTTP
48
49 #ifndef QT_NO_OPENSSL
50 #    include <QtNetwork/qsslkey.h>
51 #    include <QtNetwork/qsslcipher.h>
52 #    include <QtNetwork/qsslconfiguration.h>
53 #endif
54
55 QT_BEGIN_NAMESPACE
56
57 QHttpNetworkReply::QHttpNetworkReply(const QUrl &url, QObject *parent)
58     : QObject(*new QHttpNetworkReplyPrivate(url), parent)
59 {
60 }
61
62 QHttpNetworkReply::~QHttpNetworkReply()
63 {
64     Q_D(QHttpNetworkReply);
65     if (d->connection) {
66         d->connection->d_func()->removeReply(this);
67     }
68 }
69
70 QUrl QHttpNetworkReply::url() const
71 {
72     return d_func()->url;
73 }
74 void QHttpNetworkReply::setUrl(const QUrl &url)
75 {
76     Q_D(QHttpNetworkReply);
77     d->url = url;
78 }
79
80 qint64 QHttpNetworkReply::contentLength() const
81 {
82     return d_func()->contentLength();
83 }
84
85 void QHttpNetworkReply::setContentLength(qint64 length)
86 {
87     Q_D(QHttpNetworkReply);
88     d->setContentLength(length);
89 }
90
91 QList<QPair<QByteArray, QByteArray> > QHttpNetworkReply::header() const
92 {
93     return d_func()->fields;
94 }
95
96 QByteArray QHttpNetworkReply::headerField(const QByteArray &name, const QByteArray &defaultValue) const
97 {
98     return d_func()->headerField(name, defaultValue);
99 }
100
101 void QHttpNetworkReply::setHeaderField(const QByteArray &name, const QByteArray &data)
102 {
103     Q_D(QHttpNetworkReply);
104     d->setHeaderField(name, data);
105 }
106
107 void QHttpNetworkReply::parseHeader(const QByteArray &header)
108 {
109     Q_D(QHttpNetworkReply);
110     d->parseHeader(header);
111 }
112
113 QHttpNetworkRequest QHttpNetworkReply::request() const
114 {
115     return d_func()->request;
116 }
117
118 void QHttpNetworkReply::setRequest(const QHttpNetworkRequest &request)
119 {
120     Q_D(QHttpNetworkReply);
121     d->request = request;
122     d->ssl = request.isSsl();
123 }
124
125 int QHttpNetworkReply::statusCode() const
126 {
127     return d_func()->statusCode;
128 }
129
130 void QHttpNetworkReply::setStatusCode(int code)
131 {
132     Q_D(QHttpNetworkReply);
133     d->statusCode = code;
134 }
135
136 QString QHttpNetworkReply::errorString() const
137 {
138     return d_func()->errorString;
139 }
140
141 QString QHttpNetworkReply::reasonPhrase() const
142 {
143     return d_func()->reasonPhrase;
144 }
145
146 void QHttpNetworkReply::setErrorString(const QString &error)
147 {
148     Q_D(QHttpNetworkReply);
149     d->errorString = error;
150 }
151
152 int QHttpNetworkReply::majorVersion() const
153 {
154     return d_func()->majorVersion;
155 }
156
157 int QHttpNetworkReply::minorVersion() const
158 {
159     return d_func()->minorVersion;
160 }
161
162 qint64 QHttpNetworkReply::bytesAvailable() const
163 {
164     Q_D(const QHttpNetworkReply);
165     if (d->connection)
166         return d->connection->d_func()->uncompressedBytesAvailable(*this);
167     else
168         return -1;
169 }
170
171 qint64 QHttpNetworkReply::bytesAvailableNextBlock() const
172 {
173     Q_D(const QHttpNetworkReply);
174     if (d->connection)
175         return d->connection->d_func()->uncompressedBytesAvailableNextBlock(*this);
176     else
177         return -1;
178 }
179
180 bool QHttpNetworkReply::readAnyAvailable() const
181 {
182     Q_D(const QHttpNetworkReply);
183     return (d->responseData.bufferCount() > 0);
184 }
185
186 QByteArray QHttpNetworkReply::readAny()
187 {
188     Q_D(QHttpNetworkReply);
189     if (d->responseData.bufferCount() == 0)
190         return QByteArray();
191
192     // we'll take the last buffer, so schedule another read from http
193     if (d->downstreamLimited && d->responseData.bufferCount() == 1)
194         d->connection->d_func()->readMoreLater(this);
195     return d->responseData.read();
196 }
197
198 QByteArray QHttpNetworkReply::readAll()
199 {
200     Q_D(QHttpNetworkReply);
201     return d->responseData.readAll();
202 }
203
204 void QHttpNetworkReply::setDownstreamLimited(bool dsl)
205 {
206     Q_D(QHttpNetworkReply);
207     d->downstreamLimited = dsl;
208     d->connection->d_func()->readMoreLater(this);
209 }
210
211 bool QHttpNetworkReply::supportsUserProvidedDownloadBuffer()
212 {
213     Q_D(QHttpNetworkReply);
214     return (!d->isChunked() && !d->autoDecompress && d->bodyLength > 0);
215 }
216
217 void QHttpNetworkReply::setUserProvidedDownloadBuffer(char* b)
218 {
219     Q_D(QHttpNetworkReply);
220     if (supportsUserProvidedDownloadBuffer())
221         d->userProvidedDownloadBuffer = b;
222 }
223
224 char* QHttpNetworkReply::userProvidedDownloadBuffer()
225 {
226     Q_D(QHttpNetworkReply);
227     return d->userProvidedDownloadBuffer;
228 }
229
230 bool QHttpNetworkReply::isFinished() const
231 {
232     return d_func()->state == QHttpNetworkReplyPrivate::AllDoneState;
233 }
234
235 bool QHttpNetworkReply::isPipeliningUsed() const
236 {
237     return d_func()->pipeliningUsed;
238 }
239
240 QHttpNetworkConnection* QHttpNetworkReply::connection()
241 {
242     return d_func()->connection;
243 }
244
245
246 QHttpNetworkReplyPrivate::QHttpNetworkReplyPrivate(const QUrl &newUrl)
247     : QHttpNetworkHeaderPrivate(newUrl)
248     , state(NothingDoneState)
249     , ssl(false)
250     , statusCode(100),
251       majorVersion(0), minorVersion(0), bodyLength(0), contentRead(0), totalProgress(0),
252       chunkedTransferEncoding(false),
253       connectionCloseEnabled(true),
254       forceConnectionCloseEnabled(false),
255       currentChunkSize(0), currentChunkRead(0), connection(0), initInflate(false),
256       autoDecompress(false), responseData(), requestIsPrepared(false)
257       ,pipeliningUsed(false), downstreamLimited(false)
258       ,userProvidedDownloadBuffer(0)
259 {
260 }
261
262 QHttpNetworkReplyPrivate::~QHttpNetworkReplyPrivate()
263 {
264 }
265
266 void QHttpNetworkReplyPrivate::clearHttpLayerInformation()
267 {
268     state = NothingDoneState;
269     statusCode = 100;
270     bodyLength = 0;
271     contentRead = 0;
272     totalProgress = 0;
273     currentChunkSize = 0;
274     currentChunkRead = 0;
275     connectionCloseEnabled = true;
276 #ifndef QT_NO_COMPRESS
277     if (initInflate)
278         inflateEnd(&inflateStrm);
279 #endif
280     initInflate = false;
281     streamEnd = false;
282     fields.clear();
283 }
284
285 // TODO: Isn't everything HTTP layer related? We don't need to set connection and connectionChannel to 0 at all
286 void QHttpNetworkReplyPrivate::clear()
287 {
288     connection = 0;
289     connectionChannel = 0;
290     autoDecompress = false;
291     clearHttpLayerInformation();
292 }
293
294 // QHttpNetworkReplyPrivate
295 qint64 QHttpNetworkReplyPrivate::bytesAvailable() const
296 {
297     return (state != ReadingDataState ? 0 : fragment.size());
298 }
299
300 bool QHttpNetworkReplyPrivate::isGzipped()
301 {
302     QByteArray encoding = headerField("content-encoding");
303     return qstricmp(encoding.constData(), "gzip") == 0;
304 }
305
306 void QHttpNetworkReplyPrivate::removeAutoDecompressHeader()
307 {
308     // The header "Content-Encoding  = gzip" is retained.
309     // Content-Length is removed since the actual one send by the server is for compressed data
310     QByteArray name("content-length");
311     QList<QPair<QByteArray, QByteArray> >::Iterator it = fields.begin(),
312                                                    end = fields.end();
313     while (it != end) {
314         if (qstricmp(name.constData(), it->first.constData()) == 0) {
315             fields.erase(it);
316             break;
317         }
318         ++it;
319     }
320
321 }
322
323 bool QHttpNetworkReplyPrivate::findChallenge(bool forProxy, QByteArray &challenge) const
324 {
325     challenge.clear();
326     // find out the type of authentication protocol requested.
327     QByteArray header = forProxy ? "proxy-authenticate" : "www-authenticate";
328     // pick the best protocol (has to match parsing in QAuthenticatorPrivate)
329     QList<QByteArray> challenges = headerFieldValues(header);
330     for (int i = 0; i<challenges.size(); i++) {
331         QByteArray line = challenges.at(i);
332         // todo use qstrincmp
333         if (!line.toLower().startsWith("negotiate"))
334             challenge = line;
335     }
336     return !challenge.isEmpty();
337 }
338
339 QAuthenticatorPrivate::Method QHttpNetworkReplyPrivate::authenticationMethod(bool isProxy) const
340 {
341     // The logic is same as the one used in void QAuthenticatorPrivate::parseHttpResponse()
342     QAuthenticatorPrivate::Method method = QAuthenticatorPrivate::None;
343     QByteArray header = isProxy ? "proxy-authenticate" : "www-authenticate";
344     QList<QByteArray> challenges = headerFieldValues(header);
345     for (int i = 0; i<challenges.size(); i++) {
346         QByteArray line = challenges.at(i).trimmed().toLower();
347         if (method < QAuthenticatorPrivate::Basic
348             && line.startsWith("basic")) {
349             method = QAuthenticatorPrivate::Basic;
350         } else if (method < QAuthenticatorPrivate::Ntlm
351             && line.startsWith("ntlm")) {
352             method = QAuthenticatorPrivate::Ntlm;
353         } else if (method < QAuthenticatorPrivate::DigestMd5
354             && line.startsWith("digest")) {
355             method = QAuthenticatorPrivate::DigestMd5;
356         }
357     }
358     return method;
359 }
360
361 #ifndef QT_NO_COMPRESS
362 bool QHttpNetworkReplyPrivate::gzipCheckHeader(QByteArray &content, int &pos)
363 {
364     int method = 0; // method byte
365     int flags = 0;  // flags byte
366     bool ret = false;
367
368     // Assure two bytes in the buffer so we can peek ahead -- handle case
369     // where first byte of header is at the end of the buffer after the last
370     // gzip segment
371     pos = -1;
372     QByteArray &body = content;
373     int maxPos = body.size()-1;
374     if (maxPos < 1) {
375         return ret;
376     }
377
378     // Peek ahead to check the gzip magic header
379     if (body[0] != char(gz_magic[0]) ||
380         body[1] != char(gz_magic[1])) {
381         return ret;
382     }
383     pos += 2;
384     // Check the rest of the gzip header
385     if (++pos <= maxPos)
386         method = body[pos];
387     if (pos++ <= maxPos)
388         flags = body[pos];
389     if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
390         return ret;
391     }
392
393     // Discard time, xflags and OS code:
394     pos += 6;
395     if (pos > maxPos)
396         return ret;
397     if ((flags & EXTRA_FIELD) && ((pos+2) <= maxPos)) { // skip the extra field
398         unsigned len =  (unsigned)body[++pos];
399         len += ((unsigned)body[++pos])<<8;
400         pos += len;
401         if (pos > maxPos)
402             return ret;
403     }
404     if ((flags & ORIG_NAME) != 0) { // skip the original file name
405         while(++pos <= maxPos && body[pos]) {}
406     }
407     if ((flags & COMMENT) != 0) {   // skip the .gz file comment
408         while(++pos <= maxPos && body[pos]) {}
409     }
410     if ((flags & HEAD_CRC) != 0) {  // skip the header crc
411         pos += 2;
412         if (pos > maxPos)
413             return ret;
414     }
415     ret = (pos < maxPos); // return failed, if no more bytes left
416     return ret;
417 }
418
419 int QHttpNetworkReplyPrivate::gunzipBodyPartially(QByteArray &compressed, QByteArray &inflated)
420 {
421     int ret = Z_DATA_ERROR;
422     unsigned have;
423     unsigned char out[CHUNK];
424     int pos = -1;
425
426     if (!initInflate) {
427         // check the header
428         if (!gzipCheckHeader(compressed, pos))
429             return ret;
430         // allocate inflate state
431         inflateStrm.zalloc = Z_NULL;
432         inflateStrm.zfree = Z_NULL;
433         inflateStrm.opaque = Z_NULL;
434         inflateStrm.avail_in = 0;
435         inflateStrm.next_in = Z_NULL;
436         ret = inflateInit2(&inflateStrm, -MAX_WBITS);
437         if (ret != Z_OK)
438             return ret;
439         initInflate = true;
440         streamEnd = false;
441     }
442
443     //remove the header.
444     compressed.remove(0, pos+1);
445     // expand until deflate stream ends
446     inflateStrm.next_in = (unsigned char *)compressed.data();
447     inflateStrm.avail_in = compressed.size();
448     do {
449         inflateStrm.avail_out = sizeof(out);
450         inflateStrm.next_out = out;
451         ret = inflate(&inflateStrm, Z_NO_FLUSH);
452         switch (ret) {
453         case Z_NEED_DICT:
454             ret = Z_DATA_ERROR;
455             // and fall through
456         case Z_DATA_ERROR:
457         case Z_MEM_ERROR:
458             inflateEnd(&inflateStrm);
459             initInflate = false;
460             return ret;
461         }
462         have = sizeof(out) - inflateStrm.avail_out;
463         inflated.append(QByteArray((const char *)out, have));
464      } while (inflateStrm.avail_out == 0 && inflateStrm.avail_in > 0);
465     // clean up and return
466     if (ret <= Z_ERRNO || ret == Z_STREAM_END) {
467         gunzipBodyPartiallyEnd();
468     }
469     streamEnd = (ret == Z_STREAM_END);
470     return ret;
471 }
472
473 void QHttpNetworkReplyPrivate::gunzipBodyPartiallyEnd()
474 {
475     inflateEnd(&inflateStrm);
476     initInflate = false;
477 }
478
479 #endif
480
481 qint64 QHttpNetworkReplyPrivate::readStatus(QAbstractSocket *socket)
482 {
483     if (fragment.isEmpty()) {
484         // reserve bytes for the status line. This is better than always append() which reallocs the byte array
485         fragment.reserve(32);
486     }
487
488     qint64 bytes = 0;
489     char c;
490     qint64 haveRead = 0;
491
492     do {
493         haveRead = socket->read(&c, 1);
494         if (haveRead == -1)
495             return -1; // unexpected EOF
496         else if (haveRead == 0)
497             break; // read more later
498         else if (haveRead == 1 && bytes == 0 && (c == 11 || c == '\n' || c == '\r' || c == ' ' || c == 31))
499             continue; // Ignore all whitespace that was trailing froma previous request on that socket
500
501         bytes++;
502
503         // allow both CRLF & LF (only) line endings
504         if (c == '\n') {
505             // remove the CR at the end
506             if (fragment.endsWith('\r')) {
507                 fragment.truncate(fragment.length()-1);
508             }
509             bool ok = parseStatus(fragment);
510             state = ReadingHeaderState;
511             fragment.clear();
512             if (!ok) {
513                 return -1;
514             }
515             break;
516         } else {
517             fragment.append(c);
518         }
519
520         // is this a valid reply?
521         if (fragment.length() >= 5 && !fragment.startsWith("HTTP/"))
522         {
523             fragment.clear();
524             return -1;
525         }
526     } while (haveRead == 1);
527
528     return bytes;
529 }
530
531 bool QHttpNetworkReplyPrivate::parseStatus(const QByteArray &status)
532 {
533     // from RFC 2616:
534     //        Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
535     //        HTTP-Version   = "HTTP" "/" 1*DIGIT "." 1*DIGIT
536     // that makes: 'HTTP/n.n xxx Message'
537     // byte count:  0123456789012
538
539     static const int minLength = 11;
540     static const int dotPos = 6;
541     static const int spacePos = 8;
542     static const char httpMagic[] = "HTTP/";
543
544     if (status.length() < minLength
545         || !status.startsWith(httpMagic)
546         || status.at(dotPos) != '.'
547         || status.at(spacePos) != ' ') {
548         // I don't know how to parse this status line
549         return false;
550     }
551
552     // optimize for the valid case: defer checking until the end
553     majorVersion = status.at(dotPos - 1) - '0';
554     minorVersion = status.at(dotPos + 1) - '0';
555
556     int i = spacePos;
557     int j = status.indexOf(' ', i + 1); // j == -1 || at(j) == ' ' so j+1 == 0 && j+1 <= length()
558     const QByteArray code = status.mid(i + 1, j - i - 1);
559
560     bool ok;
561     statusCode = code.toInt(&ok);
562     reasonPhrase = QString::fromLatin1(status.constData() + j + 1);
563
564     return ok && uint(majorVersion) <= 9 && uint(minorVersion) <= 9;
565 }
566
567 qint64 QHttpNetworkReplyPrivate::readHeader(QAbstractSocket *socket)
568 {
569     if (fragment.isEmpty()) {
570         // according to http://dev.opera.com/articles/view/mama-http-headers/ the average size of the header
571         // block is 381 bytes.
572         // reserve bytes. This is better than always append() which reallocs the byte array.
573         fragment.reserve(512);
574     }
575
576     qint64 bytes = 0;
577     char c = 0;
578     bool allHeaders = false;
579     qint64 haveRead = 0;
580     do {
581         haveRead = socket->read(&c, 1);
582         if (haveRead == 0) {
583             // read more later
584             break;
585         } else if (haveRead == -1) {
586             // connection broke down
587             return -1;
588         } else {
589             fragment.append(c);
590             bytes++;
591
592             if (c == '\n') {
593                 // check for possible header endings. As per HTTP rfc,
594                 // the header endings will be marked by CRLFCRLF. But
595                 // we will allow CRLFCRLF, CRLFLF, LFLF
596                 if (fragment.endsWith("\r\n\r\n")
597                     || fragment.endsWith("\r\n\n")
598                     || fragment.endsWith("\n\n"))
599                     allHeaders = true;
600
601                 // there is another case: We have no headers. Then the fragment equals just the line ending
602                 if ((fragment.length() == 2 && fragment.endsWith("\r\n"))
603                     || (fragment.length() == 1 && fragment.endsWith("\n")))
604                     allHeaders = true;
605             }
606         }
607     } while (!allHeaders && haveRead > 0);
608
609     // we received all headers now parse them
610     if (allHeaders) {
611         parseHeader(fragment);
612         state = ReadingDataState;
613         fragment.clear(); // next fragment
614         bodyLength = contentLength(); // cache the length
615
616         // cache isChunked() since it is called often
617         chunkedTransferEncoding = headerField("transfer-encoding").toLower().contains("chunked");
618
619         // cache isConnectionCloseEnabled since it is called often
620         QByteArray connectionHeaderField = headerField("connection");
621         // check for explicit indication of close or the implicit connection close of HTTP/1.0
622         connectionCloseEnabled = (connectionHeaderField.toLower().contains("close") ||
623             headerField("proxy-connection").toLower().contains("close")) ||
624             (majorVersion == 1 && minorVersion == 0 && connectionHeaderField.isEmpty());
625     }
626     return bytes;
627 }
628
629 void QHttpNetworkReplyPrivate::parseHeader(const QByteArray &header)
630 {
631     // see rfc2616, sec 4 for information about HTTP/1.1 headers.
632     // allows relaxed parsing here, accepts both CRLF & LF line endings
633     const QByteArrayMatcher lf("\n");
634     const QByteArrayMatcher colon(":");
635     int i = 0;
636     while (i < header.count()) {
637         int j = colon.indexIn(header, i); // field-name
638         if (j == -1)
639             break;
640         const QByteArray field = header.mid(i, j - i).trimmed();
641         j++;
642         // any number of LWS is allowed before and after the value
643         QByteArray value;
644         do {
645             i = lf.indexIn(header, j);
646             if (i == -1)
647                 break;
648             if (!value.isEmpty())
649                 value += ' ';
650             // check if we have CRLF or only LF
651             bool hasCR = (i && header[i-1] == '\r');
652             int length = i -(hasCR ? 1: 0) - j;
653             value += header.mid(j, length).trimmed();
654             j = ++i;
655         } while (i < header.count() && (header.at(i) == ' ' || header.at(i) == '\t'));
656         if (i == -1)
657             break; // something is wrong
658
659         fields.append(qMakePair(field, value));
660     }
661 }
662
663 bool QHttpNetworkReplyPrivate::isChunked()
664 {
665     return chunkedTransferEncoding;
666 }
667
668 bool QHttpNetworkReplyPrivate::isConnectionCloseEnabled()
669 {
670     return connectionCloseEnabled || forceConnectionCloseEnabled;
671 }
672
673 // note this function can only be used for non-chunked, non-compressed with
674 // known content length
675 qint64 QHttpNetworkReplyPrivate::readBodyVeryFast(QAbstractSocket *socket, char *b)
676 {
677     // This first read is to flush the buffer inside the socket
678     qint64 haveRead = 0;
679     haveRead = socket->read(b, bodyLength - contentRead);
680     if (haveRead == -1) {
681         return 0; // ### error checking here;
682     }
683     contentRead += haveRead;
684
685     if (contentRead == bodyLength) {
686         state = AllDoneState;
687     }
688
689     return haveRead;
690 }
691
692 // note this function can only be used for non-chunked, non-compressed with
693 // known content length
694 qint64 QHttpNetworkReplyPrivate::readBodyFast(QAbstractSocket *socket, QByteDataBuffer *rb)
695 {
696
697     qint64 toBeRead = qMin(socket->bytesAvailable(), bodyLength - contentRead);
698     QByteArray bd;
699     bd.resize(toBeRead);
700     qint64 haveRead = socket->read(bd.data(), toBeRead);
701     if (haveRead == -1) {
702         bd.clear();
703         return 0; // ### error checking here;
704     }
705     bd.resize(haveRead);
706
707     rb->append(bd);
708
709     if (contentRead + haveRead == bodyLength) {
710         state = AllDoneState;
711     }
712
713     contentRead += haveRead;
714     return haveRead;
715 }
716
717
718 qint64 QHttpNetworkReplyPrivate::readBody(QAbstractSocket *socket, QByteDataBuffer *out)
719 {
720     qint64 bytes = 0;
721     if (isChunked()) {
722         // chunked transfer encoding (rfc 2616, sec 3.6)
723         bytes += readReplyBodyChunked(socket, out);
724     } else if (bodyLength > 0) {
725         // we have a Content-Length
726         bytes += readReplyBodyRaw(socket, out, bodyLength - contentRead);
727         if (contentRead + bytes == bodyLength)
728             state = AllDoneState;
729     } else {
730         // no content length. just read what's possible
731         bytes += readReplyBodyRaw(socket, out, socket->bytesAvailable());
732     }
733     contentRead += bytes;
734     return bytes;
735 }
736
737 qint64 QHttpNetworkReplyPrivate::readReplyBodyRaw(QAbstractSocket *socket, QByteDataBuffer *out, qint64 size)
738 {
739     // FIXME get rid of this function and just use readBodyFast and give it socket->bytesAvailable()
740     qint64 bytes = 0;
741     Q_ASSERT(socket);
742     Q_ASSERT(out);
743
744     int toBeRead = qMin<qint64>(128*1024, qMin<qint64>(size, socket->bytesAvailable()));
745
746     while (toBeRead > 0) {
747         QByteArray byteData;
748         byteData.resize(toBeRead);
749         qint64 haveRead = socket->read(byteData.data(), byteData.size());
750         if (haveRead <= 0) {
751             // ### error checking here
752             byteData.clear();
753             return bytes;
754         }
755
756         byteData.resize(haveRead);
757         out->append(byteData);
758         bytes += haveRead;
759         size -= haveRead;
760
761         toBeRead = qMin<qint64>(128*1024, qMin<qint64>(size, socket->bytesAvailable()));
762     }
763     return bytes;
764
765 }
766
767 qint64 QHttpNetworkReplyPrivate::readReplyBodyChunked(QAbstractSocket *socket, QByteDataBuffer *out)
768 {
769     qint64 bytes = 0;
770     while (socket->bytesAvailable()) {
771         if (currentChunkRead >= currentChunkSize) {
772             // For the first chunk and when we're done with a chunk
773             currentChunkSize = 0;
774             currentChunkRead = 0;
775             if (bytes) {
776                 // After a chunk
777                 char crlf[2];
778                 // read the "\r\n" after the chunk
779                 qint64 haveRead = socket->read(crlf, 2);
780                 // FIXME: This code is slightly broken and not optimal. What if the 2 bytes are not available yet?!
781                 // For nice reasons (the toLong in getChunkSize accepting \n at the beginning
782                 // it right now still works, but we should definitely fix this.
783
784                 if (haveRead != 2)
785                     return bytes; // FIXME
786                 bytes += haveRead;
787             }
788             // Note that chunk size gets stored in currentChunkSize, what is returned is the bytes read
789             bytes += getChunkSize(socket, &currentChunkSize);
790             if (currentChunkSize == -1)
791                 break;
792         }
793         // if the chunk size is 0, end of the stream
794         if (currentChunkSize == 0) {
795             state = AllDoneState;
796             break;
797         }
798
799         // otherwise, try to begin reading this chunk / to read what is missing for this chunk
800         qint64 haveRead = readReplyBodyRaw (socket, out, currentChunkSize - currentChunkRead);
801         currentChunkRead += haveRead;
802         bytes += haveRead;
803
804         // ### error checking here
805
806     }
807     return bytes;
808 }
809
810 qint64 QHttpNetworkReplyPrivate::getChunkSize(QAbstractSocket *socket, qint64 *chunkSize)
811 {
812     qint64 bytes = 0;
813     char crlf[2];
814     *chunkSize = -1;
815
816     int bytesAvailable = socket->bytesAvailable();
817     // FIXME rewrite to permanent loop without bytesAvailable
818     while (bytesAvailable > bytes) {
819         qint64 sniffedBytes = socket->peek(crlf, 2);
820         int fragmentSize = fragment.size();
821
822         // check the next two bytes for a "\r\n", skip blank lines
823         if ((fragmentSize && sniffedBytes == 2 && crlf[0] == '\r' && crlf[1] == '\n')
824            ||(fragmentSize > 1 && fragment.endsWith('\r')  && crlf[0] == '\n'))
825         {
826             bytes += socket->read(crlf, 1);     // read the \r or \n
827             if (crlf[0] == '\r')
828                 bytes += socket->read(crlf, 1); // read the \n
829             bool ok = false;
830             // ignore the chunk-extension
831             fragment = fragment.mid(0, fragment.indexOf(';')).trimmed();
832             *chunkSize = fragment.toLong(&ok, 16);
833             fragment.clear();
834             break; // size done
835         } else {
836             // read the fragment to the buffer
837             char c = 0;
838             qint64 haveRead = socket->read(&c, 1);
839             if (haveRead < 0) {
840                 return -1; // FIXME
841             }
842             bytes += haveRead;
843             fragment.append(c);
844         }
845     }
846
847     return bytes;
848 }
849
850 void QHttpNetworkReplyPrivate::appendUncompressedReplyData(QByteArray &qba)
851 {
852     responseData.append(qba);
853
854     // clear the original! helps with implicit sharing and
855     // avoiding memcpy when the user is reading the data
856     qba.clear();
857 }
858
859 void QHttpNetworkReplyPrivate::appendUncompressedReplyData(QByteDataBuffer &data)
860 {
861     responseData.append(data);
862
863     // clear the original! helps with implicit sharing and
864     // avoiding memcpy when the user is reading the data
865     data.clear();
866 }
867
868 void QHttpNetworkReplyPrivate::appendCompressedReplyData(QByteDataBuffer &data)
869 {
870     // Work in progress: Later we will directly use a list of QByteArray or a QRingBuffer
871     // instead of one QByteArray.
872     for(int i = 0; i < data.bufferCount(); i++) {
873         QByteArray &byteData = data[i];
874         compressedData.append(byteData.constData(), byteData.size());
875     }
876     data.clear();
877 }
878
879
880 bool QHttpNetworkReplyPrivate::shouldEmitSignals()
881 {
882     // for 401 & 407 don't emit the data signals. Content along with these
883     // responses are send only if the authentication fails.
884     return (statusCode != 401 && statusCode != 407);
885 }
886
887 bool QHttpNetworkReplyPrivate::expectContent()
888 {
889     // check whether we can expect content after the headers (rfc 2616, sec4.4)
890     if ((statusCode >= 100 && statusCode < 200)
891         || statusCode == 204 || statusCode == 304)
892         return false;
893     if (request.operation() == QHttpNetworkRequest::Head)
894         return false; // no body expected for HEAD request
895     qint64 expectedContentLength = contentLength();
896     if (expectedContentLength == 0)
897         return false;
898     if (expectedContentLength == -1 && bodyLength == 0) {
899         // The content-length header was stripped, but its value was 0.
900         // This would be the case for an explicitly zero-length compressed response.
901         return false;
902     }
903     return true;
904 }
905
906 void QHttpNetworkReplyPrivate::eraseData()
907 {
908     compressedData.clear();
909     responseData.clear();
910 }
911
912
913 // SSL support below
914 #ifndef QT_NO_OPENSSL
915
916 QSslConfiguration QHttpNetworkReply::sslConfiguration() const
917 {
918     Q_D(const QHttpNetworkReply);
919
920     if (!d->connectionChannel)
921         return QSslConfiguration();
922
923     QSslSocket *sslSocket = qobject_cast<QSslSocket*>(d->connectionChannel->socket);
924     if (!sslSocket)
925         return QSslConfiguration();
926
927     return sslSocket->sslConfiguration();
928 }
929
930 void QHttpNetworkReply::setSslConfiguration(const QSslConfiguration &config)
931 {
932     Q_D(QHttpNetworkReply);
933     if (d->connection)
934         d->connection->setSslConfiguration(config);
935 }
936
937 void QHttpNetworkReply::ignoreSslErrors()
938 {
939     Q_D(QHttpNetworkReply);
940     if (d->connection)
941         d->connection->ignoreSslErrors();
942 }
943
944 void QHttpNetworkReply::ignoreSslErrors(const QList<QSslError> &errors)
945 {
946     Q_D(QHttpNetworkReply);
947     if (d->connection)
948         d->connection->ignoreSslErrors(errors);
949 }
950
951
952 #endif //QT_NO_OPENSSL
953
954
955 QT_END_NAMESPACE
956
957 #endif // QT_NO_HTTP