netwerk/dns/nsIEffectiveTLDService.idl

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsISupports.idl"
   7
   8 interface nsIURI;
   9
  10 [scriptable, uuid(68067eb5-ad8d-43cb-a043-1cc85ebe06e7)]
  11 interface nsIEffectiveTLDService : nsISupports
  12 {
  13     /**
  14      * Returns the public suffix of a URI. A public suffix is the highest-level domain
  15      * under which individual domains may be registered; it may therefore contain one
  16      * or more dots. For example, the public suffix for "www.bbc.co.uk" is "co.uk",
  17      * because the .uk TLD does not allow the registration of domains at the
  18      * second level ("bbc.uk" is forbidden).
  19      *
  20      * The public suffix will be returned encoded in ASCII/ACE and will be normalized
  21      * according to RFC 3454, i.e. the same encoding returned by nsIURI::GetAsciiHost().
  22      * If consumers wish to compare the result of this method against the host from
  23      * another nsIURI, the host should be obtained using nsIURI::GetAsciiHost().
  24      * In the case of nested URIs, the innermost URI will be used.
  25      *
  26      * @param   aURI   The URI to be analyzed
  27      *
  28      * @returns the public suffix
  29      *
  30      * @throws NS_ERROR_UNEXPECTED
  31      *         or other error returned by nsIIDNService::normalize when
  32      *         the hostname contains characters disallowed in URIs
  33      * @throws NS_ERROR_HOST_IS_IP_ADDRESS
  34      *         if the host is a numeric IPv4 or IPv6 address (as determined by
  35      *         the success of a call to PR_StringToNetAddr()).
  36      */
  37     ACString getPublicSuffix(in nsIURI aURI);
  38
  39     /**
  40      * Similar to getPublicSuffix, but the suffix is validated against
  41      * the Public Suffix List. If the suffix is unknown this will return
  42      * an empty string.
  43      *
  44      * If you only need to know if the host ends in a valid suffix, and not the
  45      * actual public suffix, consider the more performant hasKnownPublicSuffix()
  46      * instead.
  47      *
  48      * @param   aURI   The URI to be analyzed
  49      * @returns the public suffix if known, an empty string otherwise
  50      * @see     getPublicSuffixFromHost()
  51      */
  52     ACString getKnownPublicSuffix(in nsIURI aURI);
  53
  54     /**
  55      * Returns the base domain of a URI; that is, the public suffix with a given
  56      * number of additional domain name parts. For example, the result of this method
  57      * for "www.bbc.co.uk", depending on the value of aAdditionalParts parameter, will
  58      * be:
  59      *
  60      *    0 (default) -> bbc.co.uk
  61      *    1           -> www.bbc.co.uk
  62      *
  63      * Similarly, the public suffix for "www.developer.mozilla.org" is "org", and the base
  64      * domain will be:
  65      *
  66      *    0 (default) -> mozilla.org
  67      *    1           -> developer.mozilla.org
  68      *    2           -> www.developer.mozilla.org
  69      *
  70      * The base domain will be returned encoded in ASCII/ACE and will be normalized
  71      * according to RFC 3454, i.e. the same encoding returned by nsIURI::GetAsciiHost().
  72      * If consumers wish to compare the result of this method against the host from
  73      * another nsIURI, the host should be obtained using nsIURI::GetAsciiHost().
  74      * In the case of nested URIs, the innermost URI will be used.
  75      *
  76      * @param   aURI               The URI to be analyzed
  77      * @param   aAdditionalParts   Number of domain name parts to be
  78      *                             returned in addition to the public suffix
  79      *
  80      * @returns the base domain (public suffix plus the requested number of additional parts)
  81      *
  82      * @throws NS_ERROR_UNEXPECTED
  83      *         or other error returned by nsIIDNService::normalize when
  84      *         the hostname contains characters disallowed in URIs
  85      * @throws NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS
  86      *         when there are insufficient subdomain levels in the hostname to satisfy the
  87      *         requested aAdditionalParts value.
  88      * @throws NS_ERROR_HOST_IS_IP_ADDRESS
  89      *         if aHost is a numeric IPv4 or IPv6 address (as determined by
  90      *         the success of a call to PR_StringToNetAddr()).
  91      *
  92      * @see    getPublicSuffix()
  93      */
  94     ACString getBaseDomain(in nsIURI aURI, [optional] in uint32_t aAdditionalParts);
  95
  96     /**
  97      * Get the Site without the scheme for the origin of aURI; e.g. for
  98      * "https://www.bbc.co.uk/index.html", this would be "bbc.co.uk".
  99      * This uses getBaseDomain() internally. This is appropriately permissive,
 100      * and will return a schemeless site for aliased hostnames and IP addresses
 101      * and will therefore not throw NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS or
 102      * NS_ERROR_HOST_IS_IP_ADDRESS, e.g. "http://localhost/index.html" will
 103      * return "localhost" successfully, rather than throwing an error.
 104      *
 105      * @param aHostURI
 106      *        The URI to analyze.
 107      *
 108      * @return the Site.
 109      *
 110      * @throws NS_ERROR_UNEXPECTED
 111      *         or other error returned by nsIIDNService::normalize when
 112      *         the hostname contains characters disallowed in URIs
 113      *
 114      * @see    getBaseDomain()
 115      * @see    getSite()
 116      *
 117      * @warning This function should not be used without good reason. Please
 118      * use getSite() or the Origin if you are not absolutely certain.
 119      */
 120     ACString getSchemelessSite(in nsIURI aURI);
 121
 122     /**
 123      * Get the Site for the origin of aURI; e.g. for
 124      * "https://www.bbc.co.uk/index.html", this would be "https://bbc.co.uk".
 125      * This uses getBaseDomain() internally. This is appropriately permissive,
 126      * and will return a scheme for alaised hostnames and IP addresses and will
 127      * therefore not throw NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS or
 128      * NS_ERROR_HOST_IS_IP_ADDRESS, e.g. "http://localhost/index.html" will
 129      * return "http://localhost" successfully, rather than throwing an error.
 130      *
 131      * @param aHostURI
 132      *        The URI to analyze.
 133      *
 134      * @return the Site.
 135      *
 136      * @throws NS_ERROR_UNEXPECTED
 137      *         or other error returned by nsIIDNService::normalize when
 138      *         the hostname contains characters disallowed in URIs
 139      *
 140      * @see    getBaseDomain()
 141      */
 142     ACString getSite(in nsIURI aURI);
 143
 144     /**
 145      * NOTE: It is strongly recommended to use getPublicSuffix() above if a suitable
 146      * nsIURI is available. Only use this method if this is not the case.
 147      *
 148      * Returns the public suffix of a host string. Otherwise identical to getPublicSuffix().
 149      *
 150      * @param   aHost   The host to be analyzed. Any additional parts (e.g. scheme,
 151      *                  port, or path) will cause this method to throw. ASCII/ACE and
 152      *                  UTF8 encodings are acceptable as input; normalization will
 153      *                  be performed as specified in getBaseDomain().
 154      *
 155      * @see     getPublicSuffix()
 156      */
 157     ACString getPublicSuffixFromHost(in AUTF8String aHost);
 158
 159     /**
 160      * Similar to getPublicSuffixFromHost, but the suffix is validated against
 161      * the Public Suffix List. If the suffix is unknown this will return
 162      * an empty string.
 163      *
 164      * @param   aHost   The host to be analyzed.
 165      * @returns the public suffix if known, an empty string otherwise
 166      * @see     getPublicSuffixFromHost()
 167      */
 168     ACString getKnownPublicSuffixFromHost(in AUTF8String aHost);
 169
 170     /**
 171      * NOTE: It is strongly recommended to use getBaseDomain() above if a suitable
 172      * nsIURI is available. Only use this method if this is not the case.
 173      *
 174      * Returns the base domain of a host string. Otherwise identical to getBaseDomain().
 175      *
 176      * @param   aHost   The host to be analyzed. Any additional parts (e.g. scheme,
 177      *                  port, or path) will cause this method to throw. ASCII/ACE and
 178      *                  UTF8 encodings are acceptable as input; normalization will
 179      *                  be performed as specified in getBaseDomain().
 180      *
 181      * @see     getBaseDomain()
 182      */
 183     ACString getBaseDomainFromHost(in AUTF8String aHost, [optional] in uint32_t aAdditionalParts);
 184
 185     /**
 186      * Returns the parent sub-domain of a host string. If the host is a base
 187      * domain, it will throw NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS.
 188      *
 189      * For example: "player.bbc.co.uk" would return "bbc.co.uk" and
 190      *              "bbc.co.uk" would throw NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS.
 191      *
 192      * @param   aHost   The host to be analyzed. Any additional parts (e.g. scheme,
 193      *                  port, or path) will cause this method to throw. ASCII/ACE and
 194      *                  UTF8 encodings are acceptable as input; normalization will
 195      *                  be performed as specified in getBaseDomain().
 196      */
 197     ACString getNextSubDomain(in AUTF8String aHost);
 198
 199     /**
 200      * Returns true if the |aInput| in is part of the root domain of |aHost|.
 201      * For example, if |aInput| is "www.mozilla.org", and we pass in
 202      * "mozilla.org" as |aHost|, this will return true.  It would return false
 203      * the other way around.
 204      *
 205      * @param aInput The host to be analyzed.
 206      * @param aHost  The host to compare to.
 207      */
 208     boolean hasRootDomain(in AUTF8String aInput, in AUTF8String aHost);
 209
 210     /**
 211      * Returns true if the host of |aURI| ends with, or is, a suffix that is on
 212      * the public suffix list.
 213      *
 214      * @param aURI The URI to be checked
 215      */
 216     boolean hasKnownPublicSuffix(in nsIURI aURI);
 217
 218     /**
 219      * Returns true if |aHost| ends with, or is, a suffix that is on the public
 220      * suffix list.
 221      *
 222      * @param aHost The hostname to be checked
 223      * @see         hasKnownPublicSuffix()
 224      */
 225     boolean hasKnownPublicSuffixFromHost(in AUTF8String aHost);
 226 };