1 files changed, 45 insertions, 27 deletions

diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs
index 998b4fcb1a1..3e69902dcb6 100644
--- a/src/libstd/sys/windows/net.rs
+++ b/src/libstd/sys/windows/net.rs
@@ -9,23 +9,30 @@
 // except according to those terms.
 
 use io;
-use libc::consts::os::extra::INVALID_SOCKET;
-use libc::{self, c_int, c_void};
+use libc::{c_int, c_void};
 use mem;
-use net::SocketAddr;
+use net::{SocketAddr, Shutdown};
 use num::One;
 use ops::Neg;
 use ptr;
 use sync::Once;
-use sys;
 use sys::c;
+use sys;
 use sys_common::{self, AsInner, FromInner, IntoInner};
-use sys_common::net::{setsockopt, getsockopt};
+use sys_common::net;
 use time::Duration;
 
 pub type wrlen_t = i32;
 
-pub struct Socket(libc::SOCKET);
+pub mod netc {
+    pub use sys::c::*;
+    pub use sys::c::SOCKADDR as sockaddr;
+    pub use sys::c::SOCKADDR_STORAGE_LH as sockaddr_storage;
+    pub use sys::c::ADDRINFOA as addrinfo;
+    pub use sys::c::ADDRESS_FAMILY as sa_family_t;
+}
+
+pub struct Socket(c::SOCKET);
 
 /// Checks whether the Windows socket interface has been started already, and
 /// if not, starts it.
@@ -76,13 +83,13 @@ pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
 impl Socket {
     pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
         let fam = match *addr {
-            SocketAddr::V4(..) => libc::AF_INET,
-            SocketAddr::V6(..) => libc::AF_INET6,
+            SocketAddr::V4(..) => c::AF_INET,
+            SocketAddr::V6(..) => c::AF_INET6,
         };
         let socket = try!(unsafe {
             match c::WSASocketW(fam, ty, 0, ptr::null_mut(), 0,
                                 c::WSA_FLAG_OVERLAPPED) {
-                INVALID_SOCKET => Err(last_error()),
+                c::INVALID_SOCKET => Err(last_error()),
                 n => Ok(Socket(n)),
             }
         });
@@ -90,11 +97,11 @@ impl Socket {
         Ok(socket)
     }
 
-    pub fn accept(&self, storage: *mut libc::sockaddr,
-                  len: *mut libc::socklen_t) -> io::Result<Socket> {
+    pub fn accept(&self, storage: *mut c::SOCKADDR,
+                  len: *mut c_int) -> io::Result<Socket> {
         let socket = try!(unsafe {
-            match libc::accept(self.0, storage, len) {
-                INVALID_SOCKET => Err(last_error()),
+            match c::accept(self.0, storage, len) {
+                c::INVALID_SOCKET => Err(last_error()),
                 n => Ok(Socket(n)),
             }
         });
@@ -113,7 +120,7 @@ impl Socket {
                                 info.iProtocol,
                                 &mut info, 0,
                                 c::WSA_FLAG_OVERLAPPED) {
-                INVALID_SOCKET => Err(last_error()),
+                c::INVALID_SOCKET => Err(last_error()),
                 n => Ok(Socket(n)),
             }
         });
@@ -125,7 +132,7 @@ impl Socket {
         // On unix when a socket is shut down all further reads return 0, so we
         // do the same on windows to map a shut down socket to returning EOF.
         unsafe {
-            match libc::recv(self.0, buf.as_mut_ptr() as *mut c_void,
+            match c::recv(self.0, buf.as_mut_ptr() as *mut c_void,
                              buf.len() as i32, 0) {
                 -1 if c::WSAGetLastError() == c::WSAESHUTDOWN => Ok(0),
                 -1 => Err(last_error()),
@@ -134,7 +141,8 @@ impl Socket {
         }
     }
 
-    pub fn set_timeout(&self, dur: Option<Duration>, kind: libc::c_int) -> io::Result<()> {
+    pub fn set_timeout(&self, dur: Option<Duration>,
+                       kind: c_int) -> io::Result<()> {
         let timeout = match dur {
             Some(dur) => {
                 let timeout = sys::dur2timeout(dur);
@@ -146,11 +154,11 @@ impl Socket {
             }
             None => 0
         };
-        setsockopt(self, libc::SOL_SOCKET, kind, timeout)
+        net::setsockopt(self, c::SOL_SOCKET, kind, timeout)
     }
 
-    pub fn timeout(&self, kind: libc::c_int) -> io::Result<Option<Duration>> {
-        let raw: libc::DWORD = try!(getsockopt(self, libc::SOL_SOCKET, kind));
+    pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> {
+        let raw: c::DWORD = try!(net::getsockopt(self, c::SOL_SOCKET, kind));
         if raw == 0 {
             Ok(None)
         } else {
@@ -162,28 +170,38 @@ impl Socket {
 
     fn set_no_inherit(&self) -> io::Result<()> {
         sys::cvt(unsafe {
-            c::SetHandleInformation(self.0 as libc::HANDLE,
+            c::SetHandleInformation(self.0 as c::HANDLE,
                                     c::HANDLE_FLAG_INHERIT, 0)
         }).map(|_| ())
     }
+
+    pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
+        let how = match how {
+            Shutdown::Write => c::SD_SEND,
+            Shutdown::Read => c::SD_RECEIVE,
+            Shutdown::Both => c::SD_BOTH,
+        };
+        try!(cvt(unsafe { c::shutdown(self.0, how) }));
+        Ok(())
+    }
 }
 
 impl Drop for Socket {
     fn drop(&mut self) {
-        let _ = unsafe { libc::closesocket(self.0) };
+        let _ = unsafe { c::closesocket(self.0) };
     }
 }
 
-impl AsInner<libc::SOCKET> for Socket {
-    fn as_inner(&self) -> &libc::SOCKET { &self.0 }
+impl AsInner<c::SOCKET> for Socket {
+    fn as_inner(&self) -> &c::SOCKET { &self.0 }
 }
 
-impl FromInner<libc::SOCKET> for Socket {
-    fn from_inner(sock: libc::SOCKET) -> Socket { Socket(sock) }
+impl FromInner<c::SOCKET> for Socket {
+    fn from_inner(sock: c::SOCKET) -> Socket { Socket(sock) }
 }
 
-impl IntoInner<libc::SOCKET> for Socket {
-    fn into_inner(self) -> libc::SOCKET {
+impl IntoInner<c::SOCKET> for Socket {
+    fn into_inner(self) -> c::SOCKET {
         let ret = self.0;
         mem::forget(self);
         ret