| // Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT |
| // file at the top-level directory of this distribution and at |
| // http://rust-lang.org/COPYRIGHT. |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| //! Dynamic library facilities. |
| //! |
| //! A simple wrapper over the platform's dynamic library facilities |
| |
| #![unstable(feature = "dynamic_lib", |
| reason = "API has not been scrutinized and is highly likely to \ |
| either disappear or change", |
| issue = "27810")] |
| #![rustc_deprecated(since = "1.5.0", reason = "replaced with 'dylib' on crates.io")] |
| #![allow(missing_docs)] |
| #![allow(deprecated)] |
| |
| use prelude::v1::*; |
| |
| use env; |
| use ffi::{CString, OsString}; |
| use path::{Path, PathBuf}; |
| |
| pub struct DynamicLibrary { |
| handle: *mut u8 |
| } |
| |
| impl Drop for DynamicLibrary { |
| fn drop(&mut self) { |
| match dl::check_for_errors_in(|| { |
| unsafe { |
| dl::close(self.handle) |
| } |
| }) { |
| Ok(()) => {}, |
| Err(str) => panic!("{}", str) |
| } |
| } |
| } |
| |
| impl DynamicLibrary { |
| /// Lazily open a dynamic library. When passed None it gives a |
| /// handle to the calling process |
| pub fn open(filename: Option<&Path>) -> Result<DynamicLibrary, String> { |
| let maybe_library = dl::open(filename.map(|path| path.as_os_str())); |
| |
| // The dynamic library must not be constructed if there is |
| // an error opening the library so the destructor does not |
| // run. |
| match maybe_library { |
| Err(err) => Err(err), |
| Ok(handle) => Ok(DynamicLibrary { handle: handle }) |
| } |
| } |
| |
| /// Prepends a path to this process's search path for dynamic libraries |
| pub fn prepend_search_path(path: &Path) { |
| let mut search_path = DynamicLibrary::search_path(); |
| search_path.insert(0, path.to_path_buf()); |
| env::set_var(DynamicLibrary::envvar(), &DynamicLibrary::create_path(&search_path)); |
| } |
| |
| /// From a slice of paths, create a new vector which is suitable to be an |
| /// environment variable for this platforms dylib search path. |
| pub fn create_path(path: &[PathBuf]) -> OsString { |
| let mut newvar = OsString::new(); |
| for (i, path) in path.iter().enumerate() { |
| if i > 0 { newvar.push(DynamicLibrary::separator()); } |
| newvar.push(path); |
| } |
| return newvar; |
| } |
| |
| /// Returns the environment variable for this process's dynamic library |
| /// search path |
| pub fn envvar() -> &'static str { |
| if cfg!(windows) { |
| "PATH" |
| } else if cfg!(target_os = "macos") { |
| "DYLD_LIBRARY_PATH" |
| } else { |
| "LD_LIBRARY_PATH" |
| } |
| } |
| |
| fn separator() -> &'static str { |
| if cfg!(windows) { ";" } else { ":" } |
| } |
| |
| /// Returns the current search path for dynamic libraries being used by this |
| /// process |
| pub fn search_path() -> Vec<PathBuf> { |
| match env::var_os(DynamicLibrary::envvar()) { |
| Some(var) => env::split_paths(&var).collect(), |
| None => Vec::new(), |
| } |
| } |
| |
| /// Accesses the value at the symbol of the dynamic library. |
| pub unsafe fn symbol<T>(&self, symbol: &str) -> Result<*mut T, String> { |
| // This function should have a lifetime constraint of 'a on |
| // T but that feature is still unimplemented |
| |
| let raw_string = CString::new(symbol).unwrap(); |
| let maybe_symbol_value = dl::check_for_errors_in(|| { |
| dl::symbol(self.handle, raw_string.as_ptr()) |
| }); |
| |
| // The value must not be constructed if there is an error so |
| // the destructor does not run. |
| match maybe_symbol_value { |
| Err(err) => Err(err), |
| Ok(symbol_value) => Ok(symbol_value as *mut T) |
| } |
| } |
| } |
| |
| #[cfg(all(test, not(target_os = "ios"), not(target_os = "nacl")))] |
| mod tests { |
| use super::*; |
| use prelude::v1::*; |
| use libc; |
| use mem; |
| use path::Path; |
| |
| #[test] |
| #[cfg_attr(any(windows, |
| target_os = "android", // FIXME #10379 |
| target_env = "musl"), ignore)] |
| #[allow(deprecated)] |
| fn test_loading_cosine() { |
| // The math library does not need to be loaded since it is already |
| // statically linked in |
| let libm = match DynamicLibrary::open(None) { |
| Err(error) => panic!("Could not load self as module: {}", error), |
| Ok(libm) => libm |
| }; |
| |
| let cosine: extern fn(libc::c_double) -> libc::c_double = unsafe { |
| match libm.symbol("cos") { |
| Err(error) => panic!("Could not load function cos: {}", error), |
| Ok(cosine) => mem::transmute::<*mut u8, _>(cosine) |
| } |
| }; |
| |
| let argument = 0.0; |
| let expected_result = 1.0; |
| let result = cosine(argument); |
| if result != expected_result { |
| panic!("cos({}) != {} but equaled {} instead", argument, |
| expected_result, result) |
| } |
| } |
| |
| #[test] |
| #[cfg(any(target_os = "linux", |
| target_os = "macos", |
| target_os = "freebsd", |
| target_os = "dragonfly", |
| target_os = "bitrig", |
| target_os = "netbsd", |
| target_os = "openbsd"))] |
| #[allow(deprecated)] |
| fn test_errors_do_not_crash() { |
| // Open /dev/null as a library to get an error, and make sure |
| // that only causes an error, and not a crash. |
| let path = Path::new("/dev/null"); |
| match DynamicLibrary::open(Some(&path)) { |
| Err(_) => {} |
| Ok(_) => panic!("Successfully opened the empty library.") |
| } |
| } |
| } |
| |
| #[cfg(any(target_os = "linux", |
| target_os = "android", |
| target_os = "macos", |
| target_os = "ios", |
| target_os = "freebsd", |
| target_os = "dragonfly", |
| target_os = "bitrig", |
| target_os = "netbsd", |
| target_os = "openbsd"))] |
| mod dl { |
| use prelude::v1::*; |
| |
| use ffi::{CStr, OsStr}; |
| use str; |
| use libc; |
| use ptr; |
| |
| pub fn open(filename: Option<&OsStr>) -> Result<*mut u8, String> { |
| check_for_errors_in(|| { |
| unsafe { |
| match filename { |
| Some(filename) => open_external(filename), |
| None => open_internal(), |
| } |
| } |
| }) |
| } |
| |
| const LAZY: libc::c_int = 1; |
| |
| unsafe fn open_external(filename: &OsStr) -> *mut u8 { |
| let s = filename.to_cstring().unwrap(); |
| libc::dlopen(s.as_ptr(), LAZY) as *mut u8 |
| } |
| |
| unsafe fn open_internal() -> *mut u8 { |
| libc::dlopen(ptr::null(), LAZY) as *mut u8 |
| } |
| |
| pub fn check_for_errors_in<T, F>(f: F) -> Result<T, String> where |
| F: FnOnce() -> T, |
| { |
| use sync::StaticMutex; |
| static LOCK: StaticMutex = StaticMutex::new(); |
| unsafe { |
| // dlerror isn't thread safe, so we need to lock around this entire |
| // sequence |
| let _guard = LOCK.lock(); |
| let _old_error = libc::dlerror(); |
| |
| let result = f(); |
| |
| let last_error = libc::dlerror() as *const _; |
| let ret = if ptr::null() == last_error { |
| Ok(result) |
| } else { |
| let s = CStr::from_ptr(last_error).to_bytes(); |
| Err(str::from_utf8(s).unwrap().to_owned()) |
| }; |
| |
| ret |
| } |
| } |
| |
| pub unsafe fn symbol(handle: *mut u8, |
| symbol: *const libc::c_char) -> *mut u8 { |
| libc::dlsym(handle as *mut libc::c_void, symbol) as *mut u8 |
| } |
| pub unsafe fn close(handle: *mut u8) { |
| libc::dlclose(handle as *mut libc::c_void); () |
| } |
| } |
| |
| #[cfg(target_os = "windows")] |
| mod dl { |
| use prelude::v1::*; |
| |
| use ffi::OsStr; |
| use libc; |
| use os::windows::prelude::*; |
| use ptr; |
| use sys::c; |
| use sys::os; |
| |
| pub fn open(filename: Option<&OsStr>) -> Result<*mut u8, String> { |
| // disable "dll load failed" error dialog. |
| let mut use_thread_mode = true; |
| let prev_error_mode = unsafe { |
| // SEM_FAILCRITICALERRORS 0x01 |
| let new_error_mode = 1; |
| let mut prev_error_mode = 0; |
| // Windows >= 7 supports thread error mode. |
| let result = c::SetThreadErrorMode(new_error_mode, |
| &mut prev_error_mode); |
| if result == 0 { |
| let err = os::errno(); |
| if err == c::ERROR_CALL_NOT_IMPLEMENTED as i32 { |
| use_thread_mode = false; |
| // SetThreadErrorMode not found. use fallback solution: |
| // SetErrorMode() Note that SetErrorMode is process-wide so |
| // this can cause race condition! However, since even |
| // Windows APIs do not care of such problem (#20650), we |
| // just assume SetErrorMode race is not a great deal. |
| prev_error_mode = c::SetErrorMode(new_error_mode); |
| } |
| } |
| prev_error_mode |
| }; |
| |
| unsafe { |
| c::SetLastError(0); |
| } |
| |
| let result = match filename { |
| Some(filename) => { |
| let filename_str: Vec<_> = |
| filename.encode_wide().chain(Some(0)).collect(); |
| let result = unsafe { |
| c::LoadLibraryW(filename_str.as_ptr()) |
| }; |
| // beware: Vec/String may change errno during drop! |
| // so we get error here. |
| if result == ptr::null_mut() { |
| let errno = os::errno(); |
| Err(os::error_string(errno)) |
| } else { |
| Ok(result as *mut u8) |
| } |
| } |
| None => { |
| let mut handle = ptr::null_mut(); |
| let succeeded = unsafe { |
| c::GetModuleHandleExW(0 as c::DWORD, ptr::null(), |
| &mut handle) |
| }; |
| if succeeded == c::FALSE { |
| let errno = os::errno(); |
| Err(os::error_string(errno)) |
| } else { |
| Ok(handle as *mut u8) |
| } |
| } |
| }; |
| |
| unsafe { |
| if use_thread_mode { |
| c::SetThreadErrorMode(prev_error_mode, ptr::null_mut()); |
| } else { |
| c::SetErrorMode(prev_error_mode); |
| } |
| } |
| |
| result |
| } |
| |
| pub fn check_for_errors_in<T, F>(f: F) -> Result<T, String> where |
| F: FnOnce() -> T, |
| { |
| unsafe { |
| c::SetLastError(0); |
| |
| let result = f(); |
| |
| let error = os::errno(); |
| if 0 == error { |
| Ok(result) |
| } else { |
| Err(format!("Error code {}", error)) |
| } |
| } |
| } |
| |
| pub unsafe fn symbol(handle: *mut u8, symbol: *const libc::c_char) -> *mut u8 { |
| c::GetProcAddress(handle as c::HMODULE, symbol) as *mut u8 |
| } |
| pub unsafe fn close(handle: *mut u8) { |
| c::FreeLibrary(handle as c::HMODULE); |
| } |
| } |
| |
| #[cfg(target_os = "nacl")] |
| pub mod dl { |
| use ffi::OsStr; |
| use ptr; |
| use result::Result; |
| use result::Result::Err; |
| use libc; |
| use string::String; |
| use ops::FnOnce; |
| use option::Option; |
| |
| pub fn open(_filename: Option<&OsStr>) -> Result<*mut u8, String> { |
| Err(format!("NaCl + Newlib doesn't impl loading shared objects")) |
| } |
| |
| pub fn check_for_errors_in<T, F>(_f: F) -> Result<T, String> |
| where F: FnOnce() -> T, |
| { |
| Err(format!("NaCl doesn't support shared objects")) |
| } |
| |
| pub unsafe fn symbol(_handle: *mut u8, _symbol: *const libc::c_char) -> *mut u8 { |
| ptr::null_mut() |
| } |
| pub unsafe fn close(_handle: *mut u8) { } |
| } |