Struct xpcom::interfaces::nsIAuthPrompt2

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

interface nsIAuthPrompt2 : nsISupports

/**
 * An interface allowing to prompt for a username and password. This interface
 * is usually acquired using getInterface on notification callbacks or similar.
 * It can be used to prompt users for authentication information, either
 * synchronously or asynchronously.
 */

Methods

impl nsIAuthPrompt2

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

Cast this nsIAuthPrompt2 to one of its base interfaces.

impl nsIAuthPrompt2

pub const LEVEL_NONE: i64

LEVEL_NONE: i64 = 0

/** @name Security Levels */
/**
   * The password will be sent unencrypted. No security provided.
   */

pub const LEVEL_PW_ENCRYPTED: i64

LEVEL_PW_ENCRYPTED: i64 = 1

/**
   * Password will be sent encrypted, but the connection is otherwise
   * insecure.
   */

pub const LEVEL_SECURE: i64

LEVEL_SECURE: i64 = 2

/**
   * The connection, both for password and data, is secure.
   */

pub unsafe fn PromptAuth(
    &self,
    aChannel: *const nsIChannel,
    level: uint32_t,
    authInfo: *const nsIAuthInformation,
    _retval: *mut bool
) -> nsresult

/**
   * Requests a username and a password. Implementations will commonly show a
   * dialog with a username and password field, depending on flags also a
   * domain field.
   *
   * @param aChannel
   *        The channel that requires authentication.
   * @param level
   *        One of the level constants from above. See there for descriptions
   *        of the levels.
   * @param authInfo
   *        Authentication information object. The implementation should fill in
   *        this object with the information entered by the user before
   *        returning.
   *
   * @retval true
   *         Authentication can proceed using the values in the authInfo
   *         object.
   * @retval false
   *         Authentication should be cancelled, usually because the user did
   *         not provide username/password.
   *
   * @note   Exceptions thrown from this function will be treated like a
   *         return value of false.
   */

boolean promptAuth (in nsIChannel aChannel, in uint32_t level, in nsIAuthInformation authInfo);

pub unsafe fn AsyncPromptAuth(
    &self,
    aChannel: *const nsIChannel,
    aCallback: *const nsIAuthPromptCallback,
    aContext: *const nsISupports,
    level: uint32_t,
    authInfo: *const nsIAuthInformation,
    _retval: *mut *const nsICancelable
) -> nsresult

/**
   * Asynchronously prompt the user for a username and password.
   * This has largely the same semantics as promptUsernameAndPassword(),
   * but must return immediately after calling and return the entered
   * data in a callback.
   *
   * If the user closes the dialog using a cancel button or similar,
   * the callback's nsIAuthPromptCallback::onAuthCancelled method must be
   * called.
   * Calling nsICancelable::cancel on the returned object SHOULD close the
   * dialog and MUST call nsIAuthPromptCallback::onAuthCancelled on the provided
   * callback.
   *
   * This implementation may:
   *
   *  1) Coalesce identical prompts.  This means prompts that are guaranteed to
   *     want the same auth information from the user.  A single prompt will be
   *     shown; then the callbacks for all the coalesced prompts will be notified
   *     with the resulting auth information.
   *  2) Serialize prompts that are all in the same "context" (this might mean
   *     application-wide, for a given window, or something else depending on
   *     the user interface) so that the user is not deluged with prompts.
   *
   * @throw
   *     This method may throw any exception when the prompt fails to queue e.g
   *     because of out-of-memory error. It must not throw when the prompt
   *     could already be potentially shown to the user. In that case information
   *     about the failure has to come through the callback. This way we
   *     prevent multiple dialogs shown to the user because consumer may fall
   *     back to synchronous prompt on synchronous failure of this method.
   */

nsICancelable asyncPromptAuth (in nsIChannel aChannel, in nsIAuthPromptCallback aCallback, in nsISupports aContext, in uint32_t level, in nsIAuthInformation authInfo);

Methods from Deref<Target = nsISupports>

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

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIAuthPrompt2

const IID: nsIID

IID: nsIID = nsID(1695782379, 34322, 18550, [138, 192, 168, 141, 77, 206, 158, 30])

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 nsIAuthPrompt2

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIAuthPrompt2

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.