Added set_timeout() method to SctpStream

Author: pierresy

examples/stream.rs

@@ -15,9 +15,12 @@ fn main() {
     		println!("{}", peer.has_nodelay().unwrap());
 
     		// Set socket send buffer size
-    		let oldsize = peer.get_buffer_size(SoBuffer::Send).unwrap();
-    		peer.set_buffer_size(SoBuffer::Send, 4096).unwrap();
-    		println!("Set send buffer size to {} (was : {})", peer.get_buffer_size(SoBuffer::Send).unwrap(), oldsize);
+    		let oldsize = peer.get_buffer_size(SoDirection::Send).unwrap();
+    		peer.set_buffer_size(SoDirection::Send, 4096).unwrap();
+    		println!("Set send buffer size to {} (was : {})", peer.get_buffer_size(SoDirection::Send).unwrap(), oldsize);
+    		
+    		println!("Setting read timeout to 10 s");
+    		peer.set_timeout(SoDirection::Receive, 10).unwrap();
 
     		// Write a message using the io::Write trait
     		peer.write_all("foo bar\n".as_bytes()).unwrap();

src/lib.rs

@@ -1,7 +1,7 @@
 //! This crate provides high level SCTP networking.
 //! Currently it only supports basic SCTP features like multi-homing
 //! in one-to-one and one-to-many associations.
-//! SCTP notifications and working directly on associtaion is not supported yet
+//! SCTP notifications and working directly on association is not supported yet
 //! but is in the TODO list.  
 
 extern crate sctp_sys;
@@ -20,19 +20,26 @@ use std::os::unix::io::{AsRawFd, RawFd, FromRawFd};
 #[cfg(target_os="windows")]
 use std::os::windows::io::{AsRawHandle, RawHandle, FromRawHandle};
 
-/// Socket buffer type
-pub enum SoBuffer {
-	/// RCV buffer
+/// Socket direction
+pub enum SoDirection {
+	/// RCV direction
 	Receive,
-	/// SND buffer
+	/// SND direction
 	Send
 }
 
-impl SoBuffer {
-	fn optname(&self) -> libc::c_int {
+impl SoDirection {
+	fn buffer_opt(&self) -> libc::c_int {
 		return match *self {
-			SoBuffer::Receive => libc::SO_RCVBUF,
-			SoBuffer::Send => libc::SO_SNDBUF
+			SoDirection::Receive => libc::SO_RCVBUF,
+			SoDirection::Send => libc::SO_SNDBUF
+		};
+	}
+	
+	fn timeout_opt(&self) -> libc::c_int {
+		return match *self {
+			SoDirection::Receive => libc::SO_RCVTIMEO,
+			SoDirection::Send => libc::SO_SNDTIMEO
 		};
 	}
 }
@@ -108,18 +115,24 @@ impl SctpStream {
 		return Ok(val == 1);
 	}
 
-	/// Set the socket buffer size for the buffer specifid by `buf`.
-	/// Linux system will double the provided size
-	pub fn set_buffer_size(&self, buf: SoBuffer, size: usize) -> Result<()> {
-		return self.0.setsockopt(libc::SOL_SOCKET, buf.optname(), &(size as libc::c_int));
+	/// Set the socket buffer size for the direction specified by `dir`.
+	/// Linux systems will double the provided size
+	pub fn set_buffer_size(&self, dir: SoDirection, size: usize) -> Result<()> {
+		return self.0.setsockopt(libc::SOL_SOCKET, dir.buffer_opt(), &(size as libc::c_int));
 	}
 
-	/// Get the socket buffer size for the buffer specifid by `buf`
-	pub fn get_buffer_size(&self, buf: SoBuffer) -> Result<(usize)> {
-		let val: u32 = try!(self.0.getsockopt(libc::SOL_SOCKET, buf.optname()));
+	/// Get the socket buffer size for the direction specified by `dir`
+	pub fn get_buffer_size(&self, dir: SoDirection) -> Result<(usize)> {
+		let val: u32 = try!(self.0.getsockopt(libc::SOL_SOCKET, dir.buffer_opt()));
 		return Ok(val as usize);
 	}
 
+	/// Set `timeout` in seconds for operation `dir` (either receive or send)
+	pub fn set_timeout(&self, dir: SoDirection, timeout: i32) -> Result<()> {
+		let tval = libc::timeval { tv_sec: timeout as libc::c_int, tv_usec: 0 };
+		return self.0.setsockopt(libc::SOL_SOCKET, dir.timeout_opt(), &tval);
+	}
+	
 	/// Try to clone the SctpStream. On success, returns a new stream
 	/// wrapping a new socket handler
 	pub fn try_clone(&self) -> Result<SctpStream> {

src/sctpsock.rs

@@ -47,15 +47,6 @@ extern "system" {
 	#[cfg(target_os="windows")]
 	fn getsockopt(sock: SOCKET, level: libc::c_int, optname: libc::c_int, optval: *mut libc::c_char, optlen: *mut libc::c_int) -> libc::c_int;
 }
-#[cfg(target_os="linux")]
-pub const SO_RCVTIMEO: libc::c_int = 20;
-#[cfg(target_os="linux")]
-pub const SO_SNDTIMEO: libc::c_int = 21;
-
-#[cfg(target_os="windows")]
-pub const SO_RCVTIMEO: libc::c_int = 0x1006;
-#[cfg(target_os="windows")]
-pub const SO_SNDTIMEO: libc::c_int = 0x1005;
 
 /// SCTP bind operation
 #[allow(dead_code)]
@@ -267,7 +258,7 @@ impl SctpSocket {
 			let addr_ptr: *mut libc::sockaddr = transmute(&mut addr);
 			let sock = try!(check_socket(libc::accept(self.0, addr_ptr, &mut len)));
 			let addr = try!(SocketAddr::from_raw_ptr(addr_ptr, len));
-			return Ok((SctpSocket::from_raw_fd(sock), addr));
+			return Ok((SctpSocket(sock), addr));
 		}
 	}
 
@@ -421,12 +412,6 @@ impl SctpSocket {
 			return Ok(SctpSocket(new_sock));
 		}
 	}
-	
-	/// Wrap the given socket descriptor in a `SctpSocket`. This is unsafe because we can't be sure
-	/// that the given socket is valid
-	pub unsafe fn from_raw_fd(sock: SOCKET) -> SctpSocket {
-		return SctpSocket(sock);
-	}
 }
 
 impl Read for SctpSocket {