/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/*!

    \class QUrl

    \brief The QUrl class provides a convenient interface for working

    with URLs.

    \reentrant

    \ingroup io

    \ingroup network

    \ingroup shared

    It can parse and construct URLs in both encoded and unencoded

    form. QUrl also has support for internationalized domain names

    (IDNs).

    The most common way to use QUrl is to initialize it via the

    constructor by passing a QString. Otherwise, setUrl() and

    setEncodedUrl() can also be used.

    URLs can be represented in two forms: encoded or unencoded. The

    unencoded representation is suitable for showing to users, but

    the encoded representation is typically what you would send to

    a web server. For example, the unencoded URL

    "http://b\uuml\c{}hler.example.com" would be sent to the server as

    "http://xn--bhler-kva.example.com/List%20of%20applicants.xml".

    A URL can also be constructed piece by piece by calling

    setScheme(), setUserName(), setPassword(), setHost(), setPort(),

    setPath(), setEncodedQuery() and setFragment(). Some convenience

    functions are also available: setAuthority() sets the user name,

    password, host and port. setUserInfo() sets the user name and

    password at once.

    Call isValid() to check if the URL is valid. This can be done at

    any point during the constructing of a URL.

    Constructing a query is particularly convenient through the use

    of setQueryItems(), addQueryItem() and removeQueryItem(). Use

    setQueryDelimiters() to customize the delimiters used for

    generating the query string.

    For the convenience of generating encoded URL strings or query

    strings, there are two static functions called

    fromPercentEncoding() and toPercentEncoding() which deal with

    percent encoding and decoding of QStrings.

    Calling isRelative() will tell whether or not the URL is

    relative. A relative URL can be resolved by passing it as argument

    to resolved(), which returns an absolute URL. isParentOf() is used

    for determining whether one URL is a parent of another.

    fromLocalFile() constructs a QUrl by parsing a local

    file path. toLocalFile() converts a URL to a local file path.

    The human readable representation of the URL is fetched with

    toString(). This representation is appropriate for displaying a

    URL to a user in unencoded form. The encoded form however, as

    returned by toEncoded(), is for internal use, passing to web

    servers, mail clients and so on.

    QUrl conforms to the URI specification from

    \l{RFC 3986} (Uniform Resource Identifier: Generic Syntax), and includes

    scheme extensions from \l{RFC 1738} (Uniform Resource Locators). Case

    folding rules in QUrl conform to \l{RFC 3491} (Nameprep: A Stringprep

    Profile for Internationalized Domain Names (IDN)).

    \sa QUrlInfo

*/

/*!

    \enum QUrl::ParsingMode

    The parsing mode controls the way QUrl parses strings.

    \value TolerantMode QUrl will try to correct some common errors in URLs.

                        This mode is useful when processing URLs entered by

                        users.

    \value StrictMode Only valid URLs are accepted. This mode is useful for

                      general URL validation.

    In TolerantMode, the parser corrects the following invalid input:

    \list

    \o Spaces and "%20": If an encoded URL contains a space, this will be

    replaced with "%20". If a decoded URL contains "%20", this will be

    replaced with a single space before the URL is parsed.

    \o Single "%" characters: Any occurrences of a percent character "%" not

    followed by exactly two hexadecimal characters (e.g., "13% coverage.html")

    will be replaced by "%25".

    \o Reserved and unreserved characters: An encoded URL should only

    contain a few characters as literals; all other characters should

    be percent-encoded. In TolerantMode, these characters will be

    automatically percent-encoded where they are not allowed:

            space / double-quote / "<" / ">" / "[" / "\" /

            "]" / "^" / "`" / "{" / "|" / "}"

    \endlist

*/

/*!

    \enum QUrl::FormattingOption

    The formatting options define how the URL is formatted when written out

    as text.

    \value None The format of the URL is unchanged.

    \value RemoveScheme  The scheme is removed from the URL.

    \value RemovePassword  Any password in the URL is removed.

    \value RemoveUserInfo  Any user information in the URL is removed.

    \value RemovePort      Any specified port is removed from the URL.

    \value RemoveAuthority

    \value RemovePath   The URL's path is removed, leaving only the scheme,

                        host address, and port (if present).

    \value RemoveQuery  The query part of the URL (following a '?' character)

                        is removed.

    \value RemoveFragment

    \value StripTrailingSlash  The trailing slash is removed if one is present.

    Note that the case folding rules in \l{RFC 3491}{Nameprep}, which QUrl

    conforms to, require host names to always be converted to lower case,

    regardless of the Qt::FormattingOptions used.

*/

#include "qplatformdefs.h"

#include "qurl.h"

#include "private/qunicodetables_p.h"

#include "qatomic.h"

#include "qbytearray.h"

#include "qdir.h"

#include "qfile.h"

#include "qlist.h"

#ifndef QT_NO_REGEXP

#include "qregexp.h"

#endif

#include "qstring.h"

#include "qstringlist.h"

#include "qstack.h"

#include "qvarlengtharray.h"

#include "qdebug.h"

#if defined QT3_SUPPORT

#include "qfileinfo.h"

#endif

#if defined(Q_OS_WINCE_WM)

#pragma optimize("g", off)

#endif

QT_BEGIN_NAMESPACE

extern void q_normalizePercentEncoding(QByteArray *ba, const char *exclude);

extern void q_toPercentEncoding(QByteArray *ba, const char *exclude, const char *include = 0);

extern void q_fromPercentEncoding(QByteArray *ba);

static QByteArray toPercentEncodingHelper(const QString &s, const char *exclude, const char *include = 0)

{

    if (s.isNull())

        return QByteArray();    // null

    QByteArray ba = s.toUtf8();

    q_toPercentEncoding(&ba, exclude, include);

    return ba;

}

static QString fromPercentEncodingHelper(const QByteArray &ba)

{

    if (ba.isNull())

        return QString();       // null

    QByteArray copy = ba;

    q_fromPercentEncoding(&copy);

    return QString::fromUtf8(copy.constData(), copy.length());

}

static QString fromPercentEncodingMutable(QByteArray *ba)

{

    if (ba->isNull())

        return QString();       // null

    q_fromPercentEncoding(ba);

    return QString::fromUtf8(ba->constData(), ba->length());

}

// ### Qt 5: Consider accepting empty strings as valid. See task 144227.

//#define QURL_DEBUG

// implemented in qvsnprintf.cpp

Q_CORE_EXPORT int qsnprintf(char *str, size_t n, const char *fmt, ...);

// needed by the punycode encoder/decoder

#define Q_MAXINT ((uint)((uint)(-1)>>1))

static const uint base = 36;

static const uint tmin = 1;

static const uint tmax = 26;

static const uint skew = 38;

static const uint damp = 700;

static const uint initial_bias = 72;

static const uint initial_n = 128;

#define QURL_SETFLAG(a, b) { (a) |= (b); }

#define QURL_UNSETFLAG(a, b) { (a) &= ~(b); }

#define QURL_HASFLAG(a, b) (((a) & (b)) == (b))

struct QUrlErrorInfo {

    inline QUrlErrorInfo() : _source(0), _message(0), _expected(0), _found(0)

    { }

    const char *_source;

    const char *_message;

    char _expected;

    char _found;

    inline void setParams(const char *source, const char *message, char expected, char found)

    {

        _source = source;

        _message = message;

        _expected = expected;

        _found = found;

    }

};

struct QUrlParseData

{

    const char *scheme;

    int schemeLength;

    const char *userInfo;

    int userInfoDelimIndex;

    int userInfoLength;

    const char *host;

    int hostLength;

    int port;

    const char *path;

    int pathLength;

    const char *query;

    int queryLength;

    const char *fragment;

    int fragmentLength;

};

class QUrlPrivate

{

public:

    QUrlPrivate();

    QUrlPrivate(const QUrlPrivate &other);

    bool setUrl(const QString &url);

    QString canonicalHost() const;

    void ensureEncodedParts() const;

    QString authority(QUrl::FormattingOptions options = QUrl::None) const;

    void setAuthority(const QString &auth);

    void setUserInfo(const QString &userInfo);

    QString userInfo(QUrl::FormattingOptions options = QUrl::None) const;

    void setEncodedAuthority(const QByteArray &authority);

    void setEncodedUserInfo(const QUrlParseData *parseData);

    QByteArray mergePaths(const QByteArray &relativePath) const;

    void queryItem(int pos, int *value, int *end);

    enum ParseOptions {

        ParseAndSet,

        ParseOnly

    };

    void validate() const;

    void parse(ParseOptions parseOptions = ParseAndSet) const;

    void clear();

    QByteArray toEncoded(QUrl::FormattingOptions options = QUrl::None) const;

    QAtomicInt ref;

    QString scheme;

    QString userName;

    QString password;

    QString host;

    QString path;

    QByteArray query;

    QString fragment;

    QByteArray encodedOriginal;

    QByteArray encodedUserName;

    QByteArray encodedPassword;

    QByteArray encodedPath;

    QByteArray encodedFragment;

    int port;

    QUrl::ParsingMode parsingMode;

    bool hasQuery;

    bool hasFragment;

    bool isValid;

    char valueDelimiter;

    char pairDelimiter;

    enum State {

        Parsed = 0x1,

        Validated = 0x2,

        Normalized = 0x4,

        HostCanonicalized = 0x8

    };

    int stateFlags;

    QByteArray encodedNormalized;

    const QByteArray & normalized();

    mutable QUrlErrorInfo errorInfo;

    QString createErrorString();

};

static bool QT_FASTCALL _HEXDIG(const char **ptr)

{

    char ch = **ptr;

    if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) {

        ++(*ptr);

        return true;

    }

    return false;

}

// pct-encoded = "%" HEXDIG HEXDIG

static bool QT_FASTCALL _pctEncoded(const char **ptr)

{

    const char *ptrBackup = *ptr;

    if (**ptr != '%')

        return false;

    ++(*ptr);

    if (!_HEXDIG(ptr)) {

        *ptr = ptrBackup;

        return false;

    }

    if (!_HEXDIG(ptr)) {

        *ptr = ptrBackup;

        return false;

    }

    return true;

}

#if 0

// gen-delims  = ":" / "/" / "?" / "#" / "[" / "]" / "@"

static bool QT_FASTCALL _genDelims(const char **ptr, char *c)

{

    char ch = **ptr;

    switch (ch) {

    case ':': case '/': case '?': case '#':

    case '[': case ']': case '@':

        *c = ch;

        ++(*ptr);

        return true;

    default:

        return false;

    }

}

#endif

// sub-delims  = "!" / "$" / "&" / "'" / "(" / ")"

//             / "*" / "+" / "," / ";" / "="

static bool QT_FASTCALL _subDelims(const char **ptr)

{

    char ch = **ptr;

    switch (ch) {

    case '!': case '$': case '&': case '\'':

    case '(': case ')': case '*': case '+':

    case ',': case ';': case '=':

        ++(*ptr);

        return true;

    default:

        return false;

    }

}

// unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"

static bool QT_FASTCALL _unreserved(const char **ptr)

{

    char ch = **ptr;

    if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')

        || (ch >= '0' && ch <= '9')

        || ch == '-' || ch == '.' || ch == '_' || ch == '~') {

        ++(*ptr);

        return true;

    } 

    return false;

}

// scheme      = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

static void QT_FASTCALL _scheme(const char **ptr, QUrlParseData *parseData)

{

    bool first = true;

    parseData->scheme = *ptr;

    for (;;) {

        char ch = **ptr;

        if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {

            ;

        } else if (!first && ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')) {

            ;

        } else {

            break;

        }

        ++(*ptr);

        first = false;

    }

    if (**ptr != ':') {

        *ptr = parseData->scheme;

    } else {

        parseData->schemeLength = *ptr - parseData->scheme;

        ++(*ptr); // skip ':'

    }

}

// IPvFuture  = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )

static bool QT_FASTCALL _IPvFuture(const char **ptr)

{

    if (**ptr != 'v')

        return false;

    const char *ptrBackup = *ptr;

    ++(*ptr);

    if (!_HEXDIG(ptr)) {

        *ptr = ptrBackup;

        return false;

    }

    while (_HEXDIG(ptr))

        ;

    if (**ptr != '.') {

        *ptr = ptrBackup;

        return false;

    }

    ++(*ptr);

    if (!_unreserved(ptr) && !_subDelims(ptr) && *((*ptr)++) != ':') {

        *ptr = ptrBackup;

        return false;

    }

    while (_unreserved(ptr) || _subDelims(ptr) || *((*ptr)++) == ':')

        ;

    return true;

}

// h16         = 1*4HEXDIG

//             ; 16 bits of address represented in hexadecimal

static bool QT_FASTCALL _h16(const char **ptr)

{

    int i = 0;

    for (; i < 4; ++i) {

        if (!_HEXDIG(ptr))

            break;

    }

    return (i != 0);

}

// dec-octet   = DIGIT                 ; 0-9

//             / %x31-39 DIGIT         ; 10-99

//             / "1" 2DIGIT            ; 100-199

//             / "2" %x30-34 DIGIT     ; 200-249

//             / "25" %x30-35          ; 250-255

static bool QT_FASTCALL _decOctet(const char **ptr)

{

    const char *ptrBackup = *ptr;

    char c1 = **ptr;

    if (c1 < '0' || c1 > '9') 

        return false;

    ++(*ptr);