path: root/library/cpp/uri/uri.cpp

#include "uri.h"
#include "parse.h"

#include <util/string/cast.h>
#include <util/string/util.h>
#include <util/system/yassert.h>

namespace NUri {
    TState::EParsed TUri::CheckHost(const TStringBuf& host) {
        if (host.empty())
            return ParsedOK;

        unsigned domainLevel = 0;
        unsigned domainLevelOfUnderscore = 0;

        bool isAlnum = false;
        bool startLabel = true;
        for (size_t i = 0; i != host.length(); ++i) {
            const char ch = host[i];

            if ('.' == ch) {                // label separator
                if (!isAlnum || startLabel) // previous label must end in alnum
                    return ParsedBadHost;
                startLabel = true;
                continue;
            }

            isAlnum = isalnum((const unsigned char)ch);

            if (startLabel) {              // label is starting
                if (!isAlnum && '_' != ch) // new label must start with alnum or '_'
                    return ParsedBadHost;
                startLabel = false;
                ++domainLevel;
                if (ch == '_')
                    domainLevelOfUnderscore = domainLevel;
                continue;
            }

            if (isAlnum || '-' == ch)
                continue;

            if (ch == '_') { // non-standard case we allow for certain hosts
                domainLevelOfUnderscore = domainLevel;
                continue;
            }

            return ParsedBadHost;
        }

        if (0 < domainLevelOfUnderscore && domainLevel < 2 + domainLevelOfUnderscore)
            return ParsedBadHost;

        return ParsedOK;
    }

    /********************************************************/
    TUri::TUri(const TStringBuf& host, ui16 port, const TStringBuf& path, const TStringBuf& query, const TStringBuf& scheme, unsigned defaultPort)
        : FieldsSet(0)
        , Port(port)
        , DefaultPort(0)
        , Scheme(SchemeEmpty)
        , FieldsDirty(0)
    {
        if (!scheme.empty()) {
            if (SetSchemeImpl(TSchemeInfo::Get(scheme)).Str.empty())
                FldSet(FieldScheme, scheme);
        }

        if (0 < defaultPort) // override the scheme's default port
            DefaultPort = static_cast<ui16>(defaultPort);

        char sport[6]; // enough for ui16
        if (0 != port) {
            const size_t len = ToString(port, sport, sizeof(sport));
            FldSet(FieldPort, TStringBuf(sport, len));
        }

        FldTrySet(FieldHost, host);
        FldTrySet(FieldPath, path);
        FldTrySet(FieldQuery, query);

        Rewrite();
    }

    /********************************************************/
    bool TUri::FldSetImpl(
        EField field, TStringBuf value, bool strconst, bool nocopy) {
        if (!FldIsValid(field))
            return false;

        switch (field) {
            case FieldScheme:
                if (!SetScheme(TSchemeInfo::Get(value)).Str.empty())
                    return false;
                break;

            case FieldPort:
                Port = value.empty() ? 0 : FromString<ui16>(value);
                break;

            default:
                break;
        }

        if (!value.IsInited()) {
            FldClr(field);
            return false;
        }

        if (strconst) { // string constants don't need to be saved in the buffer
            FldMarkClean(field);
            FldSetNoDirty(field, value);
            return false;
        }

        if (nocopy) {
            FldSet(field, value);
            return true;
        }

        return FldTryCpy(field, value);
    }

    /********************************************************/
    bool TUri::FldTryCpy(EField field, const TStringBuf& value) {
        if (!FldIsDirty(field)) {
            do {
                if (!FldIsSet(field))
                    break;

                TStringBuf& fld = Fields[field];
                if (fld.length() < value.length())
                    break;

                char* oldV = (char*)fld.data();
                if (!IsInBuffer(oldV))
                    break;

                memcpy(oldV, value.data(), value.length());
                oldV[value.length()] = 0;
                fld.Trunc(value.length());
                return false;
            } while (false);

            FldMarkDirty(field);
        }

        FldSetNoDirty(field, value);
        return true;
    }

    /********************************************************/
    void TUri::RewriteImpl() {
        size_t len = 0;
        for (int i = 0; i < FieldAllMAX; ++i) {
            const EField fld = EField(i);
            if (FldIsSet(fld))
                len += 1 + Fields[fld].length();
        }

        if (!len)
            Buffer.Clear();
        else {
            TBuffer newbuf;
            newbuf.Resize(len);
            TMemoryWriteBuffer out(newbuf.data(), newbuf.size());
            for (int i = 0; i < FieldAllMAX; ++i) {
                const EField fld = EField(i);
                if (!FldIsSet(fld))
                    continue;

                const char* beg = out.Buf();
                const TStringBuf& val = Fields[fld];
                out << val;
                FldSetNoDirty(fld, TStringBuf(beg, val.length()));
                out << '\0';
            }
            Buffer = std::move(newbuf);
        }

        CheckMissingFields();

        FieldsDirty = 0;
    }

    void TUri::CheckMissingFields() {
        // if host is set but path is not...
        if (FldSetCmp(FlagPath | FlagHost, FlagHost))
            // ... and the scheme requires a path...
            if (GetSchemeInfo().FldReq & FlagPath)
                // ... set path
                FldSetNoDirty(FieldPath, TStringBuf("/"));
    }

    /********************************************************/
    void TUri::Merge(const TUri& base, int correctAbs) {
        if (base.Scheme == SchemeUnknown)
            return;

        if (!base.IsValidGlobal())
            return;

        const TStringBuf& selfscheme = GetField(FieldScheme);
        // basescheme is present since IsValidGlobal() succeeded
        const TStringBuf& basescheme = base.GetField(FieldScheme);
        const bool noscheme = !selfscheme.IsInited();
        if (!noscheme && !EqualNoCase(selfscheme, basescheme))
            return;

        const ui32 cleanFields = ~FieldsDirty;
        do {
            static constexpr TStringBuf rootPath = "/";

            if (noscheme) {
                if (!basescheme.empty()) {
                    FldSetNoDirty(FieldScheme, basescheme);
                    // check if it is canonical
                    if (basescheme.data() != base.GetSchemeInfo().Str.data())
                        FldMarkDirty(FieldScheme);
                }
                Scheme = base.Scheme;
                DefaultPort = base.DefaultPort;
            }

            if (!IsNull(FlagHost))
                break; // no merge

            FldTrySet(FieldHost, base);
            FldChkSet(FieldPort, base);
            Port = base.Port;

            if (noscheme && IsNull(FlagQuery) && IsNull(FlagPath))
                FldTrySet(FieldQuery, base);

            if (IsNull(FlagAuth) && !base.IsNull(FlagAuth)) {
                FldChkSet(FieldUser, base);
                FldChkSet(FieldPass, base);
            }

            if (IsValidAbs())
                break;

            TStringBuf p0 = base.GetField(FieldPath);
            if (!p0.IsInited())
                p0 = rootPath;

            TStringBuf p1 = GetField(FieldPath);
            if (!p1.IsInited()) {
                if (p0.data() != rootPath.data())
                    FldSet(FieldPath, p0);
                else
                    FldSetNoDirty(FieldPath, rootPath);
                break;
            }
            if (p1 && '/' == p1[0])
                p1.Skip(1); // p0 will have one

            bool pathop = true;

            TTempBufOutput out(p0.length() + p1.length() + 4);
            out << p0;
            if ('/' != p0.back())
                out << "/../";
            else if (p1.empty() || '.' != p1[0])
                pathop = false;
            out << p1;

            char* beg = out.Data();
            char* end = beg + out.Filled();
            if (pathop && !PathOperation(beg, end, correctAbs)) {
                Clear();
                break;
            }

            // Needs immediate forced rewrite because of TTempBuf
            FldSetNoDirty(FieldPath, TStringBuf(beg, end));
            RewriteImpl();
        } while (false);

        CheckMissingFields();

        // rewrite only if borrowed fields from base
        if (cleanFields & FieldsDirty)
            RewriteImpl();
    }

    /********************************************************/
    TUri::TLinkType TUri::Normalize(const TUri& base,
                                    const TStringBuf& link, const TStringBuf& codebase, long careFlags, ECharset enc) {
        // parse URL
        if (ParsedOK != ParseImpl(link, careFlags, 0, SchemeEmpty, enc))
            return LinkIsBad;

        const TStringBuf& host = GetHost();

        // merge with base URL
        // taken either from _BASE_ property or from optional argument
        if (!codebase.empty()) {
            // if optional code base given -- parse it
            TUri codebaseUrl;
            if (codebaseUrl.ParseImpl(codebase, careFlags, 0, SchemeEmpty, enc) != ParsedOK || !codebaseUrl.IsValidAbs())
                return LinkIsBad;
            Merge(codebaseUrl);
        } else {
            // Base is already in this variable
            // see SetProperty() for details
            Merge(base);
        }

        // check result: must be correct absolute URL
        if (!IsValidAbs())
            return LinkBadAbs;

        if (!host.empty()) {
            //  - we don't care about different ports for the same server
            //  - we don't care about win|www|koi|etc. preffixes for the same server
            if (GetPort() != base.GetPort() || !EqualNoCase(host, base.GetHost()))
                return LinkIsGlobal;
        }

        // find out if it is link to itself then ignore it
        if (!Compare(base, FlagPath | FlagQuery))
            return LinkIsFragment;

        return LinkIsLocal;
    }

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

    size_t TUri::PrintSize(ui32 flags) const {
        size_t len = 10;
        flags &= FieldsSet; // can't output what we don't have
        if (flags & FlagHostAscii)
            flags &= ~FlagHost; // don't want to print both of them
        ui32 opt = 1;
        for (int fld = 0; opt <= flags && fld < FieldAllMAX; ++fld, opt <<= 1) {
            if (opt & flags) {
                const TStringBuf& v = Fields[fld];
                if (v.IsInited()) {
                    if (opt & FlagAuth)
                        len += 3 * v.length() + 1;
                    else
                        len += v.length() + 1;
                }
            }
        }

        return len;
    }

    IOutputStream& TUri::PrintImpl(IOutputStream& out, int flags) const {
        TStringBuf v;
 
        const int wantFlags = flags; // save the original
        flags &= FieldsSet;          // can't print what we don't have
        if (flags & FlagHostAscii)
            flags |= FlagHost; // to make host checks simpler below

        if (flags & FlagScheme) {
            v = Fields[FieldScheme];
            if (!v.empty())
                out << v << ':';
        }

        TStringBuf host;
        if (flags & FlagHost) {
            const EField fldhost =
                flags & FlagHostAscii ? FieldHostAscii : FieldHost;
            host = Fields[fldhost];
        }

        TStringBuf port;
        if ((flags & FlagPort) && 0 != Port && Port != DefaultPort)
            port = Fields[FieldPort];

        if (host) {
            if (wantFlags & FlagScheme)
                out << "//";

            if (flags & FlagAuth) {
                if (flags & FlagUser) {
                    v = Fields[FieldUser];
                    if (!v.empty())
                        TEncoder::EncodeNotAlnum(out, v);
                }

                if (flags & FlagPass) {
                    v = Fields[FieldPass];
                    if (v.IsInited()) {
                        out << ':';
                        TEncoder::EncodeAll(out, v);
                    }
                }

                out << '@';
            }

            out << host;

            if (port)
                out << ':';
        }
        if (port)
            out << port;

        if (flags & FlagPath) {
            v = Fields[FieldPath];
            // for relative, empty path is not the same as missing
            if (v.empty() && 0 == (flags & FlagHost))
                v = TStringBuf(".");
            out << v;
        }

        if (flags & FlagQuery) {
            v = Fields[FieldQuery];
            if (v.IsInited())
                out << '?' << v;
        }

        if (flags & FlagFrag) {
            v = Fields[FieldFrag];
            if (v.IsInited())
                out << '#' << v;
        }

        return out;
    }

    /********************************************************/
    int TUri::CompareField(EField fld, const TUri& url) const {
        const TStringBuf& v0 = GetField(fld);
        const TStringBuf& v1 = url.GetField(fld);
        switch (fld) {
            case FieldScheme:
            case FieldHost:
                return CompareNoCase(v0, v1);
            default:
                return v0.compare(v1);
        }
    }

    /********************************************************/
    int TUri::Compare(const TUri& url, int flags) const {
        // first compare fields with default values
        if (flags & FlagPort) {
            const int ret = GetPort() - url.GetPort();
            if (ret)
                return ret;
            flags &= ~FlagPort;
        }

        // compare remaining sets of available fields
        const int rtflags = flags & url.FieldsSet;
        flags &= FieldsSet;
        const int fldcmp = flags - rtflags;
        if (fldcmp)
            return fldcmp;

        // field sets are the same, compare the fields themselves
        for (int i = 0; i < FieldAllMAX; ++i) {
            const EField fld = EField(i);
            if (flags & FldFlag(fld)) {
                const int ret = CompareField(fld, url);
                if (ret)
                    return ret;
            }
        }

        return 0;
    }

    /********************************************************/
    bool TUri::PathOperation(char*& pathPtr, char*& pathEnd, int correctAbs) {
        if (!pathPtr)
            return false;
        if (pathPtr == pathEnd)
            return true;

        if ((pathEnd - pathPtr) >= 2 && *(pathEnd - 2) == '/' && *(pathEnd - 1) == '.') {
            --pathEnd;
        }

        char* p_wr = pathEnd;
        int upCount = 0;

        char* p_prev = pathEnd;
        Y_ASSERT(p_prev > pathPtr);
        while (p_prev > pathPtr && *(p_prev - 1) == '/')
            p_prev--;

        for (char* p_rd = p_prev; p_rd; p_rd = p_prev) {
            Y_ASSERT(p_rd == pathEnd || p_rd[0] == '/');
            p_prev = nullptr;

            char* p = p_rd;

            if (p > pathPtr) {
                for (p--; *p != '/'; p--) {
                    if (p == pathPtr)
                        break;
                }
                if (*p == '/') {
                    p_prev = p++;
                    if ((p_prev - pathPtr >= 6 && !strnicmp(p_prev - 6, "http://", 7)) ||
                        (p_prev - pathPtr >= 7 && !strnicmp(p_prev - 7, "https://", 8))) {
                        --p_prev;
                        --p;
                    } else {
                        //skip multiple from head '/'
                        while (p_prev > pathPtr && *(p_prev - 1) == '/')
                            p_prev--;
                    }
                }
            }

            Y_ASSERT(p_prev == nullptr || p_prev[0] == '/');
            //and the first symbol !='/' after p_prev is p

            if (p == p_rd) {
                //empty block:
                if (p_prev) { //either tail:
                    Y_ASSERT(p_rd == p_wr && *(p - 1) == '/');
                    --p_wr;
                    continue;
                } else { //or head of abs path
                    *(--p_wr) = '/';
                    break;
                }
            }

            if (p[0] == '.') {
                if (p + 1 == p_rd) {
                    if (correctAbs || p_prev > pathPtr || pathPtr[0] != '/')
                        // ignore "./"
                        continue;
                } else {
                    if ((p[1] == '.') && (p + 2 == p_rd)) {
                        // register "../" but not print
                        upCount++;
                        continue;
                    }
                }
            }

            if (upCount) {
                //unregister "../" and not print
                upCount--;
                continue;
            }

            // print
            Y_ASSERT(p < p_rd);
            Y_ASSERT(!p_prev || *(p - 1) == '/');
            if (p_wr == p_rd) { //just skip
                p_wr = p;
            } else { //copy
                int l = p_rd - p + 1;
                p_wr -= l;
                memmove(p_wr, p, l);
            }
        }

        if (upCount) {
            if (*pathPtr != '/') {
                if (pathEnd == p_wr && *(p_wr - 1) == '.') {
                    Y_ASSERT(*(p_wr - 2) == '.');
                    p_wr -= 2;
                    upCount--;
                }
                for (; upCount > 0; upCount--) {
                    *(--p_wr) = '/';
                    *(--p_wr) = '.';
                    *(--p_wr) = '.';
                }
            } else {
                if (correctAbs > 0)
                    return false;
                if (correctAbs == 0) {
                    //Bad path but present in RFC:
                    // "Similarly, parsers must avoid treating "." and ".."
                    // as special when they are not complete components of
                    // a relative path. "
                    for (; upCount > 0; upCount--) {
                        *(--p_wr) = '.';
                        *(--p_wr) = '.';
                        *(--p_wr) = '/';
                    }
                } else {
                    upCount = false;
                }
            }
        }

        Y_ASSERT(p_wr >= pathPtr);

        if (upCount)
            return false;
        pathPtr = p_wr;
        return true;
    }

    /********************************************************/
    const char* LinkTypeToString(const TUri::TLinkType& t) {
        switch (t) {
            case TUri::LinkIsBad:
                return "LinkIsBad";
            case TUri::LinkBadAbs:
                return "LinkBadAbs";
            case TUri::LinkIsFragment:
                return "LinkIsFragment";
            case TUri::LinkIsLocal:
                return "LinkIsLocal";
            case TUri::LinkIsGlobal:
                return "LinkIsGlobal";
        }
        Y_ASSERT(0);
        return "";
    }

}