ClientSession.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "BodyReader.h"
#include "BodyWriter.h"
#include "ClientSession.h"
#include "HeaderReader.h"
#include "HeaderWriter.h"
#include "RequestHeader.h"
#include "ResponseHeader.h"
#include "Imports.cpp"

using namespace Http;

namespace Http {

enum Constants
{
    MajorVersion    = 1,
    MinorVersion    = 1
};

class ClientSessionPrivate
{
public:
    Connection      *connection;
    HeaderReader    *headerReader;
    HeaderWriter    *headerWriter;
    BodyReader      *bodyReader;
    BodyWriter      *bodyWriter;

    QByteArray      requestBody;
    QBuffer         postBuffer;

    ClientSessionPrivate() :    connection (0), headerReader (0),
                                headerWriter (0), bodyReader (0),
                                bodyWriter (0), requestBody(), postBuffer()
    {}

private:
    REFERENCE_OBJECT (ClientSessionPrivate)
};

} // namespace Http;

ClientSession::ClientSession (Connection *connection)
 :  p (new ClientSessionPrivate)
{
    p->connection   = connection;
    p->headerReader = new HeaderReader (connection);
    p->headerWriter = new HeaderWriter (connection);
    p->bodyReader   = new BodyReader (connection);
    p->bodyWriter   = new BodyWriter (connection);

    connect (p->headerWriter, SIGNAL (headerWritten()),
             this, SLOT (writeRequestBody()));
    connect (p->bodyWriter, SIGNAL (bodyWritten()),
             this, SLOT (startReadingResponse()));
    connect (p->headerReader, SIGNAL (headerRead()),
             this, SIGNAL (responseHeaderRead()));
    connect (p->bodyReader, SIGNAL (bodyRead()),
             this, SIGNAL (responseBodyRead()));
    // \todo Connect the error signals to something!
}

ClientSession::~ClientSession()
{
    p->headerReader->disconnect (this);
    p->headerWriter->disconnect (this);
    p->bodyReader->disconnect (this);
    p->bodyWriter->disconnect (this);

    delete p->headerReader;
    delete p->headerWriter;
    delete p->bodyReader;
    delete p->bodyWriter;
    delete p;
}

void ClientSession::get (const QUrl &url, const Header &header)
{
    sendRequest ("GET", url ,header, QByteArray());
}

void ClientSession::head (const QUrl &url, const Header &header)
{
    sendRequest ("HEAD", url ,header, QByteArray());
}

void ClientSession::post (const QUrl &url, const Header &header,
                          const QByteArray &requestBody)
{
    sendRequest ("POST", url, header, requestBody);
}

inline void ClientSession::sendRequest (const QString &method,
                                        const QUrl &url,
                                        const Header &header,
                                        const QByteArray &requestBody)
{
    Q_ASSERT (p->headerWriter->canWrite());

    QString path = url.toEncoded (QUrl::RemoveScheme | QUrl::RemoveAuthority |
                                  QUrl::RemoveFragment);
    RequestHeader request (method, path, MajorVersion, MinorVersion);
    request.Header::operator= (header);
    request.setFieldValue ("Host", url.host());

    qDebug() << request.toString();
    p->requestBody = requestBody;
    p->headerWriter->write (request);
}

void ClientSession::writeRequestBody()
{
    qDebug() << "starting writing request body...";
    if (p->requestBody.length() > 0) {
        p->postBuffer.setBuffer (&p->requestBody);
        p->bodyWriter->write (&p->postBuffer, p->requestBody.length());
    } else {
        startReadingResponse();
    }
}

void ClientSession::startReadingResponse()
{
    qDebug() << "starting reading response header...";
    p->headerReader->startReading (new ResponseHeader);
}

const ResponseHeader * ClientSession::responseHeader() const
{
    return dynamic_cast <const ResponseHeader *>  (p->headerReader->header());
}

void ClientSession::readResponseBody (QIODevice *file)
{
    qint64 length = 0;
    // \todo Id no Content-Length field is given, try Transfer-Encoding: chunked
    // or read until connectio gets closed (HTTP/1.0 behavior)
    length = responseHeader()->fieldValue ("Content-Length").toLongLong();
    qDebug() << "starting reading response body of size" << length;
    p->bodyReader->startReading (file, length);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.