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.
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 //! Implementation of `std::os` functionality for unix systems
13 #![allow(unused_imports)] // lots of cfg code here
16 use os
::unix
::prelude
::*;
18 use error
::Error
as StdError
;
19 use ffi
::{CString, CStr, OsString, OsStr}
;
23 use libc
::{self, c_int, c_char, c_void}
;
25 #[allow(deprecated)] use old_io::{IoError, IoResult};
27 use path
::{self, PathBuf}
;
32 use sys
::fs
::FileDesc
;
35 const BUF_BYTES
: usize = 2048;
36 const TMPBUF_SZ
: usize = 128;
38 fn bytes2path(b
: &[u8]) -> PathBuf
{
39 PathBuf
::from(<OsStr
as OsStrExt
>::from_bytes(b
))
42 fn os2path(os
: OsString
) -> PathBuf
{
43 bytes2path(os
.as_bytes())
46 /// Returns the platform-specific value of errno
47 pub fn errno() -> i32 {
48 #[cfg(any(target_os = "macos",
50 target_os
= "freebsd"))]
51 unsafe fn errno_location() -> *const c_int
{
52 extern { fn __error() -> *const c_int; }
56 #[cfg(target_os = "bitrig")]
57 fn errno_location() -> *const c_int
{
59 fn __errno() -> *const c_int
;
66 #[cfg(target_os = "dragonfly")]
67 unsafe fn errno_location() -> *const c_int
{
68 extern { fn __dfly_error() -> *const c_int; }
72 #[cfg(target_os = "openbsd")]
73 unsafe fn errno_location() -> *const c_int
{
74 extern { fn __errno() -> *const c_int; }
78 #[cfg(any(target_os = "linux", target_os = "android"))]
79 unsafe fn errno_location() -> *const c_int
{
80 extern { fn __errno_location() -> *const c_int; }
85 (*errno_location()) as i32
89 /// Get a detailed string description for the given error number
90 pub fn error_string(errno
: i32) -> String
{
91 #[cfg(target_os = "linux")]
93 #[link_name = "__xpg_strerror_r"]
94 fn strerror_r(errnum
: c_int
, buf
: *mut c_char
,
95 buflen
: libc
::size_t
) -> c_int
;
97 #[cfg(not(target_os = "linux"))]
99 fn strerror_r(errnum
: c_int
, buf
: *mut c_char
,
100 buflen
: libc
::size_t
) -> c_int
;
103 let mut buf
= [0 as c_char
; TMPBUF_SZ
];
105 let p
= buf
.as_mut_ptr();
107 if strerror_r(errno
as c_int
, p
, buf
.len() as libc
::size_t
) < 0 {
108 panic
!("strerror_r failure");
111 let p
= p
as *const _
;
112 str::from_utf8(CStr
::from_ptr(p
).to_bytes()).unwrap().to_string()
116 pub fn getcwd() -> io
::Result
<PathBuf
> {
117 let mut buf
= [0 as c_char
; BUF_BYTES
];
119 if libc
::getcwd(buf
.as_mut_ptr(), buf
.len() as libc
::size_t
).is_null() {
120 Err(io
::Error
::last_os_error())
122 Ok(bytes2path(CStr
::from_ptr(buf
.as_ptr()).to_bytes()))
127 pub fn chdir(p
: &path
::Path
) -> io
::Result
<()> {
128 let p
: &OsStr
= p
.as_ref();
129 let p
= try
!(CString
::new(p
.as_bytes()));
131 match libc
::chdir(p
.as_ptr()) == (0 as c_int
) {
133 false => Err(io
::Error
::last_os_error()),
138 pub struct SplitPaths
<'a
> {
139 iter
: iter
::Map
<slice
::Split
<'a
, u8, fn(&u8) -> bool
>,
140 fn(&'a
[u8]) -> PathBuf
>,
143 pub fn split_paths
<'a
>(unparsed
: &'a OsStr
) -> SplitPaths
<'a
> {
144 fn is_colon(b
: &u8) -> bool { *b == b':' }
145 let unparsed
= unparsed
.as_bytes();
147 iter
: unparsed
.split(is_colon
as fn(&u8) -> bool
)
148 .map(bytes2path
as fn(&'a
[u8]) -> PathBuf
)
152 impl<'a
> Iterator
for SplitPaths
<'a
> {
154 fn next(&mut self) -> Option
<PathBuf
> { self.iter.next() }
155 fn size_hint(&self) -> (usize, Option
<usize>) { self.iter.size_hint() }
159 pub struct JoinPathsError
;
161 pub fn join_paths
<I
, T
>(paths
: I
) -> Result
<OsString
, JoinPathsError
>
162 where I
: Iterator
<Item
=T
>, T
: AsRef
<OsStr
>
164 let mut joined
= Vec
::new();
167 for (i
, path
) in paths
.enumerate() {
168 let path
= path
.as_ref().as_bytes();
169 if i
> 0 { joined.push(sep) }
170 if path
.contains(&sep
) {
171 return Err(JoinPathsError
)
173 joined
.push_all(path
);
175 Ok(OsStringExt
::from_vec(joined
))
178 impl fmt
::Display
for JoinPathsError
{
179 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
180 "path segment contains separator `:`".fmt(f
)
184 impl StdError
for JoinPathsError
{
185 fn description(&self) -> &str { "failed to join paths" }
188 #[cfg(target_os = "freebsd")]
189 pub fn current_exe() -> io
::Result
<PathBuf
> {
191 use libc
::funcs
::bsd44
::*;
192 use libc
::consts
::os
::extra
::*;
193 let mut mib
= vec
![CTL_KERN
as c_int
,
195 KERN_PROC_PATHNAME
as c_int
,
197 let mut sz
: libc
::size_t
= 0;
198 let err
= sysctl(mib
.as_mut_ptr(), mib
.len() as ::libc
::c_uint
,
199 ptr
::null_mut(), &mut sz
, ptr
::null_mut(),
201 if err
!= 0 { return Err(io::Error::last_os_error()); }
202 if sz
== 0 { return Err(io::Error::last_os_error()); }
203 let mut v
: Vec
<u8> = Vec
::with_capacity(sz
as usize);
204 let err
= sysctl(mib
.as_mut_ptr(), mib
.len() as ::libc
::c_uint
,
205 v
.as_mut_ptr() as *mut libc
::c_void
, &mut sz
,
206 ptr
::null_mut(), 0 as libc
::size_t
);
207 if err
!= 0 { return Err(io::Error::last_os_error()); }
208 if sz
== 0 { return Err(io::Error::last_os_error()); }
209 v
.set_len(sz
as usize - 1); // chop off trailing NUL
210 Ok(PathBuf
::from(OsString
::from_vec(v
)))
214 #[cfg(target_os = "dragonfly")]
215 pub fn current_exe() -> io
::Result
<PathBuf
> {
216 ::fs
::read_link("/proc/curproc/file")
219 #[cfg(any(target_os = "bitrig", target_os = "openbsd"))]
220 pub fn current_exe() -> io
::Result
<PathBuf
> {
221 use sync
::{StaticMutex, MUTEX_INIT}
;
222 static LOCK
: StaticMutex
= MUTEX_INIT
;
225 fn rust_current_exe() -> *const c_char
;
228 let _guard
= LOCK
.lock();
231 let v
= rust_current_exe();
233 Err(io
::Error
::last_os_error())
235 let vec
= CStr
::from_ptr(v
).to_bytes().to_vec();
236 Ok(PathBuf
::from(OsString
::from_vec(vec
)))
241 #[cfg(any(target_os = "linux", target_os = "android"))]
242 pub fn current_exe() -> io
::Result
<PathBuf
> {
243 ::fs
::read_link("/proc/self/exe")
246 #[cfg(any(target_os = "macos", target_os = "ios"))]
247 pub fn current_exe() -> io
::Result
<PathBuf
> {
249 use libc
::funcs
::extra
::_NSGetExecutablePath
;
251 _NSGetExecutablePath(ptr
::null_mut(), &mut sz
);
252 if sz
== 0 { return Err(io::Error::last_os_error()); }
253 let mut v
: Vec
<u8> = Vec
::with_capacity(sz
as usize);
254 let err
= _NSGetExecutablePath(v
.as_mut_ptr() as *mut i8, &mut sz
);
255 if err
!= 0 { return Err(io::Error::last_os_error()); }
256 v
.set_len(sz
as usize - 1); // chop off trailing NUL
257 Ok(PathBuf
::from(OsString
::from_vec(v
)))
262 iter
: vec
::IntoIter
<OsString
>,
263 _dont_send_or_sync_me
: *mut (),
266 impl Iterator
for Args
{
267 type Item
= OsString
;
268 fn next(&mut self) -> Option
<OsString
> { self.iter.next() }
269 fn size_hint(&self) -> (usize, Option
<usize>) { self.iter.size_hint() }
272 impl ExactSizeIterator
for Args
{
273 fn len(&self) -> usize { self.iter.len() }
276 /// Returns the command line arguments
278 /// Returns a list of the command line arguments.
279 #[cfg(target_os = "macos")]
280 pub fn args() -> Args
{
282 // These functions are in crt_externs.h.
283 fn _NSGetArgc() -> *mut c_int
;
284 fn _NSGetArgv() -> *mut *mut *mut c_char
;
288 let (argc
, argv
) = (*_NSGetArgc() as isize,
289 *_NSGetArgv() as *const *const c_char
);
290 (0.. argc
as isize).map(|i
| {
291 let bytes
= CStr
::from_ptr(*argv
.offset(i
)).to_bytes().to_vec();
292 OsStringExt
::from_vec(bytes
)
293 }).collect
::<Vec
<_
>>()
296 iter
: vec
.into_iter(),
297 _dont_send_or_sync_me
: 0 as *mut (),
301 // As _NSGetArgc and _NSGetArgv aren't mentioned in iOS docs
302 // and use underscores in their names - they're most probably
303 // are considered private and therefore should be avoided
304 // Here is another way to get arguments using Objective C
307 // In general it looks like:
309 // let args = [[NSProcessInfo processInfo] arguments]
310 // for i in (0..[args count])
311 // res.push([args objectAtIndex:i])
313 #[cfg(target_os = "ios")]
314 pub fn args() -> Args
{
317 #[link(name = "objc")]
319 fn sel_registerName(name
: *const libc
::c_uchar
) -> Sel
;
320 fn objc_msgSend(obj
: NsId
, sel
: Sel
, ...) -> NsId
;
321 fn objc_getClass(class_name
: *const libc
::c_uchar
) -> NsId
;
324 #[link(name = "Foundation", kind = "framework")]
327 type Sel
= *const libc
::c_void
;
328 type NsId
= *const libc
::c_void
;
330 let mut res
= Vec
::new();
333 let process_info_sel
= sel_registerName("processInfo\0".as_ptr());
334 let arguments_sel
= sel_registerName("arguments\0".as_ptr());
335 let utf8_sel
= sel_registerName("UTF8String\0".as_ptr());
336 let count_sel
= sel_registerName("count\0".as_ptr());
337 let object_at_sel
= sel_registerName("objectAtIndex:\0".as_ptr());
339 let klass
= objc_getClass("NSProcessInfo\0".as_ptr());
340 let info
= objc_msgSend(klass
, process_info_sel
);
341 let args
= objc_msgSend(info
, arguments_sel
);
343 let cnt
: usize = mem
::transmute(objc_msgSend(args
, count_sel
));
345 let tmp
= objc_msgSend(args
, object_at_sel
, i
);
346 let utf_c_str
: *const libc
::c_char
=
347 mem
::transmute(objc_msgSend(tmp
, utf8_sel
));
348 let bytes
= CStr
::from_ptr(utf_c_str
).to_bytes();
349 res
.push(OsString
::from(str::from_utf8(bytes
).unwrap()))
353 Args { iter: res.into_iter(), _dont_send_or_sync_me: 0 as *mut _ }
356 #[cfg(any(target_os = "linux",
357 target_os
= "android",
358 target_os
= "freebsd",
359 target_os
= "dragonfly",
360 target_os
= "bitrig",
361 target_os
= "openbsd"))]
362 pub fn args() -> Args
{
364 let bytes
= rt
::args
::clone().unwrap_or(Vec
::new());
365 let v
: Vec
<OsString
> = bytes
.into_iter().map(|v
| {
366 OsStringExt
::from_vec(v
)
368 Args { iter: v.into_iter(), _dont_send_or_sync_me: 0 as *mut _ }
372 iter
: vec
::IntoIter
<(OsString
, OsString
)>,
373 _dont_send_or_sync_me
: *mut (),
376 impl Iterator
for Env
{
377 type Item
= (OsString
, OsString
);
378 fn next(&mut self) -> Option
<(OsString
, OsString
)> { self.iter.next() }
379 fn size_hint(&self) -> (usize, Option
<usize>) { self.iter.size_hint() }
382 #[cfg(target_os = "macos")]
383 pub unsafe fn environ() -> *mut *const *const c_char
{
384 extern { fn _NSGetEnviron() -> *mut *const *const c_char; }
388 #[cfg(not(target_os = "macos"))]
389 pub unsafe fn environ() -> *mut *const *const c_char
{
390 extern { static mut environ: *const *const c_char; }
394 /// Returns a vector of (variable, value) byte-vector pairs for all the
395 /// environment variables of the current process.
396 pub fn env() -> Env
{
398 let mut environ
= *environ();
399 if environ
as usize == 0 {
400 panic
!("os::env() failure getting env string from OS: {}",
401 io
::Error
::last_os_error());
403 let mut result
= Vec
::new();
404 while *environ
!= ptr
::null() {
405 result
.push(parse(CStr
::from_ptr(*environ
).to_bytes()));
406 environ
= environ
.offset(1);
408 Env { iter: result.into_iter(), _dont_send_or_sync_me: 0 as *mut _ }
411 fn parse(input
: &[u8]) -> (OsString
, OsString
) {
412 let mut it
= input
.splitn(2, |b
| *b
== b'
='
);
413 let key
= it
.next().unwrap().to_vec();
414 let default: &[u8] = &[];
415 let val
= it
.next().unwrap_or(default).to_vec();
416 (OsStringExt
::from_vec(key
), OsStringExt
::from_vec(val
))
420 pub fn getenv(k
: &OsStr
) -> Option
<OsString
> {
422 let s
= k
.to_cstring().unwrap();
423 let s
= libc
::getenv(s
.as_ptr()) as *const _
;
427 Some(OsStringExt
::from_vec(CStr
::from_ptr(s
).to_bytes().to_vec()))
432 pub fn setenv(k
: &OsStr
, v
: &OsStr
) {
434 let k
= k
.to_cstring().unwrap();
435 let v
= v
.to_cstring().unwrap();
436 if libc
::funcs
::posix01
::unistd
::setenv(k
.as_ptr(), v
.as_ptr(), 1) != 0 {
437 panic
!("failed setenv: {}", io
::Error
::last_os_error());
442 pub fn unsetenv(n
: &OsStr
) {
444 let nbuf
= n
.to_cstring().unwrap();
445 if libc
::funcs
::posix01
::unistd
::unsetenv(nbuf
.as_ptr()) != 0 {
446 panic
!("failed unsetenv: {}", io
::Error
::last_os_error());
452 pub unsafe fn pipe() -> IoResult
<(FileDesc
, FileDesc
)> {
453 let mut fds
= [0; 2];
454 if libc
::pipe(fds
.as_mut_ptr()) == 0 {
455 Ok((FileDesc
::new(fds
[0], true), FileDesc
::new(fds
[1], true)))
457 Err(IoError
::last_error())
461 pub fn page_size() -> usize {
463 libc
::sysconf(libc
::_SC_PAGESIZE
) as usize
467 pub fn temp_dir() -> PathBuf
{
468 getenv("TMPDIR".as_ref()).map(os2path
).unwrap_or_else(|| {
469 if cfg
!(target_os
= "android") {
470 PathBuf
::from("/data/local/tmp")
472 PathBuf
::from("/tmp")
477 pub fn home_dir() -> Option
<PathBuf
> {
478 return getenv("HOME".as_ref()).or_else(|| unsafe {
482 #[cfg(any(target_os = "android",
484 unsafe fn fallback() -> Option
<OsString
> { None }
485 #[cfg(not(any(target_os = "android",
486 target_os
= "ios")))]
487 unsafe fn fallback() -> Option
<OsString
> {
488 let amt
= match libc
::sysconf(c
::_SC_GETPW_R_SIZE_MAX
) {
489 n
if n
< 0 => 512 as usize,
492 let me
= libc
::getuid();
494 let mut buf
= Vec
::with_capacity(amt
);
495 let mut passwd
: c
::passwd
= mem
::zeroed();
496 let mut result
= 0 as *mut _
;
497 match c
::getpwuid_r(me
, &mut passwd
, buf
.as_mut_ptr(),
498 buf
.capacity() as libc
::size_t
,
500 0 if !result
.is_null() => {}
503 let ptr
= passwd
.pw_dir
as *const _
;
504 let bytes
= CStr
::from_ptr(ptr
).to_bytes().to_vec();
505 return Some(OsStringExt
::from_vec(bytes
))
510 pub fn exit(code
: i32) -> ! {
511 unsafe { libc::exit(code as c_int) }