Uri.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_SRC_ANYP_URI_H
#define SQUID_SRC_ANYP_URI_H
 
#include "anyp/UriScheme.h"
#include "ip/Address.h"
#include "rfc2181.h"
#include "sbuf/SBuf.h"
 
#include <iosfwd>
 
class HttpRequestMethod;
 
namespace AnyP
{
 
class Uri
{
    MEMPROXY_CLASS(Uri);
 
public:
    Uri(): hostIsNumeric_(false) { *host_ = 0; }
    Uri(AnyP::UriScheme const &aScheme);
    Uri(const Uri &other) {
        this->operator =(other);
    }
    Uri &operator =(const Uri &o) {
        scheme_ = o.scheme_;
        userInfo_ = o.userInfo_;
        memcpy(host_, o.host_, sizeof(host_));
        hostIsNumeric_ = o.hostIsNumeric_;
        hostAddr_ = o.hostAddr_;
        port_ = o.port_;
        path_ = o.path_;
        touch();
        return *this;
    }
 
    void clear() {
        scheme_=AnyP::PROTO_NONE;
        hostIsNumeric_ = false;
        *host_ = 0;
        hostAddr_.setEmpty();
        port_ = std::nullopt;
        touch();
    }
    void touch(); 
 
    bool parse(const HttpRequestMethod &, const SBuf &url);
 
    static char *cleanup(const char *uri);
 
    AnyP::UriScheme const & getScheme() const {return scheme_;}
 
    void setScheme(const AnyP::ProtocolType &p, const char *str) {
        scheme_ = AnyP::UriScheme(p, str);
        touch();
    }
    void setScheme(const AnyP::UriScheme &s) {
        scheme_ = s;
        touch();
    }
 
    void userInfo(const SBuf &s) {userInfo_=s; touch();}
    const SBuf &userInfo() const {return userInfo_;}
 
    void host(const char *src);
    const char *host(void) const {return host_;}
    int hostIsNumeric(void) const {return hostIsNumeric_;}
    Ip::Address const & hostIP(void) const {return hostAddr_;}
 
    SBuf hostOrIp() const;
 
    void port(const Port p) { port_ = p; touch(); }
    Port port() const { return port_; }
    void defaultPort() { port(getScheme().defaultPort()); }
 
    void path(const char *p) {path_=p; touch();}
    void path(const SBuf &p) {path_=p; touch();}
    const SBuf &path() const;
 
    void addRelativePath(const char *relUrl);
 
    static const SBuf &SlashPath();
 
    static const SBuf &Asterisk();
 
    static SBuf Encode(const SBuf &, const CharacterSet &expected);
 
    SBuf &authority(bool requirePort = false) const;
 
    SBuf &absolute() const;
 
private:
    void parseUrn(Parser::Tokenizer&);
 
    AnyP::UriScheme scheme_;
 
    SBuf userInfo_; // aka 'URL-login'
 
    // XXX: uses char[] instead of SBUf to reduce performance regressions
    //      from c_str() since most code using this is not yet using SBuf
    char host_[SQUIDHOSTNAMELEN];   
    bool hostIsNumeric_;            
    Ip::Address hostAddr_;          
 
    Port port_; 
 
    // XXX: for now includes query-string.
    SBuf path_;     
 
    // pre-assembled URI forms
    mutable SBuf authorityHttp_;     
    mutable SBuf authorityWithPort_; 
    mutable SBuf absolute_;          
};
 
inline std::ostream &
operator <<(std::ostream &os, const Uri &url)
{
    // none means explicit empty string for scheme.
    if (url.getScheme() != PROTO_NONE)
        os << url.getScheme().image();
    os << ":";
 
    // no authority section on URN
    if (url.getScheme() != PROTO_URN)
        os << "//" << url.authority();
 
    // path is what it is - including absent
    os << url.path();
    return os;
}
 
} // namespace AnyP
 
/* Deprecated functions for Legacy code handling URLs */
 
class HttpRequest;
 
void urlInitialize(void);
char *urlCanonicalCleanWithoutRequest(const SBuf &url, const HttpRequestMethod &, const AnyP::UriScheme &);
const char *urlCanonicalFakeHttps(const HttpRequest * request);
bool urlIsRelative(const char *);
char *urlRInternal(const char *host, unsigned short port, const char *dir, const char *name);
char *urlInternal(const char *dir, const char *name);
bool urlAppendDomain(char *host); 
 
enum MatchDomainNameFlags {
    mdnNone = 0,
    mdnHonorWildcards = 1 << 0,
    mdnRejectSubsubDomains = 1 << 1
};
 
int matchDomainName(const char *host, const char *domain, MatchDomainNameFlags flags = mdnNone);
bool urlCheckRequest(const HttpRequest *);
void urlExtMethodConfigure(void);
 
#endif /* SQUID_SRC_ANYP_URI_H */