path: root/netwerk/dns/nsIDNSService.idl

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsISupports.idl"
#include "nsIRequest.idl"
#include "nsITRRSkipReason.idl"

%{ C++
#include "mozilla/BasePrincipal.h"
#include "mozilla/TypedEnumBits.h"
%}

interface nsICancelable;
interface nsIEventTarget;
interface nsIDNSRecord;
interface nsIDNSListener;
interface nsIDNSAdditionalInfo;

%{C++
#include "nsTArrayForwardDeclare.h"
namespace mozilla { namespace net {
    struct DNSCacheEntries;
} }
%}

[ptr] native EntriesArray(nsTArray<mozilla::net::DNSCacheEntries>);
[ref] native OriginAttributes(const mozilla::OriginAttributes);

/**
 * nsIDNSService
 */
[scriptable, builtinclass, uuid(de5642c6-61fc-4fcf-9a47-03226b0d4e21)]
interface nsIDNSService : nsISupports
{
    /**
     * These are the dns request types that are currently supported.
     * RESOLVE_TYPE_DEFAULT is standard A/AAAA lookup
     */
    cenum ResolveType : 16 {
        RESOLVE_TYPE_DEFAULT = 0,
        RESOLVE_TYPE_TXT = 16,
        RESOLVE_TYPE_HTTPSSVC = 65,
    };

    cenum ResolverMode : 32 { // 32 bits to allow this to be stored in an Atomic
        MODE_NATIVEONLY = 0,  // TRR OFF (by default)
        MODE_RESERVED1 = 1,   // Reserved value. Used to be parallel resolve.
        MODE_TRRFIRST = 2,    // fallback to native on TRR failure
        MODE_TRRONLY = 3,     // don't even fallback
        MODE_RESERVED4 = 4,   // Reserved value. Used to be race TRR with native.
        MODE_TRROFF = 5       // identical to MODE_NATIVEONLY but explicitly selected
    };

    cenum DNSFlags : 32 {
        RESOLVE_DEFAULT_FLAGS = 0,
        // if set, this flag suppresses the internal DNS lookup cache.
        RESOLVE_BYPASS_CACHE = (1 << 0),
        // if set, the canonical name of the specified host will be queried.
        RESOLVE_CANONICAL_NAME = (1 << 1),
        // If PRIORITY flags are set, the query is given lower priority.
        // Medium takes precedence if both MEDIUM and LOW are used.
        RESOLVE_PRIORITY_MEDIUM = (1 << 2),
        RESOLVE_PRIORITY_LOW    = (1 << 3),
        // if set, indicates request is speculative. Speculative requests
        // return errors if prefetching is disabled by configuration.
        RESOLVE_SPECULATE = (1 << 4),
        // If set, only IPv4 addresses will be returned from resolve/asyncResolve.
        RESOLVE_DISABLE_IPV6 = (1 << 5),
        // If set, only literals and cached entries will be returned from resolve/asyncResolve.
        RESOLVE_OFFLINE = (1 << 6),
        // If set, only IPv6 addresses will be returned from resolve/asyncResolve.
        RESOLVE_DISABLE_IPV4 = (1 << 7),
        // If set, allow name collision results (127.0.53.53) which are normally filtered.
        RESOLVE_ALLOW_NAME_COLLISION = (1 << 8),
        // If set, do not use TRR for resolving the host name.
        RESOLVE_DISABLE_TRR = (1 << 9),
        // if set (together with RESOLVE_BYPASS_CACHE), invalidate the DNS
        // existing cache entry first (if existing) then make a new resolve.
        RESOLVE_REFRESH_CACHE = (1 << 10),
        // These two bits encode the TRR mode of the request.
        // Use the static helper methods GetFlagsFromTRRMode and
        // GetTRRModeFromFlags to convert between the TRR mode and flags.
        RESOLVE_TRR_MODE_MASK = (1 << 11) | (1 << 12),
        RESOLVE_TRR_DISABLED_MODE = (1 << 11),
        // Force resolution even when SOCKS proxy with DNS forwarding is configured.
        // Only to be used for the proxy host resolution.
        RESOLVE_IGNORE_SOCKS_DNS = (1 << 13),
        // If set, only cached IP hint addresses will be returned from resolve/asyncResolve.
        RESOLVE_IP_HINT = (1 << 14),
        // If set, do not use ODoH for resolving the host name.
        RESOLVE_DISABLE_ODOH = (1 << 15),
        // If set, the DNS service will pass a DNS record to
        // OnLookupComplete even when there was a resolution error.
        RESOLVE_WANT_RECORD_ON_ERROR = (1 << 16),

        // Bitflag containing all possible flags.
        ALL_DNSFLAGS_BITS = ((1 << 17) - 1),
    };

    /**
     * kicks off an asynchronous host lookup.
     *
     * @param aHostName
     *        the hostname or IP-address-literal to resolve.
     * @param aType
     *        one of RESOLVE_TYPE_*.
     * @param aFlags
     *        a bitwise OR of the RESOLVE_ prefixed constants defined below.
     * @param aInfo
     *        a AdditionalInfo object that holds information about:
     *         - the resolver to be used such as TRR URL
     *         - the port number that could be used to construct a QNAME
     *           for HTTPS RR
     *        If null we use the default configuration.
     * @param aListener
     *        the listener to be notified when the result is available.
     * @param aListenerTarget
     *        optional parameter (may be null).  if non-null, this parameter
     *        specifies the nsIEventTarget of the thread on which the
     *        listener's onLookupComplete should be called.  however, if this
     *        parameter is null, then onLookupComplete will be called on an
     *        unspecified thread (possibly recursively).
     * @param aOriginAttributes
     *        the originAttribute for this resolving, the DNS cache will be
     *        separated according to this originAttributes. This attribute is
     *        optional to avoid breaking add-ons.
     *
     * @return An object that can be used to cancel the host lookup.
     */
    [implicit_jscontext, optional_argc]
    nsICancelable asyncResolve(in AUTF8String       aHostName,
                               in nsIDNSService_ResolveType aType,
                               in nsIDNSService_DNSFlags aFlags,
                               in nsIDNSAdditionalInfo aInfo,
                               in nsIDNSListener    aListener,
                               in nsIEventTarget    aListenerTarget,
                    [optional] in jsval aOriginAttributes);

    [notxpcom]
    nsresult asyncResolveNative(in AUTF8String       aHostName,
                                in nsIDNSService_ResolveType aType,
                                in nsIDNSService_DNSFlags aFlags,
                                in nsIDNSAdditionalInfo aInfo,
                                in nsIDNSListener    aListener,
                                in nsIEventTarget    aListenerTarget,
                                in OriginAttributes  aOriginAttributes,
                                out nsICancelable    aResult);

    /**
     * Returns a new nsIDNSAdditionalInfo object containing the URL we pass to it.
     */
    nsIDNSAdditionalInfo newAdditionalInfo(in AUTF8String aTrrURL,
                                           in int32_t aPort);

    /**
     * Attempts to cancel a previously requested async DNS lookup
     *
     * @param aHostName
     *        the hostname or IP-address-literal to resolve.
     * @param aType
     *        one of RESOLVE_TYPE_*.
     * @param aFlags
     *        a bitwise OR of the RESOLVE_ prefixed constants defined below.
     * @param aInfo
     *        a AdditionalInfo object that holds information about:
     *         - the resolver to be used such as TRR URL
     *         - the port number that could be used to construct a QNAME
     *           for HTTPS RR
     *        If null we use the default configuration.
     * @param aListener
     *        the original listener which was to be notified about the host lookup
     *        result - used to match request information to requestor.
     * @param aReason
     *        nsresult reason for the cancellation
     * @param aOriginAttributes
     *        the originAttribute for this resolving. This attribute is optional
     *        to avoid breaking add-ons.
     */
    [implicit_jscontext, optional_argc]
    void cancelAsyncResolve(in AUTF8String       aHostName,
                            in nsIDNSService_ResolveType aType,
                            in nsIDNSService_DNSFlags aFlags,
                            in nsIDNSAdditionalInfo aResolver,
                            in nsIDNSListener    aListener,
                            in nsresult          aReason,
                 [optional] in jsval             aOriginAttributes);

    [notxpcom]
    nsresult cancelAsyncResolveNative(in AUTF8String       aHostName,
                                      in nsIDNSService_ResolveType aType,
                                      in nsIDNSService_DNSFlags aFlags,
                                      in nsIDNSAdditionalInfo aResolver,
                                      in nsIDNSListener    aListener,
                                      in nsresult          aReason,
                                      in OriginAttributes  aOriginAttributes);

    /**
     * called to synchronously resolve a hostname.
     *
     * Since this method may block the calling thread for a long period of
     * time, it may not be accessed from the main thread.
     *
     * @param aHostName
     *        the hostname or IP-address-literal to resolve.
     * @param aFlags
     *        a bitwise OR of the RESOLVE_ prefixed constants defined below.
     * @param aOriginAttributes
     *        the originAttribute for this resolving, the DNS cache will be
     *        separated according to this originAttributes. This attribute is
     *        optional to avoid breaking add-ons.
     *
     * @return DNS record corresponding to the given hostname.
     * @throws NS_ERROR_UNKNOWN_HOST if host could not be resolved.
     * @throws NS_ERROR_NOT_AVAILABLE if accessed from the main thread.
     */
    [implicit_jscontext, optional_argc]
    nsIDNSRecord resolve(in AUTF8String   aHostName,
                         in nsIDNSService_DNSFlags aFlags,
              [optional] in jsval         aOriginAttributes);

    [notxpcom]
    nsresult resolveNative(in AUTF8String       aHostName,
                           in nsIDNSService_DNSFlags aFlags,
                           in OriginAttributes  aOriginAttributes,
                           out nsIDNSRecord     aResult);

    /**
     * The method takes a pointer to an nsTArray
     * and fills it with cache entry data
     * Called by the networking dashboard
     */
    [noscript] void getDNSCacheEntries(in EntriesArray args);


    /**
     * Clears the DNS cache.
     * @param aTrrToo
     *        If true we will clear TRR cached entries too. Since these
     *        are resolved remotely it's not necessary to clear them when
     *        the network status changes, but it's sometimes useful to do so
     *        for tests or other situations.
     */
    void clearCache(in boolean aTrrToo);

    /**
     * The method is used only for test purpose. We use this to recheck if
     * parental control is enabled or not.
     */
    void reloadParentalControlEnabled();

    /**
     * Notifies the TRR service of a TRR that was automatically detected based
     * on network preferences.
     */
    void setDetectedTrrURI(in AUTF8String aURI);

    ACString getTRRSkipReasonName(in nsITRRSkipReason_value value);

    /**
     * Notifies the DNS service that we failed to connect to this alternative
     * endpoint.
     * @param aOwnerName
     *        The owner name of this HTTPS RRs.
     * @param aSVCDomainName
     *        The domain name of this alternative endpoint.
     */
    [noscript] void ReportFailedSVCDomainName(in ACString aOwnerName,
                                              in ACString aSVCDomainName);

    /**
     * Check if the given domain name was failed to connect to before.
     * @param aOwnerName
     *        The owner name of this HTTPS RRs.
     * @param aSVCDomainName
     *        The domain name of this alternative endpoint.
     */
    [noscript] boolean IsSVCDomainNameFailed(in ACString aOwnerName,
                                             in ACString aSVCDomainName);

    /**
     * Reset the exclusion list.
     * @param aOwnerName
     *        The owner name of this HTTPS RRs.
     */
    [noscript] void ResetExcludedSVCDomainName(in ACString aOwnerName);

    /**
     * Returns a string containing the URI currently used by the TRR service.
     */
    readonly attribute AUTF8String currentTrrURI;

    /**
     * Returns the value of the TRR Service's current default mode.
     */
    readonly attribute nsIDNSService_ResolverMode currentTrrMode;

    /**
     * The TRRService's current confirmation state.
     * This is mostly for testing purposes.
     */
    readonly attribute unsigned long currentTrrConfirmationState;

    /**
     * @return the hostname of the operating system.
     */
    readonly attribute AUTF8String myHostName;

    /**
     * returns the current TRR domain.
     */
    readonly attribute ACString trrDomain;

    /**
     * Returns true when we have valid ODoHConfigs to encrypt/decrypt oblivious
     * DNS packets.
     */
    readonly attribute boolean ODoHActivated;

    /*************************************************************************
     * Listed below are the various flags that may be OR'd together to form
     * the aFlags parameter passed to asyncResolve() and resolve().
     */

%{C++
    static nsIDNSService::DNSFlags GetFlagsFromTRRMode(nsIRequest::TRRMode aMode) {
        return static_cast<nsIDNSService::DNSFlags>(static_cast<uint32_t>(aMode) << 11);
    }

    static nsIRequest::TRRMode GetTRRModeFromFlags(nsIDNSService::DNSFlags aFlags) {
        return static_cast<nsIRequest::TRRMode>((aFlags & RESOLVE_TRR_MODE_MASK) >> 11);
    }
%}

};

%{C++

/**
 * An observer notification for this topic is sent whenever the URI that the
 * TRR service is using has changed.
 */
#define NS_NETWORK_TRR_URI_CHANGED_TOPIC "network:trr-uri-changed"

/**
 * An observer notification for this topic is sent whenever the mode that the
 * TRR service is using has changed.
 */
#define NS_NETWORK_TRR_MODE_CHANGED_TOPIC "network:trr-mode-changed"

MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(nsIDNSService::DNSFlags)

%}