Uri.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 "Uri.h"
#include "Imports.cpp"

Uri::Uri()
    : d (new PrivateData)
{
}


Uri::Uri (const Uri &other)
    : d (other.d)
{
}


Uri & Uri::operator= (const Uri &other)
{
    d = other.d;
    return *this;
}


QByteArray Uri::authority() const
{
    QByteArray res;
    if (!d->userInfo.isEmpty())
        res += d->userInfo + '@';
    res += d->host;
    if (!d->port.isEmpty())
        res += ':' + d->port;
    return res;
}

QByteArray Uri::query() const
{
    QByteArray query (d->query);
    bool decoded = doDecode (query, true);
    Q_ASSERT (decoded); // Must have been encoded correctly.
    return query;
}


QByteArray Uri::queryItemValue (const QByteArray &key) const
{
    foreach (const QueryItem item, queryItems()) {
        if (item.first == key)
            return item.second;
    }
    return QByteArray();
}


Uri::QueryItemList Uri::queryItems() const
{
    if (d->query.isEmpty())
        return QueryItemList();

    QueryItemList list;
    QList <QByteArray> items = d->query.split ('&');
    foreach (QByteArray item, items) {
        QList <QByteArray> subitems = item.split ('=');
        QByteArray key = subitems.value (0);
        QByteArray value = subitems.value (1);
        bool decoded = doDecode (key, true);
        Q_ASSERT (decoded); // Must have been verified when parsing.
        decoded = doDecode (value, true);
        Q_ASSERT (decoded); // Must have been verified when parsing.
        list += QueryItem (key, value);
    }
    return list;
}


QByteArray Uri::toQByteArray (Fields fields, bool encode) const
{
    QByteArray res;
    // scheme ":"
    if (!d->scheme.isNull() && fields & Scheme)
        res += d->scheme + ':'; // \todo encode?
    // "//" [userInfo "@"] host [":" port] (only hierarchical schemes)
    if (!d->host.isNull() && fields & Authority) {
        res += "//";
        if (!d->userInfo.isNull() && fields & UserInfo)
            res += doEncode (d->userInfo, encode, UserInfoEncodeExcludeChars)
                += '@';
        if (fields & Host)
            res += doEncode (d->host, encode, HostEncodeExcludeChars);
        if (!d->port.isNull() && fields & Port)
            res += ':' + d->port; // \todo encode?
    }
    if (fields & Path) // path
        res += doEncode (d->path, encode, PathEncodeExcludeChars);
    // "?" query (optional)
    if (!d->query.isNull() && fields & Query)
        if (encode)
            res += '?' + d->query; // which is already stored in encoded form.
        else {
            QByteArray query = d->query;
            bool decoded = doDecode (query, true);
            Q_ASSERT (decoded); // Must have been encoded correctly!
            res += '?' + query;
        }
    // "#" fragment (optional)
    if (!d->fragment.isNull() && fields & Fragment)
        res += '#' + doEncode (d->fragment, encode, FragmentEncodeExcludeChars);
    // Done!
    return res;
}


QByteArray Uri::doEncode (const QByteArray &bytes, bool encode,
                          const QByteArray &charsToExclude)
{
    if (encode) {
        QByteArray res;
        // Each octet will be encoded in at most 3 unreserved octets:
        res.reserve (bytes.length() * 3);
        foreach (char ch, bytes)
            if (shouldEncode (ch, charsToExclude))
                res += quoted (ch);
            else
                res += ch;
        return res;
    } else
        return bytes;
}


bool Uri::shouldEncode (char ch, const QByteArray &charsToExclude)
{
    if (ch >= 'a' && ch <= 'z'
        || ch >= 'A' && ch <= 'Z'
        || ch >= '0' && ch <= '9'
        || ch == '-'
        || ch == '.'
        || ch == '_'
        || ch == '~'
        || charsToExclude.indexOf(ch) != -1) // other excluded from encoding
        return false;
    else
        return true;
}


char Uri::hex (char ch)
{
    static char hexmap[] = "0123456789ABCDEF";
    return hexmap [ch & 0x0F];
}


QByteArray Uri::quoted (char ch)
{
    return QByteArray ("%") + hex (ch >> 4) + hex (ch);
}


QByteArray Uri::unencoded (Fields fields) const
{
    return toQByteArray (fields, false);
}


QByteArray Uri::encoded (Fields fields) const
{
    return toQByteArray (fields, true);
}

bool Uri::parse (const QByteArray &bytes, bool decode)
{
    QRegExp re ("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?",
                 Qt::CaseSensitive, QRegExp::RegExp2);
    if (re.indexIn (QString::fromLatin1 (bytes)) > -1) {
        if (!re.cap (1).isEmpty()) { // scheme ":"
            d->scheme = re.cap (2).toLatin1();
            if (!doDecode (d->scheme, decode))
                return false;
        }
        if (!re.cap (3).isEmpty()) { // "//" authority
            if (!parseAuthority (re.cap (4).toLatin1(), decode))
                return false;
        }
        if (!re.cap (5).isEmpty()) { // path
            d->path = re.cap (5).toLatin1();
            if (!doDecode (d->path, decode))
                return false;
        }
        if (!re.cap (6).isEmpty()) { // "?" query
            d->query = re.cap (7).toLatin1();
            // We do not want to store query in decoded form but we want to
            // check whether it could be parsed:
            QByteArray query = d->query;
            if (!doDecode (query, decode))
                return false;
            ensureNotNull (d->query);
        }
        if (!re.cap (8).isEmpty()) { // "#" fragment
            d->fragment = re.cap (9).toLatin1();
            if (!doDecode (d->fragment, decode))
                return false;
        }
        return true;
    } else
        return false;
}


bool Uri::doDecode (QByteArray &bytes, bool decode)
{
    if (decode) {
        QByteArray res;
        // Decoded string should be no longer than the undecoded one:
        res.reserve (bytes.length());
        const char *pos = bytes.constData();
        const char *end = bytes.constData() + bytes.length();
        for (; pos != end; ++pos) {
            if (*pos != '%')
                res += *pos;
            else if (pos + 2 < end) {
                char hex1 = *++pos;
                char hex2 = *++pos;
                if (fromHex (hex1) && fromHex (hex2))
                    res += unquoted (hex1, hex2);
                else
                    return false;
            } else
                return false;
        }
        bytes = res;
    }
    ensureNotNull (bytes);
    return true;
}


bool Uri::fromHex (char &hex)
{
    if (hex >= 'a' && hex <= 'f')
        hex -= 'a' - 10;
    else if (hex >= 'A' && hex <= 'F')
        hex -= 'A' - 10;
    else if (hex >= '0' && hex <= '9')
        hex -= '0';
    else
        return false;
    return true;
}


char Uri::unquoted (char hex1, char hex2)
{
    return hex1 << 4 | hex2;
}


void Uri::setAuthority (const QByteArray &authority)
{
    Uri tempUri = *this;
    if (tempUri.parseAuthority (authority, false))
        *this = tempUri;
    else
        Q_ASSERT (false); // Invalid authority component was set!
}


void Uri::setAuthority (const QByteArray &userInfo,
                        const QByteArray &host,
                        const QByteArray &port)
{
    Q_ASSERT (!host.isEmpty());
    d->userInfo = userInfo;
    d->host = host;
    d->port = port;
}


bool Uri::parseAuthority (const QByteArray &authority, bool decode)
{
    int userInfoEnd = authority.indexOf ('@');
    if (userInfoEnd >= 0) {
        d->userInfo = authority.left (userInfoEnd++);
        if (!doDecode (d->userInfo, decode))
            return false;
    } else
        userInfoEnd = 0;
    int hostEnd = authority.indexOf (':', userInfoEnd);
    if (hostEnd >= 0) {
        d->port = authority.mid (hostEnd +1);
        if (!doDecode (d->port, decode))
            return false;
    } else
        hostEnd = authority.length();

    d->host = authority.mid (userInfoEnd, hostEnd - userInfoEnd);
    if (!doDecode (d->host, decode))
        return false;
    // The authority component is only valid if host is not empty when
    // userInfo and/or port are set.
    if (d->host.isEmpty()
        && (!d->port.isEmpty() || !d->userInfo.isEmpty()))
        return false;
    else
        return true;
}

void Uri::setQuery (const QByteArray &query)
{
    d->query = doEncode (query, true, QueryEncodeExcludeChars);
}


void Uri::ensureNotNull (QByteArray &bytes)
{
    if (bytes.isNull())
        bytes = QByteArray (""); // forces bytes.isNull() to return false.
}


void Uri::appendQuery (const QByteArray &bytes)
{
    d->query += doEncode (bytes, true, QueryEncodeExcludeChars);
}


void Uri::appendQueryItem (const QByteArray &key, const QByteArray &value)
{
    QByteArray query = d->query;
    if (!query.isEmpty())
        query += '&';
    query += doEncode (key, true, QueryItemEncodeExcludeChars);
    if (!value.isEmpty())
        query += '=' + doEncode (value, true, QueryItemEncodeExcludeChars);
    d->query = query;
}

void Uri::appendQueryItem (const QueryItem &item)
{
    appendQueryItem (item.first, item.second);
}


void Uri::appendQueryItems (const QueryItemList &itemList)
{
    foreach (QueryItem item, itemList)
        appendQueryItem (item);
}


bool Uri::operator== (const Uri &other) const
{
    return unencoded() == other.unencoded();
}


bool Uri::operator!= (const Uri &other) const
{
    return !(*this == other);
}


Uri Uri::fromUnencoded (const QByteArray &bytes)
{
    Uri temp;
    if (temp.parse (bytes, false))
        return temp;
    else
        return Uri();
}


Uri Uri::fromEncoded (const QByteArray &bytes)
{
    Uri temp;
    if (temp.parse (bytes, true))
        return temp;
    else
        return Uri();
}

uint Utils::qHash (const Uri &uri)
{
    return qHash (uri.unencoded());
}

const QByteArray Uri::UserInfoEncodeExcludeChars    ("!$&'()*+,;=:");
const QByteArray Uri::HostEncodeExcludeChars        ("[]:");
const QByteArray Uri::PathEncodeExcludeChars        ("!$&'()*+,;=:@/");
const QByteArray Uri::QueryEncodeExcludeChars       ("!$&'()*+,;=:@/?");
const QByteArray Uri::QueryItemEncodeExcludeChars   ("!$'()*+,;:@/?");
const QByteArray Uri::FragmentEncodeExcludeChars    ("!$&'()*+,;=:@/?");

Copyright © 2006 Peter Dimov.
Powered by Doxygen.