ssdp 0.1.5

An asynchronous abstraction for discovering devices and services on a network.
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use std::io::{self, ErrorKind, Read, Write};
use std::net::{UdpSocket, SocketAddr};
use std::time::Duration;
use hyper::net::{NetworkStream};

/// A type that wraps a UdpSocket and a SocketAddr and implements the NetworkStream
/// trait.
///
/// Note that reading from this stream will generate an error, this object is
/// used for intercepting Http messages from Hyper and sending them out via Udp.
/// The response(s) from client(s) are to be handled by some other object that
/// has a cloned handle to our internal UdpSocket handle.
pub struct UdpSender {
    udp: UdpSocket,
    dst: SocketAddr
}

impl UdpSender {
    /// Creates a new UdpSender object.
    pub fn new(udp: UdpSocket, dst: SocketAddr) -> UdpSender {
        UdpSender{ udp: udp, dst: dst }
    }
}

impl NetworkStream for UdpSender {
    fn peer_addr(&mut self) -> io::Result<SocketAddr> {
        Ok(self.dst)
    }
    fn set_read_timeout(&self, _dur: Option<Duration>) -> io::Result<()> {
        Ok(())
    }
    fn set_write_timeout(&self, _dur: Option<Duration>) -> io::Result<()> {
        Ok(())
    }
}

unsafe impl Send for UdpSender { }

impl Read for UdpSender {
    fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
        // Simulate Some Network Error So Our Process Doesnt Hang
        Err(io::Error::new(ErrorKind::ConnectionAborted, "UdpSender Can Not Be Read From"))
    }
}

impl Write for UdpSender {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        // Hyper will generate a request with a /, we need to intercept that.
        let mut buffer = vec![0u8; buf.len()];

        let mut found = false;
        for (src, dst) in buf.iter().zip(buffer.iter_mut()) {
            if *src == b'/' && !found && buf[0] != b'H' {
                *dst = b'*';
                found = true;
            } else {
                *dst = *src;
            }
        }
        debug!("Sent HTTP Request:\n{}", String::from_utf8_lossy(&buffer[..]));

        self.udp.send_to(&buffer[..], self.dst)
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

impl Clone for UdpSender {
    fn clone(&self) -> UdpSender {
        let udp_clone = self.udp.try_clone().unwrap();

        UdpSender{ udp: udp_clone, dst: self.dst }
    }

    fn clone_from(&mut self, source: &UdpSender) {
        let udp_clone = source.udp.try_clone().unwrap();

        self.udp = udp_clone;
        self.dst = source.dst;
    }
}