Renamed SctpDatagram to SctpEndpoint, added some comments, and removed some panic!(...)

Author: pierresy

examples/one_to_many.rs

@@ -3,8 +3,8 @@ use sctp::*;
 
 fn main() {
 	// Create a new Sctp endpoint, and bind it to one or more socket addresses
-//	let sock = match SctpDatagram::bind("0.0.0.0:3868") {
-	let sock = match SctpDatagram::bindx(&["10.0.2.15:3868", "127.0.0.1:3868"]) {
+//	let sock = match SctpEndpoint::bind("0.0.0.0:3868") {
+	let sock = match SctpEndpoint::bindx(&["10.0.2.15:3868", "127.0.0.1:3868"]) {
 		Ok(s) => s,
 		Err(e) => panic!("{:?}", e.kind())
 	};

examples/stream.rs

@@ -5,7 +5,8 @@ use std::io::prelude::*;
 
 fn main() {
 	// Create a new one-to-one stream
-    match SctpStream::connect("127.0.0.1:3868") {
+//    match SctpStream::connect("127.0.0.1:3868") {
+	match SctpStream::connectx(&["10.0.2.15:3868", "127.0.0.1:3868"]) {
     	Err(e) => println!("{:?}", e.kind()),
     	Ok(mut peer) => {
     		// Set SCTP no delay

src/lib.rs

@@ -1,3 +1,9 @@
+//! 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
+//! but is in the TODO list.  
+
 extern crate sctp_sys;
 extern crate libc;
 
@@ -14,9 +20,11 @@ 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
 	Receive,
+	/// SND buffer
 	Send
 }
 
@@ -44,7 +52,7 @@ impl SctpStream {
 		return Ok(SctpStream(sock));
 	}
 
-	/// Create a new stream by connecting it to a remote endpoint
+	/// Create a new stream by connecting it to a remote endpoint having multiple addresses
 	pub fn connectx<A: ToSocketAddrs>(addresses: &[A]) -> Result<SctpStream> {
 		if addresses.len() == 0 { return Err(Error::new(ErrorKind::InvalidInput, "No addresses given")); }
 		let mut vec = Vec::with_capacity(addresses.len());
@@ -164,18 +172,21 @@ impl FromRawFd for SctpStream {
 }
 
 
-/// One-to-many SCTP stream.
-pub struct SctpDatagram(SctpSocket);
+/// One-to-many SCTP endpoint.
+pub struct SctpEndpoint(SctpSocket);
 
-impl SctpDatagram {
+impl SctpEndpoint {
 
-	/// Create a one-to-many SCTP socket bound to a single address
-	pub fn bind<A: ToSocketAddrs>(address: A) -> Result<SctpDatagram> {
-		return Self::bindx(&[address]);
+	/// Create a one-to-many SCTP endpoint bound to a single address
+	pub fn bind<A: ToSocketAddrs>(address: A) -> Result<SctpEndpoint> {
+		let raw_addr = try!(SocketAddr::from_addr(&address));
+		let sock = try!(SctpSocket::new(raw_addr.family(), libc::SOCK_STREAM));
+		try!(sock.bind(raw_addr));
+		return Ok(SctpEndpoint(sock));
 	}
 
-	/// Create a one-to-many SCTP socket bound to a multiple addresses. Requires at least one address
-	pub fn bindx<A: ToSocketAddrs>(addresses: &[A]) -> Result<SctpDatagram> {
+	/// Create a one-to-many SCTP endpoint bound to a multiple addresses. Requires at least one address
+	pub fn bindx<A: ToSocketAddrs>(addresses: &[A]) -> Result<SctpEndpoint> {
 		if addresses.len() == 0 { return Err(Error::new(ErrorKind::InvalidInput, "No addresses given")); }
 		let mut vec = Vec::with_capacity(addresses.len());
 		let mut family = libc::AF_INET;
@@ -188,7 +199,7 @@ impl SctpDatagram {
 		let sock = try!(SctpSocket::new(family, SOCK_SEQPACKET));
 		try!(sock.bindx(&vec, BindOp::AddAddr));
 		try!(sock.listen(-1));
-		return Ok(SctpDatagram(sock));
+		return Ok(SctpEndpoint(sock));
 	}
 
 	/// Wait for data to be received. On success, returns a triplet containing
@@ -200,7 +211,7 @@ impl SctpDatagram {
 
 	/// Send data in Sctp style, to the provided address on the stream `stream`.
 	/// On success, returns the quantity on bytes sent
-	pub fn send_to<A: ToSocketAddrs>(&self, msg: &mut [u8], address: A, stream: u16, ) -> Result<usize> {
+	pub fn send_to<A: ToSocketAddrs>(&self, msg: &mut [u8], address: A, stream: u16) -> Result<usize> {
 		return self.0.sendmsg(msg, Some(address), stream, 0);
 	}
 
@@ -210,36 +221,36 @@ impl SctpDatagram {
 	}
 
 	/// Try to clone this socket
-	pub fn try_clone(&self) -> Result<SctpDatagram> {
-		return Ok(SctpDatagram(try!(self.0.try_clone())));
+	pub fn try_clone(&self) -> Result<SctpEndpoint> {
+		return Ok(SctpEndpoint(try!(self.0.try_clone())));
 	}
 }
 
 #[cfg(target_os="windows")]
-impl AsRawHandle for SctpDatagram {
+impl AsRawHandle for SctpEndpoint {
 	fn as_raw_handle(&self) -> RawHandle {
 		return return self.0.as_raw_handle();	
 	}
 }
 
 #[cfg(target_os="windows")]
-impl FromRawHandle for SctpDatagram {
-	unsafe fn from_raw_handle(hdl: RawHandle) -> SctpDatagram {
-		return SctpDatagram(SctpSocket::from_raw_handle(hdl));
+impl FromRawHandle for SctpEndpoint {
+	unsafe fn from_raw_handle(hdl: RawHandle) -> SctpEndpoint {
+		return SctpEndpoint(SctpSocket::from_raw_handle(hdl));
 	}
 }
 
 #[cfg(target_os="linux")]
-impl AsRawFd for SctpDatagram {
+impl AsRawFd for SctpEndpoint {
 	fn as_raw_fd(&self) -> RawFd {
 		return self.0.as_raw_fd();	
 	}
 }
 
 #[cfg(target_os="linux")]
-impl FromRawFd for SctpDatagram {
-	unsafe fn from_raw_fd(fd: RawFd) -> SctpDatagram {
-		return SctpDatagram(SctpSocket::from_raw_fd(fd));
+impl FromRawFd for SctpEndpoint {
+	unsafe fn from_raw_fd(fd: RawFd) -> SctpEndpoint {
+		return SctpEndpoint(SctpSocket::from_raw_fd(fd));
 	}
 }
 
@@ -267,7 +278,10 @@ impl SctpListener {
 
 	/// Create a listener bound to a single address
 	pub fn bind<A: ToSocketAddrs>(address: A) -> Result<SctpListener> {
-		return Self::bindx(&[address]);
+		let raw_addr = try!(SocketAddr::from_addr(&address));
+		let sock = try!(SctpSocket::new(raw_addr.family(), libc::SOCK_STREAM));
+		try!(sock.bind(raw_addr));
+		return Ok(SctpListener(sock));
 	}
 
 	/// Create a listener bound to multiple addresses. Requires at least one address

src/sctpsock.rs

@@ -47,6 +47,15 @@ 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)]
@@ -126,7 +135,7 @@ impl RawSocketAddr for SocketAddr {
 
 	unsafe fn from_raw_ptr(addr: *const libc::sockaddr, len: libc::socklen_t) -> Result<SocketAddr> {
 		if len < size_of::<libc::sockaddr>() as libc::socklen_t {
-			panic!("Invalid address length");
+			return Err(Error::new(ErrorKind::InvalidInput, "Invalid address length"));
 		}
 		return match (*addr).sa_family as libc::c_int {
 			libc::AF_INET if len >= size_of::<libc::sockaddr_in>() as libc::socklen_t => Ok(SocketAddr::V4(transmute(*(addr as *const libc::sockaddr_in)))),
@@ -195,13 +204,23 @@ impl SctpSocket {
 			}
 
 			let mut assoc: sctp_sys::sctp_assoc_t = 0;
-			if sctp_sys::sctp_connectx(self.0, buf as *mut libc::sockaddr, addresses.len() as i32, &mut assoc) != 0 {
-				let err = Error::last_os_error();
-				libc::free(buf as *mut libc::c_void);
-				return Err(err);
-			}
+			let ret = match sctp_sys::sctp_connectx(self.0, buf as *mut libc::sockaddr, addresses.len() as i32, &mut assoc) {
+				0 => Ok(assoc),
+				_ => Err(Error::last_os_error()),
+			};
 			libc::free(buf as *mut libc::c_void);
-			return Ok(assoc);
+			return ret;
+		}
+	}
+	
+	/// Bind the socket to a single address
+	pub fn bind<A: ToSocketAddrs>(&self, address: A) -> Result<()> {
+		let raw_addr = try!(SocketAddr::from_addr(&address));
+		unsafe {
+			return match libc::bind(self.0, raw_addr.as_ptr(), raw_addr.addr_len()) {
+				0 => Ok(()),
+				_ => Err(Error::last_os_error())
+			};
 		}
 	}
 
@@ -221,13 +240,12 @@ impl SctpSocket {
 				offset += len as isize;
 			}
 
-			if sctp_sys::sctp_bindx(self.0, buf as *mut libc::sockaddr, addresses.len() as i32, op.flag()) != 0 {
-				let err = Error::last_os_error();
-				libc::free(buf as *mut libc::c_void);
-				return Err(err);
-			}
+			let ret = match sctp_sys::sctp_bindx(self.0, buf as *mut libc::sockaddr, addresses.len() as i32, op.flag()) {
+				0 => Ok(()),
+				_ => Err(Error::last_os_error())
+			};
 			libc::free(buf as *mut libc::c_void);
-			return Ok(());
+			return ret;
 		}
 	}
 
@@ -261,14 +279,16 @@ impl SctpSocket {
 			if len == 0 { return Err(Error::new(ErrorKind::AddrNotAvailable, "Socket is unbound")); }
 
 			let mut vec = Vec::with_capacity(len as usize);
-			
 			let mut offset = 0;
 			for _ in 0..len {
 				let sockaddr = addrs.offset(offset) as *const libc::sockaddr;
 				let len = match (*sockaddr).sa_family as i32 {
 					libc::AF_INET => size_of::<libc::sockaddr_in>(),
 					libc::AF_INET6 => size_of::<libc::sockaddr_in6>(),
-					f => panic!("Unsupported address family : {}", f)
+					f => {
+						what.free(addrs as *mut libc::sockaddr);
+						return Err(Error::new(ErrorKind::Other, format!("Unsupported address family : {}", f)));
+					}
 				} as libc::socklen_t;
 				vec.push(try!(SocketAddr::from_raw_ptr(sockaddr, len)));
 				offset += len as isize;