1 use {io, sys, Ready, Poll, PollOpt, Token};
2 use event::Evented;
3 use deprecated::TryAccept;
4 use io::MapNonBlock;
5 use std::io::{Read, Write};
6 use std::path::Path;
7 pub use std::net::Shutdown;
8 use std::process;
9
10 pub use sys::Io;
11
12 #[derive(Debug)]
13 pub struct UnixSocket {
14 sys: sys::UnixSocket,
15 }
16
17 impl UnixSocket {
18 /// Returns a new, unbound, non-blocking Unix domain socket
stream() -> io::Result<UnixSocket>19 pub fn stream() -> io::Result<UnixSocket> {
20 sys::UnixSocket::stream()
21 .map(From::from)
22 }
23
24 /// Connect the socket to the specified address
connect<P: AsRef<Path> + ?Sized>(self, addr: &P) -> io::Result<(UnixStream, bool)>25 pub fn connect<P: AsRef<Path> + ?Sized>(self, addr: &P) -> io::Result<(UnixStream, bool)> {
26 let complete = match self.sys.connect(addr) {
27 Ok(()) => true,
28 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => false,
29 Err(e) => return Err(e),
30 };
31 Ok((From::from(self.sys), complete))
32 }
33
34 /// Bind the socket to the specified address
bind<P: AsRef<Path> + ?Sized>(&self, addr: &P) -> io::Result<()>35 pub fn bind<P: AsRef<Path> + ?Sized>(&self, addr: &P) -> io::Result<()> {
36 self.sys.bind(addr)
37 }
38
39 /// Listen for incoming requests
listen(self, backlog: usize) -> io::Result<UnixListener>40 pub fn listen(self, backlog: usize) -> io::Result<UnixListener> {
41 self.sys.listen(backlog)?;
42 Ok(From::from(self.sys))
43 }
44
try_clone(&self) -> io::Result<UnixSocket>45 pub fn try_clone(&self) -> io::Result<UnixSocket> {
46 self.sys.try_clone()
47 .map(From::from)
48 }
49 }
50
51 impl Evented for UnixSocket {
register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>52 fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
53 self.sys.register(poll, token, interest, opts)
54 }
55
reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>56 fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
57 self.sys.reregister(poll, token, interest, opts)
58 }
59
deregister(&self, poll: &Poll) -> io::Result<()>60 fn deregister(&self, poll: &Poll) -> io::Result<()> {
61 self.sys.deregister(poll)
62 }
63 }
64
65 impl From<sys::UnixSocket> for UnixSocket {
from(sys: sys::UnixSocket) -> UnixSocket66 fn from(sys: sys::UnixSocket) -> UnixSocket {
67 UnixSocket { sys }
68 }
69 }
70
71 /*
72 *
73 * ===== UnixStream =====
74 *
75 */
76
77 #[derive(Debug)]
78 pub struct UnixStream {
79 sys: sys::UnixSocket,
80 }
81
82 impl UnixStream {
connect<P: AsRef<Path> + ?Sized>(path: &P) -> io::Result<UnixStream>83 pub fn connect<P: AsRef<Path> + ?Sized>(path: &P) -> io::Result<UnixStream> {
84 UnixSocket::stream()
85 .and_then(|sock| sock.connect(path))
86 .map(|(sock, _)| sock)
87 }
88
try_clone(&self) -> io::Result<UnixStream>89 pub fn try_clone(&self) -> io::Result<UnixStream> {
90 self.sys.try_clone()
91 .map(From::from)
92 }
93
shutdown(&self, how: Shutdown) -> io::Result<usize>94 pub fn shutdown(&self, how: Shutdown) -> io::Result<usize> {
95 self.sys.shutdown(how).map(|_| 0)
96 }
97
read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result<(usize, Option<RawFd>)>98 pub fn read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result<(usize, Option<RawFd>)> {
99 self.sys.read_recv_fd(buf)
100 }
101
try_read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result<Option<(usize, Option<RawFd>)>>102 pub fn try_read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result<Option<(usize, Option<RawFd>)>> {
103 self.read_recv_fd(buf).map_non_block()
104 }
105
write_send_fd(&mut self, buf: &[u8], fd: RawFd) -> io::Result<usize>106 pub fn write_send_fd(&mut self, buf: &[u8], fd: RawFd) -> io::Result<usize> {
107 self.sys.write_send_fd(buf, fd)
108 }
109
try_write_send_fd(&mut self, buf: &[u8], fd: RawFd) -> io::Result<Option<usize>>110 pub fn try_write_send_fd(&mut self, buf: &[u8], fd: RawFd) -> io::Result<Option<usize>> {
111 self.write_send_fd(buf, fd).map_non_block()
112 }
113 }
114
115 impl Read for UnixStream {
read(&mut self, buf: &mut [u8]) -> io::Result<usize>116 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
117 self.sys.read(buf)
118 }
119 }
120
121 impl Write for UnixStream {
write(&mut self, buf: &[u8]) -> io::Result<usize>122 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
123 self.sys.write(buf)
124 }
125
flush(&mut self) -> io::Result<()>126 fn flush(&mut self) -> io::Result<()> {
127 self.sys.flush()
128 }
129 }
130
131 impl Evented for UnixStream {
register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>132 fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
133 self.sys.register(poll, token, interest, opts)
134 }
135
reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>136 fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
137 self.sys.reregister(poll, token, interest, opts)
138 }
139
deregister(&self, poll: &Poll) -> io::Result<()>140 fn deregister(&self, poll: &Poll) -> io::Result<()> {
141 self.sys.deregister(poll)
142 }
143 }
144
145 impl From<sys::UnixSocket> for UnixStream {
from(sys: sys::UnixSocket) -> UnixStream146 fn from(sys: sys::UnixSocket) -> UnixStream {
147 UnixStream { sys }
148 }
149 }
150
151 /*
152 *
153 * ===== UnixListener =====
154 *
155 */
156
157 #[derive(Debug)]
158 pub struct UnixListener {
159 sys: sys::UnixSocket,
160 }
161
162 impl UnixListener {
bind<P: AsRef<Path> + ?Sized>(addr: &P) -> io::Result<UnixListener>163 pub fn bind<P: AsRef<Path> + ?Sized>(addr: &P) -> io::Result<UnixListener> {
164 UnixSocket::stream().and_then(|sock| {
165 sock.bind(addr)?;
166 sock.listen(256)
167 })
168 }
169
accept(&self) -> io::Result<UnixStream>170 pub fn accept(&self) -> io::Result<UnixStream> {
171 self.sys.accept().map(From::from)
172 }
173
try_clone(&self) -> io::Result<UnixListener>174 pub fn try_clone(&self) -> io::Result<UnixListener> {
175 self.sys.try_clone().map(From::from)
176 }
177 }
178
179 impl Evented for UnixListener {
register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>180 fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
181 self.sys.register(poll, token, interest, opts)
182 }
183
reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>184 fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
185 self.sys.reregister(poll, token, interest, opts)
186 }
187
deregister(&self, poll: &Poll) -> io::Result<()>188 fn deregister(&self, poll: &Poll) -> io::Result<()> {
189 self.sys.deregister(poll)
190 }
191 }
192
193 impl TryAccept for UnixListener {
194 type Output = UnixStream;
195
accept(&self) -> io::Result<Option<UnixStream>>196 fn accept(&self) -> io::Result<Option<UnixStream>> {
197 UnixListener::accept(self).map_non_block()
198 }
199 }
200
201 impl From<sys::UnixSocket> for UnixListener {
from(sys: sys::UnixSocket) -> UnixListener202 fn from(sys: sys::UnixSocket) -> UnixListener {
203 UnixListener { sys }
204 }
205 }
206
207 /*
208 *
209 * ===== Pipe =====
210 *
211 */
212
pipe() -> io::Result<(PipeReader, PipeWriter)>213 pub fn pipe() -> io::Result<(PipeReader, PipeWriter)> {
214 let (rd, wr) = sys::pipe()?;
215 Ok((From::from(rd), From::from(wr)))
216 }
217
218 #[derive(Debug)]
219 pub struct PipeReader {
220 io: Io,
221 }
222
223 impl PipeReader {
from_stdout(stdout: process::ChildStdout) -> io::Result<Self>224 pub fn from_stdout(stdout: process::ChildStdout) -> io::Result<Self> {
225 if let Err(e) = sys::set_nonblock(stdout.as_raw_fd()) {
226 return Err(e);
227 }
228 Ok(PipeReader::from(unsafe { Io::from_raw_fd(stdout.into_raw_fd()) }))
229 }
from_stderr(stderr: process::ChildStderr) -> io::Result<Self>230 pub fn from_stderr(stderr: process::ChildStderr) -> io::Result<Self> {
231 if let Err(e) = sys::set_nonblock(stderr.as_raw_fd()) {
232 return Err(e);
233 }
234 Ok(PipeReader::from(unsafe { Io::from_raw_fd(stderr.into_raw_fd()) }))
235 }
236 }
237
238 impl Read for PipeReader {
read(&mut self, buf: &mut [u8]) -> io::Result<usize>239 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
240 self.io.read(buf)
241 }
242 }
243
244 impl<'a> Read for &'a PipeReader {
read(&mut self, buf: &mut [u8]) -> io::Result<usize>245 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
246 (&self.io).read(buf)
247 }
248 }
249
250 impl Evented for PipeReader {
register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>251 fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
252 self.io.register(poll, token, interest, opts)
253 }
254
reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>255 fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
256 self.io.reregister(poll, token, interest, opts)
257 }
258
deregister(&self, poll: &Poll) -> io::Result<()>259 fn deregister(&self, poll: &Poll) -> io::Result<()> {
260 self.io.deregister(poll)
261 }
262 }
263
264 impl From<Io> for PipeReader {
from(io: Io) -> PipeReader265 fn from(io: Io) -> PipeReader {
266 PipeReader { io }
267 }
268 }
269
270 #[derive(Debug)]
271 pub struct PipeWriter {
272 io: Io,
273 }
274
275 impl PipeWriter {
from_stdin(stdin: process::ChildStdin) -> io::Result<Self>276 pub fn from_stdin(stdin: process::ChildStdin) -> io::Result<Self> {
277 if let Err(e) = sys::set_nonblock(stdin.as_raw_fd()) {
278 return Err(e);
279 }
280 Ok(PipeWriter::from(unsafe { Io::from_raw_fd(stdin.into_raw_fd()) }))
281 }
282 }
283
284 impl Write for PipeWriter {
write(&mut self, buf: &[u8]) -> io::Result<usize>285 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
286 self.io.write(buf)
287 }
288
flush(&mut self) -> io::Result<()>289 fn flush(&mut self) -> io::Result<()> {
290 self.io.flush()
291 }
292 }
293
294 impl<'a> Write for &'a PipeWriter {
write(&mut self, buf: &[u8]) -> io::Result<usize>295 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
296 (&self.io).write(buf)
297 }
298
flush(&mut self) -> io::Result<()>299 fn flush(&mut self) -> io::Result<()> {
300 (&self.io).flush()
301 }
302 }
303
304 impl Evented for PipeWriter {
register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>305 fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
306 self.io.register(poll, token, interest, opts)
307 }
308
reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>309 fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
310 self.io.reregister(poll, token, interest, opts)
311 }
312
deregister(&self, poll: &Poll) -> io::Result<()>313 fn deregister(&self, poll: &Poll) -> io::Result<()> {
314 self.io.deregister(poll)
315 }
316 }
317
318 impl From<Io> for PipeWriter {
from(io: Io) -> PipeWriter319 fn from(io: Io) -> PipeWriter {
320 PipeWriter { io }
321 }
322 }
323
324 /*
325 *
326 * ===== Conversions =====
327 *
328 */
329
330 use std::os::unix::io::{RawFd, IntoRawFd, AsRawFd, FromRawFd};
331
332 impl IntoRawFd for UnixSocket {
into_raw_fd(self) -> RawFd333 fn into_raw_fd(self) -> RawFd {
334 self.sys.into_raw_fd()
335 }
336 }
337
338 impl AsRawFd for UnixSocket {
as_raw_fd(&self) -> RawFd339 fn as_raw_fd(&self) -> RawFd {
340 self.sys.as_raw_fd()
341 }
342 }
343
344 impl FromRawFd for UnixSocket {
from_raw_fd(fd: RawFd) -> UnixSocket345 unsafe fn from_raw_fd(fd: RawFd) -> UnixSocket {
346 UnixSocket { sys: FromRawFd::from_raw_fd(fd) }
347 }
348 }
349
350 impl IntoRawFd for UnixStream {
into_raw_fd(self) -> RawFd351 fn into_raw_fd(self) -> RawFd {
352 self.sys.into_raw_fd()
353 }
354 }
355
356 impl AsRawFd for UnixStream {
as_raw_fd(&self) -> RawFd357 fn as_raw_fd(&self) -> RawFd {
358 self.sys.as_raw_fd()
359 }
360 }
361
362 impl FromRawFd for UnixStream {
from_raw_fd(fd: RawFd) -> UnixStream363 unsafe fn from_raw_fd(fd: RawFd) -> UnixStream {
364 UnixStream { sys: FromRawFd::from_raw_fd(fd) }
365 }
366 }
367
368 impl IntoRawFd for UnixListener {
into_raw_fd(self) -> RawFd369 fn into_raw_fd(self) -> RawFd {
370 self.sys.into_raw_fd()
371 }
372 }
373
374 impl AsRawFd for UnixListener {
as_raw_fd(&self) -> RawFd375 fn as_raw_fd(&self) -> RawFd {
376 self.sys.as_raw_fd()
377 }
378 }
379
380 impl FromRawFd for UnixListener {
from_raw_fd(fd: RawFd) -> UnixListener381 unsafe fn from_raw_fd(fd: RawFd) -> UnixListener {
382 UnixListener { sys: FromRawFd::from_raw_fd(fd) }
383 }
384 }
385
386 impl IntoRawFd for PipeReader {
into_raw_fd(self) -> RawFd387 fn into_raw_fd(self) -> RawFd {
388 self.io.into_raw_fd()
389 }
390 }
391
392 impl AsRawFd for PipeReader {
as_raw_fd(&self) -> RawFd393 fn as_raw_fd(&self) -> RawFd {
394 self.io.as_raw_fd()
395 }
396 }
397
398 impl FromRawFd for PipeReader {
from_raw_fd(fd: RawFd) -> PipeReader399 unsafe fn from_raw_fd(fd: RawFd) -> PipeReader {
400 PipeReader { io: FromRawFd::from_raw_fd(fd) }
401 }
402 }
403
404 impl IntoRawFd for PipeWriter {
into_raw_fd(self) -> RawFd405 fn into_raw_fd(self) -> RawFd {
406 self.io.into_raw_fd()
407 }
408 }
409
410 impl AsRawFd for PipeWriter {
as_raw_fd(&self) -> RawFd411 fn as_raw_fd(&self) -> RawFd {
412 self.io.as_raw_fd()
413 }
414 }
415
416 impl FromRawFd for PipeWriter {
from_raw_fd(fd: RawFd) -> PipeWriter417 unsafe fn from_raw_fd(fd: RawFd) -> PipeWriter {
418 PipeWriter { io: FromRawFd::from_raw_fd(fd) }
419 }
420 }
421