Struct xpcom::interfaces::nsIPrincipal

#[repr(C)]
pub struct nsIPrincipal { /* fields omitted */ }

interface nsIPrincipal : nsISerializable

Methods

impl nsIPrincipal

pub fn coerce<T: nsIPrincipalCoerce>(&self) -> &T

Cast this nsIPrincipal to one of its base interfaces.

impl nsIPrincipal

pub unsafe fn Equals(
    &self,
    other: *const nsIPrincipal,
    _retval: *mut bool
) -> nsresult

/**
     * Returns whether the other principal is equivalent to this principal.
     * Principals are considered equal if they are the same principal, or
     * they have the same origin.
     */

boolean equals (in nsIPrincipal other);

pub unsafe fn EqualsConsideringDomain(
    &self,
    other: *const nsIPrincipal,
    _retval: *mut bool
) -> nsresult

/**
     * Like equals, but takes document.domain changes into account.
     */

boolean equalsConsideringDomain (in nsIPrincipal other);

pub unsafe fn GetHashValue(&self, aHashValue: *mut uint32_t) -> nsresult

/**
     * Returns a hash value for the principal.
     */

[noscript] readonly attribute unsigned long hashValue;

pub unsafe fn GetURI(&self, aURI: *mut *const nsIURI) -> nsresult

/**
     * The codebase URI to which this principal pertains.  This is
     * generally the document URI.
     */

readonly attribute nsIURI URI;

pub unsafe fn GetDomain(&self, aDomain: *mut *const nsIURI) -> nsresult

/**
     * The domain URI to which this principal pertains.
     * This is null unless script successfully sets document.domain to our URI
     * or a superdomain of our URI.
     * Setting this has no effect on the URI.
     * See https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy#Changing_origin
     */

[noscript] attribute nsIURI domain;

pub unsafe fn SetDomain(&self, aDomain: *const nsIURI) -> nsresult

/**
     * The domain URI to which this principal pertains.
     * This is null unless script successfully sets document.domain to our URI
     * or a superdomain of our URI.
     * Setting this has no effect on the URI.
     * See https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy#Changing_origin
     */

[noscript] attribute nsIURI domain;

pub unsafe fn Subsumes(
    &self,
    other: *const nsIPrincipal,
    _retval: *mut bool
) -> nsresult

/**
     * Returns whether the other principal is equal to or weaker than this
     * principal. Principals are equal if they are the same object or they
     * have the same origin.
     *
     * Thus a principal always subsumes itself.
     *
     * The system principal subsumes itself and all other principals.
     *
     * A null principal (corresponding to an unknown, hence assumed minimally
     * privileged, security context) is not equal to any other principal
     * (including other null principals), and therefore does not subsume
     * anything but itself.
     */

boolean subsumes (in nsIPrincipal other);

pub unsafe fn SubsumesConsideringDomain(
    &self,
    other: *const nsIPrincipal,
    _retval: *mut bool
) -> nsresult

/**
     * Same as the previous method, subsumes(), but takes document.domain into
     * account.
     */

boolean subsumesConsideringDomain (in nsIPrincipal other);

pub unsafe fn SubsumesConsideringDomainIgnoringFPD(
    &self,
    other: *const nsIPrincipal,
    _retval: *mut bool
) -> nsresult

/**
     * Same as the subsumesConsideringDomain(), but ignores the first party
     * domain in its originAttributes.
     */

boolean subsumesConsideringDomainIgnoringFPD (in nsIPrincipal other);

pub unsafe fn CheckMayLoad(
    &self,
    uri: *const nsIURI,
    report: bool,
    allowIfInheritsPrincipal: bool
) -> nsresult

/**
     * Checks whether this principal is allowed to load the network resource
     * located at the given URI under the same-origin policy. This means that
     * codebase principals are only allowed to load resources from the same
     * domain, the system principal is allowed to load anything, and null
     * principals can only load URIs where they are the principal. This is
     * changed by the optional flag allowIfInheritsPrincipal (which defaults to
     * false) which allows URIs that inherit their loader's principal.
     *
     * If the load is allowed this function does nothing. If the load is not
     * allowed the function throws NS_ERROR_DOM_BAD_URI.
     *
     * NOTE: Other policies might override this, such as the Access-Control
     *       specification.
     * NOTE: The 'domain' attribute has no effect on the behaviour of this
     *       function.
     *
     *
     * @param uri    The URI about to be loaded.
     * @param report If true, will report a warning to the console service
     *               if the load is not allowed.
     * @param allowIfInheritsPrincipal   If true, the load is allowed if the
     *                                   loadee inherits the principal of the
     *                                   loader.
     * @throws NS_ERROR_DOM_BAD_URI if the load is not allowed.
     */

void checkMayLoad (in nsIURI uri, in boolean report, in boolean allowIfInheritsPrincipal);

pub unsafe fn GetCsp(
    &self,
    aCsp: *mut *const nsIContentSecurityPolicy
) -> nsresult

/**
     * A Content Security Policy associated with this principal.
     * Use this function to query the associated CSP with this principal.
     * Please *only* use this function to *set* a CSP when you know exactly what you are doing.
     * Most likely you want to call ensureCSP instead of setCSP.
     */

[noscript] attribute nsIContentSecurityPolicy csp;

pub unsafe fn SetCsp(&self, aCsp: *const nsIContentSecurityPolicy) -> nsresult

/**
     * A Content Security Policy associated with this principal.
     * Use this function to query the associated CSP with this principal.
     * Please *only* use this function to *set* a CSP when you know exactly what you are doing.
     * Most likely you want to call ensureCSP instead of setCSP.
     */

[noscript] attribute nsIContentSecurityPolicy csp;

pub unsafe fn EnsureCSP(
    &self,
    aDocument: *const nsIDOMDocument,
    _retval: *mut *const nsIContentSecurityPolicy
) -> nsresult

[noscript] nsIContentSecurityPolicy ensureCSP (in nsIDOMDocument aDocument);

pub unsafe fn GetPreloadCsp(
    &self,
    aPreloadCsp: *mut *const nsIContentSecurityPolicy
) -> nsresult

/**
     * A speculative Content Security Policy associated with this
     * principal. Set during speculative loading (preloading) and
     * used *only* for preloads.
     *
     * If you want to query the CSP associated with that principal,
     * then this is *not* what you want. Instead query 'csp'.
     */

[noscript] readonly attribute nsIContentSecurityPolicy preloadCsp;

pub unsafe fn EnsurePreloadCSP(
    &self,
    aDocument: *const nsIDOMDocument,
    _retval: *mut *const nsIContentSecurityPolicy
) -> nsresult

[noscript] nsIContentSecurityPolicy ensurePreloadCSP (in nsIDOMDocument aDocument);

pub unsafe fn GetCspJSON(&self, aCspJSON: &mut nsAString) -> nsresult

/**
     * The CSP of the principal in JSON notation.
     * Note, that the CSP itself is not exposed to JS, but script
     * should be able to obtain a JSON representation of the CSP.
     */

readonly attribute AString cspJSON;

pub unsafe fn GetOrigin(&self, aOrigin: &mut nsACString) -> nsresult

/**
     * A canonical representation of the origin for this principal. This
     * consists of a base string (which, for codebase principals, is of the
     * format scheme://host:port), concatenated with |originAttributes| (see
     * below).
     *
     * We maintain the invariant that principalA.equals(principalB) if and only
     * if principalA.origin == principalB.origin.
     */

readonly attribute ACString origin;

pub unsafe fn GetOriginNoSuffix(
    &self,
    aOriginNoSuffix: &mut nsACString
) -> nsresult

/**
     * The base part of |origin| without the concatenation with |originSuffix|.
     * This doesn't have the important invariants described above with |origin|,
     * and as such should only be used for legacy situations.
     */

readonly attribute ACString originNoSuffix;

pub unsafe fn GetOriginSuffix(&self, aOriginSuffix: &mut nsACString) -> nsresult

/**
     * A string of the form !key1=value1&key2=value2, where each pair represents
     * an attribute with a non-default value. If all attributes have default
     * values, this is the empty string.
     *
     * The value of .originSuffix is automatically serialized into .origin, so any
     * consumers using that are automatically origin-attribute-aware. Consumers with
     * special requirements must inspect and compare .originSuffix manually.
     */

readonly attribute AUTF8String originSuffix;

pub unsafe fn GetBaseDomain(&self, aBaseDomain: &mut nsACString) -> nsresult

/**
     * The base domain of the codebase URI to which this principal pertains
     * (generally the document URI), handling null principals and
     * non-hierarchical schemes correctly.
     */

readonly attribute ACString baseDomain;

pub unsafe fn GetAppId(&self) -> uint32_t

/**
     * Gets the id of the app this principal is inside.  If this principal is
     * not inside an app, returns nsIScriptSecurityManager::NO_APP_ID.
     *
     * Note that this principal does not necessarily have the permissions of
     * the app identified by appId.  For example, this principal might
     * correspond to an iframe whose origin differs from that of the app frame
     * containing it.  In this case, the iframe will have the appId of its
     * containing app frame, but the iframe must not run with the app's
     * permissions.
     *
     * Similarly, this principal might correspond to an <iframe mozbrowser>
     * inside an app frame; in this case, the content inside the iframe should
     * not have any of the app's permissions, even if the iframe is at the same
     * origin as the app.
     */

[infallible] readonly attribute unsigned long appId;

pub unsafe fn GetAddonId(&self, aAddonId: &mut nsAString) -> nsresult

/**
     * Gets the ID of the add-on this principal belongs to.
     */

readonly attribute AString addonId;

pub unsafe fn GetAddonPolicy(
    &self,
    aAddonPolicy: *mut *const nsISupports
) -> nsresult

readonly attribute nsISupports addonPolicy;

pub unsafe fn GetUserContextId(&self) -> uint32_t

/**
     * Gets the id of the user context this principal is inside.  If this
     * principal is inside the default userContext, this returns
     * nsIScriptSecurityManager::DEFAULT_USER_CONTEXT_ID.
     */

[infallible] readonly attribute unsigned long userContextId;

pub unsafe fn GetPrivateBrowsingId(&self) -> uint32_t

/**
     * Gets the id of the private browsing state of the context containing
     * this principal. If the principal has a private browsing value of 0, it
     * is not in private browsing.
     */

[infallible] readonly attribute unsigned long privateBrowsingId;

pub unsafe fn GetIsInIsolatedMozBrowserElement(&self) -> bool

/**
     * Returns true iff the principal is inside an isolated mozbrowser element.
     * <xul:browser> is not considered to be a mozbrowser element.
     * <iframe mozbrowser noisolation> does not count as isolated since
     * isolation is disabled.  Isolation can only be disabled if the
     * containing document is chrome.
     */

[infallible] readonly attribute boolean isInIsolatedMozBrowserElement;

pub unsafe fn GetIsNullPrincipal(&self) -> bool

/**
     * Returns true iff this is a null principal (corresponding to an
     * unknown, hence assumed minimally privileged, security context).
     */

[infallible] readonly attribute boolean isNullPrincipal;

pub unsafe fn GetIsCodebasePrincipal(&self) -> bool

/**
     * Returns true iff this principal corresponds to a codebase origin.
     */

[infallible] readonly attribute boolean isCodebasePrincipal;

pub unsafe fn GetIsExpandedPrincipal(&self) -> bool

/**
     * Returns true iff this is an expanded principal.
     */

[infallible] readonly attribute boolean isExpandedPrincipal;

pub unsafe fn GetIsSystemPrincipal(&self) -> bool

/**
     * Returns true iff this is the system principal.
     */

[infallible] readonly attribute boolean isSystemPrincipal;

Methods from Deref<Target = nsISerializable>

pub fn coerce<T: nsISerializableCoerce>(&self) -> &T

Cast this nsISerializable to one of its base interfaces.

pub unsafe fn Read(&self, aInputStream: *const nsIObjectInputStream) -> nsresult

/**
     * Initialize the object implementing nsISerializable, which must have
     * been freshly constructed via CreateInstance.  All data members that
     * can't be set to default values must have been serialized by write,
     * and should be read from aInputStream in the same order by this method.
     */

void read (in nsIObjectInputStream aInputStream);

pub unsafe fn Write(
    &self,
    aOutputStream: *const nsIObjectOutputStream
) -> nsresult

/**
     * Serialize the object implementing nsISerializable to aOutputStream, by
     * writing each data member that must be recovered later to reconstitute
     * a working replica of this object, in a canonical member and byte order,
     * to aOutputStream.
     *
     * NB: a class that implements nsISerializable *must* also implement
     * nsIClassInfo, in particular nsIClassInfo::GetClassID.
     */

void write (in nsIObjectOutputStream aOutputStream);

Trait Implementations

impl XpCom for nsIPrincipal

const IID: nsIID

IID: nsIID = nsID(4150218797, 31229, 18622, [160, 121, 229, 167, 184, 248, 12, 139])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIPrincipal

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIPrincipal

type Target = nsISerializable

The resulting type after dereferencing.

fn deref(&self) -> &nsISerializable

Dereferences the value.