413 lines
14 KiB
Rust
413 lines
14 KiB
Rust
|
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
||
|
|
// file at the top-level directory of this distribution and at
|
||
|
|
// http://rust-lang.org/COPYRIGHT.
|
||
|
|
//
|
||
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||
|
|
// option. This file may not be copied, modified, or distributed
|
||
|
|
// except according to those terms.
|
||
|
|
|
||
|
|
use std::cast;
|
||
|
|
use std::io::net::ip;
|
||
|
|
use std::io;
|
||
|
|
use std::libc;
|
||
|
|
use std::mem;
|
||
|
|
use std::rt::rtio;
|
||
|
|
use std::unstable::intrinsics;
|
||
|
|
|
||
|
|
use super::IoResult;
|
||
|
|
use super::file::keep_going;
|
||
|
|
|
||
|
|
#[cfg(windows)] pub type sock_t = libc::SOCKET;
|
||
|
|
#[cfg(unix)] pub type sock_t = super::file::fd_t;
|
||
|
|
|
||
|
|
pub struct TcpStream {
|
||
|
|
priv fd: sock_t,
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(target_endian = "big")] pub fn htons(x: u16) -> u16 { x }
|
||
|
|
#[cfg(target_endian = "big")] pub fn ntohs(x: u16) -> u16 { x }
|
||
|
|
#[cfg(target_endian = "little")]
|
||
|
|
pub fn htons(u: u16) -> u16 {
|
||
|
|
unsafe { intrinsics::bswap16(u as i16) as u16 }
|
||
|
|
}
|
||
|
|
#[cfg(target_endian = "little")]
|
||
|
|
pub fn ntohs(u: u16) -> u16 {
|
||
|
|
unsafe { intrinsics::bswap16(u as i16) as u16 }
|
||
|
|
}
|
||
|
|
|
||
|
|
fn addr_to_sockaddr(addr: ip::SocketAddr) -> (libc::sockaddr_storage, uint) {
|
||
|
|
unsafe {
|
||
|
|
let storage: libc::sockaddr_storage = intrinsics::init();
|
||
|
|
let len = match addr.ip {
|
||
|
|
ip::Ipv4Addr(a, b, c, d) => {
|
||
|
|
let storage: *mut libc::sockaddr_in = cast::transmute(&storage);
|
||
|
|
(*storage).sin_family = libc::AF_INET as libc::sa_family_t;
|
||
|
|
(*storage).sin_port = htons(addr.port);
|
||
|
|
(*storage).sin_addr.s_addr = (d as u32 << 24) |
|
||
|
|
(c as u32 << 16) |
|
||
|
|
(b as u32 << 8) |
|
||
|
|
(a as u32 << 0);
|
||
|
|
mem::size_of::<libc::sockaddr_in>()
|
||
|
|
}
|
||
|
|
ip::Ipv6Addr(a, b, c, d, e, f, g, h) => {
|
||
|
|
let storage: *mut libc::sockaddr_in6 = cast::transmute(&storage);
|
||
|
|
(*storage).sin6_family = libc::AF_INET6 as libc::sa_family_t;
|
||
|
|
(*storage).sin6_port = htons(addr.port);
|
||
|
|
(*storage).sin6_addr.s6_addr[0] = htons(a);
|
||
|
|
(*storage).sin6_addr.s6_addr[1] = htons(b);
|
||
|
|
(*storage).sin6_addr.s6_addr[2] = htons(c);
|
||
|
|
(*storage).sin6_addr.s6_addr[3] = htons(d);
|
||
|
|
(*storage).sin6_addr.s6_addr[4] = htons(e);
|
||
|
|
(*storage).sin6_addr.s6_addr[5] = htons(f);
|
||
|
|
(*storage).sin6_addr.s6_addr[6] = htons(g);
|
||
|
|
(*storage).sin6_addr.s6_addr[7] = htons(h);
|
||
|
|
mem::size_of::<libc::sockaddr_in6>()
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return (storage, len);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn socket(addr: ip::SocketAddr) -> IoResult<sock_t> {
|
||
|
|
unsafe {
|
||
|
|
let fam = match addr.ip {
|
||
|
|
ip::Ipv4Addr(..) => libc::AF_INET,
|
||
|
|
ip::Ipv6Addr(..) => libc::AF_INET6,
|
||
|
|
};
|
||
|
|
match libc::socket(fam, libc::SOCK_STREAM, 0) {
|
||
|
|
-1 => Err(super::last_error()),
|
||
|
|
fd => Ok(fd),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn sockname(fd: sock_t,
|
||
|
|
f: extern "system" unsafe fn(sock_t, *mut libc::sockaddr,
|
||
|
|
*mut libc::socklen_t) -> libc::c_int)
|
||
|
|
-> IoResult<ip::SocketAddr>
|
||
|
|
{
|
||
|
|
let mut storage: libc::sockaddr_storage = unsafe { intrinsics::init() };
|
||
|
|
let mut len = mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
|
||
|
|
unsafe {
|
||
|
|
let storage = &mut storage as *mut libc::sockaddr_storage;
|
||
|
|
let ret = f(fd,
|
||
|
|
storage as *mut libc::sockaddr,
|
||
|
|
&mut len as *mut libc::socklen_t);
|
||
|
|
if ret != 0 {
|
||
|
|
return Err(super::last_error())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
match storage.ss_family as libc::c_int {
|
||
|
|
libc::AF_INET => {
|
||
|
|
assert!(len as uint >= mem::size_of::<libc::sockaddr_in>());
|
||
|
|
let storage: &mut libc::sockaddr_in = unsafe {
|
||
|
|
cast::transmute(&mut storage)
|
||
|
|
};
|
||
|
|
let addr = storage.sin_addr.s_addr as u32;
|
||
|
|
let a = (addr >> 0) as u8;
|
||
|
|
let b = (addr >> 8) as u8;
|
||
|
|
let c = (addr >> 16) as u8;
|
||
|
|
let d = (addr >> 24) as u8;
|
||
|
|
Ok(ip::SocketAddr {
|
||
|
|
ip: ip::Ipv4Addr(a, b, c, d),
|
||
|
|
port: ntohs(storage.sin_port),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
libc::AF_INET6 => {
|
||
|
|
assert!(len as uint >= mem::size_of::<libc::sockaddr_in6>());
|
||
|
|
let storage: &mut libc::sockaddr_in6 = unsafe {
|
||
|
|
cast::transmute(&mut storage)
|
||
|
|
};
|
||
|
|
let a = ntohs(storage.sin6_addr.s6_addr[0]);
|
||
|
|
let b = ntohs(storage.sin6_addr.s6_addr[1]);
|
||
|
|
let c = ntohs(storage.sin6_addr.s6_addr[2]);
|
||
|
|
let d = ntohs(storage.sin6_addr.s6_addr[3]);
|
||
|
|
let e = ntohs(storage.sin6_addr.s6_addr[4]);
|
||
|
|
let f = ntohs(storage.sin6_addr.s6_addr[5]);
|
||
|
|
let g = ntohs(storage.sin6_addr.s6_addr[6]);
|
||
|
|
let h = ntohs(storage.sin6_addr.s6_addr[7]);
|
||
|
|
Ok(ip::SocketAddr {
|
||
|
|
ip: ip::Ipv6Addr(a, b, c, d, e, f, g, h),
|
||
|
|
port: ntohs(storage.sin6_port),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
_ => {
|
||
|
|
Err(io::standard_error(io::OtherIoError))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(unix)]
|
||
|
|
pub fn init() {}
|
||
|
|
|
||
|
|
#[cfg(windows)]
|
||
|
|
pub fn init() {
|
||
|
|
static WSADESCRIPTION_LEN: uint = 256;
|
||
|
|
static WSASYS_STATUS_LEN: uint = 128;
|
||
|
|
struct WSADATA {
|
||
|
|
wVersion: libc::WORD,
|
||
|
|
wHighVersion: libc::WORD,
|
||
|
|
szDescription: [u8, ..WSADESCRIPTION_LEN + 1],
|
||
|
|
szSystemStatus: [u8, ..WSASYS_STATUS_LEN + 1],
|
||
|
|
iMaxSockets: u16,
|
||
|
|
iMaxUdpDg: u16,
|
||
|
|
lpVendorInfo: *u8,
|
||
|
|
}
|
||
|
|
type LPWSADATA = *mut WSADATA;
|
||
|
|
|
||
|
|
#[link(name = "ws2_32")]
|
||
|
|
extern "system" {
|
||
|
|
fn WSAStartup(wVersionRequested: libc::WORD,
|
||
|
|
lpWSAData: LPWSADATA) -> libc::c_int;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsafe {
|
||
|
|
use std::unstable::mutex::{Mutex, MUTEX_INIT};
|
||
|
|
static mut LOCK: Mutex = MUTEX_INIT;
|
||
|
|
static mut INITIALIZED: bool = false;
|
||
|
|
if INITIALIZED { return }
|
||
|
|
LOCK.lock();
|
||
|
|
if !INITIALIZED {
|
||
|
|
let mut data: WSADATA = intrinsics::init();
|
||
|
|
let ret = WSAStartup(0x202, // version 2.2
|
||
|
|
&mut data);
|
||
|
|
assert_eq!(ret, 0);
|
||
|
|
INITIALIZED = true;
|
||
|
|
}
|
||
|
|
LOCK.unlock();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl TcpStream {
|
||
|
|
pub fn connect(addr: ip::SocketAddr) -> IoResult<TcpStream> {
|
||
|
|
unsafe {
|
||
|
|
socket(addr).and_then(|fd| {
|
||
|
|
let (addr, len) = addr_to_sockaddr(addr);
|
||
|
|
let addrp = &addr as *libc::sockaddr_storage;
|
||
|
|
let ret = TcpStream { fd: fd };
|
||
|
|
match libc::connect(fd, addrp as *libc::sockaddr,
|
||
|
|
len as libc::socklen_t) {
|
||
|
|
-1 => Err(super::last_error()),
|
||
|
|
_ => Ok(ret),
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn fd(&self) -> sock_t { self.fd }
|
||
|
|
|
||
|
|
fn set_nodelay(&mut self, nodelay: bool) -> IoResult<()> {
|
||
|
|
unsafe {
|
||
|
|
let on = nodelay as libc::c_int;
|
||
|
|
let on = &on as *libc::c_int;
|
||
|
|
super::mkerr_libc(libc::setsockopt(self.fd,
|
||
|
|
libc::IPPROTO_TCP,
|
||
|
|
libc::TCP_NODELAY,
|
||
|
|
on as *libc::c_void,
|
||
|
|
mem::size_of::<libc::c_void>()
|
||
|
|
as libc::socklen_t))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn set_keepalive(&mut self, seconds: Option<uint>) -> IoResult<()> {
|
||
|
|
unsafe {
|
||
|
|
let on = seconds.is_some() as libc::c_int;
|
||
|
|
let on = &on as *libc::c_int;
|
||
|
|
let ret = libc::setsockopt(self.fd,
|
||
|
|
libc::SOL_SOCKET,
|
||
|
|
libc::SO_KEEPALIVE,
|
||
|
|
on as *libc::c_void,
|
||
|
|
mem::size_of::<libc::c_void>()
|
||
|
|
as libc::socklen_t);
|
||
|
|
if ret != 0 { return Err(super::last_error()) }
|
||
|
|
|
||
|
|
match seconds {
|
||
|
|
Some(n) => self.set_tcp_keepalive(n),
|
||
|
|
None => Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(target_os = "macos")]
|
||
|
|
unsafe fn set_tcp_keepalive(&mut self, seconds: uint) -> IoResult<()> {
|
||
|
|
let delay = seconds as libc::c_uint;
|
||
|
|
let delay = &delay as *libc::c_uint;
|
||
|
|
let ret = libc::setsockopt(self.fd,
|
||
|
|
libc::IPPROTO_TCP,
|
||
|
|
libc::TCP_KEEPALIVE,
|
||
|
|
delay as *libc::c_void,
|
||
|
|
mem::size_of::<libc::c_uint>()
|
||
|
|
as libc::socklen_t);
|
||
|
|
super::mkerr_libc(ret)
|
||
|
|
}
|
||
|
|
#[cfg(target_os = "freebsd")]
|
||
|
|
unsafe fn set_tcp_keepalive(&mut self, seconds: uint) -> IoResult<()> {
|
||
|
|
let delay = seconds as libc::c_uint;
|
||
|
|
let delay = &delay as *libc::c_uint;
|
||
|
|
let ret = libc::setsockopt(self.fd,
|
||
|
|
libc::IPPROTO_TCP,
|
||
|
|
libc::TCP_KEEPIDLE,
|
||
|
|
delay as *libc::c_void,
|
||
|
|
mem::size_of::<libc::c_uint>()
|
||
|
|
as libc::socklen_t);
|
||
|
|
super::mkerr_libc(ret)
|
||
|
|
}
|
||
|
|
#[cfg(not(target_os = "macos"), not(target_os = "freebsd"))]
|
||
|
|
unsafe fn set_tcp_keepalive(&mut self, _seconds: uint) -> IoResult<()> {
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(windows)] type wrlen = libc::c_int;
|
||
|
|
#[cfg(not(windows))] type wrlen = libc::size_t;
|
||
|
|
|
||
|
|
impl rtio::RtioTcpStream for TcpStream {
|
||
|
|
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
|
||
|
|
let ret = keep_going(buf, |buf, len| {
|
||
|
|
unsafe {
|
||
|
|
libc::recv(self.fd,
|
||
|
|
buf as *mut libc::c_void,
|
||
|
|
len as wrlen,
|
||
|
|
0) as i64
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if ret == 0 {
|
||
|
|
Err(io::standard_error(io::EndOfFile))
|
||
|
|
} else if ret < 0 {
|
||
|
|
Err(super::last_error())
|
||
|
|
} else {
|
||
|
|
Ok(ret as uint)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
|
||
|
|
let ret = keep_going(buf, |buf, len| {
|
||
|
|
unsafe {
|
||
|
|
libc::send(self.fd,
|
||
|
|
buf as *mut libc::c_void,
|
||
|
|
len as wrlen,
|
||
|
|
0) as i64
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if ret < 0 {
|
||
|
|
Err(super::last_error())
|
||
|
|
} else {
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fn peer_name(&mut self) -> IoResult<ip::SocketAddr> {
|
||
|
|
sockname(self.fd, libc::getpeername)
|
||
|
|
}
|
||
|
|
fn control_congestion(&mut self) -> IoResult<()> {
|
||
|
|
self.set_nodelay(false)
|
||
|
|
}
|
||
|
|
fn nodelay(&mut self) -> IoResult<()> {
|
||
|
|
self.set_nodelay(true)
|
||
|
|
}
|
||
|
|
fn keepalive(&mut self, delay_in_seconds: uint) -> IoResult<()> {
|
||
|
|
self.set_keepalive(Some(delay_in_seconds))
|
||
|
|
}
|
||
|
|
fn letdie(&mut self) -> IoResult<()> {
|
||
|
|
self.set_keepalive(None)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl rtio::RtioSocket for TcpStream {
|
||
|
|
fn socket_name(&mut self) -> IoResult<ip::SocketAddr> {
|
||
|
|
sockname(self.fd, libc::getsockname)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl Drop for TcpStream {
|
||
|
|
#[cfg(unix)]
|
||
|
|
fn drop(&mut self) {
|
||
|
|
unsafe { libc::close(self.fd); }
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(windows)]
|
||
|
|
fn drop(&mut self) {
|
||
|
|
unsafe { libc::closesocket(self.fd); }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub struct TcpListener {
|
||
|
|
priv fd: sock_t,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl TcpListener {
|
||
|
|
pub fn bind(addr: ip::SocketAddr) -> IoResult<TcpListener> {
|
||
|
|
unsafe {
|
||
|
|
socket(addr).and_then(|fd| {
|
||
|
|
let (addr, len) = addr_to_sockaddr(addr);
|
||
|
|
let addrp = &addr as *libc::sockaddr_storage;
|
||
|
|
let ret = TcpListener { fd: fd };
|
||
|
|
match libc::bind(fd, addrp as *libc::sockaddr,
|
||
|
|
len as libc::socklen_t) {
|
||
|
|
-1 => Err(super::last_error()),
|
||
|
|
_ => Ok(ret),
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn fd(&self) -> sock_t { self.fd }
|
||
|
|
|
||
|
|
pub fn native_listen(self, backlog: int) -> IoResult<TcpAcceptor> {
|
||
|
|
match unsafe { libc::listen(self.fd, backlog as libc::c_int) } {
|
||
|
|
-1 => Err(super::last_error()),
|
||
|
|
_ => Ok(TcpAcceptor { fd: self.fd })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl rtio::RtioTcpListener for TcpListener {
|
||
|
|
fn listen(~self) -> IoResult<~rtio::RtioTcpAcceptor> {
|
||
|
|
self.native_listen(128).map(|a| ~a as ~rtio::RtioTcpAcceptor)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl rtio::RtioSocket for TcpListener {
|
||
|
|
fn socket_name(&mut self) -> IoResult<ip::SocketAddr> {
|
||
|
|
sockname(self.fd, libc::getsockname)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub struct TcpAcceptor {
|
||
|
|
priv fd: sock_t,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl TcpAcceptor {
|
||
|
|
pub fn fd(&self) -> sock_t { self.fd }
|
||
|
|
|
||
|
|
pub fn native_accept(&mut self) -> IoResult<TcpStream> {
|
||
|
|
unsafe {
|
||
|
|
let mut storage: libc::sockaddr_storage = intrinsics::init();
|
||
|
|
let storagep = &mut storage as *mut libc::sockaddr_storage;
|
||
|
|
let size = mem::size_of::<libc::sockaddr_storage>();
|
||
|
|
let mut size = size as libc::socklen_t;
|
||
|
|
match libc::accept(self.fd,
|
||
|
|
storagep as *mut libc::sockaddr,
|
||
|
|
&mut size as *mut libc::socklen_t) {
|
||
|
|
-1 => Err(super::last_error()),
|
||
|
|
fd => Ok(TcpStream { fd: fd })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl rtio::RtioSocket for TcpAcceptor {
|
||
|
|
fn socket_name(&mut self) -> IoResult<ip::SocketAddr> {
|
||
|
|
sockname(self.fd, libc::getsockname)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl rtio::RtioTcpAcceptor for TcpAcceptor {
|
||
|
|
fn accept(&mut self) -> IoResult<~rtio::RtioTcpStream> {
|
||
|
|
self.native_accept().map(|s| ~s as ~rtio::RtioTcpStream)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn accept_simultaneously(&mut self) -> IoResult<()> { Ok(()) }
|
||
|
|
fn dont_accept_simultaneously(&mut self) -> IoResult<()> { Ok(()) }
|
||
|
|
}
|