1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 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 Qt3Support module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <qplatformdefs.h>

    43 #include "q3http.h"

    44 

    45 #ifndef QT_NO_HTTP

    46 

    47 #include "q3socket.h"

    48 #include "qtextstream.h"

    49 #include "qmap.h"

    50 #include "qstring.h"

    51 #include "qstringlist.h"

    52 #include "q3cstring.h"

    53 #include "qbuffer.h"

    54 #include "q3urloperator.h"

    55 #include "qtimer.h"

    56 #include "private/q3membuf_p.h"

    57 #include "qevent.h"

    58 #include "q3url.h"

    59 #include "qhttp.h"

    60 

    61 QT_BEGIN_NAMESPACE

    62 

    63 //#define Q3HTTP_DEBUG

    64 

    65 class Q3HttpPrivate

    66 {

    67 public:

    68     Q3HttpPrivate() :

    69 	state( Q3Http::Unconnected ),

    70 	error( Q3Http::NoError ),

    71 	hostname( QString() ),

    72 	port( 0 ),

    73 	toDevice( 0 ),

    74 	postDevice( 0 ),

    75 	bytesDone( 0 ),

    76 	chunkedSize( -1 ),

    77 	idleTimer( 0 )

    78     {

    79 	pending.setAutoDelete( true );

    80     }

    81 

    82     Q3Socket socket;

    83     Q3PtrList<Q3HttpRequest> pending;

    84 

    85     Q3Http::State state;

    86     Q3Http::Error error;

    87     QString errorString;

    88 

    89     QString hostname;

    90     Q_UINT16 port;

    91 

    92     QByteArray buffer;

    93     QIODevice* toDevice;

    94     QIODevice* postDevice;

    95 

    96     uint bytesDone;

    97     uint bytesTotal;

    98     Q_LONG chunkedSize;

    99 

   100     Q3HttpRequestHeader header;

   101 

   102     bool readHeader;

   103     QString headerStr;

   104     Q3HttpResponseHeader response;

   105 

   106     int idleTimer;

   107 

   108     Q3Membuf rba;

   109 };

   110 

   111 class Q3HttpRequest

   112 {

   113 public:

   114     Q3HttpRequest()

   115     {

   116 	id = ++idCounter;

   117     }

   118     virtual ~Q3HttpRequest()

   119     { }

   120 

   121     virtual void start( Q3Http * ) = 0;

   122     virtual bool hasRequestHeader();

   123     virtual Q3HttpRequestHeader requestHeader();

   124 

   125     virtual QIODevice* sourceDevice() = 0;

   126     virtual QIODevice* destinationDevice() = 0;

   127 

   128     int id;

   129 

   130 private:

   131     static int idCounter;

   132 };

   133 

   134 int Q3HttpRequest::idCounter = 0;

   135 

   136 bool Q3HttpRequest::hasRequestHeader()

   137 {

   138     return false;

   139 }

   140 

   141 Q3HttpRequestHeader Q3HttpRequest::requestHeader()

   142 {

   143     return Q3HttpRequestHeader();

   144 }

   145 

   146 /****************************************************

   147  *

   148  * Q3HttpNormalRequest

   149  *

   150  ****************************************************/

   151 

   152 class Q3HttpNormalRequest : public Q3HttpRequest

   153 {

   154 public:

   155     Q3HttpNormalRequest( const Q3HttpRequestHeader &h, QIODevice *d, QIODevice *t ) :

   156 	header(h), to(t)

   157     {

   158 	is_ba = false;

   159 	data.dev = d;

   160     }

   161 

   162     Q3HttpNormalRequest( const Q3HttpRequestHeader &h, QByteArray *d, QIODevice *t ) :

   163 	header(h), to(t)

   164     {

   165 	is_ba = true;

   166 	data.ba = d;

   167     }

   168 

   169     ~Q3HttpNormalRequest()

   170     {

   171 	if ( is_ba )

   172 	    delete data.ba;

   173     }

   174 

   175     void start( Q3Http * );

   176     bool hasRequestHeader();

   177     Q3HttpRequestHeader requestHeader();

   178 

   179     QIODevice* sourceDevice();

   180     QIODevice* destinationDevice();

   181 

   182 protected:

   183     Q3HttpRequestHeader header;

   184 

   185 private:

   186     union {

   187 	QByteArray *ba;

   188 	QIODevice *dev;

   189     } data;

   190     bool is_ba;

   191     QIODevice *to;

   192 };

   193 

   194 void Q3HttpNormalRequest::start( Q3Http *http )

   195 {

   196     http->d->header = header;

   197 

   198     if ( is_ba ) {

   199 	http->d->buffer = *data.ba;

   200 	if ( http->d->buffer.size() > 0 )

   201 	    http->d->header.setContentLength( http->d->buffer.size() );

   202 

   203 	http->d->postDevice = 0;

   204     } else {

   205 	http->d->buffer = QByteArray();

   206 

   207 	if ( data.dev && ( data.dev->isOpen() || data.dev->open(IO_ReadOnly) ) ) {

   208 	    http->d->postDevice = data.dev;

   209 	    if ( http->d->postDevice->size() > 0 )

   210 		http->d->header.setContentLength( http->d->postDevice->size() );

   211 	} else {

   212 	    http->d->postDevice = 0;

   213 	}

   214     }

   215 

   216     if ( to && ( to->isOpen() || to->open(IO_WriteOnly) ) )

   217 	http->d->toDevice = to;

   218     else

   219 	http->d->toDevice = 0;

   220 

   221     http->sendRequest();

   222 }

   223 

   224 bool Q3HttpNormalRequest::hasRequestHeader()

   225 {

   226     return true;

   227 }

   228 

   229 Q3HttpRequestHeader Q3HttpNormalRequest::requestHeader()

   230 {

   231     return header;

   232 }

   233 

   234 QIODevice* Q3HttpNormalRequest::sourceDevice()

   235 {

   236     if ( is_ba )

   237 	return 0;

   238     return data.dev;

   239 }

   240 

   241 QIODevice* Q3HttpNormalRequest::destinationDevice()

   242 {

   243     return to;

   244 }

   245 

   246 /****************************************************

   247  *

   248  * Q3HttpPGHRequest

   249  * (like a Q3HttpNormalRequest, but for the convenience

   250  * functions put(), get() and head() -- i.e. set the

   251  * host header field correctly before sending the

   252  * request)

   253  *

   254  ****************************************************/

   255 

   256 class Q3HttpPGHRequest : public Q3HttpNormalRequest

   257 {

   258 public:

   259     Q3HttpPGHRequest( const Q3HttpRequestHeader &h, QIODevice *d, QIODevice *t ) :

   260 	Q3HttpNormalRequest( h, d, t )

   261     { }

   262 

   263     Q3HttpPGHRequest( const Q3HttpRequestHeader &h, QByteArray *d, QIODevice *t ) :

   264 	Q3HttpNormalRequest( h, d, t )

   265     { }

   266 

   267     ~Q3HttpPGHRequest()

   268     { }

   269 

   270     void start( Q3Http * );

   271 };

   272 

   273 void Q3HttpPGHRequest::start( Q3Http *http )

   274 {

   275     header.setValue( QLatin1String("Host"), http->d->hostname );

   276     Q3HttpNormalRequest::start( http );

   277 }

   278 

   279 /****************************************************

   280  *

   281  * Q3HttpSetHostRequest

   282  *

   283  ****************************************************/

   284 

   285 class Q3HttpSetHostRequest : public Q3HttpRequest

   286 {

   287 public:

   288     Q3HttpSetHostRequest( const QString &h, Q_UINT16 p ) :

   289 	hostname(h), port(p)

   290     { }

   291 

   292     void start( Q3Http * );

   293 

   294     QIODevice* sourceDevice()

   295     { return 0; }

   296     QIODevice* destinationDevice()

   297     { return 0; }

   298 

   299 private:

   300     QString hostname;

   301     Q_UINT16 port;

   302 };

   303 

   304 void Q3HttpSetHostRequest::start( Q3Http *http )

   305 {

   306     http->d->hostname = hostname;

   307     http->d->port = port;

   308     http->finishedWithSuccess();

   309 }

   310 

   311 /****************************************************

   312  *

   313  * Q3HttpCloseRequest

   314  *

   315  ****************************************************/

   316 

   317 class Q3HttpCloseRequest : public Q3HttpRequest

   318 {

   319 public:

   320     Q3HttpCloseRequest()

   321     { }

   322     void start( Q3Http * );

   323 

   324     QIODevice* sourceDevice()

   325     { return 0; }

   326     QIODevice* destinationDevice()

   327     { return 0; }

   328 };

   329 

   330 void Q3HttpCloseRequest::start( Q3Http *http )

   331 {

   332     http->close();

   333 }

   334 

   335 /****************************************************

   336  *

   337  * Q3HttpHeader

   338  *

   339  ****************************************************/

   340 

   341 /*!

   342     \class Q3HttpHeader

   343     \brief The Q3HttpHeader class contains header information for HTTP.

   344 

   345     \compat

   346 

   347     In most cases you should use the more specialized derivatives of

   348     this class, Q3HttpResponseHeader and Q3HttpRequestHeader, rather

   349     than directly using Q3HttpHeader.

   350 

   351     Q3HttpHeader provides the HTTP header fields. A HTTP header field

   352     consists of a name followed by a colon, a single space, and the

   353     field value. (See RFC 1945.) Field names are case-insensitive. A

   354     typical header field looks like this:

   355     \snippet doc/src/snippets/code/src_qt3support_network_q3http.cpp 0

   356 

   357     In the API the header field name is called the "key" and the

   358     content is called the "value". You can get and set a header

   359     field's value by using its key with value() and setValue(), e.g.

   360     \snippet doc/src/snippets/code/src_qt3support_network_q3http.cpp 1

   361 

   362     Some fields are so common that getters and setters are provided

   363     for them as a convenient alternative to using \l value() and

   364     \l setValue(), e.g. contentLength() and contentType(),

   365     setContentLength() and setContentType().

   366 

   367     Each header key has a \e single value associated with it. If you

   368     set the value for a key which already exists the previous value

   369     will be discarded.

   370 

   371     \sa Q3HttpRequestHeader Q3HttpResponseHeader

   372 */

   373 

   374 /*!

   375     \fn int Q3HttpHeader::majorVersion() const

   376 

   377     Returns the major protocol-version of the HTTP header.

   378 */

   379 

   380 /*!

   381     \fn int Q3HttpHeader::minorVersion() const

   382 

   383     Returns the minor protocol-version of the HTTP header.

   384 */

   385 

   386 /*!

   387 	Constructs an empty HTTP header.

   388 */

   389 Q3HttpHeader::Q3HttpHeader()

   390     : valid( true )

   391 {

   392 }

   393 

   394 /*!

   395 	Constructs a copy of \a header.

   396 */

   397 Q3HttpHeader::Q3HttpHeader( const Q3HttpHeader& header )

   398     : valid( header.valid )

   399 {

   400     values = header.values;

   401 }

   402 

   403 /*!

   404     Constructs a HTTP header for \a str.

   405 

   406     This constructor parses the string \a str for header fields and

   407     adds this information. The \a str should consist of one or more

   408     "\r\n" delimited lines; each of these lines should have the format

   409     key, colon, space, value.

   410 */

   411 Q3HttpHeader::Q3HttpHeader( const QString& str )

   412     : valid( true )

   413 {

   414     parse( str );

   415 }

   416 

   417 /*!

   418     Destructor.

   419 */

   420 Q3HttpHeader::~Q3HttpHeader()

   421 {

   422 }

   423 

   424 /*!

   425     Assigns \a h and returns a reference to this http header.

   426 */

   427 Q3HttpHeader& Q3HttpHeader::operator=( const Q3HttpHeader& h )

   428 {

   429     values = h.values;

   430     valid = h.valid;

   431     return *this;

   432 }

   433 

   434 /*!

   435     Returns true if the HTTP header is valid; otherwise returns false.

   436 

   437     A Q3HttpHeader is invalid if it was created by parsing a malformed string.

   438 */

   439 bool Q3HttpHeader::isValid() const

   440 {

   441     return valid;

   442 }

   443 

   444 /*! \internal

   445     Parses the HTTP header string \a str for header fields and adds

   446     the keys/values it finds. If the string is not parsed successfully

   447     the Q3HttpHeader becomes \link isValid() invalid\endlink.

   448 

   449     Returns true if \a str was successfully parsed; otherwise returns false.

   450 

   451     \sa toString()

   452 */

   453 bool Q3HttpHeader::parse( const QString& str )

   454 {

   455     QStringList lst;

   456     int pos = str.find( QLatin1Char('\n') );

   457     if ( pos > 0 && str.at( pos - 1 ) == QLatin1Char('\r') )

   458 	lst = QStringList::split( QLatin1String("\r\n"), str.stripWhiteSpace(), false );

   459     else

   460 	lst = QStringList::split( QLatin1String("\n"), str.stripWhiteSpace(), false );

   461 

   462     if ( lst.isEmpty() )

   463 	return true;

   464 

   465     QStringList lines;

   466     QStringList::Iterator it = lst.begin();

   467     for( ; it != lst.end(); ++it ) {

   468 	if ( !(*it).isEmpty() ) {

   469 	    if ( (*it)[0].isSpace() ) {

   470 		if ( !lines.isEmpty() ) {

   471 		    lines.last() += QLatin1Char(' ');

   472 		    lines.last() += (*it).stripWhiteSpace();

   473 		}

   474 	    } else {

   475 		lines.append( (*it) );

   476 	    }

   477 	}

   478     }

   479 

   480     int number = 0;

   481     it = lines.begin();

   482     for( ; it != lines.end(); ++it ) {

   483 	if ( !parseLine( *it, number++ ) ) {

   484 	    valid = false;

   485 	    return false;

   486 	}

   487     }

   488     return true;

   489 }

   490 

   491 /*! \internal

   492 */

   493 void Q3HttpHeader::setValid( bool v )

   494 {

   495     valid = v;

   496 }

   497 

   498 /*!

   499     Returns the value for the entry with the given \a key. If no entry

   500     has this \a key, an empty string is returned.

   501 

   502     \sa setValue() removeValue() hasKey() keys()

   503 */

   504 QString Q3HttpHeader::value( const QString& key ) const

   505 {

   506     return values[ key.lower() ];

   507 }

   508 

   509 /*!

   510     Returns a list of the keys in the HTTP header.

   511 

   512     \sa hasKey()

   513 */

   514 QStringList Q3HttpHeader::keys() const

   515 {

   516     return values.keys();

   517 }

   518 

   519 /*!

   520     Returns true if the HTTP header has an entry with the given \a

   521     key; otherwise returns false.

   522 

   523     \sa value() setValue() keys()

   524 */

   525 bool Q3HttpHeader::hasKey( const QString& key ) const

   526 {

   527     return values.contains( key.lower() );

   528 }

   529 

   530 /*!

   531     Sets the value of the entry with the \a key to \a value.

   532 

   533     If no entry with \a key exists, a new entry with the given \a key

   534     and \a value is created. If an entry with the \a key already

   535     exists, its value is discarded and replaced with the given \a

   536     value.

   537 

   538     \sa value() hasKey() removeValue()

   539 */

   540 void Q3HttpHeader::setValue( const QString& key, const QString& value )

   541 {

   542     values[ key.lower() ] = value;

   543 }

   544 

   545 /*!

   546     Removes the entry with the key \a key from the HTTP header.

   547 

   548     \sa value() setValue()

   549 */

   550 void Q3HttpHeader::removeValue( const QString& key )

   551 {

   552     values.remove( key.lower() );

   553 }

   554 

   555 /*! \internal

   556     Parses the single HTTP header line \a line which has the format

   557     key, colon, space, value, and adds key/value to the headers. The

   558     linenumber is \a number. Returns true if the line was successfully

   559     parsed and the key/value added; otherwise returns false.

   560 

   561     \sa parse()

   562 */

   563 bool Q3HttpHeader::parseLine( const QString& line, int )

   564 {

   565     int i = line.find( QLatin1Char(':') );

   566     if ( i == -1 )

   567 	return false;

   568 

   569     values.insert( line.left( i ).stripWhiteSpace().lower(), line.mid( i + 1 ).stripWhiteSpace() );

   570 

   571     return true;

   572 }

   573 

   574 /*!

   575     Returns a string representation of the HTTP header.

   576 

   577     The string is suitable for use by the constructor that takes a

   578     QString. It consists of lines with the format: key, colon, space,

   579     value, "\r\n".

   580 */

   581 QString Q3HttpHeader::toString() const

   582 {

   583     if ( !isValid() )

   584 	return QLatin1String("");

   585 

   586     QString ret = QLatin1String("");

   587 

   588     QMap<QString,QString>::ConstIterator it = values.begin();

   589     for( ; it != values.end(); ++it )

   590 	ret += it.key() + QLatin1String(": ") + it.data() + QLatin1String("\r\n");

   591 

   592     return ret;

   593 }

   594 

   595 /*!

   596     Returns true if the header has an entry for the special HTTP

   597     header field \c content-length; otherwise returns false.

   598 

   599     \sa contentLength() setContentLength()

   600 */

   601 bool Q3HttpHeader::hasContentLength() const

   602 {

   603     return hasKey( QLatin1String("content-length") );

   604 }

   605 

   606 /*!

   607     Returns the value of the special HTTP header field \c

   608     content-length.

   609 

   610     \sa setContentLength() hasContentLength()

   611 */

   612 uint Q3HttpHeader::contentLength() const

   613 {

   614     return values[ QLatin1String("content-length") ].toUInt();

   615 }

   616 

   617 /*!

   618     Sets the value of the special HTTP header field \c content-length

   619     to \a len.

   620 

   621     \sa contentLength() hasContentLength()

   622 */

   623 void Q3HttpHeader::setContentLength( int len )

   624 {

   625     values[ QLatin1String("content-length") ] = QString::number( len );

   626 }

   627 

   628 /*!

   629     Returns true if the header has an entry for the special HTTP

   630     header field \c content-type; otherwise returns false.

   631 

   632     \sa contentType() setContentType()

   633 */

   634 bool Q3HttpHeader::hasContentType() const

   635 {

   636     return hasKey( QLatin1String("content-type") );

   637 }

   638 

   639 /*!

   640     Returns the value of the special HTTP header field \c content-type.

   641 

   642     \sa setContentType() hasContentType()

   643 */

   644 QString Q3HttpHeader::contentType() const

   645 {

   646     QString type = values[ QLatin1String("content-type") ];

   647     if ( type.isEmpty() )

   648 	return QString();

   649 

   650     int pos = type.find( QLatin1Char(';') );

   651     if ( pos == -1 )

   652 	return type;

   653 

   654     return type.left( pos ).stripWhiteSpace();

   655 }

   656 

   657 /*!

   658     Sets the value of the special HTTP header field \c content-type to

   659     \a type.

   660 

   661     \sa contentType() hasContentType()

   662 */

   663 void Q3HttpHeader::setContentType( const QString& type )

   664 {

   665     values[ QLatin1String("content-type") ] = type;

   666 }

   667 

   668 /****************************************************

   669  *

   670  * Q3HttpResponseHeader

   671  *

   672  ****************************************************/

   673 

   674 /*!

   675     \class Q3HttpResponseHeader

   676     \brief The Q3HttpResponseHeader class contains response header information for HTTP.

   677 

   678     \compat

   679 

   680     This class is used by the Q3Http class to report the header

   681     information that the client received from the server.

   682 

   683     HTTP responses have a status code that indicates the status of the

   684     response. This code is a 3-digit integer result code (for details

   685     see to RFC 1945). In addition to the status code, you can also

   686     specify a human-readable text that describes the reason for the

   687     code ("reason phrase"). This class allows you to get the status

   688     code and the reason phrase.

   689 

   690     \sa Q3HttpRequestHeader Q3Http

   691 */

   692 

   693 /*!

   694     Constructs an empty HTTP response header.

   695 */

   696 Q3HttpResponseHeader::Q3HttpResponseHeader()

   697 {

   698     setValid( false );

   699 }

   700 

   701 /*!

   702     Constructs a HTTP response header with the status code \a code,

   703     the reason phrase \a text and the protocol-version \a majorVer and

   704     \a minorVer.

   705 */

   706 Q3HttpResponseHeader::Q3HttpResponseHeader( int code, const QString& text, int majorVer, int minorVer )

   707     : Q3HttpHeader(), statCode( code ), reasonPhr( text ), majVer( majorVer ), minVer( minorVer )

   708 {

   709 }

   710 

   711 /*!

   712     Constructs a copy of \a header.

   713 */

   714 Q3HttpResponseHeader::Q3HttpResponseHeader( const Q3HttpResponseHeader& header )

   715     : Q3HttpHeader( header ), statCode( header.statCode ), reasonPhr( header.reasonPhr ), majVer( header.majVer ), minVer( header.minVer )

   716 {

   717 }

   718 

   719 /*!

   720     Constructs a HTTP response header from the string \a str. The

   721     string is parsed and the information is set. The \a str should

   722     consist of one or more "\r\n" delimited lines; the first line should be the

   723     status-line (format: HTTP-version, space, status-code, space,

   724     reason-phrase); each of remaining lines should have the format key, colon,

   725     space, value.

   726 */

   727 Q3HttpResponseHeader::Q3HttpResponseHeader( const QString& str )

   728     : Q3HttpHeader()

   729 {

   730     parse( str );

   731 }

   732 

   733 /*!

   734     Sets the status code to \a code, the reason phrase to \a text and

   735     the protocol-version to \a majorVer and \a minorVer.

   736 

   737     \sa statusCode() reasonPhrase() majorVersion() minorVersion()

   738 */

   739 void Q3HttpResponseHeader::setStatusLine( int code, const QString& text, int majorVer, int minorVer )

   740 {

   741     setValid( true );

   742     statCode = code;

   743     reasonPhr = text;

   744     majVer = majorVer;

   745     minVer = minorVer;

   746 }

   747 

   748 /*!

   749     Returns the status code of the HTTP response header.

   750 

   751     \sa reasonPhrase() majorVersion() minorVersion()

   752 */

   753 int Q3HttpResponseHeader::statusCode() const

   754 {

   755     return statCode;

   756 }

   757 

   758 /*!

   759     Returns the reason phrase of the HTTP response header.

   760 

   761     \sa statusCode() majorVersion() minorVersion()

   762 */

   763 QString Q3HttpResponseHeader::reasonPhrase() const

   764 {

   765     return reasonPhr;

   766 }

   767 

   768 /*!

   769     Returns the major protocol-version of the HTTP response header.

   770 

   771     \sa minorVersion() statusCode() reasonPhrase()

   772 */

   773 int Q3HttpResponseHeader::majorVersion() const

   774 {

   775     return majVer;

   776 }

   777 

   778 /*!

   779     Returns the minor protocol-version of the HTTP response header.

   780 

   781     \sa majorVersion() statusCode() reasonPhrase()

   782 */

   783 int Q3HttpResponseHeader::minorVersion() const

   784 {

   785     return minVer;

   786 }

   787 

   788 /*! \internal

   789 */

   790 bool Q3HttpResponseHeader::parseLine( const QString& line, int number )

   791 {

   792     if ( number != 0 )

   793 	return Q3HttpHeader::parseLine( line, number );

   794 

   795     QString l = line.simplifyWhiteSpace();

   796     if ( l.length() < 10 )

   797 	return false;

   798 

   799     if ( l.left( 5 ) == QLatin1String("HTTP/") && l[5].isDigit() && l[6] == QLatin1Char('.') &&

   800 	    l[7].isDigit() && l[8] == QLatin1Char(' ') && l[9].isDigit() ) {

   801 	majVer = l[5].latin1() - '0';

   802 	minVer = l[7].latin1() - '0';

   803 

   804 	int pos = l.find( QLatin1Char(' '), 9 );

   805 	if ( pos != -1 ) {

   806 	    reasonPhr = l.mid( pos + 1 );

   807 	    statCode = l.mid( 9, pos - 9 ).toInt();

   808 	} else {

   809 	    statCode = l.mid( 9 ).toInt();

   810 	    reasonPhr.clear();

   811 	}

   812     } else {

   813 	return false;

   814     }

   815 

   816     return true;

   817 }

   818 

   819 /*! \reimp

   820 */

   821 QString Q3HttpResponseHeader::toString() const

   822 {

   823     QString ret( QLatin1String("HTTP/%1.%2 %3 %4\r\n%5\r\n") );

   824     return ret.arg( majVer ).arg ( minVer ).arg( statCode ).arg( reasonPhr ).arg( Q3HttpHeader::toString() );

   825 }

   826 

   827 /****************************************************

   828  *

   829  * Q3HttpRequestHeader

   830  *

   831  ****************************************************/

   832 

   833 /*!

   834     \class Q3HttpRequestHeader

   835     \brief The Q3HttpRequestHeader class contains request header information for

   836     HTTP.

   837 

   838     \compat

   839 

   840     This class is used in the Q3Http class to report the header

   841     information if the client requests something from the server.

   842 

   843     HTTP requests have a method which describes the request's action.

   844     The most common requests are "GET" and "POST". In addition to the

   845     request method the header also includes a request-URI to specify

   846     the location for the method to use.

   847 

   848     The method, request-URI and protocol-version can be set using a

   849     constructor or later using setRequest(). The values can be

   850     obtained using method(), path(), majorVersion() and

   851     minorVersion().

   852 

   853     This class is a Q3HttpHeader subclass so that class's functions,

   854     e.g. \link Q3HttpHeader::setValue() setValue()\endlink, \link

   855     Q3HttpHeader::value() value()\endlink, etc. are also available.

   856 

   857     \sa Q3HttpResponseHeader Q3Http

   858 */

   859 

   860 /*!

   861     Constructs an empty HTTP request header.

   862 */

   863 Q3HttpRequestHeader::Q3HttpRequestHeader()

   864     : Q3HttpHeader()

   865 {

   866     setValid( false );

   867 }

   868 

   869 /*!

   870     Constructs a HTTP request header for the method \a method, the

   871     request-URI \a path and the protocol-version \a majorVer and \a minorVer.

   872 */

   873 Q3HttpRequestHeader::Q3HttpRequestHeader( const QString& method, const QString& path, int majorVer, int minorVer )

   874     : Q3HttpHeader(), m( method ), p( path ), majVer( majorVer ), minVer( minorVer )

   875 {

   876 }

   877 

   878 /*!

   879     Constructs a copy of \a header.

   880 */

   881 Q3HttpRequestHeader::Q3HttpRequestHeader( const Q3HttpRequestHeader& header )

   882     : Q3HttpHeader( header ), m( header.m ), p( header.p ), majVer( header.majVer ), minVer( header.minVer )

   883 {

   884 }

   885 

   886 /*!

   887     Constructs a HTTP request header from the string \a str. The \a

   888     str should consist of one or more "\r\n" delimited lines; the first line

   889     should be the request-line (format: method, space, request-URI, space

   890     HTTP-version); each of the remaining lines should have the format key,

   891     colon, space, value.

   892 */

   893 Q3HttpRequestHeader::Q3HttpRequestHeader( const QString& str )

   894     : Q3HttpHeader()

   895 {

   896     parse( str );

   897 }

   898 

   899 /*!

   900     This function sets the request method to \a method, the

   901     request-URI to \a path and the protocol-version to \a majorVer and

   902     \a minorVer.

   903 

   904     \sa method() path() majorVersion() minorVersion()

   905 */

   906 void Q3HttpRequestHeader::setRequest( const QString& method, const QString& path, int majorVer, int minorVer )

   907 {

   908     setValid( true );

   909     m = method;

   910     p = path;

   911     majVer = majorVer;

   912     minVer = minorVer;

   913 }

   914 

   915 /*!

   916     Returns the method of the HTTP request header.

   917 

   918     \sa path() majorVersion() minorVersion() setRequest()

   919 */

   920 QString Q3HttpRequestHeader::method() const

   921 {

   922     return m;

   923 }

   924 

   925 /*!

   926     Returns the request-URI of the HTTP request header.

   927 

   928     \sa method() majorVersion() minorVersion() setRequest()

   929 */

   930 QString Q3HttpRequestHeader::path() const

   931 {

   932     return p;

   933 }

   934 

   935 /*!

   936     Returns the major protocol-version of the HTTP request header.

   937 

   938     \sa minorVersion() method() path() setRequest()

   939 */

   940 int Q3HttpRequestHeader::majorVersion() const

   941 {

   942     return majVer;

   943 }

   944 

   945 /*!

   946     Returns the minor protocol-version of the HTTP request header.

   947 

   948     \sa majorVersion() method() path() setRequest()

   949 */

   950 int Q3HttpRequestHeader::minorVersion() const

   951 {

   952     return minVer;

   953 }

   954 

   955 /*! \internal

   956 */

   957 bool Q3HttpRequestHeader::parseLine( const QString& line, int number )

   958 {

   959     if ( number != 0 )

   960 	return Q3HttpHeader::parseLine( line, number );

   961 

   962     QStringList lst = QStringList::split( QLatin1String(" "), line.simplifyWhiteSpace() );

   963     if ( lst.count() > 0 ) {

   964 	m = lst[0];

   965 	if ( lst.count() > 1 ) {

   966 	    p = lst[1];

   967 	    if ( lst.count() > 2 ) {

   968 		QString v = lst[2];

   969 		if ( v.length() >= 8 && v.left( 5 ) == QLatin1String("HTTP/") &&

   970 			v[5].isDigit() && v[6] == QLatin1Char('.') && v[7].isDigit() ) {

   971 		    majVer = v[5].latin1() - '0';

   972 		    minVer = v[7].latin1() - '0';

   973 		    return true;

   974 		}

   975 	    }

   976 	}

   977     }

   978 

   979     return false;

   980 }

   981 

   982 /*! \reimp

   983 */

   984 QString Q3HttpRequestHeader::toString() const

   985 {

   986     QString first( QLatin1String("%1 %2"));

   987     QString last(QLatin1String(" HTTP/%3.%4\r\n%5\r\n") );

   988     return first.arg( m ).arg( p ) +

   989 	last.arg( majVer ).arg( minVer ).arg( Q3HttpHeader::toString());

   990 }

   991 

   992 

   993 /****************************************************

   994  *

   995  * Q3Http

   996  *

   997  ****************************************************/

   998 /*!

   999     \class Q3Http

  1000     \brief The Q3Http class provides an implementation of the HTTP protocol.

  1001 

  1002     \compat

  1003 

  1004     This class provides two different interfaces: one is the

  1005     Q3NetworkProtocol interface that allows you to use HTTP through the

  1006     QUrlOperator abstraction. The other is a direct interface to HTTP

  1007     that allows you to have more control over the requests and that

  1008     allows you to access the response header fields.

  1009 

  1010     Don't mix the two interfaces, since the behavior is not

  1011     well-defined.

  1012 

  1013     If you want to use Q3Http with the Q3NetworkProtocol interface, you

  1014     do not use it directly, but rather through a QUrlOperator, for

  1015     example:

  1016 

  1017     \snippet doc/src/snippets/code/src_qt3support_network_q3http.cpp 2

  1018 

  1019     This code will only work if the Q3Http class is registered; to

  1020     register the class, you must call q3InitNetworkProtocols() before

  1021     using a QUrlOperator with HTTP.

  1022 

  1023     The Q3NetworkProtocol interface for HTTP only supports the

  1024     operations operationGet() and operationPut(), i.e.

  1025     QUrlOperator::get() and QUrlOperator::put(), if you use it with a

  1026     QUrlOperator.

  1027 

  1028     The rest of this descrption describes the direct interface to

  1029     HTTP.

  1030 

  1031     The class works asynchronously, so there are no blocking

  1032     functions. If an operation cannot be executed immediately, the

  1033     function will still return straight away and the operation will be

  1034     scheduled for later execution. The results of scheduled operations

  1035     are reported via signals. This approach depends on the event loop

  1036     being in operation.

  1037 

  1038     The operations that can be scheduled (they are called "requests"

  1039     in the rest of the documentation) are the following: setHost(),

  1040     get(), post(), head() and request().

  1041 

  1042     All of these requests return a unique identifier that allows you

  1043     to keep track of the request that is currently executed. When the

  1044     execution of a request starts, the requestStarted() signal with

  1045     the identifier is emitted and when the request is finished, the

  1046     requestFinished() signal is emitted with the identifier and a bool

  1047     that indicates if the request finished with an error.

  1048 

  1049     To make an HTTP request you must set up suitable HTTP headers. The

  1050     following example demonstrates, how to request the main HTML page

  1051     from the Qt website (i.e. the URL \c http://qt.nokia.com/index.html):

  1052 

  1053     \snippet doc/src/snippets/code/src_qt3support_network_q3http.cpp 3

  1054 

  1055     For the common HTTP requests \c GET, \c POST and \c HEAD, Q3Http

  1056     provides the convenience functions get(), post() and head(). They

  1057     already use a reasonable header and if you don't have to set

  1058     special header fields, they are easier to use. The above example

  1059     can also be written as:

  1060 

  1061     \snippet doc/src/snippets/code/src_qt3support_network_q3http.cpp 4

  1062 

  1063     For this example the following sequence of signals is emitted

  1064     (with small variations, depending on network traffic, etc.):

  1065 

  1066     \snippet doc/src/snippets/code/src_qt3support_network_q3http.cpp 5

  1067 

  1068     The dataSendProgress() and dataReadProgress() signals in the above

  1069     example are useful if you want to show a \link QProgressBar

  1070     progress bar\endlink to inform the user about the progress of the

  1071     download. The second argument is the total size of data. In

  1072     certain cases it is not possible to know the total amount in

  1073     advance, in which case the second argument is 0. (If you connect

  1074     to a QProgressBar a total of 0 results in a busy indicator.)

  1075 

  1076     When the response header is read, it is reported with the

  1077     responseHeaderReceived() signal.

  1078 

  1079     The readyRead() signal tells you that there is data ready to be

  1080     read. The amount of data can then be queried with the

  1081     bytesAvailable() function and it can be read with the readBlock()

  1082     or readAll() functions.

  1083 

  1084     If an error occurs during the execution of one of the commands in

  1085     a sequence of commands, all the pending commands (i.e. scheduled,

  1086     but not yet executed commands) are cleared and no signals are

  1087     emitted for them.

  1088 

  1089     For example, if you have the following sequence of reqeusts

  1090 

  1091     \snippet doc/src/snippets/code/src_qt3support_network_q3http.cpp 6

  1092 

  1093     and the get() request fails because the host lookup fails, then

  1094     the post() request is never executed and the signals would look

  1095     like this:

  1096 

  1097     \snippet doc/src/snippets/code/src_qt3support_network_q3http.cpp 7

  1098 

  1099     You can then get details about the error with the error() and

  1100     errorString() functions. Note that only unexpected behaviour, like

  1101     network failure is considered as an error. If the server response

  1102     contains an error status, like a 404 response, this is reported as

  1103     a normal response case. So you should always check the \link

  1104     Q3HttpResponseHeader::statusCode() status code \endlink of the

  1105     response header.

  1106 

  1107     The functions currentId() and currentRequest() provide more

  1108     information about the currently executing request.

  1109 

  1110     The functions hasPendingRequests() and clearPendingRequests()

  1111     allow you to query and clear the list of pending requests.

  1112 

  1113     \sa Q3NetworkProtocol, Q3UrlOperator, Q3Ftp

  1114 */

  1115 

  1116 /*!

  1117     Constructs a Q3Http object.

  1118 */

  1119 Q3Http::Q3Http()

  1120 {

  1121     init();

  1122 }

  1123 

  1124 /*!

  1125     Constructs a Q3Http object. The parameters \a parent and \a name

  1126     are passed on to the QObject constructor.

  1127 */

  1128 Q3Http::Q3Http( QObject* parent, const char* name )

  1129 {

  1130     if ( parent )

  1131 	parent->insertChild( this );

  1132     setName( name );

  1133     init();

  1134 }