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
84
85
86
87

use message::IsMessage;
use message::response::CoAPResponse;
use message::packet::Packet;
use message::header::Header;
use std::net::SocketAddr;

#[derive(Debug)]
pub struct CoAPRequest {
    pub message: Packet,
    pub response: Option<CoAPResponse>,
    pub source: Option<SocketAddr>,
}

impl CoAPRequest {
    pub fn new() -> CoAPRequest {
        CoAPRequest {
            response: None,
            message: Packet::new(),
            source: None,
        }
    }

    pub fn from_packet(packet: Packet, source: &SocketAddr) -> CoAPRequest {
        CoAPRequest {
            response: CoAPResponse::new(&packet),
            message: packet,
            source: Some(source.clone()),
        }
    }
}

impl IsMessage for CoAPRequest {
    fn get_message(&self) -> &Packet {
        &self.message
    }
    fn get_mut_message(&mut self) -> &mut Packet {
        &mut self.message
    }
    fn get_header(&self) -> &Header {
        &self.message.header
    }
    fn get_mut_header(&mut self) -> &mut Header {
        &mut self.message.header
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use message::packet::{Packet, CoAPOption};
    use message::header::MessageType;
    use message::IsMessage;
    use std::net::SocketAddr;
    use std::str::FromStr;

    #[test]
    fn test_request_create() {

        let mut packet = Packet::new();
        let mut request1 = CoAPRequest::new();

        packet.set_token(vec![0x17, 0x38]);
        request1.set_token(vec![0x17, 0x38]);

        packet.add_option(CoAPOption::UriPath, b"test-interface".to_vec());
        request1.add_option(CoAPOption::UriPath, b"test-interface".to_vec());

        packet.header.set_message_id(42);
        request1.set_message_id(42);

        packet.header.set_version(2);
        request1.set_version(2);

        packet.header.set_type(MessageType::Confirmable);
        request1.set_type(MessageType::Confirmable);

        packet.header.set_code("0.04");
        request1.set_code("0.04");

        let request2 = CoAPRequest::from_packet(packet,
                                                &SocketAddr::from_str("127.0.0.1:1234").unwrap());

        assert_eq!(request1.message.to_bytes().unwrap(),
                   request2.message.to_bytes().unwrap());

    }
}