Fix windows

Also back out keepalive support for TCP since the API is perhaps not
actually what we want. You can't read the interval on Windows, and
we should probably separate the functionality of turning keepalive on
and overriding the interval.

2 files changed, 43 insertions, 76 deletions

diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs
index cc420763fd7..472ffdf9e1d 100644
--- a/src/libstd/sys/windows/c.rs
+++ b/src/libstd/sys/windows/c.rs
@@ -13,7 +13,7 @@
 #![allow(bad_style)]
 #![cfg_attr(test, allow(dead_code))]
 
-use os::raw::{c_int, c_uint, c_ulong, c_long, c_longlong, c_ushort};
+use os::raw::{c_int, c_uint, c_ulong, c_long, c_longlong, c_ushort,};
 use os::raw::{c_char, c_ulonglong};
 use libc::{wchar_t, size_t, c_void};
 use ptr;
@@ -78,13 +78,6 @@ pub type SOCKET = ::os::windows::raw::SOCKET;
 pub type socklen_t = c_int;
 pub type ADDRESS_FAMILY = USHORT;
 
-pub type LPWSAOVERLAPPED_COMPLETION_ROUTINE =
-    Option<unsafe extern "system" fn(dwError: DWORD,
-                                     cbTransferred: DWORD,
-                                     lpOverlapped: LPWSAOVERLAPPED,
-                                     dwFlags: DWORD)>;
-pub type LPWSAOVERLAPPED = *mut OVERLAPPED;
-
 pub const TRUE: BOOL = 1;
 pub const FALSE: BOOL = 0;
 
@@ -121,7 +114,6 @@ pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000;
 pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000;
 pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000;
 
-pub const SIO_KEEPALIVE_VALS: DWORD = 0x98000004;
 pub const FIONBIO: c_ulong = 0x8004667e;
 
 #[repr(C)]
@@ -233,6 +225,33 @@ pub const SOL_SOCKET: c_int = 0xffff;
 pub const SO_RCVTIMEO: c_int = 0x1006;
 pub const SO_SNDTIMEO: c_int = 0x1005;
 pub const SO_REUSEADDR: c_int = 0x0004;
+pub const IPPROTO_IP: c_int = 0;
+pub const IPPROTO_TCP: c_int = 6;
+pub const IPPROTO_IPV6: c_int = 41;
+pub const TCP_NODELAY: c_int = 0x0001;
+pub const IP_TTL: c_int = 4;
+pub const IPV6_V6ONLY: c_int = 27;
+pub const SO_ERROR: c_int = 0x1007;
+pub const SO_BROADCAST: c_int = 0x0020;
+pub const IP_MULTICAST_LOOP: c_int = 11;
+pub const IPV6_MULTICAST_LOOP: c_int = 11;
+pub const IP_MULTICAST_TTL: c_int = 10;
+pub const IP_ADD_MEMBERSHIP: c_int = 12;
+pub const IP_DROP_MEMBERSHIP: c_int = 13;
+pub const IPV6_ADD_MEMBERSHIP: c_int = 12;
+pub const IPV6_DROP_MEMBERSHIP: c_int = 13;
+
+#[repr(C)]
+pub struct ip_mreq {
+    pub imr_multiaddr: in_addr,
+    pub imr_interface: in_addr,
+}
+
+#[repr(C)]
+pub struct ipv6_mreq {
+    pub ipv6mr_multiaddr: in6_addr,
+    pub ipv6mr_interface: c_uint,
+}
 
 pub const VOLUME_NAME_DOS: DWORD = 0x0;
 pub const MOVEFILE_REPLACE_EXISTING: DWORD = 1;
@@ -785,13 +804,6 @@ pub struct in6_addr {
     pub s6_addr: [u8; 16],
 }
 
-#[repr(C)]
-pub struct tcp_keepalive {
-    pub onoff: c_ulong,
-    pub keepalivetime: c_ulong,
-    pub keepaliveinterval: c_ulong,
-}
-
 #[cfg(all(target_arch = "x86_64", target_env = "gnu"))]
 pub enum UNWIND_HISTORY_TABLE {}
 
@@ -850,17 +862,7 @@ extern "system" {
                       lpProtocolInfo: LPWSAPROTOCOL_INFO,
                       g: GROUP,
                       dwFlags: DWORD) -> SOCKET;
-    pub fn WSAIoctl(s: SOCKET,
-                    dwIoControlCode: DWORD,
-                    lpvInBuffer: LPVOID,
-                    cbInBuffer: DWORD,
-                    lpvOutBuffer: LPVOID,
-                    cbOutBuffer: DWORD,
-                    lpcbBytesReturned: LPDWORD,
-                    lpOverlapped: LPWSAOVERLAPPED,
-                    lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE)
-                    -> c_int;
-    pub fn ioctlsocket(s: SOCKET, cmd: c_long, argp: *mut u_long) -> c_int;
+    pub fn ioctlsocket(s: SOCKET, cmd: c_long, argp: *mut c_ulong) -> c_int;
     pub fn InitializeCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
     pub fn EnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
     pub fn TryEnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION) -> BOOLEAN;
diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs
index be13657aaf4..dfa44a651e6 100644
--- a/src/libstd/sys/windows/net.rs
+++ b/src/libstd/sys/windows/net.rs
@@ -10,7 +10,7 @@
 
 use cmp;
 use io;
-use libc::{c_int, c_void};
+use libc::{c_int, c_void, c_ulong};
 use mem;
 use net::{SocketAddr, Shutdown};
 use num::One;
@@ -186,58 +186,23 @@ impl Socket {
         Ok(())
     }
 
-    pub fn set_keepalive(&self, keepalive: Option<Duration>) -> io::Result<()> {
-        let ms = keepalive.map(sys::dur2timeout).unwrap_or(c::INFINITE);
-        let ka = c::tcp_keepalive {
-            onoff: keepalive.is_some() as c::c_ulong,
-            keepalivetime: ms as c::c_ulong,
-            keepaliveinterval: ms as c::c_ulong,
-        };
-        sys::cvt(unsafe {
-            c::WSAIoctl(self.0,
-                        c::SIO_KEEPALIVE_VALS,
-                        &ka as *const _ as *mut _,
-                        mem::size_of_val(&ka) as c::DWORD,
-                        0 as *mut _,
-                        0,
-                        0 as *mut _,
-                        0 as *mut _,
-                        None)
-        }).map(|_| ())
-    }
-
-    pub fn keepalive(&self) -> io::Result<Option<Duration>> {
-        let mut ka = c::tcp_keepalive {
-            onoff: 0,
-            keepalivetime: 0,
-            keepaliveinterval: 0,
-        };
-        try!(sys::cvt(unsafe {
-            WSAIoctl(self.0,
-                     c::SIO_KEEPALIVE_VALS,
-                     0 as *mut _,
-                     0,
-                     &mut ka as *mut _ as *mut _,
-                     mem::size_of_val(&ka) as c::DWORD,
-                     0 as *mut _,
-                     0 as *mut _,
-                     None)
-        }));
-
-        if ka.onoff == 0 {
-            Ok(None)
+    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+        let mut nonblocking = nonblocking as c_ulong;
+        let r = unsafe { c::ioctlsocket(self.0, c::FIONBIO as c_int, &mut nonblocking) };
+        if r == 0 {
+            Ok(())
         } else {
-            let secs = ka.keepaliveinterval / 1000;
-            let nsec = (ka.keepaliveinterval % 1000) * 1000000;
-            Ok(Some(Duration::new(secs as u64, nsec as u32)))
+            Err(io::Error::last_os_error())
         }
     }
 
-    pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
-        let mut nonblocking = nonblocking as c::c_ulong;
-        sys::cvt(unsafe {
-            c::ioctlsocket(self.0, c::FIONBIO as c::c_int, &mut nonblocking)
-        }).map(|_| ())
+    pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
+        net::setsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY, nodelay as c::BYTE)
+    }
+
+    pub fn nodelay(&self) -> io::Result<bool> {
+        let raw: c::BYTE = try!(net::getsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY));
+        Ok(raw != 0)
     }
 }