1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 use std::cmp;
12 use std::fmt;
13 use std::io::{Read, Write};
14 use std::io;
15 use std::mem;
16 use std::net::Shutdown;
17 use std::net::{self, Ipv4Addr, Ipv6Addr};
18 use std::os::windows::prelude::*;
19 use std::ptr;
20 use std::sync::{Once, ONCE_INIT};
21 use std::time::Duration;
22
23 use kernel32;
24 use winapi::*;
25 use ws2_32;
26
27 use SockAddr;
28
29 const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
30 const MSG_PEEK: c_int = 0x2;
31 const SD_BOTH: c_int = 2;
32 const SD_RECEIVE: c_int = 0;
33 const SD_SEND: c_int = 1;
34 const SIO_KEEPALIVE_VALS: DWORD = 0x98000004;
35 const WSA_FLAG_OVERLAPPED: DWORD = 0x01;
36
37 pub const IPPROTO_ICMP: i32 = ws2def::IPPROTO_ICMP.0 as i32;
38 pub const IPPROTO_ICMPV6: i32 = ws2def::IPPROTO_ICMPV6.0 as i32;
39 pub const IPPROTO_TCP: i32 = ws2def::IPPROTO_TCP.0 as i32;
40 pub const IPPROTO_UDP: i32 = ws2def::IPPROTO_UDP.0 as i32;
41
42 #[repr(C)]
43 struct tcp_keepalive {
44 onoff: c_ulong,
45 keepalivetime: c_ulong,
46 keepaliveinterval: c_ulong,
47 }
48
init()49 fn init() {
50 static INIT: Once = ONCE_INIT;
51
52 INIT.call_once(|| {
53 // Initialize winsock through the standard library by just creating a
54 // dummy socket. Whether this is successful or not we drop the result as
55 // libstd will be sure to have initialized winsock.
56 let _ = net::UdpSocket::bind("127.0.0.1:34254");
57 });
58 }
59
last_error() -> io::Error60 fn last_error() -> io::Error {
61 io::Error::from_raw_os_error(unsafe { ws2_32::WSAGetLastError() })
62 }
63
64 pub struct Socket {
65 socket: SOCKET,
66 }
67
68 impl Socket {
new(family: c_int, ty: c_int, protocol: c_int) -> io::Result<Socket>69 pub fn new(family: c_int, ty: c_int, protocol: c_int) -> io::Result<Socket> {
70 init();
71 unsafe {
72 let socket = match ws2_32::WSASocketW(family,
73 ty,
74 protocol,
75 ptr::null_mut(),
76 0,
77 WSA_FLAG_OVERLAPPED) {
78 INVALID_SOCKET => return Err(last_error()),
79 socket => socket,
80 };
81 let socket = Socket::from_raw_socket(socket);
82 socket.set_no_inherit()?;
83 Ok(socket)
84 }
85 }
86
bind(&self, addr: &SockAddr) -> io::Result<()>87 pub fn bind(&self, addr: &SockAddr) -> io::Result<()> {
88 unsafe {
89 if ws2_32::bind(self.socket, addr.as_ptr(), addr.len()) == 0 {
90 Ok(())
91 } else {
92 Err(last_error())
93 }
94 }
95 }
96
listen(&self, backlog: i32) -> io::Result<()>97 pub fn listen(&self, backlog: i32) -> io::Result<()> {
98 unsafe {
99 if ws2_32::listen(self.socket, backlog) == 0 {
100 Ok(())
101 } else {
102 Err(last_error())
103 }
104 }
105 }
106
connect(&self, addr: &SockAddr) -> io::Result<()>107 pub fn connect(&self, addr: &SockAddr) -> io::Result<()> {
108 unsafe {
109 if ws2_32::connect(self.socket, addr.as_ptr(), addr.len()) == 0 {
110 Ok(())
111 } else {
112 Err(last_error())
113 }
114 }
115 }
116
connect_timeout(&self, addr: &SockAddr, timeout: Duration) -> io::Result<()>117 pub fn connect_timeout(&self, addr: &SockAddr, timeout: Duration) -> io::Result<()> {
118 self.set_nonblocking(true)?;
119 let r = self.connect(addr);
120 self.set_nonblocking(false)?;
121
122 match r {
123 Ok(()) => return Ok(()),
124 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
125 Err(e) => return Err(e),
126 }
127
128 if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
129 return Err(io::Error::new(io::ErrorKind::InvalidInput,
130 "cannot set a 0 duration timeout"));
131 }
132
133 let mut timeout = timeval {
134 tv_sec: timeout.as_secs() as c_long,
135 tv_usec: (timeout.subsec_nanos() / 1000) as c_long,
136 };
137 if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
138 timeout.tv_usec = 1;
139 }
140
141 let fds = unsafe {
142 let mut fds = mem::zeroed::<fd_set>();
143 fds.fd_count = 1;
144 fds.fd_array[0] = self.socket;
145 fds
146 };
147
148 let mut writefds = fds;
149 let mut errorfds = fds;
150
151 match unsafe { ws2_32::select(1, ptr::null_mut(), &mut writefds, &mut errorfds, &timeout) } {
152 SOCKET_ERROR => return Err(io::Error::last_os_error()),
153 0 => return Err(io::Error::new(io::ErrorKind::TimedOut, "connection timed out")),
154 _ => {
155 if writefds.fd_count != 1 {
156 if let Some(e) = self.take_error()? {
157 return Err(e);
158 }
159 }
160 Ok(())
161 }
162 }
163 }
164
local_addr(&self) -> io::Result<SockAddr>165 pub fn local_addr(&self) -> io::Result<SockAddr> {
166 unsafe {
167 let mut storage: SOCKADDR_STORAGE = mem::zeroed();
168 let mut len = mem::size_of_val(&storage) as c_int;
169 if ws2_32::getsockname(self.socket,
170 &mut storage as *mut _ as *mut _,
171 &mut len) != 0 {
172 return Err(last_error())
173 }
174 Ok(SockAddr::from_raw_parts(&storage as *const _ as *const _, len))
175 }
176 }
177
peer_addr(&self) -> io::Result<SockAddr>178 pub fn peer_addr(&self) -> io::Result<SockAddr> {
179 unsafe {
180 let mut storage: SOCKADDR_STORAGE = mem::zeroed();
181 let mut len = mem::size_of_val(&storage) as c_int;
182 if ws2_32::getpeername(self.socket,
183 &mut storage as *mut _ as *mut _,
184 &mut len) != 0 {
185 return Err(last_error())
186 }
187 Ok(SockAddr::from_raw_parts(&storage as *const _ as *const _, len))
188 }
189 }
190
try_clone(&self) -> io::Result<Socket>191 pub fn try_clone(&self) -> io::Result<Socket> {
192 unsafe {
193 let mut info: WSAPROTOCOL_INFOW = mem::zeroed();
194 let r = ws2_32::WSADuplicateSocketW(self.socket,
195 kernel32::GetCurrentProcessId(),
196 &mut info);
197 if r != 0 {
198 return Err(io::Error::last_os_error())
199 }
200 let socket = ws2_32::WSASocketW(info.iAddressFamily,
201 info.iSocketType,
202 info.iProtocol,
203 &mut info,
204 0,
205 WSA_FLAG_OVERLAPPED);
206 let socket = match socket {
207 INVALID_SOCKET => return Err(last_error()),
208 n => Socket::from_raw_socket(n),
209 };
210 socket.set_no_inherit()?;
211 Ok(socket)
212 }
213 }
214
accept(&self) -> io::Result<(Socket, SockAddr)>215 pub fn accept(&self) -> io::Result<(Socket, SockAddr)> {
216 unsafe {
217 let mut storage: SOCKADDR_STORAGE = mem::zeroed();
218 let mut len = mem::size_of_val(&storage) as c_int;
219 let socket = {
220 ws2_32::accept(self.socket,
221 &mut storage as *mut _ as *mut _,
222 &mut len)
223 };
224 let socket = match socket {
225 INVALID_SOCKET => return Err(last_error()),
226 socket => Socket::from_raw_socket(socket),
227 };
228 socket.set_no_inherit()?;
229 let addr = SockAddr::from_raw_parts(&storage as *const _ as *const _, len);
230 Ok((socket, addr))
231 }
232 }
233
take_error(&self) -> io::Result<Option<io::Error>>234 pub fn take_error(&self) -> io::Result<Option<io::Error>> {
235 unsafe {
236 let raw: c_int = self.getsockopt(SOL_SOCKET, SO_ERROR)?;
237 if raw == 0 {
238 Ok(None)
239 } else {
240 Ok(Some(io::Error::from_raw_os_error(raw as i32)))
241 }
242 }
243 }
244
set_nonblocking(&self, nonblocking: bool) -> io::Result<()>245 pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
246 unsafe {
247 let mut nonblocking = nonblocking as c_ulong;
248 let r = ws2_32::ioctlsocket(self.socket,
249 FIONBIO as c_int,
250 &mut nonblocking);
251 if r == 0 {
252 Ok(())
253 } else {
254 Err(io::Error::last_os_error())
255 }
256 }
257 }
258
shutdown(&self, how: Shutdown) -> io::Result<()>259 pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
260
261 let how = match how {
262 Shutdown::Write => SD_SEND,
263 Shutdown::Read => SD_RECEIVE,
264 Shutdown::Both => SD_BOTH,
265 };
266 if unsafe { ws2_32::shutdown(self.socket, how) == 0 } {
267 Ok(())
268 } else {
269 Err(last_error())
270 }
271 }
272
recv(&self, buf: &mut [u8]) -> io::Result<usize>273 pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
274 unsafe {
275 let n = {
276 ws2_32::recv(self.socket,
277 buf.as_mut_ptr() as *mut c_char,
278 clamp(buf.len()),
279 0)
280 };
281 match n {
282 SOCKET_ERROR if ws2_32::WSAGetLastError() == WSAESHUTDOWN as i32 => Ok(0),
283 SOCKET_ERROR => Err(last_error()),
284 n => Ok(n as usize)
285 }
286 }
287 }
288
peek(&self, buf: &mut [u8]) -> io::Result<usize>289 pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
290 unsafe {
291 let n = {
292 ws2_32::recv(self.socket,
293 buf.as_mut_ptr() as *mut c_char,
294 clamp(buf.len()),
295 MSG_PEEK)
296 };
297 match n {
298 SOCKET_ERROR if ws2_32::WSAGetLastError() == WSAESHUTDOWN as i32 => Ok(0),
299 SOCKET_ERROR => Err(last_error()),
300 n => Ok(n as usize)
301 }
302 }
303 }
304
recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SockAddr)>305 pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SockAddr)> {
306 self.recvfrom(buf, 0)
307 }
308
peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SockAddr)>309 pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SockAddr)> {
310 self.recvfrom(buf, MSG_PEEK)
311 }
312
recvfrom(&self, buf: &mut [u8], flags: c_int) -> io::Result<(usize, SockAddr)>313 fn recvfrom(&self, buf: &mut [u8], flags: c_int)
314 -> io::Result<(usize, SockAddr)> {
315 unsafe {
316 let mut storage: SOCKADDR_STORAGE = mem::zeroed();
317 let mut addrlen = mem::size_of_val(&storage) as c_int;
318
319 let n = {
320 ws2_32::recvfrom(self.socket,
321 buf.as_mut_ptr() as *mut c_char,
322 clamp(buf.len()),
323 flags,
324 &mut storage as *mut _ as *mut _,
325 &mut addrlen)
326 };
327 let n = match n {
328 SOCKET_ERROR if ws2_32::WSAGetLastError() == WSAESHUTDOWN as i32 => 0,
329 SOCKET_ERROR => return Err(last_error()),
330 n => n as usize,
331 };
332 let addr = SockAddr::from_raw_parts(&storage as *const _ as *const _, addrlen);
333 Ok((n, addr))
334 }
335 }
336
send(&self, buf: &[u8]) -> io::Result<usize>337 pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
338 unsafe {
339 let n = {
340 ws2_32::send(self.socket,
341 buf.as_ptr() as *const c_char,
342 clamp(buf.len()),
343 0)
344 };
345 if n == SOCKET_ERROR {
346 Err(last_error())
347 } else {
348 Ok(n as usize)
349 }
350 }
351 }
352
send_to(&self, buf: &[u8], addr: &SockAddr) -> io::Result<usize>353 pub fn send_to(&self, buf: &[u8], addr: &SockAddr) -> io::Result<usize> {
354 unsafe {
355 let n = {
356 ws2_32::sendto(self.socket,
357 buf.as_ptr() as *const c_char,
358 clamp(buf.len()),
359 0,
360 addr.as_ptr(),
361 addr.len())
362 };
363 if n == SOCKET_ERROR {
364 Err(last_error())
365 } else {
366 Ok(n as usize)
367 }
368 }
369 }
370
371 // ================================================
372
ttl(&self) -> io::Result<u32>373 pub fn ttl(&self) -> io::Result<u32> {
374 unsafe {
375 let raw: c_int = self.getsockopt(IPPROTO_IP, IP_TTL)?;
376 Ok(raw as u32)
377 }
378 }
379
set_ttl(&self, ttl: u32) -> io::Result<()>380 pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
381 unsafe {
382 self.setsockopt(IPPROTO_IP, IP_TTL, ttl as c_int)
383 }
384 }
385
only_v6(&self) -> io::Result<bool>386 pub fn only_v6(&self) -> io::Result<bool> {
387 unsafe {
388 let raw: c_int = self.getsockopt(IPPROTO_IPV6.0 as c_int,
389 IPV6_V6ONLY)?;
390 Ok(raw != 0)
391 }
392 }
393
set_only_v6(&self, only_v6: bool) -> io::Result<()>394 pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> {
395 unsafe {
396 self.setsockopt(IPPROTO_IPV6.0 as c_int,
397 IPV6_V6ONLY,
398 only_v6 as c_int)
399 }
400 }
401
read_timeout(&self) -> io::Result<Option<Duration>>402 pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
403 unsafe {
404 Ok(ms2dur(self.getsockopt(SOL_SOCKET, SO_RCVTIMEO)?))
405 }
406 }
407
set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()>408 pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
409 unsafe {
410 self.setsockopt(SOL_SOCKET, SO_RCVTIMEO, dur2ms(dur)?)
411 }
412 }
413
write_timeout(&self) -> io::Result<Option<Duration>>414 pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
415 unsafe {
416 Ok(ms2dur(self.getsockopt(SOL_SOCKET, SO_SNDTIMEO)?))
417 }
418 }
419
set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()>420 pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
421 unsafe {
422 self.setsockopt(SOL_SOCKET, SO_SNDTIMEO, dur2ms(dur)?)
423 }
424 }
425
nodelay(&self) -> io::Result<bool>426 pub fn nodelay(&self) -> io::Result<bool> {
427 unsafe {
428 let raw: c_int = self.getsockopt(IPPROTO_TCP,
429 TCP_NODELAY)?;
430 Ok(raw != 0)
431 }
432 }
433
set_nodelay(&self, nodelay: bool) -> io::Result<()>434 pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
435 unsafe {
436 self.setsockopt(IPPROTO_TCP,
437 TCP_NODELAY,
438 nodelay as c_int)
439 }
440 }
441
broadcast(&self) -> io::Result<bool>442 pub fn broadcast(&self) -> io::Result<bool> {
443 unsafe {
444 let raw: c_int = self.getsockopt(SOL_SOCKET, SO_BROADCAST)?;
445 Ok(raw != 0)
446 }
447 }
448
set_broadcast(&self, broadcast: bool) -> io::Result<()>449 pub fn set_broadcast(&self, broadcast: bool) -> io::Result<()> {
450 unsafe {
451 self.setsockopt(SOL_SOCKET, SO_BROADCAST, broadcast as c_int)
452 }
453 }
454
multicast_loop_v4(&self) -> io::Result<bool>455 pub fn multicast_loop_v4(&self) -> io::Result<bool> {
456 unsafe {
457 let raw: c_int = self.getsockopt(IPPROTO_IP, IP_MULTICAST_LOOP)?;
458 Ok(raw != 0)
459 }
460 }
461
set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()>462 pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()> {
463 unsafe {
464 self.setsockopt(IPPROTO_IP,
465 IP_MULTICAST_LOOP,
466 multicast_loop_v4 as c_int)
467 }
468 }
469
multicast_ttl_v4(&self) -> io::Result<u32>470 pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
471 unsafe {
472 let raw: c_int = self.getsockopt(IPPROTO_IP, IP_MULTICAST_TTL)?;
473 Ok(raw as u32)
474 }
475 }
476
set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()>477 pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()> {
478 unsafe {
479 self.setsockopt(IPPROTO_IP,
480 IP_MULTICAST_TTL,
481 multicast_ttl_v4 as c_int)
482 }
483 }
484
multicast_loop_v6(&self) -> io::Result<bool>485 pub fn multicast_loop_v6(&self) -> io::Result<bool> {
486 unsafe {
487 let raw: c_int = self.getsockopt(IPPROTO_IPV6.0 as c_int,
488 IPV6_MULTICAST_LOOP)?;
489 Ok(raw != 0)
490 }
491 }
492
set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> io::Result<()>493 pub fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> io::Result<()> {
494 unsafe {
495 self.setsockopt(IPPROTO_IPV6.0 as c_int,
496 IPV6_MULTICAST_LOOP,
497 multicast_loop_v6 as c_int)
498 }
499 }
500
join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()>501 pub fn join_multicast_v4(&self,
502 multiaddr: &Ipv4Addr,
503 interface: &Ipv4Addr) -> io::Result<()> {
504 let multiaddr = to_s_addr(multiaddr);
505 let interface = to_s_addr(interface);
506 let mreq = ip_mreq {
507 imr_multiaddr: in_addr { S_un: multiaddr },
508 imr_interface: in_addr { S_un: interface },
509 };
510 unsafe {
511 self.setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP, mreq)
512 }
513 }
514
join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()>515 pub fn join_multicast_v6(&self,
516 multiaddr: &Ipv6Addr,
517 interface: u32) -> io::Result<()> {
518 let multiaddr = to_in6_addr(multiaddr);
519 let mreq = ipv6_mreq {
520 ipv6mr_multiaddr: multiaddr,
521 ipv6mr_interface: interface,
522 };
523 unsafe {
524 self.setsockopt(IPPROTO_IP, IPV6_ADD_MEMBERSHIP, mreq)
525 }
526 }
527
leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()>528 pub fn leave_multicast_v4(&self,
529 multiaddr: &Ipv4Addr,
530 interface: &Ipv4Addr) -> io::Result<()> {
531 let multiaddr = to_s_addr(multiaddr);
532 let interface = to_s_addr(interface);
533 let mreq = ip_mreq {
534 imr_multiaddr: in_addr { S_un: multiaddr },
535 imr_interface: in_addr { S_un: interface },
536 };
537 unsafe {
538 self.setsockopt(IPPROTO_IP, IP_DROP_MEMBERSHIP, mreq)
539 }
540 }
541
leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()>542 pub fn leave_multicast_v6(&self,
543 multiaddr: &Ipv6Addr,
544 interface: u32) -> io::Result<()> {
545 let multiaddr = to_in6_addr(multiaddr);
546 let mreq = ipv6_mreq {
547 ipv6mr_multiaddr: multiaddr,
548 ipv6mr_interface: interface,
549 };
550 unsafe {
551 self.setsockopt(IPPROTO_IP, IPV6_DROP_MEMBERSHIP, mreq)
552 }
553 }
554
linger(&self) -> io::Result<Option<Duration>>555 pub fn linger(&self) -> io::Result<Option<Duration>> {
556 unsafe {
557 Ok(linger2dur(self.getsockopt(SOL_SOCKET, SO_LINGER)?))
558 }
559 }
560
set_linger(&self, dur: Option<Duration>) -> io::Result<()>561 pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> {
562 unsafe {
563 self.setsockopt(SOL_SOCKET, SO_LINGER, dur2linger(dur))
564 }
565 }
566
set_reuse_address(&self, reuse: bool) -> io::Result<()>567 pub fn set_reuse_address(&self, reuse: bool) -> io::Result<()> {
568 unsafe {
569 self.setsockopt(SOL_SOCKET, SO_REUSEADDR, reuse as c_int)
570 }
571 }
572
reuse_address(&self) -> io::Result<bool>573 pub fn reuse_address(&self) -> io::Result<bool> {
574 unsafe {
575 let raw: c_int = self.getsockopt(SOL_SOCKET, SO_REUSEADDR)?;
576 Ok(raw != 0)
577 }
578 }
579
recv_buffer_size(&self) -> io::Result<usize>580 pub fn recv_buffer_size(&self) -> io::Result<usize> {
581 unsafe {
582 let raw: c_int = self.getsockopt(SOL_SOCKET, SO_RCVBUF)?;
583 Ok(raw as usize)
584 }
585 }
586
set_recv_buffer_size(&self, size: usize) -> io::Result<()>587 pub fn set_recv_buffer_size(&self, size: usize) -> io::Result<()> {
588 unsafe {
589 // TODO: casting usize to a c_int should be a checked cast
590 self.setsockopt(SOL_SOCKET, SO_RCVBUF, size as c_int)
591 }
592 }
593
send_buffer_size(&self) -> io::Result<usize>594 pub fn send_buffer_size(&self) -> io::Result<usize> {
595 unsafe {
596 let raw: c_int = self.getsockopt(SOL_SOCKET, SO_SNDBUF)?;
597 Ok(raw as usize)
598 }
599 }
600
set_send_buffer_size(&self, size: usize) -> io::Result<()>601 pub fn set_send_buffer_size(&self, size: usize) -> io::Result<()> {
602 unsafe {
603 // TODO: casting usize to a c_int should be a checked cast
604 self.setsockopt(SOL_SOCKET, SO_SNDBUF, size as c_int)
605 }
606 }
607
keepalive(&self) -> io::Result<Option<Duration>>608 pub fn keepalive(&self) -> io::Result<Option<Duration>> {
609 let mut ka = tcp_keepalive {
610 onoff: 0,
611 keepalivetime: 0,
612 keepaliveinterval: 0,
613 };
614 let n = unsafe {
615 ws2_32::WSAIoctl(self.socket,
616 SIO_KEEPALIVE_VALS,
617 0 as *mut _,
618 0,
619 &mut ka as *mut _ as *mut _,
620 mem::size_of_val(&ka) as DWORD,
621 0 as *mut _,
622 0 as *mut _,
623 None)
624 };
625 if n == 0 {
626 Ok(if ka.onoff == 0 {
627 None
628 } else if ka.keepaliveinterval == 0 {
629 None
630 } else {
631 let seconds = ka.keepaliveinterval / 1000;
632 let nanos = (ka.keepaliveinterval % 1000) * 1_000_000;
633 Some(Duration::new(seconds as u64, nanos as u32))
634 })
635 } else {
636 Err(last_error())
637 }
638 }
639
set_keepalive(&self, keepalive: Option<Duration>) -> io::Result<()>640 pub fn set_keepalive(&self, keepalive: Option<Duration>) -> io::Result<()> {
641 let ms = dur2ms(keepalive)?;
642 // TODO: checked casts here
643 let ka = tcp_keepalive {
644 onoff: keepalive.is_some() as c_ulong,
645 keepalivetime: ms as c_ulong,
646 keepaliveinterval: ms as c_ulong,
647 };
648 let n = unsafe {
649 ws2_32::WSAIoctl(self.socket,
650 SIO_KEEPALIVE_VALS,
651 &ka as *const _ as *mut _,
652 mem::size_of_val(&ka) as DWORD,
653 0 as *mut _,
654 0,
655 0 as *mut _,
656 0 as *mut _,
657 None)
658 };
659 if n == 0 {
660 Ok(())
661 } else {
662 Err(last_error())
663 }
664 }
665
setsockopt<T>(&self, opt: c_int, val: c_int, payload: T) -> io::Result<()> where T: Copy,666 unsafe fn setsockopt<T>(&self,
667 opt: c_int,
668 val: c_int,
669 payload: T) -> io::Result<()>
670 where T: Copy,
671 {
672 let payload = &payload as *const T as *const c_char;
673 if ws2_32::setsockopt(self.socket,
674 opt,
675 val,
676 payload,
677 mem::size_of::<T>() as c_int) == 0 {
678 Ok(())
679 } else {
680 Err(last_error())
681 }
682 }
683
getsockopt<T: Copy>(&self, opt: c_int, val: c_int) -> io::Result<T>684 unsafe fn getsockopt<T: Copy>(&self, opt: c_int, val: c_int) -> io::Result<T> {
685 let mut slot: T = mem::zeroed();
686 let mut len = mem::size_of::<T>() as c_int;
687 if ws2_32::getsockopt(self.socket,
688 opt,
689 val,
690 &mut slot as *mut _ as *mut _,
691 &mut len) == 0 {
692 assert_eq!(len as usize, mem::size_of::<T>());
693 Ok(slot)
694 } else {
695 Err(last_error())
696 }
697 }
698
set_no_inherit(&self) -> io::Result<()>699 fn set_no_inherit(&self) -> io::Result<()> {
700 unsafe {
701 let r = kernel32::SetHandleInformation(self.socket as HANDLE,
702 HANDLE_FLAG_INHERIT,
703 0);
704 if r == 0 {
705 Err(io::Error::last_os_error())
706 } else {
707 Ok(())
708 }
709 }
710 }
711 }
712
713 impl Read for Socket {
read(&mut self, buf: &mut [u8]) -> io::Result<usize>714 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
715 <&Socket>::read(&mut &*self, buf)
716 }
717 }
718
719 impl<'a> Read for &'a Socket {
read(&mut self, buf: &mut [u8]) -> io::Result<usize>720 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
721 self.recv(buf)
722 }
723 }
724
725 impl Write for Socket {
write(&mut self, buf: &[u8]) -> io::Result<usize>726 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
727 <&Socket>::write(&mut &*self, buf)
728 }
729
flush(&mut self) -> io::Result<()>730 fn flush(&mut self) -> io::Result<()> {
731 <&Socket>::flush(&mut &*self)
732 }
733 }
734
735 impl<'a> Write for &'a Socket {
write(&mut self, buf: &[u8]) -> io::Result<usize>736 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
737 self.send(buf)
738 }
739
flush(&mut self) -> io::Result<()>740 fn flush(&mut self) -> io::Result<()> {
741 Ok(())
742 }
743 }
744
745 impl fmt::Debug for Socket {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result746 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
747 let mut f = f.debug_struct("Socket");
748 f.field("socket", &self.socket);
749 if let Ok(addr) = self.local_addr() {
750 f.field("local_addr", &addr);
751 }
752 if let Ok(addr) = self.peer_addr() {
753 f.field("peer_addr", &addr);
754 }
755 f.finish()
756 }
757 }
758
759 impl AsRawSocket for Socket {
as_raw_socket(&self) -> SOCKET760 fn as_raw_socket(&self) -> SOCKET {
761 self.socket
762 }
763 }
764
765 impl IntoRawSocket for Socket {
into_raw_socket(self) -> SOCKET766 fn into_raw_socket(self) -> SOCKET {
767 let socket = self.socket;
768 mem::forget(self);
769 return socket
770 }
771 }
772
773 impl FromRawSocket for Socket {
from_raw_socket(socket: SOCKET) -> Socket774 unsafe fn from_raw_socket(socket: SOCKET) -> Socket {
775 Socket { socket: socket }
776 }
777 }
778
779 impl AsRawSocket for ::Socket {
as_raw_socket(&self) -> SOCKET780 fn as_raw_socket(&self) -> SOCKET {
781 self.inner.as_raw_socket()
782 }
783 }
784
785 impl IntoRawSocket for ::Socket {
into_raw_socket(self) -> SOCKET786 fn into_raw_socket(self) -> SOCKET {
787 self.inner.into_raw_socket()
788 }
789 }
790
791 impl FromRawSocket for ::Socket {
from_raw_socket(socket: SOCKET) -> ::Socket792 unsafe fn from_raw_socket(socket: SOCKET) -> ::Socket {
793 ::Socket { inner: Socket::from_raw_socket(socket) }
794 }
795 }
796
797 impl Drop for Socket {
drop(&mut self)798 fn drop(&mut self) {
799 unsafe {
800 let _ = ws2_32::closesocket(self.socket);
801 }
802 }
803 }
804
805 impl From<Socket> for net::TcpStream {
from(socket: Socket) -> net::TcpStream806 fn from(socket: Socket) -> net::TcpStream {
807 unsafe { net::TcpStream::from_raw_socket(socket.into_raw_socket()) }
808 }
809 }
810
811 impl From<Socket> for net::TcpListener {
from(socket: Socket) -> net::TcpListener812 fn from(socket: Socket) -> net::TcpListener {
813 unsafe { net::TcpListener::from_raw_socket(socket.into_raw_socket()) }
814 }
815 }
816
817 impl From<Socket> for net::UdpSocket {
from(socket: Socket) -> net::UdpSocket818 fn from(socket: Socket) -> net::UdpSocket {
819 unsafe { net::UdpSocket::from_raw_socket(socket.into_raw_socket()) }
820 }
821 }
822
823 impl From<net::TcpStream> for Socket {
from(socket: net::TcpStream) -> Socket824 fn from(socket: net::TcpStream) -> Socket {
825 unsafe { Socket::from_raw_socket(socket.into_raw_socket()) }
826 }
827 }
828
829 impl From<net::TcpListener> for Socket {
from(socket: net::TcpListener) -> Socket830 fn from(socket: net::TcpListener) -> Socket {
831 unsafe { Socket::from_raw_socket(socket.into_raw_socket()) }
832 }
833 }
834
835 impl From<net::UdpSocket> for Socket {
from(socket: net::UdpSocket) -> Socket836 fn from(socket: net::UdpSocket) -> Socket {
837 unsafe { Socket::from_raw_socket(socket.into_raw_socket()) }
838 }
839 }
840
clamp(input: usize) -> c_int841 fn clamp(input: usize) -> c_int {
842 cmp::min(input, <c_int>::max_value() as usize) as c_int
843 }
844
dur2ms(dur: Option<Duration>) -> io::Result<DWORD>845 fn dur2ms(dur: Option<Duration>) -> io::Result<DWORD> {
846 match dur {
847 Some(dur) => {
848 // Note that a duration is a (u64, u32) (seconds, nanoseconds)
849 // pair, and the timeouts in windows APIs are typically u32
850 // milliseconds. To translate, we have two pieces to take care of:
851 //
852 // * Nanosecond precision is rounded up
853 // * Greater than u32::MAX milliseconds (50 days) is rounded up to
854 // INFINITE (never time out).
855 let ms = dur.as_secs().checked_mul(1000).and_then(|ms| {
856 ms.checked_add((dur.subsec_nanos() as u64) / 1_000_000)
857 }).and_then(|ms| {
858 ms.checked_add(if dur.subsec_nanos() % 1_000_000 > 0 {1} else {0})
859 }).map(|ms| {
860 if ms > <DWORD>::max_value() as u64 {
861 INFINITE
862 } else {
863 ms as DWORD
864 }
865 }).unwrap_or(INFINITE);
866 if ms == 0 {
867 return Err(io::Error::new(io::ErrorKind::InvalidInput,
868 "cannot set a 0 duration timeout"));
869 }
870 Ok(ms)
871 }
872 None => Ok(0),
873 }
874 }
875
ms2dur(raw: DWORD) -> Option<Duration>876 fn ms2dur(raw: DWORD) -> Option<Duration> {
877 if raw == 0 {
878 None
879 } else {
880 let secs = raw / 1000;
881 let nsec = (raw % 1000) * 1000000;
882 Some(Duration::new(secs as u64, nsec as u32))
883 }
884 }
885
to_s_addr(addr: &Ipv4Addr) -> ULONG886 fn to_s_addr(addr: &Ipv4Addr) -> ULONG {
887 let octets = addr.octets();
888 ::hton(((octets[0] as ULONG) << 24) |
889 ((octets[1] as ULONG) << 16) |
890 ((octets[2] as ULONG) << 8) |
891 ((octets[3] as ULONG) << 0))
892 }
893
to_in6_addr(addr: &Ipv6Addr) -> in6_addr894 fn to_in6_addr(addr: &Ipv6Addr) -> in6_addr {
895 let mut ret: in6_addr = unsafe { mem::zeroed() };
896 ret.s6_addr = addr.octets();
897 return ret
898 }
899
linger2dur(linger_opt: linger) -> Option<Duration>900 fn linger2dur(linger_opt: linger) -> Option<Duration> {
901 if linger_opt.l_onoff == 0 {
902 None
903 } else {
904 Some(Duration::from_secs(linger_opt.l_linger as u64))
905 }
906 }
907
dur2linger(dur: Option<Duration>) -> linger908 fn dur2linger(dur: Option<Duration>) -> linger {
909 match dur {
910 Some(d) => {
911 linger {
912 l_onoff: 1,
913 l_linger: d.as_secs() as u16,
914 }
915 }
916 None => linger { l_onoff: 0, l_linger: 0 },
917 }
918 }
919