Struct xpcom::interfaces::nsISocketTransportService

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

interface nsISocketTransportService : nsISupports

Methods

impl nsISocketTransportService

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

Cast this nsISocketTransportService to one of its base interfaces.

impl nsISocketTransportService

pub unsafe fn CreateTransport(
    &self,
    aSocketTypes: *mut *const c_char,
    aTypeCount: uint32_t,
    aHost: &nsACString,
    aPort: int32_t,
    aProxyInfo: *const nsIProxyInfo,
    _retval: *mut *const nsISocketTransport
) -> nsresult

/**
     * Creates a transport for a specified host and port.
     *
     * @param aSocketTypes
     *        array of socket type strings.  null if using default socket type.
     * @param aTypeCount
     *        specifies length of aSocketTypes.
     * @param aHost
     *        specifies the target hostname or IP address literal of the peer
     *        for this socket.
     * @param aPort
     *        specifies the target port of the peer for this socket.
     * @param aProxyInfo
     *        specifies the transport-layer proxy type to use.  null if no
     *        proxy.  used for communicating information about proxies like
     *        SOCKS (which are transparent to upper protocols).
     *
     * @see nsIProxiedProtocolHandler
     * @see nsIProtocolProxyService::GetProxyInfo
     *
     * NOTE: this function can be called from any thread
     */

nsISocketTransport createTransport ([array, size_is (aTypeCount)] in string aSocketTypes, in unsigned long aTypeCount, in AUTF8String aHost, in long aPort, in nsIProxyInfo aProxyInfo);

pub unsafe fn CreateUnixDomainTransport(
    &self,
    aPath: *const nsIFile,
    _retval: *mut *const nsISocketTransport
) -> nsresult

/**
     * Create a transport built on a Unix domain socket, connecting to the
     * given filename.
     *
     * Since Unix domain sockets are always local to the machine, they are
     * not affected by the nsIIOService's 'offline' flag.
     *
     * On systems that don't support Unix domain sockets at all, this
     * returns NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED.
     *
     * The system-level socket API may impose restrictions on the length of
     * the filename that are stricter than those of the underlying
     * filesystem. If the file name is too long, this returns
     * NS_ERROR_FILE_NAME_TOO_LONG.
     *
     * The |aPath| parameter must specify an existing directory entry.
     * Otherwise, this returns NS_ERROR_FILE_NOT_FOUND.
     *
     * The program must have search permission on all components of the
     * path prefix of |aPath|, and read and write permission on |aPath|
     * itself. Without such permission, this returns
     * NS_ERROR_CONNECTION_REFUSED.
     *
     * The |aPath| parameter must refer to a unix-domain socket. Otherwise,
     * this returns NS_ERROR_CONNECTION_REFUSED. (POSIX specifies
     * ECONNREFUSED when "the target address was not listening for
     * connections", and this is what Linux returns.)
     *
     * @param aPath
     *        The file name of the Unix domain socket to which we should
     *        connect.
     */

nsISocketTransport createUnixDomainTransport (in nsIFile aPath);

pub unsafe fn NotifyWhenCanAttachSocket(
    &self,
    aEvent: *const nsIRunnable
) -> nsresult

/**
     * if the number of sockets reaches the limit, then consumers can be
     * notified when the number of sockets becomes less than the limit.  the
     * notification is asynchronous, delivered via the given nsIRunnable
     * instance on the socket transport thread.
     *
     * @param aEvent
     *        Event that will receive the notification when a new socket can
     *        be attached
     *
     * NOTE: this function may only be called from an event dispatch on the
     *       socket thread.
     */

[noscript] void notifyWhenCanAttachSocket (in nsIRunnable aEvent);

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 nsISocketTransportService

const IID: nsIID

IID: nsIID = nsID(2908140127, 59067, 19891, [159, 123, 91, 125, 179, 63, 210, 177])

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 nsISocketTransportService

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsISocketTransportService

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.