Struct xpcom::interfaces::nsIServerSocket

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

interface nsIServerSocket : nsISupports

/**
 * nsIServerSocket
 *
 * An interface to a server socket that can accept incoming connections.
 */

Methods

impl nsIServerSocket

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

Cast this nsIServerSocket to one of its base interfaces.

impl nsIServerSocket

pub const LoopbackOnly: i64

LoopbackOnly: i64 = 1

/**
     * @name Server Socket Flags
     * These flags define various socket options.
     * @{
     */

pub const KeepWhenOffline: i64

KeepWhenOffline: i64 = 2

pub unsafe fn Init(
    &self,
    aPort: int32_t,
    aLoopbackOnly: bool,
    aBackLog: int32_t
) -> nsresult

/** @} */
/**
     * init
     *
     * This method initializes a server socket.
     *
     * @param aPort
     *        The port of the server socket.  Pass -1 to indicate no preference,
     *        and a port will be selected automatically.
     * @param aLoopbackOnly
     *        If true, the server socket will only respond to connections on the
     *        local loopback interface.  Otherwise, it will accept connections
     *        from any interface.  To specify a particular network interface,
     *        use initWithAddress.
     * @param aBackLog
     *        The maximum length the queue of pending connections may grow to.
     *        This parameter may be silently limited by the operating system.
     *        Pass -1 to use the default value.
     */

void init (in long aPort, in boolean aLoopbackOnly, in long aBackLog);

pub unsafe fn InitSpecialConnection(
    &self,
    aPort: int32_t,
    aFlags: nsServerSocketFlag,
    aBackLog: int32_t
) -> nsresult

/**
     * initSpecialConnection
     *
     * This method initializes a server socket and offers the ability to have
     * that socket not get terminated if Gecko is set offline.
     *
     * @param aPort
     *        The port of the server socket.  Pass -1 to indicate no preference,
     *        and a port will be selected automatically.
     * @param aFlags
     *        Flags for the socket.
     * @param aBackLog
     *        The maximum length the queue of pending connections may grow to.
     *        This parameter may be silently limited by the operating system.
     *        Pass -1 to use the default value.
     */

void initSpecialConnection (in long aPort, in nsServerSocketFlag aFlags, in long aBackLog);

pub unsafe fn InitWithFilename(
    &self,
    aPath: *const nsIFile,
    aPermissions: uint32_t,
    aBacklog: int32_t
) -> nsresult

/**
     * initWithFilename
     *
     * This method initializes a Unix domain or "local" server socket. Such
     * a socket has a name in the filesystem, like an ordinary file. To
     * connect, a client supplies the socket's filename, and the usual
     * permission checks on socket apply.
     *
     * This makes Unix domain sockets useful for communication between the
     * programs being run by a specific user on a single machine: the
     * operating system takes care of authentication, and the user's home
     * directory or profile directory provide natural per-user rendezvous
     * points.
     *
     * Since Unix domain sockets are always local to the machine, they are
     * not affected by the nsIIOService's 'offline' flag.
     *
     * 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.
     *
     * All components of the path prefix of |aPath| must name directories;
     * otherwise, this returns NS_ERROR_FILE_NOT_DIRECTORY.
     *
     * This call requires execute permission on all directories containing
     * the one in which the socket is to be created, and write and execute
     * permission on the directory itself. Otherwise, this returns
     * NS_ERROR_CONNECTION_REFUSED.
     *
     * This call creates the socket's directory entry. There must not be
     * any existing entry with the given name. If there is, this returns
     * NS_ERROR_SOCKET_ADDRESS_IN_USE.
     *
     * On systems that don't support Unix domain sockets at all, this
     * returns NS_ERROR_SOCKET_ADDRESS_NOT_SUPPORTED.
     *
     * @param aPath nsIFile
     *        The file name at which the socket should be created.
     *
     * @param aPermissions unsigned long
     *        Unix-style permission bits to be applied to the new socket.
     *
     * Note about permissions: Linux's unix(7) man page claims that some
     * BSD-derived systems ignore permissions on UNIX-domain sockets;
     * NetBSD's bind(2) man page agrees, but says it does check now (dated
     * 2005). POSIX has required 'connect' to fail if write permission on
     * the socket itself is not granted since 2003 (Issue 6). NetBSD says
     * that the permissions on the containing directory (execute) have
     * always applied, so creating sockets in appropriately protected
     * directories should be secure on both old and new systems.
     */

void initWithFilename (in nsIFile aPath, in unsigned long aPermissions, in long aBacklog);

pub unsafe fn Close(&self) -> nsresult

/**
     * close
     *
     * This method closes a server socket.  This does not affect already
     * connected client sockets (i.e., the nsISocketTransport instances
     * created from this server socket).  This will cause the onStopListening
     * event to asynchronously fire with a status of NS_BINDING_ABORTED.
     */

void close ();

pub unsafe fn AsyncListen(
    &self,
    aListener: *const nsIServerSocketListener
) -> nsresult

/**
     * asyncListen
     *
     * This method puts the server socket in the listening state.  It will
     * asynchronously listen for and accept client connections.  The listener
     * will be notified once for each client connection that is accepted.  The
     * listener's onSocketAccepted method will be called on the same thread
     * that called asyncListen (the calling thread must have a nsIEventTarget).
     *
     * The listener will be passed a reference to an already connected socket
     * transport (nsISocketTransport).  See below for more details.
     *
     * @param aListener
     *        The listener to be notified when client connections are accepted.
     */

void asyncListen (in nsIServerSocketListener aListener);

pub unsafe fn GetPort(&self, aPort: *mut int32_t) -> nsresult

/**
     * Returns the port of this server socket.
     */

readonly attribute long port;

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 nsIServerSocket

const IID: nsIID

IID: nsIID = nsID(2057058763, 41279, 20207, [155, 223, 167, 67, 1, 98, 135, 66])

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 nsIServerSocket

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIServerSocket

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.