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}
;
26 use path
::{self, PathBuf}
;
33 const BUF_BYTES
: usize = 2048;
34 const TMPBUF_SZ
: usize = 128;
36 fn bytes2path(b
: &[u8]) -> PathBuf
{
37 PathBuf
::from(<OsStr
as OsStrExt
>::from_bytes(b
))
40 fn os2path(os
: OsString
) -> PathBuf
{
41 bytes2path(os
.as_bytes())
44 /// Returns the platform-specific value of errno
45 pub fn errno() -> i32 {
46 #[cfg(any(target_os = "macos",
48 target_os
= "freebsd"))]
49 unsafe fn errno_location() -> *const c_int
{
50 extern { fn __error() -> *const c_int; }
54 #[cfg(target_os = "bitrig")]
55 fn errno_location() -> *const c_int
{
57 fn __errno() -> *const c_int
;
64 #[cfg(target_os = "dragonfly")]
65 unsafe fn errno_location() -> *const c_int
{
66 extern { fn __dfly_error() -> *const c_int; }
70 #[cfg(target_os = "openbsd")]
71 unsafe fn errno_location() -> *const c_int
{
72 extern { fn __errno() -> *const c_int; }
76 #[cfg(any(target_os = "linux", target_os = "android"))]
77 unsafe fn errno_location() -> *const c_int
{
78 extern { fn __errno_location() -> *const c_int; }
83 (*errno_location()) as i32
87 /// Gets a detailed string description for the given error number.
88 pub fn error_string(errno
: i32) -> String
{
89 #[cfg(target_os = "linux")]
91 #[link_name = "__xpg_strerror_r"]
92 fn strerror_r(errnum
: c_int
, buf
: *mut c_char
,
93 buflen
: libc
::size_t
) -> c_int
;
95 #[cfg(not(target_os = "linux"))]
97 fn strerror_r(errnum
: c_int
, buf
: *mut c_char
,
98 buflen
: libc
::size_t
) -> c_int
;
101 let mut buf
= [0 as c_char
; TMPBUF_SZ
];
103 let p
= buf
.as_mut_ptr();
105 if strerror_r(errno
as c_int
, p
, buf
.len() as libc
::size_t
) < 0 {
106 panic
!("strerror_r failure");
109 let p
= p
as *const _
;
110 str::from_utf8(CStr
::from_ptr(p
).to_bytes()).unwrap().to_string()
114 pub fn getcwd() -> io
::Result
<PathBuf
> {
115 let mut buf
= [0 as c_char
; BUF_BYTES
];
117 if libc
::getcwd(buf
.as_mut_ptr(), buf
.len() as libc
::size_t
).is_null() {
118 Err(io
::Error
::last_os_error())
120 Ok(bytes2path(CStr
::from_ptr(buf
.as_ptr()).to_bytes()))
125 pub fn chdir(p
: &path
::Path
) -> io
::Result
<()> {
126 let p
: &OsStr
= p
.as_ref();
127 let p
= try
!(CString
::new(p
.as_bytes()));
129 match libc
::chdir(p
.as_ptr()) == (0 as c_int
) {
131 false => Err(io
::Error
::last_os_error()),
136 pub struct SplitPaths
<'a
> {
137 iter
: iter
::Map
<slice
::Split
<'a
, u8, fn(&u8) -> bool
>,
138 fn(&'a
[u8]) -> PathBuf
>,
141 pub fn split_paths
<'a
>(unparsed
: &'a OsStr
) -> SplitPaths
<'a
> {
142 fn is_colon(b
: &u8) -> bool { *b == b':' }
143 let unparsed
= unparsed
.as_bytes();
145 iter
: unparsed
.split(is_colon
as fn(&u8) -> bool
)
146 .map(bytes2path
as fn(&'a
[u8]) -> PathBuf
)
150 impl<'a
> Iterator
for SplitPaths
<'a
> {
152 fn next(&mut self) -> Option
<PathBuf
> { self.iter.next() }
153 fn size_hint(&self) -> (usize, Option
<usize>) { self.iter.size_hint() }
157 pub struct JoinPathsError
;
159 pub fn join_paths
<I
, T
>(paths
: I
) -> Result
<OsString
, JoinPathsError
>
160 where I
: Iterator
<Item
=T
>, T
: AsRef
<OsStr
>
162 let mut joined
= Vec
::new();
165 for (i
, path
) in paths
.enumerate() {
166 let path
= path
.as_ref().as_bytes();
167 if i
> 0 { joined.push(sep) }
168 if path
.contains(&sep
) {
169 return Err(JoinPathsError
)
171 joined
.push_all(path
);
173 Ok(OsStringExt
::from_vec(joined
))
176 impl fmt
::Display
for JoinPathsError
{
177 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
178 "path segment contains separator `:`".fmt(f
)
182 impl StdError
for JoinPathsError
{
183 fn description(&self) -> &str { "failed to join paths" }
186 #[cfg(target_os = "freebsd")]
187 pub fn current_exe() -> io
::Result
<PathBuf
> {
189 use libc
::funcs
::bsd44
::*;
190 use libc
::consts
::os
::extra
::*;
191 let mut mib
= vec
![CTL_KERN
as c_int
,
193 KERN_PROC_PATHNAME
as c_int
,
195 let mut sz
: libc
::size_t
= 0;
196 let err
= sysctl(mib
.as_mut_ptr(), mib
.len() as ::libc
::c_uint
,
197 ptr
::null_mut(), &mut sz
, ptr
::null_mut(),
199 if err
!= 0 { return Err(io::Error::last_os_error()); }
200 if sz
== 0 { return Err(io::Error::last_os_error()); }
201 let mut v
: Vec
<u8> = Vec
::with_capacity(sz
as usize);
202 let err
= sysctl(mib
.as_mut_ptr(), mib
.len() as ::libc
::c_uint
,
203 v
.as_mut_ptr() as *mut libc
::c_void
, &mut sz
,
204 ptr
::null_mut(), 0 as libc
::size_t
);
205 if err
!= 0 { return Err(io::Error::last_os_error()); }
206 if sz
== 0 { return Err(io::Error::last_os_error()); }
207 v
.set_len(sz
as usize - 1); // chop off trailing NUL
208 Ok(PathBuf
::from(OsString
::from_vec(v
)))
212 #[cfg(target_os = "dragonfly")]
213 pub fn current_exe() -> io
::Result
<PathBuf
> {
214 ::fs
::read_link("/proc/curproc/file")
217 #[cfg(any(target_os = "bitrig", target_os = "openbsd"))]
218 pub fn current_exe() -> io
::Result
<PathBuf
> {
219 use sync
::{StaticMutex, MUTEX_INIT}
;
220 static LOCK
: StaticMutex
= MUTEX_INIT
;
223 fn rust_current_exe() -> *const c_char
;
226 let _guard
= LOCK
.lock();
229 let v
= rust_current_exe();
231 Err(io
::Error
::last_os_error())
233 let vec
= CStr
::from_ptr(v
).to_bytes().to_vec();
234 Ok(PathBuf
::from(OsString
::from_vec(vec
)))
239 #[cfg(any(target_os = "linux", target_os = "android"))]
240 pub fn current_exe() -> io
::Result
<PathBuf
> {
241 ::fs
::read_link("/proc/self/exe")
244 #[cfg(any(target_os = "macos", target_os = "ios"))]
245 pub fn current_exe() -> io
::Result
<PathBuf
> {
247 use libc
::funcs
::extra
::_NSGetExecutablePath
;
249 _NSGetExecutablePath(ptr
::null_mut(), &mut sz
);
250 if sz
== 0 { return Err(io::Error::last_os_error()); }
251 let mut v
: Vec
<u8> = Vec
::with_capacity(sz
as usize);
252 let err
= _NSGetExecutablePath(v
.as_mut_ptr() as *mut i8, &mut sz
);
253 if err
!= 0 { return Err(io::Error::last_os_error()); }
254 v
.set_len(sz
as usize - 1); // chop off trailing NUL
255 Ok(PathBuf
::from(OsString
::from_vec(v
)))
260 iter
: vec
::IntoIter
<OsString
>,
261 _dont_send_or_sync_me
: *mut (),
264 impl Iterator
for Args
{
265 type Item
= OsString
;
266 fn next(&mut self) -> Option
<OsString
> { self.iter.next() }
267 fn size_hint(&self) -> (usize, Option
<usize>) { self.iter.size_hint() }
270 impl ExactSizeIterator
for Args
{
271 fn len(&self) -> usize { self.iter.len() }
274 /// Returns the command line arguments
276 /// Returns a list of the command line arguments.
277 #[cfg(target_os = "macos")]
278 pub fn args() -> Args
{
280 // These functions are in crt_externs.h.
281 fn _NSGetArgc() -> *mut c_int
;
282 fn _NSGetArgv() -> *mut *mut *mut c_char
;
286 let (argc
, argv
) = (*_NSGetArgc() as isize,
287 *_NSGetArgv() as *const *const c_char
);
288 (0.. argc
as isize).map(|i
| {
289 let bytes
= CStr
::from_ptr(*argv
.offset(i
)).to_bytes().to_vec();
290 OsStringExt
::from_vec(bytes
)
291 }).collect
::<Vec
<_
>>()
294 iter
: vec
.into_iter(),
295 _dont_send_or_sync_me
: 0 as *mut (),
299 // As _NSGetArgc and _NSGetArgv aren't mentioned in iOS docs
300 // and use underscores in their names - they're most probably
301 // are considered private and therefore should be avoided
302 // Here is another way to get arguments using Objective C
305 // In general it looks like:
307 // let args = [[NSProcessInfo processInfo] arguments]
308 // for i in (0..[args count])
309 // res.push([args objectAtIndex:i])
311 #[cfg(target_os = "ios")]
312 pub fn args() -> Args
{
315 #[link(name = "objc")]
317 fn sel_registerName(name
: *const libc
::c_uchar
) -> Sel
;
318 fn objc_msgSend(obj
: NsId
, sel
: Sel
, ...) -> NsId
;
319 fn objc_getClass(class_name
: *const libc
::c_uchar
) -> NsId
;
322 #[link(name = "Foundation", kind = "framework")]
325 type Sel
= *const libc
::c_void
;
326 type NsId
= *const libc
::c_void
;
328 let mut res
= Vec
::new();
331 let process_info_sel
= sel_registerName("processInfo\0".as_ptr());
332 let arguments_sel
= sel_registerName("arguments\0".as_ptr());
333 let utf8_sel
= sel_registerName("UTF8String\0".as_ptr());
334 let count_sel
= sel_registerName("count\0".as_ptr());
335 let object_at_sel
= sel_registerName("objectAtIndex:\0".as_ptr());
337 let klass
= objc_getClass("NSProcessInfo\0".as_ptr());
338 let info
= objc_msgSend(klass
, process_info_sel
);
339 let args
= objc_msgSend(info
, arguments_sel
);
341 let cnt
: usize = mem
::transmute(objc_msgSend(args
, count_sel
));
343 let tmp
= objc_msgSend(args
, object_at_sel
, i
);
344 let utf_c_str
: *const libc
::c_char
=
345 mem
::transmute(objc_msgSend(tmp
, utf8_sel
));
346 let bytes
= CStr
::from_ptr(utf_c_str
).to_bytes();
347 res
.push(OsString
::from(str::from_utf8(bytes
).unwrap()))
351 Args { iter: res.into_iter(), _dont_send_or_sync_me: 0 as *mut _ }
354 #[cfg(any(target_os = "linux",
355 target_os
= "android",
356 target_os
= "freebsd",
357 target_os
= "dragonfly",
358 target_os
= "bitrig",
359 target_os
= "openbsd"))]
360 pub fn args() -> Args
{
362 let bytes
= rt
::args
::clone().unwrap_or(Vec
::new());
363 let v
: Vec
<OsString
> = bytes
.into_iter().map(|v
| {
364 OsStringExt
::from_vec(v
)
366 Args { iter: v.into_iter(), _dont_send_or_sync_me: 0 as *mut _ }
370 iter
: vec
::IntoIter
<(OsString
, OsString
)>,
371 _dont_send_or_sync_me
: *mut (),
374 impl Iterator
for Env
{
375 type Item
= (OsString
, OsString
);
376 fn next(&mut self) -> Option
<(OsString
, OsString
)> { self.iter.next() }
377 fn size_hint(&self) -> (usize, Option
<usize>) { self.iter.size_hint() }
380 #[cfg(target_os = "macos")]
381 pub unsafe fn environ() -> *mut *const *const c_char
{
382 extern { fn _NSGetEnviron() -> *mut *const *const c_char; }
386 #[cfg(not(target_os = "macos"))]
387 pub unsafe fn environ() -> *mut *const *const c_char
{
388 extern { static mut environ: *const *const c_char; }
392 /// Returns a vector of (variable, value) byte-vector pairs for all the
393 /// environment variables of the current process.
394 pub fn env() -> Env
{
396 let mut environ
= *environ();
397 if environ
as usize == 0 {
398 panic
!("os::env() failure getting env string from OS: {}",
399 io
::Error
::last_os_error());
401 let mut result
= Vec
::new();
402 while *environ
!= ptr
::null() {
403 result
.push(parse(CStr
::from_ptr(*environ
).to_bytes()));
404 environ
= environ
.offset(1);
406 Env { iter: result.into_iter(), _dont_send_or_sync_me: 0 as *mut _ }
409 fn parse(input
: &[u8]) -> (OsString
, OsString
) {
410 let mut it
= input
.splitn(2, |b
| *b
== b'
='
);
411 let key
= it
.next().unwrap().to_vec();
412 let default: &[u8] = &[];
413 let val
= it
.next().unwrap_or(default).to_vec();
414 (OsStringExt
::from_vec(key
), OsStringExt
::from_vec(val
))
418 pub fn getenv(k
: &OsStr
) -> Option
<OsString
> {
420 let s
= k
.to_cstring().unwrap();
421 let s
= libc
::getenv(s
.as_ptr()) as *const _
;
425 Some(OsStringExt
::from_vec(CStr
::from_ptr(s
).to_bytes().to_vec()))
430 pub fn setenv(k
: &OsStr
, v
: &OsStr
) {
432 let k
= k
.to_cstring().unwrap();
433 let v
= v
.to_cstring().unwrap();
434 if libc
::funcs
::posix01
::unistd
::setenv(k
.as_ptr(), v
.as_ptr(), 1) != 0 {
435 panic
!("failed setenv: {}", io
::Error
::last_os_error());
440 pub fn unsetenv(n
: &OsStr
) {
442 let nbuf
= n
.to_cstring().unwrap();
443 if libc
::funcs
::posix01
::unistd
::unsetenv(nbuf
.as_ptr()) != 0 {
444 panic
!("failed unsetenv: {}", io
::Error
::last_os_error());
449 pub fn page_size() -> usize {
451 libc
::sysconf(libc
::_SC_PAGESIZE
) as usize
455 pub fn temp_dir() -> PathBuf
{
456 getenv("TMPDIR".as_ref()).map(os2path
).unwrap_or_else(|| {
457 if cfg
!(target_os
= "android") {
458 PathBuf
::from("/data/local/tmp")
460 PathBuf
::from("/tmp")
465 pub fn home_dir() -> Option
<PathBuf
> {
466 return getenv("HOME".as_ref()).or_else(|| unsafe {
470 #[cfg(any(target_os = "android",
472 unsafe fn fallback() -> Option
<OsString
> { None }
473 #[cfg(not(any(target_os = "android",
474 target_os
= "ios")))]
475 unsafe fn fallback() -> Option
<OsString
> {
476 let amt
= match libc
::sysconf(c
::_SC_GETPW_R_SIZE_MAX
) {
477 n
if n
< 0 => 512 as usize,
480 let me
= libc
::getuid();
482 let mut buf
= Vec
::with_capacity(amt
);
483 let mut passwd
: c
::passwd
= mem
::zeroed();
484 let mut result
= 0 as *mut _
;
485 match c
::getpwuid_r(me
, &mut passwd
, buf
.as_mut_ptr(),
486 buf
.capacity() as libc
::size_t
,
488 0 if !result
.is_null() => {}
491 let ptr
= passwd
.pw_dir
as *const _
;
492 let bytes
= CStr
::from_ptr(ptr
).to_bytes().to_vec();
493 return Some(OsStringExt
::from_vec(bytes
))
498 pub fn exit(code
: i32) -> ! {
499 unsafe { libc::exit(code as c_int) }