Struct xpcom::interfaces::nsIHttpAuthenticableChannel

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

interface nsIHttpAuthenticableChannel : nsIProxiedChannel

Methods

impl nsIHttpAuthenticableChannel

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

Cast this nsIHttpAuthenticableChannel to one of its base interfaces.

impl nsIHttpAuthenticableChannel

pub unsafe fn GetIsSSL(&self, aIsSSL: *mut bool) -> nsresult

/**
     * If the channel being authenticated is using SSL.
     */

[must_use] readonly attribute boolean isSSL;

pub unsafe fn GetProxyMethodIsConnect(
    &self,
    aProxyMethodIsConnect: *mut bool
) -> nsresult

/**
     * Returns if the proxy HTTP method used is CONNECT. If no proxy is being
     * used it must return PR_FALSE.
     */

[must_use] readonly attribute boolean proxyMethodIsConnect;

pub unsafe fn Cancel(&self, aStatus: nsresult) -> nsresult

/**
     * Cancels the current request. See nsIRequest.
     */

[must_use] void cancel (in nsresult aStatus);

pub unsafe fn GetLoadFlags(&self, aLoadFlags: *mut nsLoadFlags) -> nsresult

/**
     * The load flags of this request. See nsIRequest.
     */

[must_use] readonly attribute nsLoadFlags loadFlags;

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

/**
     * The URI corresponding to the channel. See nsIChannel.
     */

[must_use] readonly attribute nsIURI URI;

pub unsafe fn GetLoadGroup(
    &self,
    aLoadGroup: *mut *const nsILoadGroup
) -> nsresult

/**
     * The load group of this request. It is here for querying its
     * notificationCallbacks. See nsIRequest.
     */

[must_use] readonly attribute nsILoadGroup loadGroup;

pub unsafe fn GetNotificationCallbacks(
    &self,
    aNotificationCallbacks: *mut *const nsIInterfaceRequestor
) -> nsresult

/**
     * The notification callbacks for the channel. See nsIChannel.
     */

[must_use] readonly attribute nsIInterfaceRequestor notificationCallbacks;

pub unsafe fn GetRequestMethod(
    &self,
    aRequestMethod: &mut nsACString
) -> nsresult

/**
     * The HTTP request method. See nsIHttpChannel.
     */

[must_use] readonly attribute ACString requestMethod;

pub unsafe fn GetServerResponseHeader(
    &self,
    aServerResponseHeader: &mut nsACString
) -> nsresult

/**
     * The "Server" response header.
     * Return NS_ERROR_NOT_AVAILABLE if not available.
     */

[must_use] readonly attribute ACString serverResponseHeader;

pub unsafe fn GetProxyChallenges(
    &self,
    aProxyChallenges: &mut nsACString
) -> nsresult

/**
     * The Proxy-Authenticate response header.
     */

[must_use] readonly attribute ACString proxyChallenges;

pub unsafe fn GetWWWChallenges(
    &self,
    aWWWChallenges: &mut nsACString
) -> nsresult

/**
     * The WWW-Authenticate response header.
     */

[must_use] readonly attribute ACString WWWChallenges;

pub unsafe fn SetProxyCredentials(&self, credentials: &nsACString) -> nsresult

/**
     * Sets the Proxy-Authorization request header. An empty string
     * will clear it.
     */

[must_use] void setProxyCredentials (in ACString credentials);

pub unsafe fn SetWWWCredentials(&self, credentials: &nsACString) -> nsresult

/**
     * Sets the Authorization request header. An empty string
     * will clear it.
     */

[must_use] void setWWWCredentials (in ACString credentials);

pub unsafe fn OnAuthAvailable(&self) -> nsresult

/**
     * Called when authentication information is ready and has been set on this
     * object using setWWWCredentials/setProxyCredentials. Implementations can
     * continue with the request and send the given information to the server.
     *
     * It is called asynchronously from
     * nsIHttpChannelAuthProvider::processAuthentication if that method returns
     * NS_ERROR_IN_PROGRESS.
     *
     * @note  Any exceptions thrown from this method should be ignored.
     */

[must_use] void onAuthAvailable ();

pub unsafe fn OnAuthCancelled(&self, userCancel: bool) -> nsresult

/**
     * Notifies that the prompt was cancelled. It is called asynchronously
     * from nsIHttpChannelAuthProvider::processAuthentication if that method
     * returns NS_ERROR_IN_PROGRESS.
     *
     * @param userCancel
     *        If the user was cancelled has cancelled the authentication prompt.
     */

[must_use] void onAuthCancelled (in boolean userCancel);

pub unsafe fn CloseStickyConnection(&self) -> nsresult

/**
     * Tells the channel to drop and close any sticky connection, since this
     * connection oriented schema cannot be negotiated second time on
     * the same connection.
     */

[must_use] void closeStickyConnection ();

pub unsafe fn ConnectionRestartable(&self, restartable: bool) -> nsresult

/**
     * Tells the channel to mark the connection as allowed to restart on
     * authentication retry.  This is allowed when the request is a start
     * of a new authentication round.
     */

void connectionRestartable (in boolean restartable);

Methods from Deref<Target = nsIProxiedChannel>

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

Cast this nsIProxiedChannel to one of its base interfaces.

pub unsafe fn GetProxyInfo(
    &self,
    aProxyInfo: *mut *const nsIProxyInfo
) -> nsresult

/**
   * Gets the proxy info the channel was constructed with. null or a
   * proxyInfo with type "direct" mean no proxy.
   *
   * The returned proxy info must not be modified.
   */

readonly attribute nsIProxyInfo proxyInfo;

Trait Implementations

impl XpCom for nsIHttpAuthenticableChannel

const IID: nsIID

IID: nsIID = nsID(1880134572, 23679, 17052, [153, 227, 66, 59, 4, 31, 204, 180])

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 nsIHttpAuthenticableChannel

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIHttpAuthenticableChannel

type Target = nsIProxiedChannel

The resulting type after dereferencing.

fn deref(&self) -> &nsIProxiedChannel

Dereferences the value.