use std::io::{Result, Error, ErrorKind};
use std::net::{ToSocketAddrs, SocketAddr, UdpSocket};
use std::time::Duration;
use url::{UrlParser, SchemeType};
use num;
use rand::{thread_rng, random, Rng};
use message::packet::{Packet, CoAPOption};
use message::header::MessageType;
use message::response::CoAPResponse;
use message::request::CoAPRequest;
use message::IsMessage;
const DEFAULT_RECEIVE_TIMEOUT: u64 = 5;
pub struct CoAPClient {
socket: UdpSocket,
peer_addr: SocketAddr,
}
impl CoAPClient {
pub fn new_with_specific_source<A: ToSocketAddrs, B: ToSocketAddrs>(bind_addr: A, peer_addr: B) -> Result<CoAPClient> {
peer_addr.to_socket_addrs().and_then(|mut iter| {
match iter.next() {
Some(paddr) => {
UdpSocket::bind(bind_addr).and_then(|s| {
s.set_read_timeout(Some(Duration::new(DEFAULT_RECEIVE_TIMEOUT, 0)))
.and_then(|_| {
Ok(CoAPClient {
socket: s,
peer_addr: paddr,
})
})
})
}
None => Err(Error::new(ErrorKind::Other, "no address")),
}
})
}
pub fn new<A: ToSocketAddrs>(addr: A) -> Result<CoAPClient> {
addr.to_socket_addrs().and_then(|mut iter| {
match iter.next() {
Some(SocketAddr::V4(_)) => {
Self::new_with_specific_source("0.0.0.0:0", addr)
}
Some(SocketAddr::V6(_)) => {
Self::new_with_specific_source(":::0", addr)
}
None => Err(Error::new(ErrorKind::Other, "no address")),
}
})
}
pub fn request_with_timeout(url: &str, timeout: Option<Duration>) -> Result<CoAPResponse> {
let mut url_parser = UrlParser::new();
url_parser.scheme_type_mapper(Self::coap_scheme_type_mapper);
match url_parser.parse(url) {
Ok(url_params) => {
let mut packet = CoAPRequest::new();
packet.set_version(1);
packet.set_type(MessageType::Confirmable);
packet.set_code("0.01");
let message_id = thread_rng().gen_range(0, num::pow(2u32, 16)) as u16;
packet.set_message_id(message_id);
let mut token: Vec<u8> = vec![1, 1, 1, 1];
for x in token.iter_mut() {
*x = random()
}
packet.set_token(token.clone());
let domain = match url_params.domain() {
Some(d) => d,
None => return Err(Error::new(ErrorKind::InvalidInput, "domain error")),
};
let port = url_params.port_or_default().unwrap();
if let Some(path) = url_params.path() {
for p in path.iter() {
packet.add_option(CoAPOption::UriPath, p.clone().into_bytes().to_vec());
}
};
let client = try!(Self::new((domain, port)));
try!(client.send(&packet));
try!(client.set_receive_timeout(timeout));
match client.receive() {
Ok(receive_packet) => {
if receive_packet.get_message_id() == message_id &&
*receive_packet.get_token() == token {
return Ok(receive_packet);
} else {
return Err(Error::new(ErrorKind::Other, "receive invalid data"));
}
}
Err(e) => Err(e),
}
}
Err(_) => Err(Error::new(ErrorKind::InvalidInput, "url error")),
}
}
pub fn request(url: &str) -> Result<CoAPResponse> {
Self::request_with_timeout(url, Some(Duration::new(DEFAULT_RECEIVE_TIMEOUT, 0)))
}
pub fn send(&self, request: &CoAPRequest) -> Result<()> {
match request.message.to_bytes() {
Ok(bytes) => {
let size = try!(self.socket.send_to(&bytes[..], self.peer_addr));
if size == bytes.len() {
Ok(())
} else {
Err(Error::new(ErrorKind::Other, "send length error"))
}
}
Err(_) => Err(Error::new(ErrorKind::InvalidInput, "packet error")),
}
}
pub fn receive(&self) -> Result<CoAPResponse> {
let mut buf = [0; 1500];
let (nread, _src) = try!(self.socket.recv_from(&mut buf));
match Packet::from_bytes(&buf[..nread]) {
Ok(packet) => Ok(CoAPResponse { message: packet }),
Err(_) => Err(Error::new(ErrorKind::InvalidInput, "packet error")),
}
}
pub fn set_receive_timeout(&self, dur: Option<Duration>) -> Result<()> {
self.socket.set_read_timeout(dur)
}
fn coap_scheme_type_mapper(scheme: &str) -> SchemeType {
match scheme {
"coap" => SchemeType::Relative(5683),
_ => SchemeType::NonRelative,
}
}
}
#[cfg(test)]
mod test {
use super::*;
use std::time::Duration;
use std::io::ErrorKind;
use message::request::CoAPRequest;
use message::response::CoAPResponse;
use server::CoAPServer;
#[test]
fn test_request_error_url() {
assert!(CoAPClient::request("http://127.0.0.1").is_err());
assert!(CoAPClient::request("coap://127.0.0.").is_err());
assert!(CoAPClient::request("127.0.0.1").is_err());
}
fn request_handler(_: CoAPRequest) -> Option<CoAPResponse> {
None
}
#[test]
fn test_request_timeout() {
let mut server = CoAPServer::new("127.0.0.1:5684").unwrap();
server.handle(request_handler).unwrap();
let error = CoAPClient::request_with_timeout("coap://127.0.0.1:5684/Rust",
Some(Duration::new(1, 0)))
.unwrap_err();
if cfg!(windows) {
assert_eq!(error.kind(), ErrorKind::TimedOut);
} else {
assert_eq!(error.kind(), ErrorKind::WouldBlock);
}
}
}