SingleHostClientHttpSession.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 "SingleHostClientHttpSession.h"
#include "ClientHttpSessionStatus.h"
#include "BodyEnd.h"
#include "RequestHeader.h"
#include "ResponseHeader.h"
#include "Imports.cpp"

SingleHostClientHttpSession::SingleHostClientHttpSession (
                                    ClientHttpSessionStatus *status,
                                    Session *session)
 :  status_ (status), session_ (session),
    receivedDataDispatcher_(), outFile_ (0)
{
    receivedDataDispatcher_.registerTypeHandler (
        Callable <void (const ResponseHeader &)>
            (this, &SingleHostClientHttpSession::received));

    receivedDataDispatcher_.registerTypeHandler (
        Callable <void (const RawData &)>
            (this, &SingleHostClientHttpSession::received));

    receivedDataDispatcher_.registerTypeHandler (
        Callable <void (const BodyEnd &)>
            (this, &SingleHostClientHttpSession::received));

    receivedDataDispatcher_.registerNotHandledHandler(
        Callable <void (const DataBase &)>
            (this, &SingleHostClientHttpSession::received));
}

SingleHostClientHttpSession::~SingleHostClientHttpSession()
{
}


void SingleHostClientHttpSession::open()
{
    session_->open();
}

void SingleHostClientHttpSession::close()
{
    session_->close();
}

void SingleHostClientHttpSession::abort()
{
    session_->abort();
}

void SingleHostClientHttpSession::get (const Uri &uri, File *outFile)
{
    Q_ASSERT (outFile != 0);
    outFile_ = outFile;
    RequestHeader requestHeader = createRequestHeader ("GET", uri);
    requestHeader.setFieldValue ("Content-Length", "0");
    session_->send (requestHeader);
}

RequestHeader
SingleHostClientHttpSession::createRequestHeader (const QByteArray &method,
                                                  const Uri &uri)
{
    RequestHeader request (method, requestUri (uri), 1, 1);
    request.setFieldValue ("Host", host (uri));
    return request;
}

QByteArray SingleHostClientHttpSession::requestUri (const Uri &uri)
{
    if (uri.path().isEmpty())
        return "/" + uri.encoded (Uri::Query);
    else
        return uri.encoded (Uri::Path | Uri::Query);
}

QByteArray SingleHostClientHttpSession::host (const Uri &uri)
{
    QByteArray res = uri.encoded (Uri::Host | Uri::Port);
    return res.mid (2); // Drop the leading "//" in "//host.tld[:port]"
}

void SingleHostClientHttpSession::sessionReceivedData (Session *,
                                                       const Data &data)
{
    receivedDataDispatcher_.dispatch (*data);
}

void SingleHostClientHttpSession::received (const ResponseHeader &header)
{
    status_->clientHttpSessionResponseStarted (header);
}

void SingleHostClientHttpSession::received (const RawData &chunk)
{
    Q_ASSERT (outFile_ != 0);
    outFile_->write (chunk.toRawBytes());
}

void SingleHostClientHttpSession::received (const BodyEnd &bodyEnd)
{
    status_->clientHttpSessionResponseFinished (bodyEnd);
}

void SingleHostClientHttpSession::received (const DataBase &)
{
    Q_ASSERT (false); // Unknown/unhandled Data type received!
}

void SingleHostClientHttpSession::sessionSendingData (Session *, const Data &)
{
    // Nothing to do here.
}

void SingleHostClientHttpSession::sessionClosing (Session *)
{
    // \todo states??
    status_->clientHttpSessionClosing();
}

void SingleHostClientHttpSession::sessionClosed (Session *)
{
    // \todo states??
    status_->clientHttpSessionClosed();
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.