Struct SctpListener

pub struct SctpListener(/* private fields */);

SCTP listener which behaves like a TcpListener. A SCTP listener is used to wait for and accept one-to-one SCTP connections. An accepted connection is represented by SctpStream.

Implementations

impl SctpListener

pub fn bind<A: ToSocketAddrs>(address: A) -> Result<SctpListener>

Create a listener bound to a single address

Examples found in repository

examples/listener.rs (line 5)

fn main() {
    match SctpListener::bind("0.0.0.0:3868") {
        //	match SctpListener::bindx(&["10.0.2.15:3868", "127.0.0.1:3868"]) {
        Ok(serv) => {
            println!("bound to {:?}", serv.local_addrs().unwrap());
            //			serv.set_timeout(5).unwrap();
            match serv.accept() {
                Err(e) => println!("{:?}", e.kind()),
                Ok((peer, _)) => {
                    println!(
                        "connection from {:?} on {:?}",
                        peer.peer_addrs().unwrap(),
                        peer.local_addrs().unwrap()
                    );
                    // Send message on stream 6
                    peer.sendmsg("foobar\n".as_bytes(), 6).unwrap();
                    let mut reply = [0u8; 1024];
                    let (len, stream) = peer.recvmsg(&mut reply).unwrap();
                    println!("Received {} bytes on stream {}", len, stream);
                }
            };
        }
        Err(e) => panic!("{:?}", e.kind()),
    }
}

pub fn bindx<A: ToSocketAddrs>(addresses: &[A]) -> Result<SctpListener>

Create a listener bound to multiple addresses. Requires at least one address

pub fn accept(&self) -> Result<(SctpStream, SocketAddr)>

Accept a new connection

Examples found in repository

examples/listener.rs (line 10)

fn main() {
    match SctpListener::bind("0.0.0.0:3868") {
        //	match SctpListener::bindx(&["10.0.2.15:3868", "127.0.0.1:3868"]) {
        Ok(serv) => {
            println!("bound to {:?}", serv.local_addrs().unwrap());
            //			serv.set_timeout(5).unwrap();
            match serv.accept() {
                Err(e) => println!("{:?}", e.kind()),
                Ok((peer, _)) => {
                    println!(
                        "connection from {:?} on {:?}",
                        peer.peer_addrs().unwrap(),
                        peer.local_addrs().unwrap()
                    );
                    // Send message on stream 6
                    peer.sendmsg("foobar\n".as_bytes(), 6).unwrap();
                    let mut reply = [0u8; 1024];
                    let (len, stream) = peer.recvmsg(&mut reply).unwrap();
                    println!("Received {} bytes on stream {}", len, stream);
                }
            };
        }
        Err(e) => panic!("{:?}", e.kind()),
    }
}

pub fn incoming(&self) -> Incoming<'_>

Iterate over new connections

pub fn local_addrs(&self) -> Result<Vec<SocketAddr>>

Get the listener local addresses

Examples found in repository

examples/listener.rs (line 8)

fn main() {
    match SctpListener::bind("0.0.0.0:3868") {
        //	match SctpListener::bindx(&["10.0.2.15:3868", "127.0.0.1:3868"]) {
        Ok(serv) => {
            println!("bound to {:?}", serv.local_addrs().unwrap());
            //			serv.set_timeout(5).unwrap();
            match serv.accept() {
                Err(e) => println!("{:?}", e.kind()),
                Ok((peer, _)) => {
                    println!(
                        "connection from {:?} on {:?}",
                        peer.peer_addrs().unwrap(),
                        peer.local_addrs().unwrap()
                    );
                    // Send message on stream 6
                    peer.sendmsg("foobar\n".as_bytes(), 6).unwrap();
                    let mut reply = [0u8; 1024];
                    let (len, stream) = peer.recvmsg(&mut reply).unwrap();
                    println!("Received {} bytes on stream {}", len, stream);
                }
            };
        }
        Err(e) => panic!("{:?}", e.kind()),
    }
}

pub fn set_timeout(&self, timeout: i32) -> Result<()>

Set timeout in seconds on accept

pub fn try_clone(&self) -> Result<SctpListener>

Try to clone this listener

Trait Implementations

impl AsRawFd for SctpListener

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl FromRawFd for SctpListener

unsafe fn from_raw_fd(fd: RawFd) -> SctpListener

Constructs a new instance of Self from the given raw file descriptor.