1 // Copyright 2013-2014 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.
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.
11 //! Native thread-blocking I/O implementation
13 //! This module contains the implementation of native thread-blocking
14 //! implementations of I/O on all platforms. This module is not intended to be
15 //! used directly, but rather the rust runtime will fall back to using it if
18 //! Rust code normally runs inside of green tasks with a local scheduler using
19 //! asynchronous I/O to cooperate among tasks. This model is not always
20 //! available, however, and that's where these native implementations come into
21 //! play. The only dependencies of these modules are the normal system libraries
22 //! that you would find on the respective platform.
24 #![allow(non_snake_case_functions)]
28 use std::c_str::CString;
31 use std::io::net::ip::SocketAddr;
32 use std::io::signal::Signum;
35 use std::rt::rtio::{RtioTcpStream, RtioTcpListener, RtioUdpSocket};
36 use std::rt::rtio::{RtioUnixListener, RtioPipe, RtioFileStream, RtioProcess};
37 use std::rt::rtio::{RtioSignal, RtioTTY, CloseBehavior, RtioTimer, ProcessConfig};
38 use ai = std::io::net::addrinfo;
41 pub use self::file::FileDesc;
42 pub use self::process::Process;
46 // Native I/O implementations
53 #[path = "file_unix.rs"]
56 #[path = "file_win32.rs"]
59 #[cfg(target_os = "macos")]
60 #[cfg(target_os = "freebsd")]
61 #[cfg(target_os = "android")]
62 #[cfg(target_os = "linux")]
63 #[path = "timer_unix.rs"]
66 #[cfg(target_os = "win32")]
67 #[path = "timer_win32.rs"]
71 #[path = "pipe_unix.rs"]
75 #[path = "pipe_win32.rs"]
78 #[cfg(unix)] #[path = "c_unix.rs"] mod c;
79 #[cfg(windows)] #[path = "c_win32.rs"] mod c;
81 pub type IoResult<T> = Result<T, IoError>;
83 fn unimpl() -> IoError {
85 kind: io::IoUnavailable,
86 desc: "unimplemented I/O interface",
91 fn last_error() -> IoError {
95 // unix has nonzero values as errors
96 fn mkerr_libc(ret: libc::c_int) -> IoResult<()> {
104 // windows has zero values as errors
106 fn mkerr_winbool(ret: libc::c_int) -> IoResult<()> {
116 fn retry(f: || -> libc::c_int) -> libc::c_int {
119 -1 if os::errno() as int == libc::WSAEINTR as int => {}
127 fn retry(f: || -> libc::c_int) -> libc::c_int {
130 -1 if os::errno() as int == libc::EINTR as int => {}
136 fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 {
137 let origamt = data.len();
138 let mut data = data.as_ptr();
139 let mut amt = origamt;
141 let ret = retry(|| f(data, amt) as libc::c_int);
144 } else if ret != -1 {
146 data = unsafe { data.offset(ret as int) };
151 return (origamt - amt) as i64;
154 /// Implementation of rt::rtio's IoFactory trait to generate handles to the
155 /// native I/O functionality.
156 pub struct IoFactory {
157 cannot_construct_outside_of_this_module: ()
161 pub fn new() -> IoFactory {
163 IoFactory { cannot_construct_outside_of_this_module: () }
167 impl rtio::IoFactory for IoFactory {
169 fn tcp_connect(&mut self, addr: SocketAddr,
170 timeout: Option<u64>) -> IoResult<Box<RtioTcpStream:Send>> {
171 net::TcpStream::connect(addr, timeout).map(|s| {
172 box s as Box<RtioTcpStream:Send>
175 fn tcp_bind(&mut self, addr: SocketAddr)
176 -> IoResult<Box<RtioTcpListener:Send>> {
177 net::TcpListener::bind(addr).map(|s| {
178 box s as Box<RtioTcpListener:Send>
181 fn udp_bind(&mut self, addr: SocketAddr)
182 -> IoResult<Box<RtioUdpSocket:Send>> {
183 net::UdpSocket::bind(addr).map(|u| box u as Box<RtioUdpSocket:Send>)
185 fn unix_bind(&mut self, path: &CString)
186 -> IoResult<Box<RtioUnixListener:Send>> {
187 pipe::UnixListener::bind(path).map(|s| {
188 box s as Box<RtioUnixListener:Send>
191 fn unix_connect(&mut self, path: &CString,
192 timeout: Option<u64>) -> IoResult<Box<RtioPipe:Send>> {
193 pipe::UnixStream::connect(path, timeout).map(|s| {
194 box s as Box<RtioPipe:Send>
197 fn get_host_addresses(&mut self, host: Option<&str>, servname: Option<&str>,
198 hint: Option<ai::Hint>) -> IoResult<Vec<ai::Info>> {
199 addrinfo::GetAddrInfoRequest::run(host, servname, hint)
202 // filesystem operations
203 fn fs_from_raw_fd(&mut self, fd: c_int, close: CloseBehavior)
204 -> Box<RtioFileStream:Send> {
205 let close = match close {
206 rtio::CloseSynchronously | rtio::CloseAsynchronously => true,
207 rtio::DontClose => false
209 box file::FileDesc::new(fd, close) as Box<RtioFileStream:Send>
211 fn fs_open(&mut self, path: &CString, fm: io::FileMode, fa: io::FileAccess)
212 -> IoResult<Box<RtioFileStream:Send>> {
213 file::open(path, fm, fa).map(|fd| box fd as Box<RtioFileStream:Send>)
215 fn fs_unlink(&mut self, path: &CString) -> IoResult<()> {
218 fn fs_stat(&mut self, path: &CString) -> IoResult<io::FileStat> {
221 fn fs_mkdir(&mut self, path: &CString,
222 mode: io::FilePermission) -> IoResult<()> {
223 file::mkdir(path, mode)
225 fn fs_chmod(&mut self, path: &CString,
226 mode: io::FilePermission) -> IoResult<()> {
227 file::chmod(path, mode)
229 fn fs_rmdir(&mut self, path: &CString) -> IoResult<()> {
232 fn fs_rename(&mut self, path: &CString, to: &CString) -> IoResult<()> {
233 file::rename(path, to)
235 fn fs_readdir(&mut self, path: &CString, _flags: c_int) -> IoResult<Vec<Path>> {
238 fn fs_lstat(&mut self, path: &CString) -> IoResult<io::FileStat> {
241 fn fs_chown(&mut self, path: &CString, uid: int, gid: int) -> IoResult<()> {
242 file::chown(path, uid, gid)
244 fn fs_readlink(&mut self, path: &CString) -> IoResult<Path> {
247 fn fs_symlink(&mut self, src: &CString, dst: &CString) -> IoResult<()> {
248 file::symlink(src, dst)
250 fn fs_link(&mut self, src: &CString, dst: &CString) -> IoResult<()> {
253 fn fs_utime(&mut self, src: &CString, atime: u64,
254 mtime: u64) -> IoResult<()> {
255 file::utime(src, atime, mtime)
259 fn timer_init(&mut self) -> IoResult<Box<RtioTimer:Send>> {
260 timer::Timer::new().map(|t| box t as Box<RtioTimer:Send>)
262 fn spawn(&mut self, cfg: ProcessConfig)
263 -> IoResult<(Box<RtioProcess:Send>,
264 Vec<Option<Box<RtioPipe:Send>>>)> {
265 process::Process::spawn(cfg).map(|(p, io)| {
266 (box p as Box<RtioProcess:Send>,
267 io.move_iter().map(|p| p.map(|p| {
268 box p as Box<RtioPipe:Send>
272 fn kill(&mut self, pid: libc::pid_t, signum: int) -> IoResult<()> {
273 process::Process::kill(pid, signum)
275 fn pipe_open(&mut self, fd: c_int) -> IoResult<Box<RtioPipe:Send>> {
276 Ok(box file::FileDesc::new(fd, true) as Box<RtioPipe:Send>)
278 fn tty_open(&mut self, fd: c_int, _readable: bool)
279 -> IoResult<Box<RtioTTY:Send>> {
280 if unsafe { libc::isatty(fd) } != 0 {
281 Ok(box file::FileDesc::new(fd, true) as Box<RtioTTY:Send>)
284 kind: io::MismatchedFileTypeForOperation,
285 desc: "file descriptor is not a TTY",
290 fn signal(&mut self, _signal: Signum, _channel: Sender<Signum>)
291 -> IoResult<Box<RtioSignal:Send>> {