rustun 0.1.4

A library for implementing STUN server and client asynchronously
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

use std::ops::{Deref, DerefMut};
use std::net::SocketAddr;
use fibers::Spawn;
use fibers::net::UdpSocket;

use HandleMessage;
use transport::{UdpTransport, UdpTransportBuilder};
use server::BaseServer;
use server::futures::BaseServerLoop;

/// UDP STUN server.
#[derive(Debug)]
pub struct UdpServer {
    builder: UdpTransportBuilder,
}
impl UdpServer {
    /// Makes a new `UdpServer` instance which will bind to `bind_addr`.
    pub fn new(bind_addr: SocketAddr) -> Self {
        let mut builder = UdpTransportBuilder::new();
        builder.bind_addr(bind_addr);
        UdpServer { builder: builder }
    }

    /// Makes a new `UdpServer` instance which uses the `socket` to communiate with clients.
    pub fn with_socket(socket: UdpSocket) -> Self {
        let builder = UdpTransportBuilder::with_socket(socket);
        UdpServer { builder: builder }
    }

    /// Starts the UDP server with `handler`.
    pub fn start<S, H>(&self, spawner: S, handler: H) -> UdpServerLoop<H>
        where S: Spawn + Send + 'static,
              H: HandleMessage
    {
        let transport = self.builder.finish();
        BaseServer::start(spawner, transport, handler)
    }
}
impl Deref for UdpServer {
    type Target = UdpTransportBuilder;
    fn deref(&self) -> &Self::Target {
        &self.builder
    }
}
impl DerefMut for UdpServer {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.builder
    }
}

/// `Future` that represent the loop of a UDP server for handling transactions issued by clients.
pub type UdpServerLoop<H> = BaseServerLoop<UdpTransport, H>;