Struct xpcom::interfaces::nsITLSServerSocket
[−]
[src]
#[repr(C)]pub struct nsITLSServerSocket { /* fields omitted */ }
interface nsITLSServerSocket : nsIServerSocket
Methods
impl nsITLSServerSocket
[src]
pub fn coerce<T: nsITLSServerSocketCoerce>(&self) -> &T
[src]
Cast this nsITLSServerSocket
to one of its base interfaces.
impl nsITLSServerSocket
[src]
pub const REQUEST_NEVER: i64
REQUEST_NEVER: i64 = 0
/**
* Values for setRequestClientCertificate
*/
pub const REQUEST_FIRST_HANDSHAKE: i64
REQUEST_FIRST_HANDSHAKE: i64 = 1
pub const REQUEST_ALWAYS: i64
REQUEST_ALWAYS: i64 = 2
pub const REQUIRE_FIRST_HANDSHAKE: i64
REQUIRE_FIRST_HANDSHAKE: i64 = 3
pub const REQUIRE_ALWAYS: i64
REQUIRE_ALWAYS: i64 = 4
pub unsafe fn GetServerCert(
&self,
aServerCert: *mut *const nsIX509Cert
) -> nsresult
[src]
&self,
aServerCert: *mut *const nsIX509Cert
) -> nsresult
/**
* serverCert
*
* The server's certificate that is presented to the client during the TLS
* handshake. This is required to be set before calling |asyncListen|.
*/
attribute nsIX509Cert serverCert;
pub unsafe fn SetServerCert(&self, aServerCert: *const nsIX509Cert) -> nsresult
[src]
/**
* serverCert
*
* The server's certificate that is presented to the client during the TLS
* handshake. This is required to be set before calling |asyncListen|.
*/
attribute nsIX509Cert serverCert;
pub unsafe fn SetSessionCache(&self, aSessionCache: bool) -> nsresult
[src]
/**
* setSessionCache
*
* Whether the server should use a session cache. Defaults to true. This
* should be set before calling |asyncListen| if you wish to change the
* default.
*/
void setSessionCache (in boolean aSessionCache);
pub unsafe fn SetSessionTickets(&self, aSessionTickets: bool) -> nsresult
[src]
/**
* setSessionTickets
*
* Whether the server should support session tickets. Defaults to true. This
* should be set before calling |asyncListen| if you wish to change the
* default.
*/
void setSessionTickets (in boolean aSessionTickets);
pub unsafe fn SetRequestClientCertificate(
&self,
aRequestClientCert: uint32_t
) -> nsresult
[src]
&self,
aRequestClientCert: uint32_t
) -> nsresult
/**
* setRequestClientCertificate
*
* Whether the server should request and/or require a client auth certificate
* from the client. Defaults to REQUEST_NEVER. See the possible options
* above. This should be set before calling |asyncListen| if you wish to
* change the default.
*/
void setRequestClientCertificate (in unsigned long aRequestClientCert);
pub unsafe fn SetCipherSuites(
&self,
aCipherSuites: *mut uint16_t,
aLength: uint32_t
) -> nsresult
[src]
&self,
aCipherSuites: *mut uint16_t,
aLength: uint32_t
) -> nsresult
/**
* setCipherSuites
*
* The server's cipher suites that is used by the TLS handshake.
* This is required to be set before calling |asyncListen|.
*/
void setCipherSuites ([array, size_is (aLength)] in unsigned short aCipherSuites, in unsigned long aLength);
pub unsafe fn SetVersionRange(
&self,
aMinVersion: uint16_t,
aMaxVersion: uint16_t
) -> nsresult
[src]
&self,
aMinVersion: uint16_t,
aMaxVersion: uint16_t
) -> nsresult
/**
* setVersionRange
*
* The server's TLS versions that is used by the TLS handshake.
* This is required to be set before calling |asyncListen|.
*
* aMinVersion and aMaxVersion is a TLS version value from
* |nsITLSClientStatus| constants.
*/
void setVersionRange (in unsigned short aMinVersion, in unsigned short aMaxVersion);
Methods from Deref<Target = nsIServerSocket>
pub fn coerce<T: nsIServerSocketCoerce>(&self) -> &T
[src]
Cast this nsIServerSocket
to one of its base interfaces.
pub const LoopbackOnly: i64
pub const KeepWhenOffline: i64
pub unsafe fn Init(
&self,
aPort: int32_t,
aLoopbackOnly: bool,
aBackLog: int32_t
) -> nsresult
[src]
&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
[src]
&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
[src]
&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
[src]
/**
* 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
[src]
&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
[src]
/**
* Returns the port of this server socket.
*/
readonly attribute long port;
Trait Implementations
impl XpCom for nsITLSServerSocket
[src]
const IID: nsIID
IID: nsIID = nsID(3425448185, 53162, 19338, [189, 68, 194, 72, 129, 152, 27, 116])
fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>
[src]
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. Read more
impl RefCounted for nsITLSServerSocket
[src]
unsafe fn addref(&self)
[src]
Increment the reference count.
unsafe fn release(&self)
[src]
Decrement the reference count, potentially freeing backing memory.
impl Deref for nsITLSServerSocket
[src]
type Target = nsIServerSocket
The resulting type after dereferencing.
fn deref(&self) -> &nsIServerSocket
[src]
Dereferences the value.