Added methods has_nodelay to SctpStream. Also added capability to

change and query send and receive socket buffer.
Added connectx methode to SctpStream

Author: pierresy

examples/stream.rs

@@ -9,7 +9,15 @@ fn main() {
     	Err(e) => println!("{:?}", e.kind()),
     	Ok(mut peer) => {
     		// Set SCTP no delay
+    		println!("{}", peer.has_nodelay().unwrap());
     		peer.set_nodelay(true).unwrap();
+    		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);
+    		
     		// Write a message using the io::Write trait
     		peer.write_all("foo bar\n".as_bytes()).unwrap();
     		// Write a message on stream 6

src/lib.rs

@@ -3,7 +3,7 @@ extern crate libc;
 
 mod sctpsock;
 use sctpsock::{SctpSocket, BindOp, RawSocketAddr};
-use sctp_sys::SOCK_SEQPACKET;
+use sctp_sys::{SOCK_SEQPACKET, SOL_SCTP};
 
 use std::io::prelude::*;
 use std::io::{Result, Error, ErrorKind};
@@ -15,6 +15,20 @@ use std::os::unix::io::{AsRawFd, RawFd, FromRawFd};
 use std::os::windows::io::{AsRawHandle, RawHandle, FromRawHandle};
 
 
+pub enum SoBuffer {
+	Receive,
+	Send
+}
+
+impl SoBuffer {
+	fn optname(&self) -> libc::c_int {
+		return match *self {
+			SoBuffer::Receive => libc::SO_RCVBUF,
+			SoBuffer::Send => libc::SO_SNDBUF
+		};
+	}
+}
+
 /// One-to-one SCTP connected stream which behaves like a TCP stream.
 /// A `SctpStream` can be obtained either actively by connecting to a SCTP endpoint with the
 /// `connect` constructor, or passively from a `SctpListener` which accepts new connections
@@ -30,6 +44,22 @@ impl SctpStream {
 		return Ok(SctpStream(sock));
 	}
 
+	/// Create a new stream by connecting it to a remote endpoint
+	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());
+		let mut family = libc::AF_INET;
+		for address in addresses {
+			let a = try!(SocketAddr::from_addr(address));
+			if a.family() == libc::AF_INET6 { family = libc::AF_INET6; }
+			vec.push(a);
+		}
+
+		let sock = try!(SctpSocket::new(family, libc::SOCK_STREAM));
+		try!(sock.connectx(&vec));
+		return Ok(SctpStream(sock));
+	}
+	
 	/// Send bytes on the specified SCTP stream. On success, returns the
 	/// quantity of bytes read
 	pub fn sendmsg(&self, msg: &[u8], stream: u16) -> Result<usize> {
@@ -58,10 +88,28 @@ impl SctpStream {
 		return self.0.shutdown(how);
 	}
 
-	/// Set or unset SCTP NO DELAY option
+	/// Set or unset SCTP_NODELAY option
 	pub fn set_nodelay(&self, nodelay: bool) -> Result<()> {
 		let val: libc::c_int = if nodelay { 1 } else { 0 };
-		return self.0.setsockopt(sctp_sys::SCTP_NODELAY, &val);
+		return self.0.setsockopt(SOL_SCTP, sctp_sys::SCTP_NODELAY, &val);
+	}
+	
+	/// Verify if SCTP_NODELAY option is activated for this socket
+	pub fn has_nodelay(&self) -> Result<bool> {
+		let val: libc::c_int = try!(self.0.sctp_opt_info(sctp_sys::SCTP_NODELAY, 0));
+		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));
+	}
+	
+	/// 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()));
+		return Ok(val as usize);
 	}
 
 	/// Try to clone the SctpStream. On success, returns a new stream

src/sctpsock.rs

@@ -40,6 +40,14 @@ fn check_socket(sock: SOCKET) -> Result<SOCKET> {
 	return Ok(sock);
 }
 
+// XXX: Until getsockopt is available in libc crate
+extern "system" {
+	#[cfg(target_os="linux")]
+	fn getsockopt(sock: SOCKET, level: libc::c_int, optname: libc::c_int, optval: *mut libc::c_void, optlen: *mut libc::socklen_t) -> libc::c_int;
+	#[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;
+}
+
 /// SCTP bind operation
 #[allow(dead_code)]
 pub enum BindOp {
@@ -170,6 +178,33 @@ impl SctpSocket {
 		}
 	}
 
+	/// Connect the socket to multiple addresses
+	pub fn connectx<A: ToSocketAddrs>(&self, addresses: &[A]) -> Result<sctp_sys::sctp_assoc_t> {
+		if addresses.len() == 0 { return Err(Error::new(ErrorKind::InvalidInput, "No addresses given")); }
+		unsafe {
+			let buf: *mut u8 = libc::malloc((addresses.len() * size_of::<libc::sockaddr_in6>()) as u64) as *mut u8;
+			if buf.is_null() {
+				return Err(Error::new(ErrorKind::Other, "Out of memory"));
+			}
+			let mut offset = 0isize;
+			for address in addresses {
+				let raw = try!(SocketAddr::from_addr(address));
+				let len = raw.addr_len();
+				std::ptr::copy_nonoverlapping(raw.as_ptr() as *mut u8, buf.offset(offset), len as usize);
+				offset += len as isize;
+			}
+			
+			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);
+			}
+			libc::free(buf as *mut libc::c_void);
+			return Ok(assoc);
+		}
+	}
+	
 	/// Bind the socket on multiple addresses
 	pub fn bindx<A: ToSocketAddrs>(&self, addresses: &[A], op: BindOp) -> Result<()> {
 		if addresses.len() == 0 { return Err(Error::new(ErrorKind::InvalidInput, "No addresses given")); }
@@ -325,18 +360,30 @@ impl SctpSocket {
 		};
 	}
 
-	/// Set SCTP socket option
-	pub fn setsockopt<T>(&self, optname: libc::c_int, optval: &T) -> Result<()> {
+	/// Set socket option
+	pub fn setsockopt<T>(&self, level: libc::c_int, optname: libc::c_int, optval: &T) -> Result<()> {
 		unsafe {
-			return match libc::setsockopt(self.0, sctp_sys::SOL_SCTP, optname, transmute(optval), size_of::<T>() as libc::socklen_t) {
+			return match libc::setsockopt(self.0, level, optname, transmute(optval), size_of::<T>() as libc::socklen_t) {
 				0 => Ok(()),
 				_ => Err(Error::last_os_error())
 			};
 		}
 	}
 
+	/// Get socket option
+	pub fn getsockopt<T>(&self, level: libc::c_int, optname: libc::c_int) -> Result<T> {
+		unsafe {
+			let mut val: T = zeroed();
+			let mut len = size_of::<T>() as libc::socklen_t;
+			return match getsockopt(self.0, level, optname, transmute(&mut val), &mut len) {
+				0 => Ok(val),
+				_ => Err(Error::last_os_error())
+			};
+		}
+	}
+	
 	/// Get SCTP socket option
-	pub fn getsockopt<T>(&self, optname: libc::c_int, assoc: sctp_sys::sctp_assoc_t) -> Result<T> {
+	pub fn sctp_opt_info<T>(&self, optname: libc::c_int, assoc: sctp_sys::sctp_assoc_t) -> Result<T> {
 		unsafe {
 			let mut val: T = zeroed();
 			let mut len = size_of::<T>() as libc::socklen_t;
@@ -347,7 +394,6 @@ impl SctpSocket {
 		}
 	}
 
-	
 	/// Try to clone this socket
 	pub fn try_clone(&self) -> Result<SctpSocket> {
 		unsafe {