diff options
Diffstat (limited to 'tqtinterface/qt4/src/network/tqhttp.cpp')
| -rw-r--r-- | tqtinterface/qt4/src/network/tqhttp.cpp | 2384 |
1 files changed, 2384 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/network/tqhttp.cpp b/tqtinterface/qt4/src/network/tqhttp.cpp new file mode 100644 index 0000000..7d324ea --- /dev/null +++ b/tqtinterface/qt4/src/network/tqhttp.cpp @@ -0,0 +1,2384 @@ +/**************************************************************************** +** +** Implementation of TQHttp and related classes. +** +** Created : 970521 +** +** Copyright (C) 1997-2008 Trolltech ASA. All rights reserved. +** +** This file is part of the network module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#include "tqhttp.h" + +#ifndef TQT_NO_NETWORKPROTOCOL_HTTP + +#include "tqsocket.h" +#include "tqtextstream.h" +#include "tqmap.h" +#include "tqstring.h" +#include "tqstringlist.h" +#include "tqcstring.h" +#include "tqbuffer.h" +#include "tqurloperator.h" +#include "tqtimer.h" +#include "private/tqinternal_p.h" + +//#define TQHTTP_DEBUG + +class TQHttpPrivate +{ +public: + TQHttpPrivate() : + state( TQHttp::Unconnected ), + error( TQHttp::NoError ), + hostname( TQString::null ), + port( 0 ), + toDevice( 0 ), + postDevice( 0 ), + bytesDone( 0 ), + chunkedSize( -1 ), + idleTimer( 0 ) + { + pending.setAutoDelete( TRUE ); + } + + TQSocket socket; + TQPtrList<TQHttpRequest> pending; + + TQHttp::State state; + TQHttp::Error error; + TQString errorString; + + TQString hostname; + TQ_UINT16 port; + + TQByteArray buffer; + TQIODevice* toDevice; + TQIODevice* postDevice; + + uint bytesDone; + uint bytesTotal; + TQ_LONG chunkedSize; + + TQHttpRequestHeader header; + + bool readHeader; + TQString headerStr; + TQHttpResponseHeader response; + + int idleTimer; + + TQMembuf rba; +}; + +class TQHttpRequest +{ +public: + TQHttpRequest() + { + id = ++idCounter; + } + virtual ~TQHttpRequest() + { } + + virtual void start( TQHttp * ) = 0; + virtual bool hasRequestHeader(); + virtual TQHttpRequestHeader requestHeader(); + + virtual TQIODevice* sourceDevice() = 0; + virtual TQIODevice* destinationDevice() = 0; + + int id; + +private: + static int idCounter; +}; + +int TQHttpRequest::idCounter = 0; + +bool TQHttpRequest::hasRequestHeader() +{ + return FALSE; +} + +TQHttpRequestHeader TQHttpRequest::requestHeader() +{ + return TQHttpRequestHeader(); +} + +/**************************************************** + * + * TQHttpNormalRequest + * + ****************************************************/ + +class TQHttpNormalRequest : public TQHttpRequest +{ +public: + TQHttpNormalRequest( const TQHttpRequestHeader &h, TQIODevice *d, TQIODevice *t ) : + header(h), to(t) + { + is_ba = FALSE; + data.dev = d; + } + + TQHttpNormalRequest( const TQHttpRequestHeader &h, TQByteArray *d, TQIODevice *t ) : + header(h), to(t) + { + is_ba = TRUE; + data.ba = d; + } + + ~TQHttpNormalRequest() + { + if ( is_ba ) + delete data.ba; + } + + void start( TQHttp * ); + bool hasRequestHeader(); + TQHttpRequestHeader requestHeader(); + + TQIODevice* sourceDevice(); + TQIODevice* destinationDevice(); + +protected: + TQHttpRequestHeader header; + +private: + union { + TQByteArray *ba; + TQIODevice *dev; + } data; + bool is_ba; + TQIODevice *to; +}; + +void TQHttpNormalRequest::start( TQHttp *http ) +{ + http->d->header = header; + + if ( is_ba ) { + http->d->buffer = *data.ba; + if ( http->d->buffer.size() > 0 ) + http->d->header.setContentLength( http->d->buffer.size() ); + + http->d->postDevice = 0; + } else { + http->d->buffer = TQByteArray(); + + if ( data.dev && ( data.dev->isOpen() || data.dev->open(IO_ReadOnly) ) ) { + http->d->postDevice = data.dev; + if ( http->d->postDevice->size() > 0 ) + http->d->header.setContentLength( http->d->postDevice->size() ); + } else { + http->d->postDevice = 0; + } + } + + if ( to && ( to->isOpen() || to->open(IO_WriteOnly) ) ) + http->d->toDevice = to; + else + http->d->toDevice = 0; + + http->sendRequest(); +} + +bool TQHttpNormalRequest::hasRequestHeader() +{ + return TRUE; +} + +TQHttpRequestHeader TQHttpNormalRequest::requestHeader() +{ + return header; +} + +TQIODevice* TQHttpNormalRequest::sourceDevice() +{ + if ( is_ba ) + return 0; + return data.dev; +} + +TQIODevice* TQHttpNormalRequest::destinationDevice() +{ + return to; +} + +/**************************************************** + * + * TQHttpPGHRequest + * (like a TQHttpNormalRequest, but for the convenience + * functions put(), get() and head() -- i.e. set the + * host header field correctly before sending the + * request) + * + ****************************************************/ + +class TQHttpPGHRequest : public TQHttpNormalRequest +{ +public: + TQHttpPGHRequest( const TQHttpRequestHeader &h, TQIODevice *d, TQIODevice *t ) : + TQHttpNormalRequest( h, d, t ) + { } + + TQHttpPGHRequest( const TQHttpRequestHeader &h, TQByteArray *d, TQIODevice *t ) : + TQHttpNormalRequest( h, d, t ) + { } + + ~TQHttpPGHRequest() + { } + + void start( TQHttp * ); +}; + +void TQHttpPGHRequest::start( TQHttp *http ) +{ + header.setValue( "Host", http->d->hostname ); + TQHttpNormalRequest::start( http ); +} + +/**************************************************** + * + * TQHttpSetHostRequest + * + ****************************************************/ + +class TQHttpSetHostRequest : public TQHttpRequest +{ +public: + TQHttpSetHostRequest( const TQString &h, TQ_UINT16 p ) : + hostname(h), port(p) + { } + + void start( TQHttp * ); + + TQIODevice* sourceDevice() + { return 0; } + TQIODevice* destinationDevice() + { return 0; } + +private: + TQString hostname; + TQ_UINT16 port; +}; + +void TQHttpSetHostRequest::start( TQHttp *http ) +{ + http->d->hostname = hostname; + http->d->port = port; + http->finishedWithSuccess(); +} + +/**************************************************** + * + * TQHttpCloseRequest + * + ****************************************************/ + +class TQHttpCloseRequest : public TQHttpRequest +{ +public: + TQHttpCloseRequest() + { } + void start( TQHttp * ); + + TQIODevice* sourceDevice() + { return 0; } + TQIODevice* destinationDevice() + { return 0; } +}; + +void TQHttpCloseRequest::start( TQHttp *http ) +{ + http->close(); +} + +/**************************************************** + * + * TQHttpHeader + * + ****************************************************/ + +/*! + \class TQHttpHeader tqhttp.h + \brief The TQHttpHeader class tqcontains header information for HTTP. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup io + \module network + + In most cases you should use the more specialized derivatives of + this class, TQHttpResponseHeader and TQHttpRequestHeader, rather + than directly using TQHttpHeader. + + TQHttpHeader provides the HTTP header fields. A HTTP header field + consists of a name followed by a colon, a single space, and the + field value. (See RFC 1945.) Field names are case-insensitive. A + typical header field looks like this: + \code + content-type: text/html + \endcode + + In the API the header field name is called the "key" and the + content is called the "value". You can get and set a header + field's value by using its key with value() and setValue(), e.g. + \code + header.setValue( "content-type", "text/html" ); + TQString contentType = header.value( "content-type" ); + \endcode + + Some fields are so common that getters and setters are provided + for them as a convenient alternative to using \l value() and + \l setValue(), e.g. contentLength() and contentType(), + setContentLength() and setContentType(). + + Each header key has a \e single value associated with it. If you + set the value for a key which already exists the previous value + will be discarded. + + \sa TQHttpRequestHeader TQHttpResponseHeader +*/ + +/*! + \fn int TQHttpHeader::majorVersion() const + + Returns the major protocol-version of the HTTP header. +*/ + +/*! + \fn int TQHttpHeader::minorVersion() const + + Returns the minor protocol-version of the HTTP header. +*/ + +/*! + Constructs an empty HTTP header. +*/ +TQHttpHeader::TQHttpHeader() + : valid( TRUE ) +{ +} + +/*! + Constructs a copy of \a header. +*/ +TQHttpHeader::TQHttpHeader( const TQHttpHeader& header ) + : valid( header.valid ) +{ + values = header.values; +} + +/*! + Constructs a HTTP header for \a str. + + This constructor parses the string \a str for header fields and + adds this information. The \a str should consist of one or more + "\r\n" delimited lines; each of these lines should have the format + key, colon, space, value. +*/ +TQHttpHeader::TQHttpHeader( const TQString& str ) + : valid( TRUE ) +{ + parse( str ); +} + +/*! + Destructor. +*/ +TQHttpHeader::~TQHttpHeader() +{ +} + +/*! + Assigns \a h and returns a reference to this http header. +*/ +TQHttpHeader& TQHttpHeader::operator=( const TQHttpHeader& h ) +{ + values = h.values; + valid = h.valid; + return *this; +} + +/*! + Returns TRUE if the HTTP header is valid; otherwise returns FALSE. + + A TQHttpHeader is invalid if it was created by parsing a malformed string. +*/ +bool TQHttpHeader::isValid() const +{ + return valid; +} + +/*! \internal + Parses the HTTP header string \a str for header fields and adds + the keys/values it tqfinds. If the string is not parsed successfully + the TQHttpHeader becomes \link isValid() invalid\endlink. + + Returns TRUE if \a str was successfully parsed; otherwise returns FALSE. + + \sa toString() +*/ +bool TQHttpHeader::parse( const TQString& str ) +{ + TQStringList lst; + int pos = str.tqfind( '\n' ); + if ( pos > 0 && str.at( pos - 1 ) == '\r' ) + lst = TQStringList::split( "\r\n", str.stripWhiteSpace(), FALSE ); + else + lst = TQStringList::split( "\n", str.stripWhiteSpace(), FALSE ); + + if ( lst.isEmpty() ) + return TRUE; + + TQStringList lines; + TQStringList::Iterator it = lst.begin(); + for( ; it != lst.end(); ++it ) { + if ( !(*it).isEmpty() ) { + if ( (*it)[0].isSpace() ) { + if ( !lines.isEmpty() ) { + lines.last() += " "; + lines.last() += (*it).stripWhiteSpace(); + } + } else { + lines.append( (*it) ); + } + } + } + + int number = 0; + it = lines.begin(); + for( ; it != lines.end(); ++it ) { + if ( !parseLine( *it, number++ ) ) { + valid = FALSE; + return FALSE; + } + } + return TRUE; +} + +/*! \internal +*/ +void TQHttpHeader::setValid( bool v ) +{ + valid = v; +} + +/*! + Returns the value for the entry with the given \a key. If no entry + has this \a key, an empty string is returned. + + \sa setValue() removeValue() hasKey() keys() +*/ +TQString TQHttpHeader::value( const TQString& key ) const +{ + return values[ key.lower() ]; +} + +/*! + Returns a list of the keys in the HTTP header. + + \sa hasKey() +*/ +TQStringList TQHttpHeader::keys() const +{ + return values.keys(); +} + +/*! + Returns TRUE if the HTTP header has an entry with the given \a + key; otherwise returns FALSE. + + \sa value() setValue() keys() +*/ +bool TQHttpHeader::hasKey( const TQString& key ) const +{ + return values.tqcontains( key.lower() ); +} + +/*! + Sets the value of the entry with the \a key to \a value. + + If no entry with \a key exists, a new entry with the given \a key + and \a value is created. If an entry with the \a key already + exists, its value is discarded and tqreplaced with the given \a + value. + + \sa value() hasKey() removeValue() +*/ +void TQHttpHeader::setValue( const TQString& key, const TQString& value ) +{ + values[ key.lower() ] = value; +} + +/*! + Removes the entry with the key \a key from the HTTP header. + + \sa value() setValue() +*/ +void TQHttpHeader::removeValue( const TQString& key ) +{ + values.remove( key.lower() ); +} + +/*! \internal + Parses the single HTTP header line \a line which has the format + key, colon, space, value, and adds key/value to the headers. The + linenumber is \a number. Returns TRUE if the line was successfully + parsed and the key/value added; otherwise returns FALSE. + + \sa parse() +*/ +bool TQHttpHeader::parseLine( const TQString& line, int ) +{ + int i = line.tqfind( ":" ); + if ( i == -1 ) + return FALSE; + + values.insert( TQT_TQSTRING(line.left( i )).stripWhiteSpace().lower(), TQT_TQSTRING(line.mid( i + 1 )).stripWhiteSpace() ); + + return TRUE; +} + +/*! + Returns a string representation of the HTTP header. + + The string is suitable for use by the constructor that takes a + TQString. It consists of lines with the format: key, colon, space, + value, "\r\n". +*/ +TQString TQHttpHeader::toString() const +{ + if ( !isValid() ) + return ""; + + TQString ret = ""; + + TQMap<TQString,TQString>::ConstIterator it = values.begin(); + for( ; it != values.end(); ++it ) + ret += it.key() + ": " + it.data() + "\r\n"; + + return ret; +} + +/*! + Returns TRUE if the header has an entry for the special HTTP + header field \c content-length; otherwise returns FALSE. + + \sa contentLength() setContentLength() +*/ +bool TQHttpHeader::hasContentLength() const +{ + return hasKey( "content-length" ); +} + +/*! + Returns the value of the special HTTP header field \c + content-length. + + \sa setContentLength() hasContentLength() +*/ +uint TQHttpHeader::contentLength() const +{ + return values[ "content-length" ].toUInt(); +} + +/*! + Sets the value of the special HTTP header field \c content-length + to \a len. + + \sa contentLength() hasContentLength() +*/ +void TQHttpHeader::setContentLength( int len ) +{ + values[ "content-length" ] = TQString::number( len ); +} + +/*! + Returns TRUE if the header has an entry for the the special HTTP + header field \c content-type; otherwise returns FALSE. + + \sa contentType() setContentType() +*/ +bool TQHttpHeader::hasContentType() const +{ + return hasKey( "content-type" ); +} + +/*! + Returns the value of the special HTTP header field \c content-type. + + \sa setContentType() hasContentType() +*/ +TQString TQHttpHeader::contentType() const +{ + TQString type = values[ "content-type" ]; + if ( type.isEmpty() ) + return TQString::null; + + int pos = type.tqfind( ";" ); + if ( pos == -1 ) + return type; + + return TQT_TQSTRING(type.left( pos )).stripWhiteSpace(); +} + +/*! + Sets the value of the special HTTP header field \c content-type to + \a type. + + \sa contentType() hasContentType() +*/ +void TQHttpHeader::setContentType( const TQString& type ) +{ + values[ "content-type" ] = type; +} + +/**************************************************** + * + * TQHttpResponseHeader + * + ****************************************************/ + +/*! + \class TQHttpResponseHeader tqhttp.h + \brief The TQHttpResponseHeader class tqcontains response header information for HTTP. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup io + \module network + + This class is used by the TQHttp class to report the header + information that the client received from the server. + + HTTP responses have a status code that indicates the status of the + response. This code is a 3-digit integer result code (for details + see to RFC 1945). In addition to the status code, you can also + specify a human-readable text that describes the reason for the + code ("reason phrase"). This class allows you to get the status + code and the reason phrase. + + \sa TQHttpRequestHeader TQHttp +*/ + +/*! + Constructs an empty HTTP response header. +*/ +TQHttpResponseHeader::TQHttpResponseHeader() +{ + setValid( FALSE ); +} + +/*! + Constructs a HTTP response header with the status code \a code, + the reason phrase \a text and the protocol-version \a majorVer and + \a minorVer. +*/ +TQHttpResponseHeader::TQHttpResponseHeader( int code, const TQString& text, int majorVer, int minorVer ) + : TQHttpHeader(), statCode( code ), reasonPhr( text ), majVer( majorVer ), minVer( minorVer ) +{ +} + +/*! + Constructs a copy of \a header. +*/ +TQHttpResponseHeader::TQHttpResponseHeader( const TQHttpResponseHeader& header ) + : TQHttpHeader( header ), statCode( header.statCode ), reasonPhr( header.reasonPhr ), majVer( header.majVer ), minVer( header.minVer ) +{ +} + +/*! + Constructs a HTTP response header from the string \a str. The + string is parsed and the information is set. The \a str should + consist of one or more "\r\n" delimited lines; the first line should be the + status-line (format: HTTP-version, space, status-code, space, + reason-phrase); each of remaining lines should have the format key, colon, + space, value. +*/ +TQHttpResponseHeader::TQHttpResponseHeader( const TQString& str ) + : TQHttpHeader() +{ + parse( str ); +} + +/*! + Sets the status code to \a code, the reason phrase to \a text and + the protocol-version to \a majorVer and \a minorVer. + + \sa statusCode() reasonPhrase() majorVersion() minorVersion() +*/ +void TQHttpResponseHeader::setqStatusLine( int code, const TQString& text, int majorVer, int minorVer ) +{ + setValid( TRUE ); + statCode = code; + reasonPhr = text; + majVer = majorVer; + minVer = minorVer; +} + +/*! + Returns the status code of the HTTP response header. + + \sa reasonPhrase() majorVersion() minorVersion() +*/ +int TQHttpResponseHeader::statusCode() const +{ + return statCode; +} + +/*! + Returns the reason phrase of the HTTP response header. + + \sa statusCode() majorVersion() minorVersion() +*/ +TQString TQHttpResponseHeader::reasonPhrase() const +{ + return reasonPhr; +} + +/*! + Returns the major protocol-version of the HTTP response header. + + \sa minorVersion() statusCode() reasonPhrase() +*/ +int TQHttpResponseHeader::majorVersion() const +{ + return majVer; +} + +/*! + Returns the minor protocol-version of the HTTP response header. + + \sa majorVersion() statusCode() reasonPhrase() +*/ +int TQHttpResponseHeader::minorVersion() const +{ + return minVer; +} + +/*! \reimp +*/ +bool TQHttpResponseHeader::parseLine( const TQString& line, int number ) +{ + if ( number != 0 ) + return TQHttpHeader::parseLine( line, number ); + + TQString l = line.simplifyWhiteSpace(); + if ( l.length() < 10 ) + return FALSE; + + if ( l.left( 5 ) == "HTTP/" && l[5].isDigit() && l[6] == '.' && + l[7].isDigit() && l[8] == ' ' && l[9].isDigit() ) { + majVer = l[5].latin1() - '0'; + minVer = l[7].latin1() - '0'; + + int pos = l.tqfind( ' ', 9 ); + if ( pos != -1 ) { + reasonPhr = l.mid( pos + 1 ); + statCode = l.mid( 9, pos - 9 ).toInt(); + } else { + statCode = l.mid( 9 ).toInt(); + reasonPhr = TQString::null; + } + } else { + return FALSE; + } + + return TRUE; +} + +/*! \reimp +*/ +TQString TQHttpResponseHeader::toString() const +{ + TQString ret( "HTTP/%1.%2 %3 %4\r\n%5\r\n" ); + return ret.arg( majVer ).arg ( minVer ).arg( statCode ).arg( reasonPhr ).arg( TQHttpHeader::toString() ); +} + +/**************************************************** + * + * TQHttpRequestHeader + * + ****************************************************/ + +/*! + \class TQHttpRequestHeader tqhttp.h + \brief The TQHttpRequestHeader class tqcontains request header information for +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + HTTP. +\if defined(commercial_edition) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup io + \module network + + This class is used in the TQHttp class to report the header + information if the client requests something from the server. + + HTTP requests have a method which describes the request's action. + The most common requests are "GET" and "POST". In addition to the + request method the header also includes a request-URI to specify + the location for the method to use. + + The method, request-URI and protocol-version can be set using a + constructor or later using setRequest(). The values can be + obtained using method(), path(), majorVersion() and + minorVersion(). + + This class is a TQHttpHeader subclass so that class's functions, + e.g. \link TQHttpHeader::setValue() setValue()\endlink, \link + TQHttpHeader::value() value()\endlink, etc. are also available. + + \sa TQHttpResponseHeader TQHttp + + \important value() setValue() +*/ + +/*! + Constructs an empty HTTP request header. +*/ +TQHttpRequestHeader::TQHttpRequestHeader() + : TQHttpHeader() +{ + setValid( FALSE ); +} + +/*! + Constructs a HTTP request header for the method \a method, the + request-URI \a path and the protocol-version \a majorVer and \a minorVer. +*/ +TQHttpRequestHeader::TQHttpRequestHeader( const TQString& method, const TQString& path, int majorVer, int minorVer ) + : TQHttpHeader(), m( method ), p( path ), majVer( majorVer ), minVer( minorVer ) +{ +} + +/*! + Constructs a copy of \a header. +*/ +TQHttpRequestHeader::TQHttpRequestHeader( const TQHttpRequestHeader& header ) + : TQHttpHeader( header ), m( header.m ), p( header.p ), majVer( header.majVer ), minVer( header.minVer ) +{ +} + +/*! + Constructs a HTTP request header from the string \a str. The \a + str should consist of one or more "\r\n" delimited lines; the first line + should be the request-line (format: method, space, request-URI, space + HTTP-version); each of the remaining lines should have the format key, + colon, space, value. +*/ +TQHttpRequestHeader::TQHttpRequestHeader( const TQString& str ) + : TQHttpHeader() +{ + parse( str ); +} + +/*! + This function sets the request method to \a method, the + request-URI to \a path and the protocol-version to \a majorVer and + \a minorVer. + + \sa method() path() majorVersion() minorVersion() +*/ +void TQHttpRequestHeader::setRequest( const TQString& method, const TQString& path, int majorVer, int minorVer ) +{ + setValid( TRUE ); + m = method; + p = path; + majVer = majorVer; + minVer = minorVer; +} + +/*! + Returns the method of the HTTP request header. + + \sa path() majorVersion() minorVersion() setRequest() +*/ +TQString TQHttpRequestHeader::method() const +{ + return m; +} + +/*! + Returns the request-URI of the HTTP request header. + + \sa method() majorVersion() minorVersion() setRequest() +*/ +TQString TQHttpRequestHeader::path() const +{ + return p; +} + +/*! + Returns the major protocol-version of the HTTP request header. + + \sa minorVersion() method() path() setRequest() +*/ +int TQHttpRequestHeader::majorVersion() const +{ + return majVer; +} + +/*! + Returns the minor protocol-version of the HTTP request header. + + \sa majorVersion() method() path() setRequest() +*/ +int TQHttpRequestHeader::minorVersion() const +{ + return minVer; +} + +/*! \reimp +*/ +bool TQHttpRequestHeader::parseLine( const TQString& line, int number ) +{ + if ( number != 0 ) + return TQHttpHeader::parseLine( line, number ); + + TQStringList lst = TQStringList::split( " ", line.simplifyWhiteSpace() ); + if ( lst.count() > 0 ) { + m = lst[0]; + if ( lst.count() > 1 ) { + p = lst[1]; + if ( lst.count() > 2 ) { + TQString v = lst[2]; + if ( v.length() >= 8 && v.left( 5 ) == "HTTP/" && + v[5].isDigit() && v[6] == '.' && v[7].isDigit() ) { + majVer = v[5].latin1() - '0'; + minVer = v[7].latin1() - '0'; + return TRUE; + } + } + } + } + + return FALSE; +} + +/*! \reimp +*/ +TQString TQHttpRequestHeader::toString() const +{ + TQString first( "%1 %2"); + TQString last(" HTTP/%3.%4\r\n%5\r\n" ); + return first.arg( m ).arg( p ) + + last.arg( majVer ).arg( minVer ).arg( TQHttpHeader::toString()); +} + + +/**************************************************** + * + * TQHttp + * + ****************************************************/ +/*! + \class TQHttp tqhttp.h + \brief The TQHttp class provides an implementation of the HTTP protocol. +\if defined(commercial) + It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>. +\endif + + \ingroup io + \module network + + This class provides two different interfaces: one is the + TQNetworkProtocol interface that allows you to use HTTP through the + TQUrlOperator abstraction. The other is a direct interface to HTTP + that allows you to have more control over the requests and that + allows you to access the response header fields. + + Don't mix the two interfaces, since the behavior is not + well-defined. + + If you want to use TQHttp with the TQNetworkProtocol interface, you + do not use it directly, but rather through a TQUrlOperator, for + example: + + \code + TQUrlOperator op( "http://www.trolltech.com" ); + op.get( "index.html" ); + \endcode + + This code will only work if the TQHttp class is registered; to + register the class, you must call qInitNetworkProtocols() before + using a TQUrlOperator with HTTP. + + The TQNetworkProtocol interface for HTTP only supports the + operations operationGet() and operationPut(), i.e. + TQUrlOperator::get() and TQUrlOperator::put(), if you use it with a + TQUrlOperator. + + The rest of this descrption describes the direct interface to + HTTP. + + The class works asynchronously, so there are no blocking + functions. If an operation cannot be executed immediately, the + function will still return straight away and the operation will be + scheduled for later execution. The results of scheduled operations + are reported via Q_SIGNALS. This approach depends on the event loop + being in operation. + + The operations that can be scheduled (they are called "requests" + in the rest of the documentation) are the following: setHost(), + get(), post(), head() and request(). + + All of these requests return a unique identifier that allows you + to keep track of the request that is currently executed. When the + execution of a request starts, the requestStarted() signal with + the identifier is emitted and when the request is finished, the + requestFinished() signal is emitted with the identifier and a bool + that indicates if the request finished with an error. + + To make an HTTP request you must set up suitable HTTP headers. The + following example demonstrates, how to request the main HTML page + from the Trolltech home page (i.e. the URL + http://www.trolltech.com/index.html): + + \code + TQHttpRequestHeader header( "GET", "/index.html" ); + header.setValue( "Host", "www.trolltech.com" ); + http->setHost( "www.trolltech.com" ); + http->request( header ); + \endcode + + For the common HTTP requests \c GET, \c POST and \c HEAD, TQHttp + provides the convenience functions get(), post() and head(). They + already use a reasonable header and if you don't have to set + special header fields, they are easier to use. The above example + can also be written as: + + \code + http->setHost( "www.trolltech.com" ); // id == 1 + http->get( "/index.html" ); // id == 2 + \endcode + + For this example the following sequence of Q_SIGNALS is emitted + (with small variations, depending on network traffic, etc.): + + \code + requestStarted( 1 ) + requestFinished( 1, FALSE ) + + requestStarted( 2 ) + stateChanged( Connecting ) + stateChanged( Sending ) + dataSendProgress( 77, 77 ) + stateChanged( Reading ) + responseHeaderReceived( responseheader ) + dataReadProgress( 5388, 0 ) + readyRead( responseheader ) + dataReadProgress( 18300, 0 ) + readyRead( responseheader ) + stateChanged( Connected ) + requestFinished( 2, FALSE ) + + done( FALSE ) + + stateChanged( Closing ) + stateChanged( Unconnected ) + \endcode + + The dataSendProgress() and dataReadProgress() Q_SIGNALS in the above + example are useful if you want to show a \link TQProgressBar + progressbar\endlink to inform the user about the progress of the + download. The second argument is the total size of data. In + certain cases it is not possible to know the total amount in + advance, in which case the second argument is 0. (If you connect + to a TQProgressBar a total of 0 results in a busy indicator.) + + When the response header is read, it is reported with the + responseHeaderReceived() signal. + + The readyRead() signal tells you that there is data ready to be + read. The amount of data can then be queried with the + bytesAvailable() function and it can be read with the readBlock() + or readAll() functions. + + If an error occurs during the execution of one of the commands in + a sequence of commands, all the pending commands (i.e. scheduled, + but not yet executed commands) are cleared and no Q_SIGNALS are + emitted for them. + + For example, if you have the following sequence of reqeusts + + \code + http->setHost( "www.foo.bar" ); // id == 1 + http->get( "/index.html" ); // id == 2 + http->post( "register.html", data ); // id == 3 + \endcode + + and the get() request fails because the host lookup fails, then + the post() request is never executed and the Q_SIGNALS would look + like this: + + \code + requestStarted( 1 ) + requestFinished( 1, FALSE ) + + requestStarted( 2 ) + stateChanged( HostLookup ) + requestFinished( 2, TRUE ) + + done( TRUE ) + + stateChanged( Unconnected ) + \endcode + + You can then get details about the error with the error() and + errorString() functions. Note that only unexpected behaviour, like + network failure is considered as an error. If the server response + tqcontains an error status, like a 404 response, this is reported as + a normal response case. So you should always check the \link + TQHttpResponseHeader::statusCode() status code \endlink of the + response header. + + The functions currentId() and currentRequest() provide more + information about the currently executing request. + + The functions hasPendingRequests() and clearPendingRequests() + allow you to query and clear the list of pending requests. + + \sa \link network.html TQt Network Documentation \endlink TQNetworkProtocol, TQUrlOperator TQFtp +*/ + +/*! + Constructs a TQHttp object. +*/ +TQHttp::TQHttp() +{ + init(); +} + +/*! + Constructs a TQHttp object. The parameters \a tqparent and \a name + are passed on to the TQObject constructor. +*/ +TQHttp::TQHttp( TQObject* tqparent, const char* name ) +{ + if ( tqparent ) + tqparent->insertChild( this ); + setName( name ); + init(); +} + +/*! + Constructs a TQHttp object. Subsequent requests are done by + connecting to the server \a hostname on port \a port. The + parameters \a tqparent and \a name are passed on to the TQObject + constructor. + + \sa setHost() +*/ +TQHttp::TQHttp( const TQString &hostname, TQ_UINT16 port, TQObject* tqparent, const char* name ) +{ + if ( tqparent ) + tqparent->insertChild( this ); + setName( name ); + init(); + + d->hostname = hostname; + d->port = port; +} + +void TQHttp::init() +{ + bytesRead = 0; + d = new TQHttpPrivate; + d->errorString = tr( "Unknown error" ); + + connect( &d->socket, TQT_SIGNAL( connected() ), + this, TQT_SLOT( slotConnected() ) ); + connect( &d->socket, TQT_SIGNAL( connectionClosed() ), + this, TQT_SLOT( slotClosed() ) ); + connect( &d->socket, TQT_SIGNAL( delayedCloseFinished() ), + this, TQT_SLOT( slotClosed() ) ); + connect( &d->socket, TQT_SIGNAL( readyRead() ), + this, TQT_SLOT( slotReadyRead() ) ); + connect( &d->socket, TQT_SIGNAL( error(int) ), + this, TQT_SLOT( slotError(int) ) ); + connect( &d->socket, TQT_SIGNAL( bytesWritten(int) ), + this, TQT_SLOT( slotBytesWritten(int) ) ); + + d->idleTimer = startTimer( 0 ); +} + +/*! + Destroys the TQHttp object. If there is an open connection, it is + closed. +*/ +TQHttp::~TQHttp() +{ + abort(); + delete d; +} + +/*! + \enum TQHttp::State + + This enum is used to specify the state the client is in: + + \value Unconnected There is no connection to the host. + \value HostLookup A host name lookup is in progress. + \value Connecting An attempt to connect to the host is in progress. + \value Sending The client is sending its request to the server. + \value Reading The client's request has been sent and the client + is reading the server's response. + \value Connected The connection to the host is open, but the client is + neither sending a request, nor waiting for a response. + \value Closing The connection is closing down, but is not yet + closed. (The state will be \c Unconnected when the connection is + closed.) + + \sa stateChanged() state() +*/ + +/*! \enum TQHttp::Error + + This enum identifies the error that occurred. + + \value NoError No error occurred. + \value HostNotFound The host name lookup failed. + \value ConnectionRefused The server refused the connection. + \value UnexpectedClose The server closed the connection unexpectedly. + \value InvalidResponseHeader The server sent an invalid response header. + \value WrongContentLength The client could not read the content correctly + because an error with respect to the content length occurred. + \value Aborted The request was aborted with abort(). + \value UnknownError An error other than those specified above + occurred. + + \sa error() +*/ + +/*! + \fn void TQHttp::stateChanged( int state ) + + This signal is emitted when the state of the TQHttp object changes. + The argument \a state is the new state of the connection; it is + one of the \l State values. + + This usually happens when a request is started, but it can also + happen when the server closes the connection or when a call to + closeConnection() succeeded. + + \sa get() post() head() request() closeConnection() state() State +*/ + +/*! + \fn void TQHttp::responseHeaderReceived( const TQHttpResponseHeader& resp ) + + This signal is emitted when the HTTP header of a server response + is available. The header is passed in \a resp. + + \sa get() post() head() request() readyRead() +*/ + +/*! + \fn void TQHttp::readyRead( const TQHttpResponseHeader& resp ) + + This signal is emitted when there is new response data to read. + + If you specified a tqdevice in the request where the data should be + written to, then this signal is \e not emitted; instead the data + is written directly to the tqdevice. + + The response header is passed in \a resp. + + You can read the data with the readAll() or readBlock() functions + + This signal is useful if you want to process the data in chunks as + soon as it becomes available. If you are only interested in the + complete data, just connect to the requestFinished() signal and + read the data then instead. + + \sa get() post() request() readAll() readBlock() bytesAvailable() +*/ + +/*! + \fn void TQHttp::dataSendProgress( int done, int total ) + + This signal is emitted when this object sends data to a HTTP + server to inform it about the progress of the upload. + + \a done is the amount of data that has already arrived and \a + total is the total amount of data. It is possible that the total + amount of data that should be transferred cannot be determined, in + which case \a total is 0.(If you connect to a TQProgressBar, the + progress bar shows a busy indicator if the total is 0). + + \warning \a done and \a total are not necessarily the size in + bytes, since for large files these values might need to be + "scaled" to avoid overflow. + + \sa dataReadProgress() post() request() TQProgressBar::setProgress() +*/ + +/*! + \fn void TQHttp::dataReadProgress( int done, int total ) + + This signal is emitted when this object reads data from a HTTP + server to indicate the current progress of the download. + + \a done is the amount of data that has already arrived and \a + total is the total amount of data. It is possible that the total + amount of data that should be transferred cannot be determined, in + which case \a total is 0.(If you connect to a TQProgressBar, the + progress bar shows a busy indicator if the total is 0). + + \warning \a done and \a total are not necessarily the size in + bytes, since for large files these values might need to be + "scaled" to avoid overflow. + + \sa dataSendProgress() get() post() request() TQProgressBar::setProgress() +*/ + +/*! + \fn void TQHttp::requestStarted( int id ) + + This signal is emitted when processing the request identified by + \a id starts. + + \sa requestFinished() done() +*/ + +/*! + \fn void TQHttp::requestFinished( int id, bool error ) + + This signal is emitted when processing the request identified by + \a id has finished. \a error is TRUE if an error occurred during + the processing; otherwise \a error is FALSE. + + \sa requestStarted() done() error() errorString() +*/ + +/*! + \fn void TQHttp::done( bool error ) + + This signal is emitted when the last pending request has finished; + (it is emitted after the last request's requestFinished() signal). + \a error is TRUE if an error occurred during the processing; + otherwise \a error is FALSE. + + \sa requestFinished() error() errorString() +*/ + +/*! + Aborts the current request and deletes all scheduled requests. + + For the current request, the requestFinished() signal with the \c + error argument \c TRUE is emitted. For all other requests that are + affected by the abort(), no Q_SIGNALS are emitted. + + Since this slot also deletes the scheduled requests, there are no + requests left and the done() signal is emitted (with the \c error + argument \c TRUE). + + \sa clearPendingRequests() +*/ +void TQHttp::abort() +{ + TQHttpRequest *r = d->pending.getFirst(); + if ( r == 0 ) + return; + + finishedWithError( tr("Request aborted"), Aborted ); + clearPendingRequests(); + d->socket.clearPendingData(); + close(); +} + +/*! + Returns the number of bytes that can be read from the response + content at the moment. + + \sa get() post() request() readyRead() readBlock() readAll() +*/ +TQ_ULONG TQHttp::bytesAvailable() const +{ +#if defined(TQHTTP_DEBUG) + qDebug( "TQHttp::bytesAvailable(): %d bytes", (int)d->rba.size() ); +#endif + return d->rba.size(); +} + +/*! + Reads \a maxlen bytes from the response content into \a data and + returns the number of bytes read. Returns -1 if an error occurred. + + \sa get() post() request() readyRead() bytesAvailable() readAll() +*/ +TQ_LONG TQHttp::readBlock( char *data, TQ_ULONG maxlen ) +{ + if ( data == 0 && maxlen != 0 ) { +#if defined(TQT_CHECK_NULL) + qWarning( "TQHttp::readBlock: Null pointer error" ); +#endif + return -1; + } + if ( maxlen >= d->rba.size() ) + maxlen = d->rba.size(); + d->rba.consumeBytes( maxlen, data ); + + d->bytesDone += maxlen; +#if defined(TQHTTP_DEBUG) + qDebug( "TQHttp::readBlock(): read %d bytes (%d bytes done)", (int)maxlen, d->bytesDone ); +#endif + return maxlen; +} + +/*! + Reads all the bytes from the response content and returns them. + + \sa get() post() request() readyRead() bytesAvailable() readBlock() +*/ +TQByteArray TQHttp::readAll() +{ + TQ_ULONG avail = bytesAvailable(); + TQByteArray tmp( avail ); + TQ_LONG read = readBlock( tmp.data(), avail ); + tmp.resize( read ); + return tmp; +} + +/*! + Returns the identifier of the HTTP request being executed or 0 if + there is no request being executed (i.e. they've all finished). + + \sa currentRequest() +*/ +int TQHttp::currentId() const +{ + TQHttpRequest *r = d->pending.getFirst(); + if ( r == 0 ) + return 0; + return r->id; +} + +/*! + Returns the request header of the HTTP request being executed. If + the request is one issued by setHost() or closeConnection(), it + returns an invalid request header, i.e. + TQHttpRequestHeader::isValid() returns FALSE. + + \sa currentId() +*/ +TQHttpRequestHeader TQHttp::currentRequest() const +{ + TQHttpRequest *r = d->pending.getFirst(); + if ( r != 0 && r->hasRequestHeader() ) + return r->requestHeader(); + return TQHttpRequestHeader(); +} + +/*! + Returns the TQIODevice pointer that is used as the data source of the HTTP + request being executed. If there is no current request or if the request + does not use an IO tqdevice as the data source, this function returns 0. + + This function can be used to delete the TQIODevice in the slot connected to + the requestFinished() signal. + + \sa currentDestinationDevice() post() request() +*/ +TQIODevice* TQHttp::currentSourceDevice() const +{ + TQHttpRequest *r = d->pending.getFirst(); + if ( !r ) + return 0; + return r->sourceDevice(); +} + +/*! + Returns the TQIODevice pointer that is used as to store the data of the HTTP + request being executed. If there is no current request or if the request + does not store the data to an IO tqdevice, this function returns 0. + + This function can be used to delete the TQIODevice in the slot connected to + the requestFinished() signal. + + \sa currentDestinationDevice() get() post() request() +*/ +TQIODevice* TQHttp::currentDestinationDevice() const +{ + TQHttpRequest *r = d->pending.getFirst(); + if ( !r ) + return 0; + return r->destinationDevice(); +} + +/*! + Returns TRUE if there are any requests scheduled that have not yet + been executed; otherwise returns FALSE. + + The request that is being executed is \e not considered as a + scheduled request. + + \sa clearPendingRequests() currentId() currentRequest() +*/ +bool TQHttp::hasPendingRequests() const +{ + return d->pending.count() > 1; +} + +/*! + Deletes all pending requests from the list of scheduled requests. + This does not affect the request that is being executed. If + you want to stop this this as well, use abort(). + + \sa hasPendingRequests() abort() +*/ +void TQHttp::clearPendingRequests() +{ + TQHttpRequest *r = 0; + if ( d->pending.count() > 0 ) + r = d->pending.take( 0 ); + d->pending.clear(); + if ( r ) + d->pending.append( r ); +} + +/*! + Sets the HTTP server that is used for requests to \a hostname on + port \a port. + + The function does not block and returns immediately. The request + is scheduled, and its execution is performed asynchronously. The + function returns a unique identifier which is passed by + requestStarted() and requestFinished(). + + When the request is started the requestStarted() signal is + emitted. When it is finished the requestFinished() signal is + emitted. + + \sa get() post() head() request() requestStarted() requestFinished() done() +*/ +int TQHttp::setHost(const TQString &hostname, TQ_UINT16 port ) +{ + return addRequest( new TQHttpSetHostRequest( hostname, port ) ); +} + +/*! + Sends a get request for \a path to the server set by setHost() or + as specified in the constructor. + + \a path must be an absolute path like \c /index.html or an + absolute URI like \c http://www.trolltech.com/index.html. + + If the IO tqdevice \a to is 0 the readyRead() signal is emitted + every time new content data is available to read. + + If the IO tqdevice \a to is not 0, the content data of the response + is written directly to the tqdevice. Make sure that the \a to + pointer is valid for the duration of the operation (it is safe to + delete it when the requestFinished() signal is emitted). + + The function does not block and returns immediately. The request + is scheduled, and its execution is performed asynchronously. The + function returns a unique identifier which is passed by + requestStarted() and requestFinished(). + + When the request is started the requestStarted() signal is + emitted. When it is finished the requestFinished() signal is + emitted. + + \sa setHost() post() head() request() requestStarted() requestFinished() done() +*/ +int TQHttp::get( const TQString& path, TQIODevice* to ) +{ + TQHttpRequestHeader header( "GET", path ); + header.setValue( "Connection", "Keep-Alive" ); + return addRequest( new TQHttpPGHRequest( header, (TQIODevice*)0, to ) ); +} + +/*! + Sends a post request for \a path to the server set by setHost() or + as specified in the constructor. + + \a path must be an absolute path like \c /index.html or an + absolute URI like \c http://www.trolltech.com/index.html. + + The incoming data comes via the \a data IO tqdevice. + + If the IO tqdevice \a to is 0 the readyRead() signal is emitted + every time new content data is available to read. + + If the IO tqdevice \a to is not 0, the content data of the response + is written directly to the tqdevice. Make sure that the \a to + pointer is valid for the duration of the operation (it is safe to + delete it when the requestFinished() signal is emitted). + + The function does not block and returns immediately. The request + is scheduled, and its execution is performed asynchronously. The + function returns a unique identifier which is passed by + requestStarted() and requestFinished(). + + When the request is started the requestStarted() signal is + emitted. When it is finished the requestFinished() signal is + emitted. + + \sa setHost() get() head() request() requestStarted() requestFinished() done() +*/ +int TQHttp::post( const TQString& path, TQIODevice* data, TQIODevice* to ) +{ + TQHttpRequestHeader header( "POST", path ); + header.setValue( "Connection", "Keep-Alive" ); + return addRequest( new TQHttpPGHRequest( header, data, to ) ); +} + +/*! + \overload + + \a data is used as the content data of the HTTP request. +*/ +int TQHttp::post( const TQString& path, const TQByteArray& data, TQIODevice* to ) +{ + TQHttpRequestHeader header( "POST", path ); + header.setValue( "Connection", "Keep-Alive" ); + return addRequest( new TQHttpPGHRequest( header, new TQByteArray(data), to ) ); +} + +/*! + Sends a header request for \a path to the server set by setHost() + or as specified in the constructor. + + \a path must be an absolute path like \c /index.html or an + absolute URI like \c http://www.trolltech.com/index.html. + + The function does not block and returns immediately. The request + is scheduled, and its execution is performed asynchronously. The + function returns a unique identifier which is passed by + requestStarted() and requestFinished(). + + When the request is started the requestStarted() signal is + emitted. When it is finished the requestFinished() signal is + emitted. + + \sa setHost() get() post() request() requestStarted() requestFinished() done() +*/ +int TQHttp::head( const TQString& path ) +{ + TQHttpRequestHeader header( "HEAD", path ); + header.setValue( "Connection", "Keep-Alive" ); + return addRequest( new TQHttpPGHRequest( header, (TQIODevice*)0, 0 ) ); +} + +/*! + Sends a request to the server set by setHost() or as specified in + the constructor. Uses the \a header as the HTTP request header. + You are responsible for setting up a header that is appropriate + for your request. + + The incoming data comes via the \a data IO tqdevice. + + If the IO tqdevice \a to is 0 the readyRead() signal is emitted + every time new content data is available to read. + + If the IO tqdevice \a to is not 0, the content data of the response + is written directly to the tqdevice. Make sure that the \a to + pointer is valid for the duration of the operation (it is safe to + delete it when the requestFinished() signal is emitted). + + The function does not block and returns immediately. The request + is scheduled, and its execution is performed asynchronously. The + function returns a unique identifier which is passed by + requestStarted() and requestFinished(). + + When the request is started the requestStarted() signal is + emitted. When it is finished the requestFinished() signal is + emitted. + + \sa setHost() get() post() head() requestStarted() requestFinished() done() +*/ +int TQHttp::request( const TQHttpRequestHeader &header, TQIODevice *data, TQIODevice *to ) +{ + return addRequest( new TQHttpNormalRequest( header, data, to ) ); +} + +/*! + \overload + + \a data is used as the content data of the HTTP request. +*/ +int TQHttp::request( const TQHttpRequestHeader &header, const TQByteArray &data, TQIODevice *to ) +{ + return addRequest( new TQHttpNormalRequest( header, new TQByteArray(data), to ) ); +} + +/*! + Closes the connection; this is useful if you have a keep-alive + connection and want to close it. + + For the requests issued with get(), post() and head(), TQHttp sets + the connection to be keep-alive. You can also do this using the + header you pass to the request() function. TQHttp only closes the + connection to the HTTP server if the response header requires it + to do so. + + The function does not block and returns immediately. The request + is scheduled, and its execution is performed asynchronously. The + function returns a unique identifier which is passed by + requestStarted() and requestFinished(). + + When the request is started the requestStarted() signal is + emitted. When it is finished the requestFinished() signal is + emitted. + + If you want to close the connection immediately, you have to use + abort() instead. + + \sa stateChanged() abort() requestStarted() requestFinished() done() +*/ +int TQHttp::closeConnection() +{ + return addRequest( new TQHttpCloseRequest() ); +} + +int TQHttp::addRequest( TQHttpRequest *req ) +{ + d->pending.append( req ); + + if ( d->pending.count() == 1 ) + // don't emit the requestStarted() signal before the id is returned + TQTimer::singleShot( 0, this, TQT_SLOT(startNextRequest()) ); + + return req->id; +} + +void TQHttp::startNextRequest() +{ + TQHttpRequest *r = d->pending.getFirst(); + if ( r == 0 ) + return; + + d->error = NoError; + d->errorString = tr( "Unknown error" ); + + if ( bytesAvailable() ) + readAll(); // clear the data + emit requestStarted( r->id ); + r->start( this ); +} + +void TQHttp::sendRequest() +{ + if ( d->hostname.isNull() ) { + finishedWithError( tr("No server set to connect to"), UnknownError ); + return; + } + + killIdleTimer(); + + // Do we need to setup a new connection or can we reuse an + // existing one ? + if ( d->socket.peerName() != d->hostname || d->socket.peerPort() != d->port + || d->socket.state() != TQSocket::Connection ) { + setState( TQHttp::Connecting ); + d->socket.connectToHost( d->hostname, d->port ); + } else { + slotConnected(); + } + +} + +void TQHttp::finishedWithSuccess() +{ + TQHttpRequest *r = d->pending.getFirst(); + if ( r == 0 ) + return; + + emit requestFinished( r->id, FALSE ); + d->pending.removeFirst(); + if ( d->pending.isEmpty() ) { + emit done( FALSE ); + } else { + startNextRequest(); + } +} + +void TQHttp::finishedWithError( const TQString& detail, int errorCode ) +{ + TQHttpRequest *r = d->pending.getFirst(); + if ( r == 0 ) + return; + + d->error = (Error)errorCode; + d->errorString = detail; + emit requestFinished( r->id, TRUE ); + + d->pending.clear(); + emit done( TRUE ); +} + +void TQHttp::slotClosed() +{ + if ( d->state == Closing ) + return; + + if ( d->state == Reading ) { + if ( d->response.hasKey( "content-length" ) ) { + // We got Content-Length, so did we get all bytes? + if ( d->bytesDone+bytesAvailable() != d->response.contentLength() ) { + finishedWithError( tr("Wrong content length"), WrongContentLength ); + } + } + } else if ( d->state == Connecting || d->state == Sending ) { + finishedWithError( tr("Server closed connection unexpectedly"), UnexpectedClose ); + } + + d->postDevice = 0; + setState( Closing ); + d->idleTimer = startTimer( 0 ); +} + +void TQHttp::slotConnected() +{ + if ( d->state != Sending ) { + d->bytesDone = 0; + setState( Sending ); + } + + TQString str = d->header.toString(); + d->bytesTotal = str.length(); + d->socket.writeBlock( str.latin1(), d->bytesTotal ); +#if defined(TQHTTP_DEBUG) + qDebug( "TQHttp: write request header:\n---{\n%s}---", str.latin1() ); +#endif + + if ( d->postDevice ) { + d->bytesTotal += d->postDevice->size(); + } else { + d->bytesTotal += d->buffer.size(); + d->socket.writeBlock( d->buffer.data(), d->buffer.size() ); + d->buffer = TQByteArray(); // save memory + } +} + +void TQHttp::slotError( int err ) +{ + d->postDevice = 0; + + if ( d->state == Connecting || d->state == Reading || d->state == Sending ) { + switch ( err ) { + case TQSocket::ErrConnectionRefused: + finishedWithError( tr("Connection refused"), ConnectionRefused ); + break; + case TQSocket::ErrHostNotFound: + finishedWithError( tr("Host %1 not found").arg(d->socket.peerName()), HostNotFound ); + break; + default: + finishedWithError( tr("HTTP request failed"), UnknownError ); + break; + } + } + + close(); +} + +void TQHttp::slotBytesWritten( int written ) +{ + d->bytesDone += written; + emit dataSendProgress( d->bytesDone, d->bytesTotal ); + + if ( !d->postDevice ) + return; + + if ( d->socket.bytesToWrite() == 0 ) { + int max = TQMIN( 4096, d->postDevice->size() - d->postDevice->at() ); + TQByteArray arr( max ); + + int n = d->postDevice->readBlock( arr.data(), max ); + if ( n != max ) { + qWarning("Could not read enough bytes from the tqdevice"); + close(); + return; + } + if ( d->postDevice->atEnd() ) { + d->postDevice = 0; + } + + d->socket.writeBlock( arr.data(), max ); + } +} + +void TQHttp::slotReadyRead() +{ + if ( d->state != Reading ) { + setState( Reading ); + d->buffer = TQByteArray(); + d->readHeader = TRUE; + d->headerStr = ""; + d->bytesDone = 0; + d->chunkedSize = -1; + } + + while ( d->readHeader ) { + bool end = FALSE; + TQString tmp; + while ( !end && d->socket.canReadLine() ) { + tmp = d->socket.readLine(); + if ( tmp == "\r\n" || tmp == "\n" ) + end = TRUE; + else + d->headerStr += tmp; + } + + if ( !end ) + return; + +#if defined(TQHTTP_DEBUG) + qDebug( "TQHttp: read response header:\n---{\n%s}---", d->headerStr.latin1() ); +#endif + d->response = TQHttpResponseHeader( d->headerStr ); + d->headerStr = ""; +#if defined(TQHTTP_DEBUG) + qDebug( "TQHttp: read response header:\n---{\n%s}---", d->response.toString().latin1() ); +#endif + // Check header + if ( !d->response.isValid() ) { + finishedWithError( tr("Invalid HTTP response header"), InvalidResponseHeader ); + close(); + return; + } + + // The 100-continue header is ignored, because when using the + // POST method, we send both the request header and data in + // one chunk. + if (d->response.statusCode() != 100) { + d->readHeader = FALSE; + if ( d->response.hasKey( "transfer-encoding" ) && + d->response.value( "transfer-encoding" ).lower().tqcontains( "chunked" ) ) + d->chunkedSize = 0; + + emit responseHeaderReceived( d->response ); + } + } + + if ( !d->readHeader ) { + bool everythingRead = FALSE; + + if ( currentRequest().method() == "HEAD" ) { + everythingRead = TRUE; + } else { + TQ_ULONG n = d->socket.bytesAvailable(); + TQByteArray *arr = 0; + if ( d->chunkedSize != -1 ) { + // transfer-encoding is chunked + for ( ;; ) { + // get chunk size + if ( d->chunkedSize == 0 ) { + if ( !d->socket.canReadLine() ) + break; + TQString sizeString = d->socket.readLine(); + int tPos = sizeString.tqfind( ';' ); + if ( tPos != -1 ) + sizeString.truncate( tPos ); + bool ok; + d->chunkedSize = sizeString.toInt( &ok, 16 ); + if ( !ok ) { + finishedWithError( tr("Invalid HTTP chunked body"), WrongContentLength ); + close(); + delete arr; + return; + } + if ( d->chunkedSize == 0 ) // last-chunk + d->chunkedSize = -2; + } + + // read trailer + while ( d->chunkedSize == -2 && d->socket.canReadLine() ) { + TQString read = d->socket.readLine(); + if ( read == "\r\n" || read == "\n" ) + d->chunkedSize = -1; + } + if ( d->chunkedSize == -1 ) { + everythingRead = TRUE; + break; + } + + // make sure that you can read the terminating CRLF, + // otherwise wait until next time... + n = d->socket.bytesAvailable(); + if ( n == 0 ) + break; + if ( (TQ_LONG)n == d->chunkedSize || (TQ_LONG)n == d->chunkedSize+1 ) { + n = d->chunkedSize - 1; + if ( n == 0 ) + break; + } + + // read data + uint toRead = TQMIN( (TQ_LONG)n, (d->chunkedSize < 0 ? (TQ_LONG)n : d->chunkedSize) ); + if ( !arr ) + arr = new TQByteArray( 0 ); + uint oldArrSize = arr->size(); + arr->resize( oldArrSize + toRead ); + TQ_LONG read = d->socket.readBlock( arr->data()+oldArrSize, toRead ); + arr->resize( oldArrSize + read ); + + d->chunkedSize -= read; + + if ( d->chunkedSize == 0 && n - read >= 2 ) { + // read terminating CRLF + char tmp[2]; + d->socket.readBlock( tmp, 2 ); + if ( tmp[0] != '\r' || tmp[1] != '\n' ) { + finishedWithError( tr("Invalid HTTP chunked body"), WrongContentLength ); + close(); + return; + } + } + } + } else if ( d->response.hasContentLength() ) { + n = TQMIN( d->response.contentLength() - d->bytesDone, n ); + if ( n > 0 ) { + arr = new TQByteArray( n ); + TQ_LONG read = d->socket.readBlock( arr->data(), n ); + arr->resize( read ); + } + if ( d->bytesDone + bytesAvailable() + n == d->response.contentLength() ) + everythingRead = TRUE; + } else if ( n > 0 ) { + // workaround for VC++ bug + TQByteArray temp = TQT_TQBYTEARRAY_OBJECT(d->socket.readAll()); + arr = new TQByteArray( temp ); + } + + if ( arr ) { + n = arr->size(); + if ( d->toDevice ) { + d->toDevice->writeBlock( arr->data(), n ); + delete arr; + d->bytesDone += n; +#if defined(TQHTTP_DEBUG) + qDebug( "TQHttp::slotReadyRead(): read %ld bytes (%d bytes done)", n, d->bytesDone ); +#endif + if ( d->response.hasContentLength() ) + emit dataReadProgress( d->bytesDone, d->response.contentLength() ); + else + emit dataReadProgress( d->bytesDone, 0 ); + } else { + d->rba.append( arr ); +#if defined(TQHTTP_DEBUG) + qDebug( "TQHttp::slotReadyRead(): read %ld bytes (%ld bytes done)", n, d->bytesDone + bytesAvailable() ); +#endif + if ( d->response.hasContentLength() ) + emit dataReadProgress( d->bytesDone + bytesAvailable(), d->response.contentLength() ); + else + emit dataReadProgress( d->bytesDone + bytesAvailable(), 0 ); + emit readyRead( d->response ); + } + } + } + + if ( everythingRead ) { + // Handle "Connection: close" + if ( d->response.value("connection").lower() == "close" ) { + close(); + } else { + setState( Connected ); + // Start a timer, so that we emit the keep alive signal + // "after" this method returned. + d->idleTimer = startTimer( 0 ); + } + } + } +} + +/*! + Returns the current state of the object. When the state changes, + the stateChanged() signal is emitted. + + \sa State stateChanged() +*/ +TQHttp::State TQHttp::state() const +{ + return d->state; +} + +/*! + Returns the last error that occurred. This is useful to tqfind out + what happened when receiving a requestFinished() or a done() + signal with the \c error argument \c TRUE. + + If you start a new request, the error status is reset to \c NoError. +*/ +TQHttp::Error TQHttp::error() const +{ + return d->error; +} + +/*! + Returns a human-readable description of the last error that + occurred. This is useful to present a error message to the user + when receiving a requestFinished() or a done() signal with the \c + error argument \c TRUE. +*/ +TQString TQHttp::errorString() const +{ + return d->errorString; +} + +/*! \reimp +*/ +void TQHttp::timerEvent( TQTimerEvent *e ) +{ + if ( e->timerId() == d->idleTimer ) { + killTimer( d->idleTimer ); + d->idleTimer = 0; + + if ( d->state == Connected ) { + finishedWithSuccess(); + } else if ( d->state != Unconnected ) { + setState( Unconnected ); + finishedWithSuccess(); + } + } else { + TQObject::timerEvent( e ); + } +} + +void TQHttp::killIdleTimer() +{ + killTimer( d->idleTimer ); + d->idleTimer = 0; +} + +void TQHttp::setState( int s ) +{ +#if defined(TQHTTP_DEBUG) + qDebug( "TQHttp state changed %d -> %d", d->state, s ); +#endif + d->state = (State)s; + emit stateChanged( s ); +} + +void TQHttp::close() +{ + // If no connection is open -> ignore + if ( d->state == Closing || d->state == Unconnected ) + return; + + d->postDevice = 0; + setState( Closing ); + + // Already closed ? + if ( !d->socket.isOpen() ) { + d->idleTimer = startTimer( 0 ); + } else { + // Close now. + d->socket.close(); + + // Did close succeed immediately ? + if ( d->socket.state() == TQSocket::Idle ) { + // Prepare to emit the requestFinished() signal. + d->idleTimer = startTimer( 0 ); + } + } +} + +/********************************************************************** + * + * TQHttp implementation of the TQNetworkProtocol interface + * + *********************************************************************/ +/*! \reimp +*/ +int TQHttp::supportedOperations() const +{ + return OpGet | OpPut; +} + +/*! \reimp +*/ +void TQHttp::operationGet( TQNetworkOperation *op ) +{ + connect( this, TQT_SIGNAL(readyRead(const TQHttpResponseHeader&)), + this, TQT_SLOT(clientReply(const TQHttpResponseHeader&)) ); + connect( this, TQT_SIGNAL(done(bool)), + this, TQT_SLOT(clientDone(bool)) ); + connect( this, TQT_SIGNAL(stateChanged(int)), + this, TQT_SLOT(clientStateChanged(int)) ); + + bytesRead = 0; + op->setState( StInProgress ); + TQUrl u( operationInProgress()->arg( 0 ) ); + TQHttpRequestHeader header( "GET", u.encodedPathAndQuery(), 1, 0 ); + header.setValue( "Host", u.host() ); + setHost( u.host(), u.port() != -1 ? u.port() : 80 ); + request( header ); +} + +/*! \reimp +*/ +void TQHttp::operationPut( TQNetworkOperation *op ) +{ + connect( this, TQT_SIGNAL(readyRead(const TQHttpResponseHeader&)), + this, TQT_SLOT(clientReply(const TQHttpResponseHeader&)) ); + connect( this, TQT_SIGNAL(done(bool)), + this, TQT_SLOT(clientDone(bool)) ); + connect( this, TQT_SIGNAL(stateChanged(int)), + this, TQT_SLOT(clientStateChanged(int)) ); + + bytesRead = 0; + op->setState( StInProgress ); + TQUrl u( operationInProgress()->arg( 0 ) ); + TQHttpRequestHeader header( "POST", u.encodedPathAndQuery(), 1, 0 ); + header.setValue( "Host", u.host() ); + setHost( u.host(), u.port() != -1 ? u.port() : 80 ); + request( header, op->rawArg(1) ); +} + +void TQHttp::clientReply( const TQHttpResponseHeader &rep ) +{ + TQNetworkOperation *op = operationInProgress(); + if ( op ) { + if ( rep.statusCode() >= 400 && rep.statusCode() < 600 ) { + op->setState( StFailed ); + op->setProtocolDetail( + TQString("%1 %2").arg(rep.statusCode()).arg(rep.reasonPhrase()) + ); + switch ( rep.statusCode() ) { + case 401: + case 403: + case 405: + op->setErrorCode( ErrPermissionDenied ); + break; + case 404: + op->setErrorCode(ErrFileNotExisting ); + break; + default: + if ( op->operation() == OpGet ) + op->setErrorCode( ErrGet ); + else + op->setErrorCode( ErrPut ); + break; + } + } + // ### In cases of an error, should we still emit the data() Q_SIGNALS? + if ( op->operation() == OpGet && bytesAvailable() > 0 ) { + TQByteArray ba = readAll(); + emit data( ba, op ); + bytesRead += ba.size(); + if ( rep.hasContentLength() ) { + emit dataTransferProgress( bytesRead, rep.contentLength(), op ); + } + } + } +} + +void TQHttp::clientDone( bool err ) +{ + disconnect( this, TQT_SIGNAL(readyRead(const TQHttpResponseHeader&)), + this, TQT_SLOT(clientReply(const TQHttpResponseHeader&)) ); + disconnect( this, TQT_SIGNAL(done(bool)), + this, TQT_SLOT(clientDone(bool)) ); + disconnect( this, TQT_SIGNAL(stateChanged(int)), + this, TQT_SLOT(clientStateChanged(int)) ); + + if ( err ) { + TQNetworkOperation *op = operationInProgress(); + if ( op ) { + op->setState( TQNetworkProtocol::StFailed ); + op->setProtocolDetail( errorString() ); + switch ( error() ) { + case ConnectionRefused: + op->setErrorCode( ErrHostNotFound ); + break; + case HostNotFound: + op->setErrorCode( ErrHostNotFound ); + break; + default: + if ( op->operation() == OpGet ) + op->setErrorCode( ErrGet ); + else + op->setErrorCode( ErrPut ); + break; + } + emit finished( op ); + } + } else { + TQNetworkOperation *op = operationInProgress(); + if ( op ) { + if ( op->state() != StFailed ) { + op->setState( TQNetworkProtocol::StDone ); + op->setErrorCode( TQNetworkProtocol::NoError ); + } + emit finished( op ); + } + } + +} + +void TQHttp::clientStateChanged( int state ) +{ + if ( url() ) { + switch ( (State)state ) { + case Connecting: + emit connectionStateChanged( ConHostFound, tr( "Host %1 found" ).arg( url()->host() ) ); + break; + case Sending: + emit connectionStateChanged( ConConnected, tr( "Connected to host %1" ).arg( url()->host() ) ); + break; + case Unconnected: + emit connectionStateChanged( ConClosed, tr( "Connection to %1 closed" ).arg( url()->host() ) ); + break; + default: + break; + } + } else { + switch ( (State)state ) { + case Connecting: + emit connectionStateChanged( ConHostFound, tr( "Host found" ) ); + break; + case Sending: + emit connectionStateChanged( ConConnected, tr( "Connected to host" ) ); + break; + case Unconnected: + emit connectionStateChanged( ConClosed, tr( "Connection closed" ) ); + break; + default: + break; + } + } +} + +#endif |