Fix indentation (tabs-consistent), Include the response automatically if possible

examples/client_and_server.rs

@@ -3,15 +3,15 @@ extern crate coap;
 use coap::packet::*;
 use coap::{CoAPServer, CoAPClient};
 
-fn request_handler(req: Packet) -> Option<Packet> {
+fn request_handler(req: Packet, response: Option<Packet>) -> Option<Packet> {
 	let uri_path = req.get_option(OptionType::UriPath).unwrap();
 
-	return match coap::packet::auto_response(req) {
-	Ok(mut response) => {
-		response.set_payload(uri_path.front().unwrap().clone());
-		Some(response)
+	return match response {
+		Some(mut packet) => {
+			packet.set_payload(uri_path.front().unwrap().clone());
+			Some(packet)
 		},
-	Err(_) => None
+		_ => None
     };
 }
 

examples/server.rs

@@ -4,13 +4,13 @@ use std::io;
 use coap::packet::*;
 use coap::CoAPServer;
 
-fn request_handler(req: Packet) -> Option<Packet> {
-    return match coap::packet::auto_response(req) {
-        Ok(mut response) => {
-		response.set_payload(b"OK".to_vec());
-		Some(response)
+fn request_handler(_: Packet, response: Option<Packet>) -> Option<Packet> {
+	return match response {
+		Some(mut packet) => {
+			packet.set_payload(b"OK".to_vec());
+			Some(packet)
 		},
-        Err(_) => None
+		_ => None
 	};
 }
 

src/client.rs

@@ -156,7 +156,7 @@ mod test {
 		assert!(CoAPClient::request("127.0.0.1").is_err());
 	}
 
-	fn request_handler(_: Packet) -> Option<Packet> {
+	fn request_handler(_: Packet, _:Option<Packet>) -> Option<Packet> {
 		None
 	}
 

src/lib.rs

@@ -29,7 +29,7 @@
 //! use coap::packet::*;
 //! use coap::{CoAPServer, CoAPClient};
 
-//! fn request_handler(req: Packet) -> Option<Packet> {
+//! fn request_handler(req: Packet, resp: Option<Packet>) -> Option<Packet> {
 //! 	println!("Receive request: {:?}", req);
 //!     None
 //! }

src/packet.rs

 use bincode;
 use std::collections::BTreeMap;
 use std::collections::LinkedList;
-use std;
 
 macro_rules! u8_to_unsigned_be {
 	($src:ident, $start:expr, $end:expr, $t:ty) => ({
@@ -437,23 +436,23 @@ impl Packet {
 }
 
 /// Convert a request to a response
-pub fn auto_response(request_packet: Packet) -> std::io::Result<Packet> {
+pub fn auto_response(request_packet: &Packet) -> Option<Packet> {
 		let mut packet = Packet::new();
 
 		packet.header.set_version(1);
 		let response_type = match request_packet.header.get_type() {
 			PacketType::Confirmable => PacketType::Acknowledgement,
 			PacketType::NonConfirmable => PacketType::NonConfirmable,
-			_ => return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, "request type error"))
+			_ => return None
 		};
 		packet.header.set_type(response_type);
 		packet.header.set_code("2.05");
 		packet.header.set_message_id(request_packet.header.get_message_id());
 		packet.set_token(request_packet.get_token().clone());
 
-		packet.payload = request_packet.payload;
+		packet.payload = request_packet.payload.clone();
 
-		Ok(packet)
+		Some(packet)
 	}
 
 #[cfg(test)]

src/server.rs

@@ -5,7 +5,7 @@ use std::net::{ToSocketAddrs, SocketAddr};
 use std::sync::mpsc;
 use mio::{EventLoop, PollOpt, EventSet, Handler, Sender, Token};
 use mio::udp::UdpSocket;
-use packet::Packet;
+use packet::{Packet, auto_response};
 use threadpool::ThreadPool;
 
 const DEFAULT_WORKER_NUM: usize = 4;
@@ -26,12 +26,12 @@ pub struct CoAPResponse {
 }
 
 pub trait CoAPHandler: Sync + Send + Copy {
-	fn handle(&self, Packet) -> Option<Packet>;
+	fn handle(&self, Packet, Option<Packet>) -> Option<Packet>;
 }
 
-impl<F> CoAPHandler for F where F: Fn(Packet) -> Option<Packet>, F: Sync + Send + Copy {
-	fn handle(&self, request: Packet) -> Option<Packet> {
-		return self(request);
+impl<F> CoAPHandler for F where F: Fn(Packet, Option<Packet>) -> Option<Packet>, F: Sync + Send + Copy {
+	fn handle(&self, request: Packet, response: Option<Packet>) -> Option<Packet> {
+		return self(request, response);
 	}
 }
 
@@ -71,12 +71,13 @@ impl<H: CoAPHandler + 'static> Handler for UdpHandler<H> {
 				debug!("Handling request from {}", src);
 				let response_q = self.tx_sender.clone();
 				self.thread_pool.execute(move || {
-
 					match Packet::from_bytes(&buf[..nread]) {
 						Ok(packet) => {
+							// Pre-generate a response
+							let auto_resp = auto_response(&packet);
 							// Dispatch user handler, if there is a response packet
 							//   send the reply via the TX thread
-							match coap_handler.handle(packet) {
+							match coap_handler.handle(packet, auto_resp) {
 								Some(response) => {
 									debug!("Response: {:?}", response);
 									response_q.send(CoAPResponse{
@@ -94,8 +95,6 @@ impl<H: CoAPHandler + 'static> Handler for UdpHandler<H> {
 							return;
 						}
 					};
-
-
 				});
 			},
 			_ => {
@@ -246,20 +245,20 @@ impl Drop for CoAPServer {
 #[cfg(test)]
 mod test {
 	use super::*;
-	use packet::{Packet, PacketType, OptionType, auto_response};
+	use packet::{Packet, PacketType, OptionType};
 	use client::CoAPClient;
 
-	fn request_handler(req: Packet) -> Option<Packet> {
+	fn request_handler(req: Packet, response: Option<Packet>) -> Option<Packet> {
 		let uri_path_list = req.get_option(OptionType::UriPath).unwrap();
 		assert!(uri_path_list.len() == 1);
 
-		return match auto_response(req) {
-			Ok(mut response) => {
-				response.set_payload(uri_path_list.front().unwrap().clone());
-				Some(response)
+		match response {
+			Some(mut packet) => {
+				packet.set_payload(uri_path_list.front().unwrap().clone());
+				Some(packet)
 			},
-			Err(_) => None
-		};
+			_ => None
+		}
 	}
 
 	#[test]