src/qt3support/network/q3http.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.trolltech.com/products/qt/opensource.html
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://www.trolltech.com/products/qt/licensing.html or contact the
** sales department at sales@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include <qplatformdefs.h>
#include "q3http.h"

#ifndef QT_NO_NETWORKPROTOCOL_HTTP

#include "q3socket.h"
#include "qtextstream.h"
#include "qmap.h"
#include "qstring.h"
#include "qstringlist.h"
#include "q3cstring.h"
#include "qbuffer.h"
#include "q3urloperator.h"
#include "qtimer.h"
#include "private/q3membuf_p.h"
#include "qevent.h"
#include "q3url.h"
#include "qhttp.h"

//#define Q3HTTP_DEBUG

class Q3HttpPrivate
{
public:
    Q3HttpPrivate() :
  state( Q3Http::Unconnected ),
  error( Q3Http::NoError ),
  hostname( QString() ),
  port( 0 ),
  toDevice( 0 ),
  postDevice( 0 ),
  bytesDone( 0 ),
  chunkedSize( -1 ),
  idleTimer( 0 )
    {
  pending.setAutoDelete( true );
    }

    Q3Socket socket;
    Q3PtrList<Q3HttpRequest> pending;

    Q3Http::State state;
    Q3Http::Error error;
    QString errorString;

    QString hostname;
    Q_UINT16 port;

    QByteArray buffer;
    QIODevice* toDevice;
    QIODevice* postDevice;

    uint bytesDone;
    uint bytesTotal;
    Q_LONG chunkedSize;

    Q3HttpRequestHeader header;

    bool readHeader;
    QString headerStr;
    Q3HttpResponseHeader response;

    int idleTimer;

    Q3Membuf rba;
};

class Q3HttpRequest
{
public:
    Q3HttpRequest()
    {
  id = ++idCounter;
    }
    virtual ~Q3HttpRequest()
    { }

    virtual void start( Q3Http * ) = 0;
    virtual bool hasRequestHeader();
    virtual Q3HttpRequestHeader requestHeader();

    virtual QIODevice* sourceDevice() = 0;
    virtual QIODevice* destinationDevice() = 0;

    int id;

private:
    static int idCounter;
};

int Q3HttpRequest::idCounter = 0;

bool Q3HttpRequest::hasRequestHeader()
{
    return false;
}

Q3HttpRequestHeader Q3HttpRequest::requestHeader()
{
    return Q3HttpRequestHeader();
}

/****************************************************
 *
 * Q3HttpNormalRequest
 *
 ****************************************************/

class Q3HttpNormalRequest : public Q3HttpRequest
{
public:
    Q3HttpNormalRequest( const Q3HttpRequestHeader &h, QIODevice *d, QIODevice *t ) :
  header(h), to(t)
    {
  is_ba = false;
  data.dev = d;
    }

    Q3HttpNormalRequest( const Q3HttpRequestHeader &h, QByteArray *d, QIODevice *t ) :
  header(h), to(t)
    {
  is_ba = true;
  data.ba = d;
    }

    ~Q3HttpNormalRequest()
    {
  if ( is_ba )
      delete data.ba;
    }

    void start( Q3Http * );
    bool hasRequestHeader();
    Q3HttpRequestHeader requestHeader();

    QIODevice* sourceDevice();
    QIODevice* destinationDevice();

protected:
    Q3HttpRequestHeader header;

private:
    union {
  QByteArray *ba;
  QIODevice *dev;
    } data;
    bool is_ba;
    QIODevice *to;
};

void Q3HttpNormalRequest::start( Q3Http *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 = QByteArray();

  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 Q3HttpNormalRequest::hasRequestHeader()
{
    return true;
}

Q3HttpRequestHeader Q3HttpNormalRequest::requestHeader()
{
    return header;
}

QIODevice* Q3HttpNormalRequest::sourceDevice()
{
    if ( is_ba )
  return 0;
    return data.dev;
}

QIODevice* Q3HttpNormalRequest::destinationDevice()
{
    return to;
}

/****************************************************
 *
 * Q3HttpPGHRequest
 * (like a Q3HttpNormalRequest, but for the convenience
 * functions put(), get() and head() -- i.e. set the
 * host header field correctly before sending the
 * request)
 *
 ****************************************************/

class Q3HttpPGHRequest : public Q3HttpNormalRequest
{
public:
    Q3HttpPGHRequest( const Q3HttpRequestHeader &h, QIODevice *d, QIODevice *t ) :
  Q3HttpNormalRequest( h, d, t )
    { }

    Q3HttpPGHRequest( const Q3HttpRequestHeader &h, QByteArray *d, QIODevice *t ) :
  Q3HttpNormalRequest( h, d, t )
    { }

    ~Q3HttpPGHRequest()
    { }

    void start( Q3Http * );
};

void Q3HttpPGHRequest::start( Q3Http *http )
{
    header.setValue( "Host", http->d->hostname );
    Q3HttpNormalRequest::start( http );
}

/****************************************************
 *
 * Q3HttpSetHostRequest
 *
 ****************************************************/

class Q3HttpSetHostRequest : public Q3HttpRequest
{
public:
    Q3HttpSetHostRequest( const QString &h, Q_UINT16 p ) :
  hostname(h), port(p)
    { }

    void start( Q3Http * );

    QIODevice* sourceDevice()
    { return 0; }
    QIODevice* destinationDevice()
    { return 0; }

private:
    QString hostname;
    Q_UINT16 port;
};

void Q3HttpSetHostRequest::start( Q3Http *http )
{
    http->d->hostname = hostname;
    http->d->port = port;
    http->finishedWithSuccess();
}

/****************************************************
 *
 * Q3HttpCloseRequest
 *
 ****************************************************/

class Q3HttpCloseRequest : public Q3HttpRequest
{
public:
    Q3HttpCloseRequest()
    { }
    void start( Q3Http * );

    QIODevice* sourceDevice()
    { return 0; }
    QIODevice* destinationDevice()
    { return 0; }
};

void Q3HttpCloseRequest::start( Q3Http *http )
{
    http->close();
}

/****************************************************
 *
 * Q3HttpHeader
 *
 ****************************************************/

Q3HttpHeader::Q3HttpHeader()
    : valid( true )
{
}

Q3HttpHeader::Q3HttpHeader( const Q3HttpHeader& header )
    : valid( header.valid )
{
    values = header.values;
}

Q3HttpHeader::Q3HttpHeader( const QString& str )
    : valid( true )
{
    parse( str );
}

Q3HttpHeader::~Q3HttpHeader()
{
}

Q3HttpHeader& Q3HttpHeader::operator=( const Q3HttpHeader& h )
{
    values = h.values;
    valid = h.valid;
    return *this;
}

bool Q3HttpHeader::isValid() const
{
    return valid;
}

bool Q3HttpHeader::parse( const QString& str )
{
    QStringList lst;
    int pos = str.find( '\n' );
    if ( pos > 0 && str.at( pos - 1 ) == '\r' )
  lst = QStringList::split( "\r\n", str.stripWhiteSpace(), false );
    else
  lst = QStringList::split( "\n", str.stripWhiteSpace(), false );

    if ( lst.isEmpty() )
  return true;

    QStringList lines;
    QStringList::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;
}

void Q3HttpHeader::setValid( bool v )
{
    valid = v;
}

QString Q3HttpHeader::value( const QString& key ) const
{
    return values[ key.lower() ];
}

QStringList Q3HttpHeader::keys() const
{
    return values.keys();
}

bool Q3HttpHeader::hasKey( const QString& key ) const
{
    return values.contains( key.lower() );
}

void Q3HttpHeader::setValue( const QString& key, const QString& value )
{
    values[ key.lower() ] = value;
}

void Q3HttpHeader::removeValue( const QString& key )
{
    values.remove( key.lower() );
}

bool Q3HttpHeader::parseLine( const QString& line, int )
{
    int i = line.find( ":" );
    if ( i == -1 )
  return false;

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

    return true;
}

QString Q3HttpHeader::toString() const
{
    if ( !isValid() )
  return "";

    QString ret = "";

    QMap<QString,QString>::ConstIterator it = values.begin();
    for( ; it != values.end(); ++it )
  ret += it.key() + ": " + it.data() + "\r\n";

    return ret;
}

bool Q3HttpHeader::hasContentLength() const
{
    return hasKey( "content-length" );
}

uint Q3HttpHeader::contentLength() const
{
    return values[ "content-length" ].toUInt();
}

void Q3HttpHeader::setContentLength( int len )
{
    values[ "content-length" ] = QString::number( len );
}

bool Q3HttpHeader::hasContentType() const
{
    return hasKey( "content-type" );
}

QString Q3HttpHeader::contentType() const
{
    QString type = values[ "content-type" ];
    if ( type.isEmpty() )
  return QString();

    int pos = type.find( ";" );
    if ( pos == -1 )
  return type;

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

void Q3HttpHeader::setContentType( const QString& type )
{
    values[ "content-type" ] = type;
}

/****************************************************
 *
 * Q3HttpResponseHeader
 *
 ****************************************************/

Q3HttpResponseHeader::Q3HttpResponseHeader()
{
    setValid( false );
}

Q3HttpResponseHeader::Q3HttpResponseHeader( int code, const QString& text, int majorVer, int minorVer )
    : Q3HttpHeader(), statCode( code ), reasonPhr( text ), majVer( majorVer ), minVer( minorVer )
{
}

Q3HttpResponseHeader::Q3HttpResponseHeader( const Q3HttpResponseHeader& header )
    : Q3HttpHeader( header ), statCode( header.statCode ), reasonPhr( header.reasonPhr ), majVer( header.majVer ), minVer( header.minVer )
{
}

Q3HttpResponseHeader::Q3HttpResponseHeader( const QString& str )
    : Q3HttpHeader()
{
    parse( str );
}

void Q3HttpResponseHeader::setStatusLine( int code, const QString& text, int majorVer, int minorVer )
{
    setValid( true );
    statCode = code;
    reasonPhr = text;
    majVer = majorVer;
    minVer = minorVer;
}

int Q3HttpResponseHeader::statusCode() const
{
    return statCode;
}

QString Q3HttpResponseHeader::reasonPhrase() const
{
    return reasonPhr;
}

int Q3HttpResponseHeader::majorVersion() const
{
    return majVer;
}

int Q3HttpResponseHeader::minorVersion() const
{
    return minVer;
}

bool Q3HttpResponseHeader::parseLine( const QString& line, int number )
{
    if ( number != 0 )
  return Q3HttpHeader::parseLine( line, number );

    QString 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.find( ' ', 9 );
  if ( pos != -1 ) {
      reasonPhr = l.mid( pos + 1 );
      statCode = l.mid( 9, pos - 9 ).toInt();
  } else {
      statCode = l.mid( 9 ).toInt();
      reasonPhr.clear();
  }
    } else {
  return false;
    }

    return true;
}

QString Q3HttpResponseHeader::toString() const
{
    QString ret( "HTTP/%1.%2 %3 %4\r\n%5\r\n" );
    return ret.arg( majVer ).arg ( minVer ).arg( statCode ).arg( reasonPhr ).arg( Q3HttpHeader::toString() );
}

/****************************************************
 *
 * Q3HttpRequestHeader
 *
 ****************************************************/

Q3HttpRequestHeader::Q3HttpRequestHeader()
    : Q3HttpHeader()
{
    setValid( false );
}

Q3HttpRequestHeader::Q3HttpRequestHeader( const QString& method, const QString& path, int majorVer, int minorVer )
    : Q3HttpHeader(), m( method ), p( path ), majVer( majorVer ), minVer( minorVer )
{
}

Q3HttpRequestHeader::Q3HttpRequestHeader( const Q3HttpRequestHeader& header )
    : Q3HttpHeader( header ), m( header.m ), p( header.p ), majVer( header.majVer ), minVer( header.minVer )
{
}

Q3HttpRequestHeader::Q3HttpRequestHeader( const QString& str )
    : Q3HttpHeader()
{
    parse( str );
}

void Q3HttpRequestHeader::setRequest( const QString& method, const QString& path, int majorVer, int minorVer )
{
    setValid( true );
    m = method;
    p = path;
    majVer = majorVer;
    minVer = minorVer;
}

QString Q3HttpRequestHeader::method() const
{
    return m;
}

QString Q3HttpRequestHeader::path() const
{
    return p;
}

int Q3HttpRequestHeader::majorVersion() const
{
    return majVer;
}

int Q3HttpRequestHeader::minorVersion() const
{
    return minVer;
}

bool Q3HttpRequestHeader::parseLine( const QString& line, int number )
{
    if ( number != 0 )
  return Q3HttpHeader::parseLine( line, number );

    QStringList lst = QStringList::split( " ", line.simplifyWhiteSpace() );
    if ( lst.count() > 0 ) {
  m = lst[0];
  if ( lst.count() > 1 ) {
      p = lst[1];
      if ( lst.count() > 2 ) {
    QString 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;
}

QString Q3HttpRequestHeader::toString() const
{
    QString first( "%1 %2");
    QString last(" HTTP/%3.%4\r\n%5\r\n" );
    return first.arg( m ).arg( p ) +
  last.arg( majVer ).arg( minVer ).arg( Q3HttpHeader::toString());
}


/****************************************************
 *
 * Q3Http
 *
 ****************************************************/
Q3Http::Q3Http()
{
    init();
}

Q3Http::Q3Http( QObject* parent, const char* name )
{
    if ( parent )
  parent->insertChild( this );
    setName( name );
    init();
}

Q3Http::Q3Http( const QString &hostname, Q_UINT16 port, QObject* parent, const char* name )
{
    if ( parent )
  parent->insertChild( this );
    setName( name );
    init();

    d->hostname = hostname;
    d->port = port;
}

void Q3Http::init()
{
    bytesRead = 0;
    d = new Q3HttpPrivate;
    d->errorString = QHttp::tr( "Unknown error" );

    connect( &d->socket, SIGNAL(connected()),
      this, SLOT(slotConnected()) );
    connect( &d->socket, SIGNAL(connectionClosed()),
      this, SLOT(slotClosed()) );
    connect( &d->socket, SIGNAL(delayedCloseFinished()),
      this, SLOT(slotClosed()) );
    connect( &d->socket, SIGNAL(readyRead()),
      this, SLOT(slotReadyRead()) );
    connect( &d->socket, SIGNAL(error(int)),
      this, SLOT(slotError(int)) );
    connect( &d->socket, SIGNAL(bytesWritten(int)),
      this, SLOT(slotBytesWritten(int)) );

    d->idleTimer = startTimer( 0 );
}

Q3Http::~Q3Http()
{
    abort();
    delete d;
}

void Q3Http::abort()
{
    Q3HttpRequest *r = d->pending.getFirst();
    if ( r == 0 )
  return;

    finishedWithError( QHttp::tr("Request aborted"), Aborted );
    clearPendingRequests();
    d->socket.clearPendingData();
    close();
}

Q_ULONG Q3Http::bytesAvailable() const
{
#if defined(Q3HTTP_DEBUG)
    qDebug( "Q3Http::bytesAvailable(): %d bytes", (int)d->rba.size() );
#endif
    return d->rba.size();
}

Q_LONG Q3Http::readBlock( char *data, Q_ULONG maxlen )
{
    if ( data == 0 && maxlen != 0 ) {
#if defined(QT_CHECK_NULL)
  qWarning( "Q3Http::readBlock: Null pointer error" );
#endif
  return -1;
    }
    if ( maxlen >= (Q_ULONG)d->rba.size() )
  maxlen = d->rba.size();
    d->rba.consumeBytes( maxlen, data );

    d->bytesDone += maxlen;
#if defined(Q3HTTP_DEBUG)
    qDebug( "Q3Http::readBlock(): read %d bytes (%d bytes done)", (int)maxlen, d->bytesDone );
#endif
    return maxlen;
}

QByteArray Q3Http::readAll()
{
    Q_ULONG avail = bytesAvailable();
    QByteArray tmp( avail );
    Q_LONG read = readBlock( tmp.data(), avail );
    tmp.resize( read );
    return tmp;
}

int Q3Http::currentId() const
{
    Q3HttpRequest *r = d->pending.getFirst();
    if ( r == 0 )
  return 0;
    return r->id;
}

Q3HttpRequestHeader Q3Http::currentRequest() const
{
    Q3HttpRequest *r = d->pending.getFirst();
    if ( r != 0 && r->hasRequestHeader() )
  return r->requestHeader();
    return Q3HttpRequestHeader();
}

QIODevice* Q3Http::currentSourceDevice() const
{
    Q3HttpRequest *r = d->pending.getFirst();
    if ( !r )
  return 0;
    return r->sourceDevice();
}

QIODevice* Q3Http::currentDestinationDevice() const
{
    Q3HttpRequest *r = d->pending.getFirst();
    if ( !r )
  return 0;
    return r->destinationDevice();
}

bool Q3Http::hasPendingRequests() const
{
    return d->pending.count() > 1;
}

void Q3Http::clearPendingRequests()
{
    Q3HttpRequest *r = 0;
    if ( d->pending.count() > 0 )
  r = d->pending.take( 0 );
    d->pending.clear();
    if ( r )
  d->pending.append( r );
}

int Q3Http::setHost(const QString &hostname, Q_UINT16 port )
{
    return addRequest( new Q3HttpSetHostRequest( hostname, port ) );
}

int Q3Http::get( const QString& path, QIODevice* to )
{
    Q3HttpRequestHeader header( "GET", path );
    header.setValue( "Connection", "Keep-Alive" );
    return addRequest( new Q3HttpPGHRequest( header, (QIODevice*)0, to ) );
}

int Q3Http::post( const QString& path, QIODevice* data, QIODevice* to  )
{
    Q3HttpRequestHeader header( "POST", path );
    header.setValue( "Connection", "Keep-Alive" );
    return addRequest( new Q3HttpPGHRequest( header, data, to ) );
}

int Q3Http::post( const QString& path, const QByteArray& data, QIODevice* to )
{
    Q3HttpRequestHeader header( "POST", path );
    header.setValue( "Connection", "Keep-Alive" );
    return addRequest( new Q3HttpPGHRequest( header, new QByteArray(data), to ) );
}

int Q3Http::head( const QString& path )
{
    Q3HttpRequestHeader header( "HEAD", path );
    header.setValue( "Connection", "Keep-Alive" );
    return addRequest( new Q3HttpPGHRequest( header, (QIODevice*)0, 0 ) );
}

int Q3Http::request( const Q3HttpRequestHeader &header, QIODevice *data, QIODevice *to )
{
    return addRequest( new Q3HttpNormalRequest( header, data, to ) );
}

int Q3Http::request( const Q3HttpRequestHeader &header, const QByteArray &data, QIODevice *to  )
{
    return addRequest( new Q3HttpNormalRequest( header, new QByteArray(data), to ) );
}

int Q3Http::closeConnection()
{
    return addRequest( new Q3HttpCloseRequest() );
}

int Q3Http::addRequest( Q3HttpRequest *req )
{
    d->pending.append( req );

    if ( d->pending.count() == 1 )
  // don't emit the requestStarted() signal before the id is returned
  QTimer::singleShot( 0, this, SLOT(startNextRequest()) );

    return req->id;
}

void Q3Http::startNextRequest()
{
    Q3HttpRequest *r = d->pending.getFirst();
    if ( r == 0 )
  return;

    d->error = NoError;
    d->errorString = QHttp::tr( "Unknown error" );

    if ( bytesAvailable() )
  readAll(); // clear the data
    emit requestStarted( r->id );
    r->start( this );
}

void Q3Http::sendRequest()
{
    if ( d->hostname.isNull() ) {
  finishedWithError( QHttp::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() != Q3Socket::Connection ) {
  setState( Q3Http::Connecting );
  d->socket.connectToHost( d->hostname, d->port );
    } else {
        slotConnected();
    }

}

void Q3Http::finishedWithSuccess()
{
    Q3HttpRequest *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 Q3Http::finishedWithError( const QString& detail, int errorCode )
{
    Q3HttpRequest *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 Q3Http::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( QHttp::tr("Wrong content length"), WrongContentLength );
      }
  }
    } else if ( d->state == Connecting || d->state == Sending ) {
  finishedWithError( QHttp::tr("Server closed connection unexpectedly"), UnexpectedClose );
    }

    d->postDevice = 0;
    setState( Closing );
    d->idleTimer = startTimer( 0 );
}

void Q3Http::slotConnected()
{
    if ( d->state != Sending ) {
  d->bytesDone = 0;
  setState( Sending );
    }

    QString str = d->header.toString();
    d->bytesTotal = str.length();
    d->socket.writeBlock( str.latin1(), d->bytesTotal );
#if defined(Q3HTTP_DEBUG)
    qDebug( "Q3Http: 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 = QByteArray(); // save memory
    }
}

void Q3Http::slotError( int err )
{
    d->postDevice = 0;

    if ( d->state == Connecting || d->state == Reading || d->state == Sending ) {
  switch ( err ) {
      case Q3Socket::ErrConnectionRefused:
    finishedWithError( QHttp::tr("Connection refused"), ConnectionRefused );
    break;
      case Q3Socket::ErrHostNotFound:
    finishedWithError( QHttp::tr("Host %1 not found").arg(d->socket.peerName()), HostNotFound );
    break;
      default:
    finishedWithError( QHttp::tr("HTTP request failed"), UnknownError );
    break;
  }
    }

    close();
}

void Q3Http::slotBytesWritten( int written )
{
    d->bytesDone += written;
    emit dataSendProgress( d->bytesDone, d->bytesTotal );

    if ( !d->postDevice )
  return;

    if ( d->socket.bytesToWrite() == 0 ) {
  int max = qMin<int>( 4096, d->postDevice->size() - d->postDevice->at() );
  QByteArray arr( max );

  int n = d->postDevice->readBlock( arr.data(), max );
  if ( n != max ) {
      qWarning("Could not read enough bytes from the device");
      close();
      return;
  }
  if ( d->postDevice->atEnd() ) {
      d->postDevice = 0;
  }

  d->socket.writeBlock( arr.data(), max );
    }
}

void Q3Http::slotReadyRead()
{
    if ( d->state != Reading ) {
  setState( Reading );
  d->buffer = QByteArray();
  d->readHeader = true;
  d->headerStr = "";
  d->bytesDone = 0;
  d->chunkedSize = -1;
    }

    while ( d->readHeader ) {
  bool end = false;
  QString 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(Q3HTTP_DEBUG)
  qDebug( "Q3Http: read response header:\n---{\n%s}---", d->headerStr.latin1() );
#endif
  d->response = Q3HttpResponseHeader( d->headerStr );
  d->headerStr = "";
#if defined(Q3HTTP_DEBUG)
  qDebug( "Q3Http: read response header:\n---{\n%s}---", d->response.toString().latin1() );
#endif
  // Check header
  if ( !d->response.isValid() ) {
      finishedWithError( QHttp::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().contains( "chunked" ) )
    d->chunkedSize = 0;

      emit responseHeaderReceived( d->response );
  }
    }

    if ( !d->readHeader ) {
  bool everythingRead = false;

  if ( currentRequest().method() == "HEAD" ) {
      everythingRead = true;
  } else {
      Q_ULONG n = d->socket.bytesAvailable();
      QByteArray *arr = 0;
      if ( d->chunkedSize != -1 ) {
    // transfer-encoding is chunked
    for ( ;; ) {
        // get chunk size
        if ( d->chunkedSize == 0 ) {
      if ( !d->socket.canReadLine() )
          break;
      QString sizeString = d->socket.readLine();
      int tPos = sizeString.find( ';' );
      if ( tPos != -1 )
          sizeString.truncate( tPos );
      bool ok;
      d->chunkedSize = sizeString.toInt( &ok, 16 );
      if ( !ok ) {
          finishedWithError( QHttp::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() ) {
      QString 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 ( (Q_LONG)n == d->chunkedSize || (Q_LONG)n == d->chunkedSize+1 ) {
      n = d->chunkedSize - 1;
      if ( n == 0 )
          break;
        }

        // read data
        uint toRead = QMIN( (Q_LONG)n, (d->chunkedSize < 0 ? (Q_LONG)n : d->chunkedSize) );
        if ( !arr )
      arr = new QByteArray( 0 );
        uint oldArrSize = arr->size();
        arr->resize( oldArrSize + toRead );
        Q_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( QHttp::tr("Invalid HTTP chunked body"), WrongContentLength );
          close();
                            delete arr;
          return;
      }
        }
    }
      } else if ( d->response.hasContentLength() ) {
    n = qMin<ulong>( d->response.contentLength() - d->bytesDone, n );
    if ( n > 0 ) {
        arr = new QByteArray( n );
        Q_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
    QByteArray temp = d->socket.readAll();
    arr = new QByteArray( temp );
      }

      if ( arr ) {
    n = arr->size();
    if ( d->toDevice ) {
        d->toDevice->writeBlock( arr->data(), n );
        delete arr;
        d->bytesDone += n;
#if defined(Q3HTTP_DEBUG)
        qDebug( "Q3Http::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(Q3HTTP_DEBUG)
        qDebug( "Q3Http::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 );
      }
  }
    }
}

Q3Http::State Q3Http::state() const
{
    return d->state;
}

Q3Http::Error Q3Http::error() const
{
    return d->error;
}

QString Q3Http::errorString() const
{
    return d->errorString;
}

void Q3Http::timerEvent( QTimerEvent *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 {
  QObject::timerEvent( e );
    }
}

void Q3Http::killIdleTimer()
{
    if (d->idleTimer)
        killTimer( d->idleTimer );
    d->idleTimer = 0;
}

void Q3Http::setState( int s )
{
#if defined(Q3HTTP_DEBUG)
    qDebug( "Q3Http state changed %d -> %d", d->state, s );
#endif
    d->state = (State)s;
    emit stateChanged( s );
}

void Q3Http::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() == Q3Socket::Idle ) {
      // Prepare to emit the requestFinished() signal.
      d->idleTimer = startTimer( 0 );
  }
    }
}

/**********************************************************************
 *
 * Q3Http implementation of the Q3NetworkProtocol interface
 *
 *********************************************************************/
int Q3Http::supportedOperations() const
{
    return OpGet | OpPut;
}

void Q3Http::operationGet( Q3NetworkOperation *op )
{
    connect( this, SIGNAL(readyRead(Q3HttpResponseHeader)),
      this, SLOT(clientReply(Q3HttpResponseHeader)) );
    connect( this, SIGNAL(done(bool)),
      this, SLOT(clientDone(bool)) );
    connect( this, SIGNAL(stateChanged(int)),
      this, SLOT(clientStateChanged(int)) );

    bytesRead = 0;
    op->setState( StInProgress );
    Q3Url u( operationInProgress()->arg( 0 ) );
    Q3HttpRequestHeader header( "GET", u.encodedPathAndQuery(), 1, 0 );
    header.setValue( "Host", u.host() );
    setHost( u.host(), u.port() != -1 ? u.port() : 80 );
    request( header );
}

void Q3Http::operationPut( Q3NetworkOperation *op )
{
    connect( this, SIGNAL(readyRead(Q3HttpResponseHeader)),
      this, SLOT(clientReply(Q3HttpResponseHeader)) );
    connect( this, SIGNAL(done(bool)),
      this, SLOT(clientDone(bool)) );
    connect( this, SIGNAL(stateChanged(int)),
      this, SLOT(clientStateChanged(int)) );

    bytesRead = 0;
    op->setState( StInProgress );
    Q3Url u( operationInProgress()->arg( 0 ) );
    Q3HttpRequestHeader 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 Q3Http::clientReply( const Q3HttpResponseHeader &rep )
{
    Q3NetworkOperation *op = operationInProgress();
    if ( op ) {
  if ( rep.statusCode() >= 400 && rep.statusCode() < 600 ) {
      op->setState( StFailed );
      op->setProtocolDetail(
        QString("%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() signals?
  if ( op->operation() == OpGet && bytesAvailable() > 0 ) {
      QByteArray ba = readAll();
      emit data( ba, op );
      bytesRead += ba.size();
      if ( rep.hasContentLength() ) {
    emit dataTransferProgress( bytesRead, rep.contentLength(), op );
      }
  }
    }
}

void Q3Http::clientDone( bool err )
{
    disconnect( this, SIGNAL(readyRead(Q3HttpResponseHeader)),
      this, SLOT(clientReply(Q3HttpResponseHeader)) );
    disconnect( this, SIGNAL(done(bool)),
      this, SLOT(clientDone(bool)) );
    disconnect( this, SIGNAL(stateChanged(int)),
      this, SLOT(clientStateChanged(int)) );

    if ( err ) {
  Q3NetworkOperation *op = operationInProgress();
  if ( op ) {
      op->setState( Q3NetworkProtocol::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 {
  Q3NetworkOperation *op = operationInProgress();
  if ( op ) {
      if ( op->state() != StFailed ) {
    op->setState( Q3NetworkProtocol::StDone );
    op->setErrorCode( Q3NetworkProtocol::NoError );
      }
      emit finished( op );
  }
    }

}

void Q3Http::clientStateChanged( int state )
{
    if ( url() ) {
  switch ( (State)state ) {
      case Connecting:
    emit connectionStateChanged( ConHostFound, QHttp::tr( "Host %1 found" ).arg( url()->host() ) );
    break;
      case Sending:
    emit connectionStateChanged( ConConnected, QHttp::tr( "Connected to host %1" ).arg( url()->host() ) );
    break;
      case Unconnected:
    emit connectionStateChanged( ConClosed, QHttp::tr( "Connection to %1 closed" ).arg( url()->host() ) );
    break;
      default:
    break;
  }
    } else {
  switch ( (State)state ) {
      case Connecting:
    emit connectionStateChanged( ConHostFound, QHttp::tr( "Host found" ) );
    break;
      case Sending:
    emit connectionStateChanged( ConConnected, QHttp::tr( "Connected to host" ) );
    break;
      case Unconnected:
    emit connectionStateChanged( ConClosed, QHttp::tr( "Connection closed" ) );
    break;
      default:
    break;
  }
    }
}

#endif

---