RequestHeader.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-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 "RequestHeader.h"

using namespace Http;

namespace Http {

class RequestHeaderPrivate
{
public:
    QString     method;
    QString     path;
    int         majorVersion;
    int         minorVersion;

    RequestHeaderPrivate() : method(), path(), majorVersion(), minorVersion() {}
};

} // namespace Http;

RequestHeader::RequestHeader()
    : d (new RequestHeaderPrivate)
{
    setValid(false);
}

RequestHeader::RequestHeader (const QString &method,
                                      const QString &path,
                                      int majorVersion,
                                      int minorVersion)
    : d (new RequestHeaderPrivate)
{
    setRequestLine (method, path, minorVersion, majorVersion);
}

RequestHeader::RequestHeader (const RequestHeader &header)
    : Header (header), d (new RequestHeaderPrivate)
{
    d->method       = header.d->method;
    d->path         = header.d->path;
    d->majorVersion = header.d->majorVersion;
    d->minorVersion = header.d->minorVersion;
}

RequestHeader::~RequestHeader()
{
}

RequestHeader &
RequestHeader::operator= (const RequestHeader &header)
{
    Header::operator= (header);
    d->method       = header.d->method;
    d->path         = header.d->path;
    d->majorVersion = header.d->majorVersion;
    d->minorVersion = header.d->minorVersion;
    return *this;
}

RequestHeader::RequestHeader(const QString &str)
    : d (new RequestHeaderPrivate)
{
    parse(str);
}

void
RequestHeader::setRequestLine (const QString &method,
                                   const QString &path,
                                   int majorVersion,
                                   int minorVersion)
{
    setValid(true);
    d->method       = method;
    d->path         = path;
    d->majorVersion = majorVersion;
    d->minorVersion = minorVersion;
}

QString
RequestHeader::method() const
{
    return d->method;
}

QString
RequestHeader::path() const
{
    return d->path;
}

int
RequestHeader::majorVersion() const
{
    return d->majorVersion;
}

int
RequestHeader::minorVersion() const
{
    return d->minorVersion;
}

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

    QStringList lst = line.simplified().split(" ");
    if (lst.count() > 0) {
        d->method = lst[0];
        if (lst.count() > 1) {
            d->path = 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()) {
                    d->majorVersion = v[5].toLatin1() - '0';
                    d->minorVersion = v[7].toLatin1() - '0';
                    return true;
                }
            }
        }
    }

    return false;
}

QString
RequestHeader::toString() const
{
    QString format("%1 %2 HTTP/%3.%4\r\n%5\r\n");
    return format.arg (d->method)
                 .arg (d->path)
                 .arg (d->majorVersion)
                 .arg (d->minorVersion)
                 .arg(Header::toString());
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.