Merge branch 'migrate-try-to-question' into rust1.64

Author: Olivier Médoc

src/lib.rs

@@ -60,9 +60,9 @@ impl SctpStream {
 
 	/// Create a new stream by connecting it to a remote endpoint
 	pub fn connect<A: ToSocketAddrs>(address: A) -> Result<SctpStream> {
-		let raw_addr = try!(SocketAddr::from_addr(&address));
-		let sock = try!(SctpSocket::new(raw_addr.family(), SOCK_STREAM));
-		try!(sock.connect(raw_addr));
+		let raw_addr = SocketAddr::from_addr(&address)?;
+		let sock = SctpSocket::new(raw_addr.family(), SOCK_STREAM)?;
+		sock.connect(raw_addr)?;
 		return Ok(SctpStream(sock));
 	}
 
@@ -72,13 +72,13 @@ impl SctpStream {
 		let mut vec = Vec::with_capacity(addresses.len());
 		let mut family = AF_INET;
 		for address in addresses {
-			let a = try!(SocketAddr::from_addr(address));
+			let a = SocketAddr::from_addr(address)?;
 			if a.family() == AF_INET6 { family = AF_INET6; }
 			vec.push(a);
 		}
 
-		let sock = try!(SctpSocket::new(family, SOCK_STREAM));
-		try!(sock.connectx(&vec));
+		let sock = SctpSocket::new(family, SOCK_STREAM)?;
+		sock.connectx(&vec)?;
 		return Ok(SctpStream(sock));
 	}
 
@@ -97,7 +97,7 @@ impl SctpStream {
 	/// Read bytes. On success, return a tuple with the quantity of
 	/// bytes received and the stream they were recived on
 	pub fn recvmsg(&self, msg: &mut [u8]) -> Result<(usize, u16)> {
-		let (size, stream, _) = try!(self.0.recvmsg(msg));
+		let (size, stream, _) = self.0.recvmsg(msg)?;
 		return Ok((size, stream));
 	}
 
@@ -124,7 +124,7 @@ impl SctpStream {
 
 	/// 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));
+		let val: libc::c_int = self.0.sctp_opt_info(sctp_sys::SCTP_NODELAY, 0)?;
 		return Ok(val == 1);
 	}
 
@@ -135,8 +135,8 @@ impl SctpStream {
 	}
 
 	/// 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(SOL_SOCKET, dir.buffer_opt()));
+	pub fn get_buffer_size(&self, dir: SoDirection) -> Result<usize> {
+		let val: u32 = self.0.getsockopt(SOL_SOCKET, dir.buffer_opt())?;
 		return Ok(val as usize);
 	}
 
@@ -150,7 +150,7 @@ impl SctpStream {
 	/// Try to clone the SctpStream. On success, returns a new stream
 	/// wrapping a new socket handler
 	pub fn try_clone(&self) -> Result<SctpStream> {
-		return Ok(SctpStream(try!(self.0.try_clone())));
+		return Ok(SctpStream(self.0.try_clone()?));
 	}
 }
 
@@ -206,10 +206,10 @@ impl SctpEndpoint {
 
 	/// 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(), SOCK_SEQPACKET));
-		try!(sock.bind(raw_addr));
-		try!(sock.listen(-1));
+		let raw_addr = SocketAddr::from_addr(&address)?;
+		let sock = SctpSocket::new(raw_addr.family(), SOCK_SEQPACKET)?;
+		sock.bind(raw_addr)?;
+		sock.listen(-1)?;
 		return Ok(SctpEndpoint(sock));
 	}
 
@@ -219,14 +219,14 @@ impl SctpEndpoint {
 		let mut vec = Vec::with_capacity(addresses.len());
 		let mut family = AF_INET;
 		for address in addresses {
-			let a = try!(SocketAddr::from_addr(address));
+			let a = SocketAddr::from_addr(address)?;
 			if a.family() == AF_INET6 { family = AF_INET6; }
 			vec.push(a);
 		}
 
-		let sock = try!(SctpSocket::new(family, SOCK_SEQPACKET));
-		try!(sock.bindx(&vec, BindOp::AddAddr));
-		try!(sock.listen(-1));
+		let sock = SctpSocket::new(family, SOCK_SEQPACKET)?;
+		sock.bindx(&vec, BindOp::AddAddr)?;
+		sock.listen(-1)?;
 		return Ok(SctpEndpoint(sock));
 	}
 
@@ -261,7 +261,7 @@ impl SctpEndpoint {
 
 	/// 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));
+		let val: libc::c_int = self.0.sctp_opt_info(sctp_sys::SCTP_NODELAY, 0)?;
 		return Ok(val == 1);
 	}
 
@@ -272,8 +272,8 @@ impl SctpEndpoint {
 	}
 
 	/// 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(SOL_SOCKET, dir.buffer_opt()));
+	pub fn get_buffer_size(&self, dir: SoDirection) -> Result<usize> {
+		let val: u32 = self.0.getsockopt(SOL_SOCKET, dir.buffer_opt())?;
 		return Ok(val as usize);
 	}
 
@@ -286,7 +286,7 @@ impl SctpEndpoint {
 
 	/// Try to clone this socket
 	pub fn try_clone(&self) -> Result<SctpEndpoint> {
-		return Ok(SctpEndpoint(try!(self.0.try_clone())));
+		return Ok(SctpEndpoint(self.0.try_clone()?));
 	}
 }
 
@@ -342,10 +342,10 @@ impl SctpListener {
 
 	/// Create a listener bound to a single address
 	pub fn bind<A: ToSocketAddrs>(address: A) -> Result<SctpListener> {
-		let raw_addr = try!(SocketAddr::from_addr(&address));
-		let sock = try!(SctpSocket::new(raw_addr.family(), SOCK_STREAM));
-		try!(sock.bind(raw_addr));
-		try!(sock.listen(-1));
+		let raw_addr = SocketAddr::from_addr(&address)?;
+		let sock = SctpSocket::new(raw_addr.family(), SOCK_STREAM)?;
+		sock.bind(raw_addr)?;
+		sock.listen(-1)?;
 		return Ok(SctpListener(sock));
 	}
 
@@ -355,20 +355,20 @@ impl SctpListener {
 		let mut vec = Vec::with_capacity(addresses.len());
 		let mut family = AF_INET;
 		for address in addresses {
-			let a = try!(SocketAddr::from_addr(address));
+			let a = SocketAddr::from_addr(address)?;
 			if a.family() == AF_INET6 { family = AF_INET6; }
 			vec.push(a);
 		}
 
-		let sock = try!(SctpSocket::new(family, SOCK_STREAM));
-		try!(sock.bindx(&vec, BindOp::AddAddr));
-		try!(sock.listen(-1));
+		let sock = SctpSocket::new(family, SOCK_STREAM)?;
+		sock.bindx(&vec, BindOp::AddAddr)?;
+		sock.listen(-1)?;
 		return Ok(SctpListener(sock));
 	}
 
 	/// Accept a new connection
 	pub fn accept(&self) -> Result<(SctpStream, SocketAddr)> {
-		let (sock, addr) = try!(self.0.accept());
+		let (sock, addr) = self.0.accept()?;
 		return Ok((SctpStream(sock), addr));
 	}
 
@@ -391,7 +391,7 @@ impl SctpListener {
 
 	/// Try to clone this listener
 	pub fn try_clone(&self) -> Result<SctpListener> {
-		return Ok(SctpListener(try!(self.0.try_clone())));
+		return Ok(SctpListener(self.0.try_clone()?));
 	}
 }
 

src/sctpsock.rs

@@ -167,7 +167,7 @@ impl RawSocketAddr for SocketAddr {
 	}
 
 	fn from_addr<A: ToSocketAddrs>(address: A) -> Result<SocketAddr> {
-		return try!(address.to_socket_addrs().or(Err(Error::new(ErrorKind::InvalidInput, "Address is not valid"))))
+		return address.to_socket_addrs().or(Err(Error::new(ErrorKind::InvalidInput, "Address is not valid")))?
 								.next().ok_or(Error::new(ErrorKind::InvalidInput, "Address is not valid"));
 	}
 }
@@ -180,13 +180,13 @@ impl SctpSocket {
 	/// Create a new SCTP socket
 	pub fn new(family: libc::c_int, sock_type: libc::c_int) -> Result<SctpSocket> {
 		unsafe {
-			return Ok(SctpSocket(try!(check_socket(socket(family, sock_type, sctp_sys::IPPROTO_SCTP)))));
+			return Ok(SctpSocket(check_socket(socket(family, sock_type, sctp_sys::IPPROTO_SCTP))?));
 		}
 	}
 
 	/// Connect the socket to `address`
 	pub fn connect<A: ToSocketAddrs>(&self, address: A) -> Result<()> {
-		let raw_addr = try!(SocketAddr::from_addr(&address));
+	  let raw_addr = SocketAddr::from_addr(&address)?;
 		unsafe {
 			return match connect(self.0, raw_addr.as_ptr(), raw_addr.addr_len()) {
 				0 => Ok(()),
@@ -205,7 +205,7 @@ impl SctpSocket {
 			}
 			let mut offset = 0isize;
 			for address in addresses {
-				let raw = try!(SocketAddr::from_addr(address));
+				let raw = 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;
@@ -223,7 +223,7 @@ impl SctpSocket {
 
 	/// Bind the socket to a single address
 	pub fn bind<A: ToSocketAddrs>(&self, address: A) -> Result<()> {
-		let raw_addr = try!(SocketAddr::from_addr(&address));
+		let raw_addr = SocketAddr::from_addr(&address)?;
 		unsafe {
 			return match bind(self.0, raw_addr.as_ptr(), raw_addr.addr_len()) {
 				0 => Ok(()),
@@ -242,7 +242,7 @@ impl SctpSocket {
 			}
 			let mut offset = 0isize;
 			for address in addresses {
-				let raw = try!(SocketAddr::from_addr(address));
+				let raw = 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;
@@ -273,8 +273,8 @@ impl SctpSocket {
 		let mut len: socklen_t = size_of::<sockaddr_in6>() as socklen_t;
 		unsafe {
 			let addr_ptr: *mut sockaddr = transmute(&mut addr);
-			let sock = try!(check_socket(accept(self.0, addr_ptr, &mut len)));
-			let addr = try!(SocketAddr::from_raw_ptr(addr_ptr, len));
+			let sock = check_socket(accept(self.0, addr_ptr, &mut len))?;
+			let addr = SocketAddr::from_raw_ptr(addr_ptr, len)?;
 			return Ok((SctpSocket(sock), addr));
 		}
 	}
@@ -298,7 +298,7 @@ impl SctpSocket {
 						return Err(Error::new(ErrorKind::Other, format!("Unsupported address family : {}", f)));
 					}
 				} as socklen_t;
-				vec.push(try!(SocketAddr::from_raw_ptr(sockaddr, len)));
+				vec.push(SocketAddr::from_raw_ptr(sockaddr, len)?);
 				offset += len as isize;
 			}
 			what.free(addrs as *mut sockaddr);
@@ -350,7 +350,7 @@ impl SctpSocket {
 			let addr_ptr: *mut sockaddr = transmute(&mut addr);
 			let mut info: sctp_sys::sctp_sndrcvinfo = std::mem::zeroed();
 			return match sctp_sys::sctp_recvmsg(self.0, msg.as_mut_ptr() as *mut libc::c_void, len, addr_ptr, &mut addr_len, &mut info, &mut flags) {
-				res if res > 0 => Ok((res as usize, info.sinfo_stream, try!(SocketAddr::from_raw_ptr(addr_ptr, addr_len)))),
+				res if res > 0 => Ok((res as usize, info.sinfo_stream, SocketAddr::from_raw_ptr(addr_ptr, addr_len)?)),
 				_ => Err(Error::last_os_error())
 			};
 		}
@@ -362,7 +362,7 @@ impl SctpSocket {
 		let len = msg.len() as libc::size_t;
 		let (raw_addr, addr_len) = match address {
 			Some(a) => {
-				let mut addr = try!(SocketAddr::from_addr(a));
+				let mut addr = SocketAddr::from_addr(a)?;
 				(addr.as_mut_ptr(), addr.addr_len())
 			},
 			None => (std::ptr::null_mut(), 0)
@@ -426,7 +426,7 @@ impl SctpSocket {
 	/// Try to clone this socket
 	pub fn try_clone(&self) -> Result<SctpSocket> {
 		unsafe {
-			let new_sock = try!(check_socket(libc::dup(self.0 as i32) as SOCKET));
+			let new_sock = check_socket(libc::dup(self.0 as i32) as SOCKET)?;
 			return Ok(SctpSocket(new_sock));
 		}
 	}