summaryrefslogtreecommitdiffstats
path: root/tqtinterface/qt4/src/network/tqhttp.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tqtinterface/qt4/src/network/tqhttp.cpp')
-rw-r--r--tqtinterface/qt4/src/network/tqhttp.cpp2384
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