зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1601823 - Use pkcs11 just-released 0.4.1. r=glandium
Removes our custom git dep and a duplicate libloading. Differential Revision: https://phabricator.services.mozilla.com/D56107 --HG-- extra : moz-landing-system : lando
This commit is contained in:
Emilio Cobos Álvarez
Родитель
8643fa630b
Коммит
8975d3be2f
|
|
@ -17,11 +17,6 @@ git = "https://github.com/mozilla/neqo"
|
|||
replace-with = "vendored-sources"
|
||||
tag = "v0.1.7"
|
||||
|
||||
[source."https://github.com/mheese/rust-pkcs11"]
|
||||
git = "https://github.com/mheese/rust-pkcs11"
|
||||
replace-with = "vendored-sources"
|
||||
rev = "0810cd5adf4ac8031cc204df3e877d84595c7438"
|
||||
|
||||
[source."https://github.com/kvark/spirv_cross"]
|
||||
branch = "wgpu"
|
||||
git = "https://github.com/kvark/spirv_cross"
|
||||
|
|
|
|||
|
|
@ -1802,16 +1802,6 @@ dependencies = [
|
|||
"pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libloading"
|
||||
version = "0.4.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libloading"
|
||||
version = "0.5.0"
|
||||
|
|
@ -2604,7 +2594,7 @@ dependencies = [
|
|||
"env_logger 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"pkcs11 0.4.1 (git+https://github.com/mheese/rust-pkcs11?rev=0810cd5adf4ac8031cc204df3e877d84595c7438)",
|
||||
"pkcs11 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
|
@ -2754,9 +2744,9 @@ dependencies = [
|
|||
[[package]]
|
||||
name = "pkcs11"
|
||||
version = "0.4.1"
|
||||
source = "git+https://github.com/mheese/rust-pkcs11?rev=0810cd5adf4ac8031cc204df3e877d84595c7438#0810cd5adf4ac8031cc204df3e877d84595c7438"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"libloading 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"libloading 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"num-bigint 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
|
|
@ -4830,7 +4820,6 @@ dependencies = [
|
|||
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
|
||||
"checksum libc 0.2.59 (registry+https://github.com/rust-lang/crates.io-index)" = "3262021842bf00fe07dbd6cf34ff25c99d7a7ebef8deea84db72be3ea3bb0aff"
|
||||
"checksum libdbus-sys 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "18cb88963258d00f4962205dbb5933d82780d9962c8c8a064b651d2ad7189210"
|
||||
"checksum libloading 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fd38073de8f7965d0c17d30546d4bb6da311ab428d1c7a3fc71dff7f9d4979b9"
|
||||
"checksum libloading 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3ad660d7cb8c5822cd83d10897b0f1f1526792737a179e73896152f85b88c2"
|
||||
"checksum libudev 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ea626d3bdf40a1c5aee3bcd4f40826970cae8d80a8fec934c82a63840094dcfe"
|
||||
"checksum libz-sys 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "2eb5e43362e38e2bca2fd5f5134c4d4564a23a5c28e9b95411652021a8675ebe"
|
||||
|
|
@ -4906,7 +4895,7 @@ dependencies = [
|
|||
"checksum phf_generator 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526"
|
||||
"checksum phf_macros 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7f6fde18ff429ffc8fe78e2bf7f8b7a5a5a6e2a8b58bc5a9ac69198bbda9189c"
|
||||
"checksum phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
|
||||
"checksum pkcs11 0.4.1 (git+https://github.com/mheese/rust-pkcs11?rev=0810cd5adf4ac8031cc204df3e877d84595c7438)" = "<none>"
|
||||
"checksum pkcs11 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c20593a99fe08068cbe2b59001527f36021d6ad53ac5f2d8793fcf2fe94015a0"
|
||||
"checksum pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "3a8b4c6b8165cd1a1cd4b9b120978131389f64bdaf456435caa41e630edba903"
|
||||
"checksum plain 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
|
||||
"checksum plane-split 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ffe16a646a08f4b4dd74035b9ff8e378eb1a4012a74f14f5889e7001cdbece33"
|
||||
|
|
|
|||
|
|
@ -12,8 +12,7 @@ byteorder = "1.3"
|
|||
env_logger = {version = "0.6", default-features = false } # disable `regex` to reduce code size
|
||||
lazy_static = "1"
|
||||
log = "0.4"
|
||||
# Waiting for a release with https://github.com/mheese/rust-pkcs11/pull/16, then this can go
|
||||
pkcs11 = { git = "https://github.com/mheese/rust-pkcs11", rev="0810cd5adf4ac8031cc204df3e877d84595c7438" }
|
||||
pkcs11 = "0.4"
|
||||
sha2 = "0.8"
|
||||
|
||||
[target."cfg(target_os = \"windows\")".dependencies.winapi]
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
{"files":{"Cargo.toml":"e3db29aefcf98671c707fab96d5d5b1964b79734faeea0d8dc6d94ef7d8fbaef","LICENSE":"b29f8b01452350c20dd1af16ef83b598fea3053578ccc1c7a0ef40e57be2620f","README.mkd":"34dc610b01f8c3e56d95de1972120ca0d53cee787f636a3ce96526ab343878b5","appveyor.yml":"8382c7f1769f6cf78029a221058c4d73f35a48308b5dfc38d875facabec1c139","build.rs":"b0cab713feb1fa86fec27af607272f2964e79cca6637ae837a1dfd9d88b67dd4","src/changelog.rs":"f0cf85f7de1c9807941bb832b2827f26efff8ec8bef14a38153c3f6c9a5831b5","src/lib.rs":"baa087dec7103adafc8c548e3baa1167af6d6d6be13a147fb19b880743f67182","src/os/mod.rs":"51d733e5522dacd6069642ad66aa6d7acf6c82950c934eb040e8dfd112e6d610","src/os/unix/mod.rs":"2af876458bf0012f7c0a06e8e976aff897410e22f3776c34ab1f2aa79fbd59aa","src/os/windows/mod.rs":"06ba72c9140c063696a579df2e57532fa3e470584fa304608a4268e6ba4ff8ad","src/test_helpers.rs":"3a55052e8cd5231e97d9282b43398c2f144c57ced2d2df64bde7f482f5c778e7","src/util.rs":"0b0155448a26db4b00b2a6ca129e0e1f6f75870c56c9777d262941818c7581b7","tests/functions.rs":"4633f3673db6a5b3623ea8927b13314c25502c9fbb63bb17a5a35650ea489012","tests/markers.rs":"8e9c1b883404d9190e4f23ed39b3d6cbbccb3a07883f733b04aed4357b9c6aca","tests/nagisa32.dll":"5c69b2bd9c8a6ad04165c221075fc9fade1dd66ca697399ace528a5a62328e36","tests/nagisa64.dll":"e20b95e3036f3289421abd100760874d4f455afd33c3b5b64fec56b191f7d477","tests/windows.rs":"7711dfe19062d91356cd127546542b1b6e13aeef76ad3098f32c8a6ae319b66a"},"package":"fd38073de8f7965d0c17d30546d4bb6da311ab428d1c7a3fc71dff7f9d4979b9"}
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||
#
|
||||
# When uploading crates to the registry Cargo will automatically
|
||||
# "normalize" Cargo.toml files for maximal compatibility
|
||||
# with all versions of Cargo and also rewrite `path` dependencies
|
||||
# to registry (e.g. crates.io) dependencies
|
||||
#
|
||||
# If you believe there's an error in this file please file an
|
||||
# issue against the rust-lang/cargo repository. If you're
|
||||
# editing this file be aware that the upstream Cargo.toml
|
||||
# will likely look very different (and much more reasonable)
|
||||
|
||||
[package]
|
||||
name = "libloading"
|
||||
version = "0.4.3"
|
||||
authors = ["Simonas Kazlauskas <libloading@kazlauskas.me>"]
|
||||
build = "build.rs"
|
||||
description = "A safer binding to platform’s dynamic library loading utilities"
|
||||
documentation = "https://docs.rs/libloading/"
|
||||
keywords = ["dlopen", "load", "shared", "dylib"]
|
||||
license = "ISC"
|
||||
repository = "https://github.com/nagisa/rust_libloading/"
|
||||
[dependencies.lazy_static]
|
||||
version = "1"
|
||||
[target."cfg(windows)".dependencies.kernel32-sys]
|
||||
version = "0.2"
|
||||
|
||||
[target."cfg(windows)".dependencies.winapi]
|
||||
version = "0.2"
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
Copyright © 2015, Simonas Kazlauskas
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with or without
|
||||
fee is hereby granted, provided that the above copyright notice and this permission notice appear
|
||||
in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
|
||||
SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
|
||||
AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
||||
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
|
||||
THIS SOFTWARE.
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
# libloading [![Travis CI][tcii]][tci] [![Appveyor CI][acii]][aci]
|
||||
|
||||
[tcii]: https://travis-ci.org/nagisa/rust_libloading.svg?branch=master
|
||||
[tci]: https://travis-ci.org/nagisa/rust_libloading
|
||||
[acii]: https://ci.appveyor.com/api/projects/status/cnncnu58qcxb1ikf/branch/master?svg=true
|
||||
[aci]: https://ci.appveyor.com/project/nagisa/rust-libloading
|
||||
|
||||
A memory-safer wrapper around system dynamic library loading primitives. The most important safety
|
||||
guarantee by this library is prevention of dangling-`Symbol`s that may occur after a `Library` is
|
||||
unloaded.
|
||||
|
||||
Using this library allows loading dynamic libraries (also known as shared libraries) as well as use
|
||||
functions and static variables these libraries contain.
|
||||
|
||||
* [Documentation][docs]
|
||||
* [Changelog][changelog]
|
||||
|
||||
[docs]: https://docs.rs/libloading/
|
||||
[changelog]: https://docs.rs/libloading/*/libloading/changelog/index.html
|
||||
|
||||
libloading is distributed under ISC (MIT-like) license.
|
||||
|
||||
---
|
||||
|
||||
Note, that this library is not a drop-in replacement for the deprecated `dynamic_lib`. Many
|
||||
dubious APIs (notably, library search path modification) were prunned and string arguments
|
||||
take types that match conventions and system APIs better.
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
environment:
|
||||
matrix:
|
||||
- TARGET: nightly-x86_64-pc-windows-msvc
|
||||
- TARGET: nightly-i686-pc-windows-msvc
|
||||
- TARGET: nightly-x86_64-pc-windows-gnu
|
||||
- TARGET: nightly-i686-pc-windows-gnu
|
||||
- TARGET: 1.14.0-x86_64-pc-windows-msvc
|
||||
- TARGET: 1.14.0-i686-pc-windows-msvc
|
||||
- TARGET: 1.14.0-x86_64-pc-windows-gnu
|
||||
- TARGET: 1.14.0-i686-pc-windows-gnu
|
||||
install:
|
||||
- ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-${env:TARGET}.exe" -FileName "rust.exe"
|
||||
- ps: .\rust.exe /VERYSILENT /NORESTART /DIR="C:\rust" | Out-Null
|
||||
- ps: $env:PATH="$env:PATH;C:\rust\bin"
|
||||
- rustc -vV
|
||||
- cargo -vV
|
||||
build: off
|
||||
test_script:
|
||||
- cargo test
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
use std::io::Write;
|
||||
use std::env;
|
||||
|
||||
fn main(){
|
||||
let target_os = env::var("CARGO_CFG_TARGET_OS");
|
||||
match target_os.as_ref().map(|x| &**x) {
|
||||
Ok("linux") | Ok("android") => println!("cargo:rustc-link-lib=dl"),
|
||||
Ok("freebsd") | Ok("dragonfly") => println!("cargo:rustc-link-lib=c"),
|
||||
// netbsd claims dl* will be available to any dynamically linked binary, but I haven’t
|
||||
// found any libraries that have to be linked to on other platforms.
|
||||
// What happens if the executable is not linked up dynamically?
|
||||
Ok("openbsd") | Ok("bitrig") | Ok("netbsd") | Ok("macos") | Ok("ios") => {}
|
||||
Ok("solaris") => {}
|
||||
// dependencies come with winapi
|
||||
Ok("windows") => {}
|
||||
tos => {
|
||||
writeln!(::std::io::stderr(),
|
||||
"Building for an unknown target_os=`{:?}`!\nPlease report an issue ",
|
||||
tos).expect("could not report the error");
|
||||
::std::process::exit(0xfc);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
//! Project changelog
|
||||
|
||||
/// Release 0.4.3 (2017-12-07)
|
||||
///
|
||||
/// * Bump lazy-static dependency to `^1.0`
|
||||
/// * `cargo test --release` now works when testing libloading.
|
||||
pub mod r0_4_3 {}
|
||||
|
||||
|
||||
/// Release 0.4.2 (2017-09-24)
|
||||
///
|
||||
/// * Improved error and race-condition handling on Windows;
|
||||
/// * Improved documentation about thread-safety of Library;
|
||||
/// * Added `Symbol::<Option<T>::lift_option() -> Option<Symbol<T>>` convenience method.
|
||||
pub mod r0_4_2 {}
|
||||
|
||||
|
||||
/// Release 0.4.1 (2017-08-29)
|
||||
///
|
||||
/// * Solaris support
|
||||
pub mod r0_4_1 {}
|
||||
|
||||
/// Release 0.4.0 (2017-05-01)
|
||||
///
|
||||
/// * Remove build-time dependency on target_build_utils (and by extension serde/phf);
|
||||
/// * Require at least version 1.14.0 of rustc to build;
|
||||
/// * Actually, it is cargo which has to be more recent here. The one shipped with rustc 1.14.0
|
||||
/// is what’s being required from now on.
|
||||
pub mod r0_4_0 {}
|
||||
|
||||
/// Release 0.3.4 (2017-03-25)
|
||||
///
|
||||
/// * Remove rogue println!
|
||||
pub mod r0_3_4 {}
|
||||
|
||||
/// Release 0.3.3 (2017-03-25)
|
||||
///
|
||||
/// * Panics when `Library::get` is called for incompatibly sized type such as named function
|
||||
/// types (which are zero-sized).
|
||||
pub mod r0_3_3 {}
|
||||
|
||||
/// Release 0.3.2 (2017-02-10)
|
||||
///
|
||||
/// * Minimum version required is now rustc 1.12.0;
|
||||
/// * Updated dependency versions (most notably target_build_utils to 0.3.0)
|
||||
pub mod r0_3_2 {}
|
||||
|
||||
/// Release 0.3.1 (2016-10-01)
|
||||
///
|
||||
/// * `Symbol<T>` and `os::*::Symbol<T>` now implement `Send` where `T: Send`;
|
||||
/// * `Symbol<T>` and `os::*::Symbol<T>` now implement `Sync` where `T: Sync`;
|
||||
/// * `Library` and `os::*::Library` now implement `Sync` (they were `Send` in 0.3.0 already).
|
||||
pub mod r0_3_1 {}
|
||||
|
||||
/// Release 0.3.0 (2016-07-27)
|
||||
///
|
||||
/// * Greatly improved documentation, especially around platform-specific behaviours;
|
||||
/// * Improved test suite by building our own library to test against;
|
||||
/// * All `Library`-ies now implement `Send`.
|
||||
/// * Added `impl From<os::platform::Library> for Library` and `impl From<Library> for
|
||||
/// os::platform::Library` allowing wrapping and extracting the platform-specific library handle;
|
||||
/// * Added methods to wrap (`Symbol::from_raw`) and unwrap (`Symbol::into_raw`) the safe `Symbol`
|
||||
/// wrapper into unsafe `os::platform::Symbol`.
|
||||
///
|
||||
/// The last two additions focus on not restricting potential usecases of this library, allowing
|
||||
/// users of the library to circumvent safety checks if need be.
|
||||
///
|
||||
/// ## Beaking Changes
|
||||
///
|
||||
/// `Library::new` defaults to `RTLD_NOW` instead of `RTLD_LAZY` on UNIX for more consistent
|
||||
/// cross-platform behaviour. If a library loaded with `Library::new` had any linking errors, but
|
||||
/// unresolved references weren’t forced to be resolved, the library would’ve “just worked”,
|
||||
/// whereas now the call to `Library::new` will return an error signifying presence of such error.
|
||||
///
|
||||
/// ## os::platform
|
||||
/// * Added `os::unix::Library::open` which allows specifying arbitrary flags (e.g. `RTLD_LAZY`);
|
||||
/// * Added `os::windows::Library::get_ordinal` which allows finding a function or variable by its
|
||||
/// ordinal number;
|
||||
pub mod r0_3_0 {}
|
||||
|
|
@ -1,314 +0,0 @@
|
|||
//! A memory-safer wrapper around system dynamic library loading primitives.
|
||||
//!
|
||||
//! Using this library allows loading [dynamic libraries](struct.Library.html) (also known as
|
||||
//! shared libraries) as well as use functions and static variables these libraries contain.
|
||||
//!
|
||||
//! While the library does expose a cross-platform interface to load a library and find stuff
|
||||
//! inside it, little is done to paper over the platform differences, especially where library
|
||||
//! loading is involved. The documentation for each function will attempt to document such
|
||||
//! differences on the best-effort basis.
|
||||
//!
|
||||
//! Less safe, platform specific bindings are also available. See the
|
||||
//! [`os::platform`](os/index.html) module for details.
|
||||
//!
|
||||
//! # Usage
|
||||
//!
|
||||
//! Add dependency to this library to your `Cargo.toml`:
|
||||
//!
|
||||
//! ```toml
|
||||
//! [dependencies]
|
||||
//! libloading = "0.4"
|
||||
//! ```
|
||||
//!
|
||||
//! Then inside your project
|
||||
//!
|
||||
//! ```no_run
|
||||
//! extern crate libloading as lib;
|
||||
//!
|
||||
//! fn call_dynamic() -> lib::Result<u32> {
|
||||
//! let lib = lib::Library::new("/path/to/liblibrary.so")?;
|
||||
//! unsafe {
|
||||
//! let func: lib::Symbol<unsafe extern fn() -> u32> = lib.get(b"my_func")?;
|
||||
//! Ok(func())
|
||||
//! }
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! The compiler will ensure that the loaded `function` will not outlive the `Library` it comes
|
||||
//! from, preventing a common cause of undefined behaviour and memory safety problems.
|
||||
use std::ffi::OsStr;
|
||||
use std::fmt;
|
||||
use std::ops;
|
||||
use std::marker;
|
||||
|
||||
#[cfg(unix)]
|
||||
#[macro_use]
|
||||
extern crate lazy_static;
|
||||
|
||||
#[cfg(unix)]
|
||||
use self::os::unix as imp;
|
||||
#[cfg(windows)]
|
||||
use self::os::windows as imp;
|
||||
|
||||
pub mod os;
|
||||
pub mod changelog;
|
||||
mod util;
|
||||
|
||||
pub type Result<T> = ::std::io::Result<T>;
|
||||
|
||||
/// A loaded dynamic library.
|
||||
pub struct Library(imp::Library);
|
||||
|
||||
impl Library {
|
||||
/// Find and load a dynamic library.
|
||||
///
|
||||
/// The `filename` argument may be any of:
|
||||
///
|
||||
/// * A library filename;
|
||||
/// * Absolute path to the library;
|
||||
/// * Relative (to the current working directory) path to the library.
|
||||
///
|
||||
/// ## Thread-safety
|
||||
///
|
||||
/// The implementation strives to be as MT-safe as sanely possible, however due to certain
|
||||
/// error-handling related resources not always being safe, this library is not MT-safe either.
|
||||
///
|
||||
/// * On Windows Vista and earlier error handling falls back to [`SetErrorMode`], which is not
|
||||
/// MT-safe. MT-scenarios involving this function may cause a traditional data race;
|
||||
/// * On some UNIX targets `dlerror` might not be MT-safe, resulting in garbage error messages
|
||||
/// in certain MT-scenarios.
|
||||
///
|
||||
/// [`SetErrorMode`]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680621(v=vs.85).aspx
|
||||
///
|
||||
/// Calling this function from multiple threads is not safe if used in conjunction with
|
||||
/// path-less filename and library search path is modified (`SetDllDirectory` function on
|
||||
/// Windows, `{DY,}LD_LIBRARY_PATH` environment variable on UNIX).
|
||||
///
|
||||
/// ## Platform-specific behaviour
|
||||
///
|
||||
/// When a plain library filename is supplied, locations where library is searched for is
|
||||
/// platform specific and cannot be adjusted in a portable manner.
|
||||
///
|
||||
/// ### Windows
|
||||
///
|
||||
/// If the `filename` specifies a library filename without path and with extension omitted,
|
||||
/// `.dll` extension is implicitly added. This behaviour may be suppressed by appending a
|
||||
/// trailing `.` to the `filename`.
|
||||
///
|
||||
/// If the library contains thread local variables (MSVC’s `_declspec(thread)`, Rust’s
|
||||
/// `#[thread_local]` attributes), loading the library will fail on versions prior to Windows
|
||||
/// Vista.
|
||||
///
|
||||
/// ## Tips
|
||||
///
|
||||
/// Distributing your dynamic libraries under a filename common to all platforms (e.g.
|
||||
/// `awesome.module`) allows to avoid code which has to account for platform’s conventional
|
||||
/// library filenames.
|
||||
///
|
||||
/// Strive to specify absolute or relative path to your library, unless system-wide libraries
|
||||
/// are being loaded. Platform-dependent library search locations combined with various quirks
|
||||
/// related to path-less filenames may cause flaky code.
|
||||
///
|
||||
/// ## Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # use ::libloading::Library;
|
||||
/// // Any of the following are valid.
|
||||
/// let _ = Library::new("/path/to/awesome.module").unwrap();
|
||||
/// let _ = Library::new("../awesome.module").unwrap();
|
||||
/// let _ = Library::new("libsomelib.so.1").unwrap();
|
||||
/// ```
|
||||
pub fn new<P: AsRef<OsStr>>(filename: P) -> Result<Library> {
|
||||
imp::Library::new(filename).map(From::from)
|
||||
}
|
||||
|
||||
/// Get a pointer to function or static variable by symbol name.
|
||||
///
|
||||
/// The `symbol` may not contain any null bytes, with an exception of last byte. A null
|
||||
/// terminated `symbol` may avoid a string allocation in some cases.
|
||||
///
|
||||
/// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
|
||||
/// most likely invalid.
|
||||
///
|
||||
/// ## Unsafety
|
||||
///
|
||||
/// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
|
||||
/// undefined.
|
||||
///
|
||||
/// ## Platform-specific behaviour
|
||||
///
|
||||
/// On Linux and Windows, a TLS variable acts just like any regular static variable. OS X uses
|
||||
/// some sort of lazy initialization scheme, which makes loading TLS variables this way
|
||||
/// impossible. Using a TLS variable loaded this way on OS X is undefined behaviour.
|
||||
///
|
||||
/// ## Examples
|
||||
///
|
||||
/// Given a loaded library:
|
||||
///
|
||||
/// ```no_run
|
||||
/// # use ::libloading::Library;
|
||||
/// let lib = Library::new("/path/to/awesome.module").unwrap();
|
||||
/// ```
|
||||
///
|
||||
/// Loading and using a function looks like this:
|
||||
///
|
||||
/// ```no_run
|
||||
/// # use ::libloading::{Library, Symbol};
|
||||
/// # let lib = Library::new("/path/to/awesome.module").unwrap();
|
||||
/// unsafe {
|
||||
/// let awesome_function: Symbol<unsafe extern fn(f64) -> f64> =
|
||||
/// lib.get(b"awesome_function\0").unwrap();
|
||||
/// awesome_function(0.42);
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// A static variable may also be loaded and inspected:
|
||||
///
|
||||
/// ```no_run
|
||||
/// # use ::libloading::{Library, Symbol};
|
||||
/// # let lib = Library::new("/path/to/awesome.module").unwrap();
|
||||
/// unsafe {
|
||||
/// let awesome_variable: Symbol<*mut f64> = lib.get(b"awesome_variable\0").unwrap();
|
||||
/// **awesome_variable = 42.0;
|
||||
/// };
|
||||
/// ```
|
||||
pub unsafe fn get<'lib, T>(&'lib self, symbol: &[u8]) -> Result<Symbol<'lib, T>> {
|
||||
self.0.get(symbol).map(|from| Symbol::from_raw(from, self))
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Library {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<imp::Library> for Library {
|
||||
fn from(lib: imp::Library) -> Library {
|
||||
Library(lib)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Library> for imp::Library {
|
||||
fn from(lib: Library) -> imp::Library {
|
||||
lib.0
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Send for Library {}
|
||||
unsafe impl Sync for Library {}
|
||||
|
||||
/// Symbol from a library.
|
||||
///
|
||||
/// This type is a safeguard against using dynamically loaded symbols after a `Library` is
|
||||
/// unloaded. Primary method to create an instance of a `Symbol` is via `Library::get`.
|
||||
///
|
||||
/// Due to implementation of the `Deref` trait, an instance of `Symbol` may be used as if it was a
|
||||
/// function or variable directly, without taking care to “extract” function or variable manually
|
||||
/// most of the time.
|
||||
///
|
||||
/// See [`Library::get`] for details.
|
||||
///
|
||||
/// [`Library::get`]: ./struct.Library.html#method.get
|
||||
pub struct Symbol<'lib, T: 'lib> {
|
||||
inner: imp::Symbol<T>,
|
||||
pd: marker::PhantomData<&'lib T>
|
||||
}
|
||||
|
||||
impl<'lib, T> Symbol<'lib, T> {
|
||||
/// Extract the wrapped `os::platform::Symbol`.
|
||||
///
|
||||
/// ## Unsafety
|
||||
/// Using this function relinquishes all the lifetime guarantees. It is up to programmer to
|
||||
/// ensure the resulting `Symbol` is not used past the lifetime of the `Library` this symbol
|
||||
/// was loaded from.
|
||||
///
|
||||
/// ## Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # use ::libloading::{Library, Symbol};
|
||||
/// let lib = Library::new("/path/to/awesome.module").unwrap();
|
||||
/// unsafe {
|
||||
/// let symbol: Symbol<*mut u32> = lib.get(b"symbol\0").unwrap();
|
||||
/// let symbol = symbol.into_raw();
|
||||
/// }
|
||||
/// ```
|
||||
pub unsafe fn into_raw(self) -> imp::Symbol<T> {
|
||||
self.inner
|
||||
}
|
||||
|
||||
/// Wrap the `os::platform::Symbol` into this safe wrapper.
|
||||
///
|
||||
/// Note that, in order to create association between the symbol and the library this symbol
|
||||
/// came from, this function requires reference to the library provided.
|
||||
///
|
||||
/// ## Unsafety
|
||||
///
|
||||
/// It is invalid to provide a reference to any other value other than the library the `sym`
|
||||
/// was loaded from. Doing so invalidates any lifetime guarantees.
|
||||
///
|
||||
/// ## Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # use ::libloading::{Library, Symbol};
|
||||
/// let lib = Library::new("/path/to/awesome.module").unwrap();
|
||||
/// unsafe {
|
||||
/// let symbol: Symbol<*mut u32> = lib.get(b"symbol\0").unwrap();
|
||||
/// let symbol = symbol.into_raw();
|
||||
/// let symbol = Symbol::from_raw(symbol, &lib);
|
||||
/// }
|
||||
/// ```
|
||||
pub unsafe fn from_raw<L>(sym: imp::Symbol<T>, _: &'lib L) -> Symbol<'lib, T> {
|
||||
Symbol {
|
||||
inner: sym,
|
||||
pd: marker::PhantomData
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lib, T> Symbol<'lib, Option<T>> {
|
||||
/// Lift Option out of the symbol.
|
||||
///
|
||||
/// ## Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # use ::libloading::{Library, Symbol};
|
||||
/// let lib = Library::new("/path/to/awesome.module").unwrap();
|
||||
/// unsafe {
|
||||
/// let symbol: Symbol<Option<*mut u32>> = lib.get(b"symbol\0").unwrap();
|
||||
/// let symbol: Symbol<*mut u32> = symbol.lift_option().expect("static is not null");
|
||||
/// }
|
||||
/// ```
|
||||
pub fn lift_option(self) -> Option<Symbol<'lib, T>> {
|
||||
self.inner.lift_option().map(|is| Symbol {
|
||||
inner: is,
|
||||
pd: marker::PhantomData,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lib, T> Clone for Symbol<'lib, T> {
|
||||
fn clone(&self) -> Symbol<'lib, T> {
|
||||
Symbol {
|
||||
inner: self.inner.clone(),
|
||||
pd: marker::PhantomData
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// FIXME: implement FnOnce for callable stuff instead.
|
||||
impl<'lib, T> ops::Deref for Symbol<'lib, T> {
|
||||
type Target = T;
|
||||
fn deref(&self) -> &T {
|
||||
ops::Deref::deref(&self.inner)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'lib, T> fmt::Debug for Symbol<'lib, T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
self.inner.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<'lib, T: Send> Send for Symbol<'lib, T> {}
|
||||
unsafe impl<'lib, T: Sync> Sync for Symbol<'lib, T> {}
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
//! Unsafe, platform specific bindings to dynamic library loading facilities.
|
||||
//!
|
||||
//! These modules expose more extensive, powerful, less principled bindings to the dynamic
|
||||
//! library loading facilities. Use of these bindings come at the cost of less (in most cases,
|
||||
//! none at all) safety guarantees, which are provided by the top-level bindings.
|
||||
//!
|
||||
//! # Examples
|
||||
//!
|
||||
//! Using these modules will likely involve conditional compilation:
|
||||
//!
|
||||
//! ```ignore
|
||||
//! # extern crate libloading;
|
||||
//! #[cfg(unix)]
|
||||
//! use libloading::os::unix::*;
|
||||
//! #[cfg(windows)]
|
||||
//! use libloading::os::windows::*;
|
||||
//! ```
|
||||
|
||||
macro_rules! unix {
|
||||
($item: item) => {
|
||||
/// UNIX implementation of dynamic library loading.
|
||||
///
|
||||
/// This module should be expanded with more UNIX-specific functionality in the future.
|
||||
$item
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! windows {
|
||||
($item: item) => {
|
||||
/// Windows implementation of dynamic library loading.
|
||||
///
|
||||
/// This module should be expanded with more Windows-specific functionality in the future.
|
||||
$item
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
unix!(pub mod unix;);
|
||||
#[cfg(unix)]
|
||||
windows!(pub mod windows {});
|
||||
|
||||
#[cfg(windows)]
|
||||
windows!(pub mod windows;);
|
||||
#[cfg(windows)]
|
||||
unix!(pub mod unix {});
|
||||
|
|
@ -1,285 +0,0 @@
|
|||
use util::{ensure_compatible_types, cstr_cow_from_bytes};
|
||||
|
||||
use std::ffi::{CStr, OsStr};
|
||||
use std::{fmt, io, marker, mem, ptr};
|
||||
use std::os::raw;
|
||||
use std::os::unix::ffi::OsStrExt;
|
||||
use std::sync::Mutex;
|
||||
|
||||
lazy_static! {
|
||||
static ref DLERROR_MUTEX: Mutex<()> = Mutex::new(());
|
||||
}
|
||||
|
||||
// libdl is crazy.
|
||||
//
|
||||
// First of all, whole error handling scheme in libdl is done via setting and querying some global
|
||||
// state, therefore it is not safe to use libdl in MT-capable environment at all. Only in POSIX
|
||||
// 2008+TC1 a thread-local state was allowed, which for our purposes is way too late.
|
||||
fn with_dlerror<T, F>(closure: F) -> Result<T, Option<io::Error>>
|
||||
where F: FnOnce() -> Option<T> {
|
||||
// We will guard all uses of libdl library with our own mutex. This makes libdl
|
||||
// safe to use in MT programs provided the only way a program uses libdl is via this library.
|
||||
let _lock = DLERROR_MUTEX.lock();
|
||||
// While we could could call libdl here to clear the previous error value, only the dlsym
|
||||
// depends on it being cleared beforehand and only in some cases too. We will instead clear the
|
||||
// error inside the dlsym binding instead.
|
||||
//
|
||||
// In all the other cases, clearing the error here will only be hiding misuse of these bindings
|
||||
// or the libdl.
|
||||
closure().ok_or_else(|| unsafe {
|
||||
// This code will only get executed if the `closure` returns `None`.
|
||||
let error = dlerror();
|
||||
if error.is_null() {
|
||||
// In non-dlsym case this may happen when there’re bugs in our bindings or there’s
|
||||
// non-libloading user of libdl; possibly in another thread.
|
||||
None
|
||||
} else {
|
||||
// You can’t even rely on error string being static here; call to subsequent dlerror
|
||||
// may invalidate or overwrite the error message. Why couldn’t they simply give up the
|
||||
// ownership over the message?
|
||||
// TODO: should do locale-aware conversion here. OTOH Rust doesn’t seem to work well in
|
||||
// any system that uses non-utf8 locale, so I doubt there’s a problem here.
|
||||
let message = CStr::from_ptr(error).to_string_lossy().into_owned();
|
||||
Some(io::Error::new(io::ErrorKind::Other, message))
|
||||
// Since we do a copy of the error string above, maybe we should call dlerror again to
|
||||
// let libdl know it may free its copy of the string now?
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// A platform-specific equivalent of the cross-platform `Library`.
|
||||
pub struct Library {
|
||||
handle: *mut raw::c_void
|
||||
}
|
||||
|
||||
unsafe impl Send for Library {}
|
||||
|
||||
// That being said... this section in the volume 2 of POSIX.1-2008 states:
|
||||
//
|
||||
// > All functions defined by this volume of POSIX.1-2008 shall be thread-safe, except that the
|
||||
// > following functions need not be thread-safe.
|
||||
//
|
||||
// With notable absence of any dl* function other than dlerror in the list. By “this volume”
|
||||
// I suppose they refer precisely to the “volume 2”. dl* family of functions are specified
|
||||
// by this same volume, so the conclusion is indeed that dl* functions are required by POSIX
|
||||
// to be thread-safe. Great!
|
||||
//
|
||||
// See for more details:
|
||||
//
|
||||
// * https://github.com/nagisa/rust_libloading/pull/17
|
||||
// * http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_09_01
|
||||
unsafe impl Sync for Library {}
|
||||
|
||||
impl Library {
|
||||
/// Find and load a shared library (module).
|
||||
///
|
||||
/// Locations where library is searched for is platform specific and can’t be adjusted
|
||||
/// portably.
|
||||
///
|
||||
/// Corresponds to `dlopen(filename, RTLD_NOW)`.
|
||||
#[inline]
|
||||
pub fn new<P: AsRef<OsStr>>(filename: P) -> ::Result<Library> {
|
||||
Library::open(Some(filename), RTLD_NOW)
|
||||
}
|
||||
|
||||
/// Load the dynamic libraries linked into main program.
|
||||
///
|
||||
/// This allows retrieving symbols from any **dynamic** library linked into the program,
|
||||
/// without specifying the exact library.
|
||||
///
|
||||
/// Corresponds to `dlopen(NULL, RTLD_NOW)`.
|
||||
#[inline]
|
||||
pub fn this() -> Library {
|
||||
Library::open(None::<&OsStr>, RTLD_NOW).unwrap()
|
||||
}
|
||||
|
||||
/// Find and load a shared library (module).
|
||||
///
|
||||
/// Locations where library is searched for is platform specific and can’t be adjusted
|
||||
/// portably.
|
||||
///
|
||||
/// If the `filename` is None, null pointer is passed to `dlopen`.
|
||||
///
|
||||
/// Corresponds to `dlopen(filename, flags)`.
|
||||
pub fn open<P>(filename: Option<P>, flags: raw::c_int) -> ::Result<Library>
|
||||
where P: AsRef<OsStr> {
|
||||
let filename = match filename {
|
||||
None => None,
|
||||
Some(ref f) => Some(try!(cstr_cow_from_bytes(f.as_ref().as_bytes()))),
|
||||
};
|
||||
with_dlerror(move || {
|
||||
let result = unsafe {
|
||||
let r = dlopen(match filename {
|
||||
None => ptr::null(),
|
||||
Some(ref f) => f.as_ptr()
|
||||
}, flags);
|
||||
// ensure filename lives until dlopen completes
|
||||
drop(filename);
|
||||
r
|
||||
};
|
||||
if result.is_null() {
|
||||
None
|
||||
} else {
|
||||
Some(Library {
|
||||
handle: result
|
||||
})
|
||||
}
|
||||
}).map_err(|e| e.unwrap_or_else(||
|
||||
panic!("dlopen failed but dlerror did not report anything")
|
||||
))
|
||||
}
|
||||
|
||||
/// Get a pointer to function or static variable by symbol name.
|
||||
///
|
||||
/// The `symbol` may not contain any null bytes, with an exception of last byte. A null
|
||||
/// terminated `symbol` may avoid a string allocation in some cases.
|
||||
///
|
||||
/// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
|
||||
/// most likely invalid.
|
||||
///
|
||||
/// ## Unsafety
|
||||
///
|
||||
/// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
|
||||
/// undefined.
|
||||
///
|
||||
/// ## Platform-specific behaviour
|
||||
///
|
||||
/// OS X uses some sort of lazy initialization scheme, which makes loading TLS variables
|
||||
/// impossible. Using a TLS variable loaded this way on OS X is undefined behaviour.
|
||||
pub unsafe fn get<T>(&self, symbol: &[u8]) -> ::Result<Symbol<T>> {
|
||||
ensure_compatible_types::<T, *mut raw::c_void>();
|
||||
let symbol = try!(cstr_cow_from_bytes(symbol));
|
||||
// `dlsym` may return nullptr in two cases: when a symbol genuinely points to a null
|
||||
// pointer or the symbol cannot be found. In order to detect this case a double dlerror
|
||||
// pattern must be used, which is, sadly, a little bit racy.
|
||||
//
|
||||
// We try to leave as little space as possible for this to occur, but we can’t exactly
|
||||
// fully prevent it.
|
||||
match with_dlerror(|| {
|
||||
dlerror();
|
||||
let symbol = dlsym(self.handle, symbol.as_ptr());
|
||||
if symbol.is_null() {
|
||||
None
|
||||
} else {
|
||||
Some(Symbol {
|
||||
pointer: symbol,
|
||||
pd: marker::PhantomData
|
||||
})
|
||||
}
|
||||
}) {
|
||||
Err(None) => Ok(Symbol {
|
||||
pointer: ptr::null_mut(),
|
||||
pd: marker::PhantomData
|
||||
}),
|
||||
Err(Some(e)) => Err(e),
|
||||
Ok(x) => Ok(x)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Library {
|
||||
fn drop(&mut self) {
|
||||
with_dlerror(|| if unsafe { dlclose(self.handle) } == 0 {
|
||||
Some(())
|
||||
} else {
|
||||
None
|
||||
}).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Library {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
f.write_str(&format!("Library@{:p}", self.handle))
|
||||
}
|
||||
}
|
||||
|
||||
/// Symbol from a library.
|
||||
///
|
||||
/// A major difference compared to the cross-platform `Symbol` is that this does not ensure the
|
||||
/// `Symbol` does not outlive `Library` it comes from.
|
||||
pub struct Symbol<T> {
|
||||
pointer: *mut raw::c_void,
|
||||
pd: marker::PhantomData<T>
|
||||
}
|
||||
|
||||
impl<T> Symbol<Option<T>> {
|
||||
/// Lift Option out of the symbol.
|
||||
pub fn lift_option(self) -> Option<Symbol<T>> {
|
||||
if self.pointer.is_null() {
|
||||
None
|
||||
} else {
|
||||
Some(Symbol {
|
||||
pointer: self.pointer,
|
||||
pd: marker::PhantomData,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<T: Send> Send for Symbol<T> {}
|
||||
unsafe impl<T: Sync> Sync for Symbol<T> {}
|
||||
|
||||
impl<T> Clone for Symbol<T> {
|
||||
fn clone(&self) -> Symbol<T> {
|
||||
Symbol { ..*self }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> ::std::ops::Deref for Symbol<T> {
|
||||
type Target = T;
|
||||
fn deref(&self) -> &T {
|
||||
unsafe {
|
||||
// Additional reference level for a dereference on `deref` return value.
|
||||
mem::transmute(&self.pointer)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> fmt::Debug for Symbol<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
unsafe {
|
||||
let mut info: DlInfo = mem::uninitialized();
|
||||
if dladdr(self.pointer, &mut info) != 0 {
|
||||
if info.dli_sname.is_null() {
|
||||
f.write_str(&format!("Symbol@{:p} from {:?}",
|
||||
self.pointer,
|
||||
CStr::from_ptr(info.dli_fname)))
|
||||
} else {
|
||||
f.write_str(&format!("Symbol {:?}@{:p} from {:?}",
|
||||
CStr::from_ptr(info.dli_sname), self.pointer,
|
||||
CStr::from_ptr(info.dli_fname)))
|
||||
}
|
||||
} else {
|
||||
f.write_str(&format!("Symbol@{:p}", self.pointer))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Platform specific things
|
||||
|
||||
extern {
|
||||
fn dlopen(filename: *const raw::c_char, flags: raw::c_int) -> *mut raw::c_void;
|
||||
fn dlclose(handle: *mut raw::c_void) -> raw::c_int;
|
||||
fn dlsym(handle: *mut raw::c_void, symbol: *const raw::c_char) -> *mut raw::c_void;
|
||||
fn dlerror() -> *mut raw::c_char;
|
||||
fn dladdr(addr: *mut raw::c_void, info: *mut DlInfo) -> raw::c_int;
|
||||
}
|
||||
|
||||
#[cfg(not(target_os="android"))]
|
||||
const RTLD_NOW: raw::c_int = 2;
|
||||
#[cfg(target_os="android")]
|
||||
const RTLD_NOW: raw::c_int = 0;
|
||||
|
||||
#[repr(C)]
|
||||
struct DlInfo {
|
||||
dli_fname: *const raw::c_char,
|
||||
dli_fbase: *mut raw::c_void,
|
||||
dli_sname: *const raw::c_char,
|
||||
dli_saddr: *mut raw::c_void
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn this() {
|
||||
Library::this();
|
||||
}
|
||||
|
|
@ -1,284 +0,0 @@
|
|||
extern crate winapi;
|
||||
extern crate kernel32;
|
||||
|
||||
use util::{ensure_compatible_types, cstr_cow_from_bytes};
|
||||
|
||||
use std::ffi::{OsStr, OsString};
|
||||
use std::{fmt, io, marker, mem, ptr};
|
||||
use std::os::windows::ffi::{OsStrExt, OsStringExt};
|
||||
use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
|
||||
|
||||
|
||||
/// A platform-specific equivalent of the cross-platform `Library`.
|
||||
pub struct Library(winapi::HMODULE);
|
||||
|
||||
unsafe impl Send for Library {}
|
||||
// Now, this is sort-of-tricky. MSDN documentation does not really make any claims as to safety of
|
||||
// the Win32 APIs. Sadly, whomever I asked, even current and former Microsoft employees, couldn’t
|
||||
// say for sure, whether the Win32 APIs used to implement `Library` are thread-safe or not.
|
||||
//
|
||||
// My investigation ended up with a question about thread-safety properties of the API involved
|
||||
// being sent to an internal (to MS) general question mailing-list. The conclusion of the mail is
|
||||
// as such:
|
||||
//
|
||||
// * Nobody inside MS (at least out of all the people who have seen the question) knows for
|
||||
// sure either;
|
||||
// * However, the general consensus between MS developers is that one can rely on the API being
|
||||
// thread-safe. In case it is not thread-safe it should be considered a bug on the Windows
|
||||
// part. (NB: bugs filled at https://connect.microsoft.com/ against Windows Server)
|
||||
unsafe impl Sync for Library {}
|
||||
|
||||
impl Library {
|
||||
/// Find and load a shared library (module).
|
||||
///
|
||||
/// Corresponds to `LoadLibraryW(filename)`.
|
||||
#[inline]
|
||||
pub fn new<P: AsRef<OsStr>>(filename: P) -> ::Result<Library> {
|
||||
let wide_filename: Vec<u16> = filename.as_ref().encode_wide().chain(Some(0)).collect();
|
||||
let _guard = ErrorModeGuard::new();
|
||||
|
||||
let ret = with_get_last_error(|| {
|
||||
// Make sure no winapi calls as a result of drop happen inside this closure, because
|
||||
// otherwise that might change the return value of the GetLastError.
|
||||
let handle = unsafe { kernel32::LoadLibraryW(wide_filename.as_ptr()) };
|
||||
if handle.is_null() {
|
||||
None
|
||||
} else {
|
||||
Some(Library(handle))
|
||||
}
|
||||
}).map_err(|e| e.unwrap_or_else(||
|
||||
panic!("LoadLibraryW failed but GetLastError did not report the error")
|
||||
));
|
||||
|
||||
drop(wide_filename); // Drop wide_filename here to ensure it doesn’t get moved and dropped
|
||||
// inside the closure by mistake. See comment inside the closure.
|
||||
ret
|
||||
}
|
||||
|
||||
/// Get a pointer to function or static variable by symbol name.
|
||||
///
|
||||
/// The `symbol` may not contain any null bytes, with an exception of last byte. A null
|
||||
/// terminated `symbol` may avoid a string allocation in some cases.
|
||||
///
|
||||
/// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
|
||||
/// most likely invalid.
|
||||
///
|
||||
/// ## Unsafety
|
||||
///
|
||||
/// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
|
||||
/// undefined.
|
||||
pub unsafe fn get<T>(&self, symbol: &[u8]) -> ::Result<Symbol<T>> {
|
||||
ensure_compatible_types::<T, winapi::FARPROC>();
|
||||
let symbol = try!(cstr_cow_from_bytes(symbol));
|
||||
with_get_last_error(|| {
|
||||
let symbol = kernel32::GetProcAddress(self.0, symbol.as_ptr());
|
||||
if symbol.is_null() {
|
||||
None
|
||||
} else {
|
||||
Some(Symbol {
|
||||
pointer: symbol,
|
||||
pd: marker::PhantomData
|
||||
})
|
||||
}
|
||||
}).map_err(|e| e.unwrap_or_else(||
|
||||
panic!("GetProcAddress failed but GetLastError did not report the error")
|
||||
))
|
||||
}
|
||||
|
||||
/// Get a pointer to function or static variable by ordinal number.
|
||||
///
|
||||
/// ## Unsafety
|
||||
///
|
||||
/// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
|
||||
/// undefined.
|
||||
pub unsafe fn get_ordinal<T>(&self, ordinal: winapi::WORD) -> ::Result<Symbol<T>> {
|
||||
ensure_compatible_types::<T, winapi::FARPROC>();
|
||||
with_get_last_error(|| {
|
||||
let ordinal = ordinal as usize as *mut _;
|
||||
let symbol = kernel32::GetProcAddress(self.0, ordinal);
|
||||
if symbol.is_null() {
|
||||
None
|
||||
} else {
|
||||
Some(Symbol {
|
||||
pointer: symbol,
|
||||
pd: marker::PhantomData
|
||||
})
|
||||
}
|
||||
}).map_err(|e| e.unwrap_or_else(||
|
||||
panic!("GetProcAddress failed but GetLastError did not report the error")
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Library {
|
||||
fn drop(&mut self) {
|
||||
with_get_last_error(|| {
|
||||
if unsafe { kernel32::FreeLibrary(self.0) == 0 } {
|
||||
None
|
||||
} else {
|
||||
Some(())
|
||||
}
|
||||
}).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Library {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
unsafe {
|
||||
let mut buf: [winapi::WCHAR; 1024] = mem::uninitialized();
|
||||
let len = kernel32::GetModuleFileNameW(self.0,
|
||||
(&mut buf[..]).as_mut_ptr(), 1024) as usize;
|
||||
if len == 0 {
|
||||
f.write_str(&format!("Library@{:p}", self.0))
|
||||
} else {
|
||||
let string: OsString = OsString::from_wide(&buf[..len]);
|
||||
f.write_str(&format!("Library@{:p} from {:?}", self.0, string))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Symbol from a library.
|
||||
///
|
||||
/// A major difference compared to the cross-platform `Symbol` is that this does not ensure the
|
||||
/// `Symbol` does not outlive `Library` it comes from.
|
||||
pub struct Symbol<T> {
|
||||
pointer: winapi::FARPROC,
|
||||
pd: marker::PhantomData<T>
|
||||
}
|
||||
|
||||
impl<T> Symbol<Option<T>> {
|
||||
/// Lift Option out of the symbol.
|
||||
pub fn lift_option(self) -> Option<Symbol<T>> {
|
||||
if self.pointer.is_null() {
|
||||
None
|
||||
} else {
|
||||
Some(Symbol {
|
||||
pointer: self.pointer,
|
||||
pd: marker::PhantomData,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<T: Send> Send for Symbol<T> {}
|
||||
unsafe impl<T: Sync> Sync for Symbol<T> {}
|
||||
|
||||
impl<T> Clone for Symbol<T> {
|
||||
fn clone(&self) -> Symbol<T> {
|
||||
Symbol { ..*self }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> ::std::ops::Deref for Symbol<T> {
|
||||
type Target = T;
|
||||
fn deref(&self) -> &T {
|
||||
unsafe {
|
||||
// Additional reference level for a dereference on `deref` return value.
|
||||
mem::transmute(&self.pointer)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> fmt::Debug for Symbol<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
f.write_str(&format!("Symbol@{:p}", self.pointer))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static USE_ERRORMODE: AtomicBool = ATOMIC_BOOL_INIT;
|
||||
struct ErrorModeGuard(winapi::DWORD);
|
||||
|
||||
impl ErrorModeGuard {
|
||||
fn new() -> Option<ErrorModeGuard> {
|
||||
const SEM_FAILCE: winapi::DWORD = 1;
|
||||
unsafe {
|
||||
if !USE_ERRORMODE.load(Ordering::Acquire) {
|
||||
let mut previous_mode = 0;
|
||||
let success = kernel32::SetThreadErrorMode(SEM_FAILCE, &mut previous_mode) != 0;
|
||||
if !success && kernel32::GetLastError() == winapi::ERROR_CALL_NOT_IMPLEMENTED {
|
||||
USE_ERRORMODE.store(true, Ordering::Release);
|
||||
} else if !success {
|
||||
// SetThreadErrorMode failed with some other error? How in the world is it
|
||||
// possible for what is essentially a simple variable swap to fail?
|
||||
// For now we just ignore the error -- the worst that can happen here is
|
||||
// the previous mode staying on and user seeing a dialog error on older Windows
|
||||
// machines.
|
||||
return None;
|
||||
} else if previous_mode == SEM_FAILCE {
|
||||
return None;
|
||||
} else {
|
||||
return Some(ErrorModeGuard(previous_mode));
|
||||
}
|
||||
}
|
||||
match kernel32::SetErrorMode(SEM_FAILCE) {
|
||||
SEM_FAILCE => {
|
||||
// This is important to reduce racy-ness when this library is used on multiple
|
||||
// threads. In particular this helps with following race condition:
|
||||
//
|
||||
// T1: SetErrorMode(SEM_FAILCE)
|
||||
// T2: SetErrorMode(SEM_FAILCE)
|
||||
// T1: SetErrorMode(old_mode) # not SEM_FAILCE
|
||||
// T2: SetErrorMode(SEM_FAILCE) # restores to SEM_FAILCE on drop
|
||||
//
|
||||
// This is still somewhat racy in a sense that T1 might resture the error
|
||||
// mode before T2 finishes loading the library, but that is less of a
|
||||
// concern – it will only end up in end user seeing a dialog.
|
||||
//
|
||||
// Also, SetErrorMode itself is probably not an atomic operation.
|
||||
None
|
||||
}
|
||||
a => Some(ErrorModeGuard(a))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for ErrorModeGuard {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
if !USE_ERRORMODE.load(Ordering::Relaxed) {
|
||||
kernel32::SetThreadErrorMode(self.0, ptr::null_mut());
|
||||
} else {
|
||||
kernel32::SetErrorMode(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn with_get_last_error<T, F>(closure: F) -> Result<T, Option<io::Error>>
|
||||
where F: FnOnce() -> Option<T> {
|
||||
closure().ok_or_else(|| {
|
||||
let error = unsafe { kernel32::GetLastError() };
|
||||
if error == 0 {
|
||||
None
|
||||
} else {
|
||||
Some(io::Error::from_raw_os_error(error as i32))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn works_getlasterror() {
|
||||
let lib = Library::new("kernel32.dll").unwrap();
|
||||
let gle: Symbol<unsafe extern "system" fn() -> winapi::DWORD> = unsafe {
|
||||
lib.get(b"GetLastError").unwrap()
|
||||
};
|
||||
unsafe {
|
||||
kernel32::SetLastError(42);
|
||||
assert_eq!(kernel32::GetLastError(), gle())
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn works_getlasterror0() {
|
||||
let lib = Library::new("kernel32.dll").unwrap();
|
||||
let gle: Symbol<unsafe extern "system" fn() -> winapi::DWORD> = unsafe {
|
||||
lib.get(b"GetLastError\0").unwrap()
|
||||
};
|
||||
unsafe {
|
||||
kernel32::SetLastError(42);
|
||||
assert_eq!(kernel32::GetLastError(), gle())
|
||||
}
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
//! This is a separate file containing helpers for tests of this library. It is built into a
|
||||
//! dynamic library by the build.rs script.
|
||||
#![crate_type="dylib"] // FIXME: should become a cdylib in due time
|
||||
#![cfg_attr(test_nightly, feature(thread_local))]
|
||||
|
||||
#[no_mangle]
|
||||
pub static mut TEST_STATIC_U32: u32 = 0;
|
||||
|
||||
#[no_mangle]
|
||||
pub static mut TEST_STATIC_PTR: *mut () = 0 as *mut _;
|
||||
|
||||
#[cfg(test_nightly)]
|
||||
#[thread_local]
|
||||
#[no_mangle]
|
||||
pub static mut TEST_THREAD_LOCAL: u32 = 0;
|
||||
|
||||
#[no_mangle]
|
||||
pub extern "C" fn test_identity_u32(x: u32) -> u32 {
|
||||
x
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
pub struct S {
|
||||
a: u64,
|
||||
b: u32,
|
||||
c: u16,
|
||||
d: u8
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub extern "C" fn test_identity_struct(x: S) -> S {
|
||||
x
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn test_get_static_u32() -> u32 {
|
||||
TEST_STATIC_U32
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn test_check_static_ptr() -> bool {
|
||||
TEST_STATIC_PTR == (&mut TEST_STATIC_PTR as *mut *mut _ as *mut _)
|
||||
}
|
||||
|
||||
#[cfg(test_nightly)]
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn test_get_thread_local() -> u32 {
|
||||
TEST_THREAD_LOCAL
|
||||
}
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
use std::ffi::{CStr, CString, NulError, FromBytesWithNulError};
|
||||
use std::borrow::Cow;
|
||||
use std::os::raw;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct NullError;
|
||||
|
||||
impl From<NulError> for NullError {
|
||||
fn from(_: NulError) -> NullError {
|
||||
NullError
|
||||
}
|
||||
}
|
||||
|
||||
impl From<FromBytesWithNulError> for NullError {
|
||||
fn from(_: FromBytesWithNulError) -> NullError {
|
||||
NullError
|
||||
}
|
||||
}
|
||||
|
||||
impl From<NullError> for ::std::io::Error {
|
||||
fn from(e: NullError) -> ::std::io::Error {
|
||||
::std::io::Error::new(::std::io::ErrorKind::Other, format!("{}", e))
|
||||
}
|
||||
}
|
||||
|
||||
impl ::std::error::Error for NullError {
|
||||
fn description(&self) -> &str { "non-final null byte found" }
|
||||
}
|
||||
|
||||
impl ::std::fmt::Display for NullError {
|
||||
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
||||
write!(f, "non-final null byte found")
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks for last byte and avoids alocatting if its zero.
|
||||
///
|
||||
/// Non-last null bytes still result in an error.
|
||||
pub fn cstr_cow_from_bytes<'a>(slice: &'a [u8]) -> Result<Cow<'a, CStr>, NullError> {
|
||||
static ZERO: raw::c_char = 0;
|
||||
Ok(match slice.last() {
|
||||
// Slice out of 0 elements
|
||||
None => unsafe { Cow::Borrowed(CStr::from_ptr(&ZERO)) },
|
||||
// Slice with trailing 0
|
||||
Some(&0) => Cow::Borrowed(try!(CStr::from_bytes_with_nul(slice))),
|
||||
// Slice with no trailing 0
|
||||
Some(_) => Cow::Owned(try!(CString::new(slice))),
|
||||
})
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn ensure_compatible_types<T, E>() {
|
||||
#[cold]
|
||||
#[inline(never)]
|
||||
fn dopanic() {
|
||||
panic!("value of requested type cannot be dynamically loaded");
|
||||
}
|
||||
if ::std::mem::size_of::<T>() != ::std::mem::size_of::<E>() {
|
||||
dopanic()
|
||||
}
|
||||
}
|
||||
|
|
@ -1,151 +0,0 @@
|
|||
extern crate libloading;
|
||||
use libloading::{Symbol, Library};
|
||||
|
||||
const LIBPATH: &'static str = concat!(env!("OUT_DIR"), "/libtest_helpers.dll");
|
||||
|
||||
fn make_helpers() {
|
||||
static ONCE: ::std::sync::Once = ::std::sync::ONCE_INIT;
|
||||
ONCE.call_once(|| {
|
||||
let mut outpath = String::from(if let Some(od) = option_env!("OUT_DIR") { od } else { return });
|
||||
let rustc = option_env!("RUSTC").unwrap_or_else(|| { "rustc".into() });
|
||||
outpath.push_str(&"/libtest_helpers.dll"); // extension for windows required, POSIX does not care.
|
||||
let _ = ::std::process::Command::new(rustc)
|
||||
.arg("src/test_helpers.rs")
|
||||
.arg("-o")
|
||||
.arg(outpath)
|
||||
.arg("-O")
|
||||
.output()
|
||||
.expect("could not compile the test helpers!");
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_id_u32() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
let f: Symbol<unsafe extern fn(u32) -> u32> = lib.get(b"test_identity_u32\0").unwrap();
|
||||
assert_eq!(42, f(42));
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone,Copy,PartialEq,Debug)]
|
||||
struct S {
|
||||
a: u64,
|
||||
b: u32,
|
||||
c: u16,
|
||||
d: u8
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_id_struct() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
let f: Symbol<unsafe extern fn(S) -> S> = lib.get(b"test_identity_struct\0").unwrap();
|
||||
assert_eq!(S { a: 1, b: 2, c: 3, d: 4 }, f(S { a: 1, b: 2, c: 3, d: 4 }));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_0_no_0() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
let f: Symbol<unsafe extern fn(S) -> S> = lib.get(b"test_identity_struct\0").unwrap();
|
||||
let f2: Symbol<unsafe extern fn(S) -> S> = lib.get(b"test_identity_struct").unwrap();
|
||||
assert_eq!(*f, *f2);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_name_fails() {
|
||||
Library::new(concat!(env!("OUT_DIR"), "/libtest_help")).err().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_symbol_fails() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
lib.get::<*mut ()>(b"test_does_not_exist").err().unwrap();
|
||||
lib.get::<*mut ()>(b"test_does_not_exist\0").err().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn interior_null_fails() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
lib.get::<*mut ()>(b"test_does\0_not_exist").err().unwrap();
|
||||
lib.get::<*mut ()>(b"test\0_does_not_exist\0").err().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_incompatible_type() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
let _ = lib.get::<()>(b"test_identity_u32\0");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_incompatible_type_named_fn() {
|
||||
make_helpers();
|
||||
unsafe fn get<'a, T>(l: &'a Library, _: T) -> libloading::Result<Symbol<'a, T>> {
|
||||
l.get::<T>(b"test_identity_u32\0")
|
||||
}
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
let _ = get(&lib, test_incompatible_type_named_fn);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_static_u32() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
let var: Symbol<*mut u32> = lib.get(b"TEST_STATIC_U32\0").unwrap();
|
||||
**var = 42;
|
||||
let help: Symbol<unsafe extern fn() -> u32> = lib.get(b"test_get_static_u32\0").unwrap();
|
||||
assert_eq!(42, help());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_static_ptr() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
let var: Symbol<*mut *mut ()> = lib.get(b"TEST_STATIC_PTR\0").unwrap();
|
||||
**var = *var as *mut _;
|
||||
let works: Symbol<unsafe extern fn() -> bool> =
|
||||
lib.get(b"test_check_static_ptr\0").unwrap();
|
||||
assert!(works());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(windows, target_os="linux"))]
|
||||
#[cfg(test_nightly)]
|
||||
#[test]
|
||||
fn test_tls_static() {
|
||||
make_helpers();
|
||||
let lib = Library::new(LIBPATH).unwrap();
|
||||
unsafe {
|
||||
let var: Symbol<*mut u32> = lib.get(b"TEST_THREAD_LOCAL\0").unwrap();
|
||||
**var = 84;
|
||||
let help: Symbol<unsafe extern fn() -> u32> = lib.get(b"test_get_thread_local\0").unwrap();
|
||||
assert_eq!(84, help());
|
||||
}
|
||||
::std::thread::spawn(move || unsafe {
|
||||
let help: Symbol<unsafe extern fn() -> u32> = lib.get(b"test_get_thread_local\0").unwrap();
|
||||
assert_eq!(0, help());
|
||||
}).join().unwrap();
|
||||
}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
extern crate libloading;
|
||||
|
||||
#[cfg(test)]
|
||||
fn assert_send<T: Send>() {}
|
||||
#[cfg(test)]
|
||||
fn assert_sync<T: Sync>() {}
|
||||
|
||||
#[test]
|
||||
fn check_library_send() {
|
||||
assert_send::<libloading::Library>();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn check_unix_library_send() {
|
||||
assert_send::<libloading::os::unix::Library>();
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn check_windows_library_send() {
|
||||
assert_send::<libloading::os::windows::Library>();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn check_library_sync() {
|
||||
assert_sync::<libloading::Library>();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn check_unix_library_sync() {
|
||||
assert_sync::<libloading::os::unix::Library>();
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn check_windows_library_sync() {
|
||||
assert_sync::<libloading::os::windows::Library>();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn check_symbol_send() {
|
||||
assert_send::<libloading::Symbol<fn() -> ()>>();
|
||||
// assert_not_send::<libloading::Symbol<*const ()>>();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn check_unix_symbol_send() {
|
||||
assert_send::<libloading::os::unix::Symbol<fn() -> ()>>();
|
||||
// assert_not_send::<libloading::os::unix::Symbol<*const ()>>();
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn check_windows_symbol_send() {
|
||||
assert_send::<libloading::os::windows::Symbol<fn() -> ()>>();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn check_symbol_sync() {
|
||||
assert_sync::<libloading::Symbol<fn() -> ()>>();
|
||||
// assert_not_sync::<libloading::Symbol<*const ()>>();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn check_unix_symbol_sync() {
|
||||
assert_sync::<libloading::os::unix::Symbol<fn() -> ()>>();
|
||||
// assert_not_sync::<libloading::os::unix::Symbol<*const ()>>();
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn check_windows_symbol_sync() {
|
||||
assert_sync::<libloading::os::windows::Symbol<fn() -> ()>>();
|
||||
// assert_not_sync::<libloading::os::windows::Symbol<*const ()>>();
|
||||
}
|
||||
Двоичный файл не отображается.
Двоичный файл не отображается.
|
|
@ -1,56 +0,0 @@
|
|||
#![cfg(windows)]
|
||||
extern crate libloading;
|
||||
use libloading::os::windows::*;
|
||||
use std::ffi::CStr;
|
||||
|
||||
// The ordinal DLL contains exactly one function (other than DllMain, that is) with ordinal number
|
||||
// 1. This function has the sugnature `fn() -> *const c_char` and returns a string "bunny\0" (in
|
||||
// reference to WindowsBunny).
|
||||
//
|
||||
// Both x86_64 and x86 versions of the .dll are functionally the same. Ideally we would compile the
|
||||
// dlls with well known ordinals from our own testing helpers library, but rustc does not allow
|
||||
// specifying a custom .def file (https://github.com/rust-lang/rust/issues/35089)
|
||||
//
|
||||
// The DLLs were kindly compiled by WindowsBunny (aka. @retep998).
|
||||
|
||||
#[cfg(target_arch="x86")]
|
||||
fn load_ordinal_lib() -> Library {
|
||||
Library::new("tests/nagisa32.dll").expect("nagisa32.dll")
|
||||
}
|
||||
|
||||
#[cfg(target_arch="x86_64")]
|
||||
fn load_ordinal_lib() -> Library {
|
||||
Library::new("tests/nagisa64.dll").expect("nagisa64.dll")
|
||||
}
|
||||
|
||||
#[cfg(any(target_arch="x86", target_arch="x86_64"))]
|
||||
#[test]
|
||||
fn test_ordinal() {
|
||||
let lib = load_ordinal_lib();
|
||||
unsafe {
|
||||
let windows: Symbol<unsafe fn() -> *const i8> = lib.get_ordinal(1).expect("function");
|
||||
assert_eq!(CStr::from_ptr(windows()).to_bytes(), b"bunny");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_arch="x86", target_arch="x86_64"))]
|
||||
#[test]
|
||||
fn test_ordinal_missing_fails() {
|
||||
let lib = load_ordinal_lib();
|
||||
unsafe {
|
||||
let r: Result<Symbol<unsafe fn() -> *const i8>, _> = lib.get_ordinal(2);
|
||||
r.err().unwrap();
|
||||
let r: Result<Symbol<unsafe fn() -> *const i8>, _> = lib.get_ordinal(!0);
|
||||
r.err().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_new_kernel23() {
|
||||
Library::new("kernel23").err().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_new_kernel32_no_ext() {
|
||||
Library::new("kernel32").unwrap();
|
||||
}
|
||||
|
|
@ -1 +1 @@
|
|||
{"files":{"Cargo.toml":"62c225dc3a9c63990f9542efc86b23aa444a24d91dab57d8d1a8a3414f0befe0","LICENSE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","NOTICE":"6e0c856925602c18a04e173be3a6e2d812a7ca4501176642a07fec1af97e0eab","README.md":"4f227c9d8a3c07e4b82b2812d3fcc512cdf477a4daf2c9c955f49fb2e94cbab8","rustfmt.toml":"925e9c7b3d6df043a11531da116439cc0d0b0368b682875a8fb0e8229fc7df01","src/errors.rs":"efcc4e8472ee06de82b122017cca4e87898034c98bc9b593110b2a4f8a557e26","src/functions.rs":"1bec1b1ac5c38d3db527880ab5b06005f567a52bba7b98b1ec0fdf64f7d0a68b","src/lib.rs":"3d22aaedf17669d9ca5f50c7ff892e7d874d257369fa40b49ed582409ee94455","src/tests.rs":"b7257ef2bff4321ac03095af9b4015fc9a88d2cddddb94ca8ae8f7516b19e7f1","src/types.rs":"797b99955b4fa30ad373ee435076c6d251978bb6ae724cc9a082020fb8f984fc"},"package":null}
|
||||
{"files":{"Cargo.toml":"b04ba4906f065e937aac92197aaa7ec3628f52c0c6277cc27401d571a3d4472c","LICENSE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","NOTICE":"6e0c856925602c18a04e173be3a6e2d812a7ca4501176642a07fec1af97e0eab","README.md":"4f227c9d8a3c07e4b82b2812d3fcc512cdf477a4daf2c9c955f49fb2e94cbab8","rustfmt.toml":"925e9c7b3d6df043a11531da116439cc0d0b0368b682875a8fb0e8229fc7df01","src/errors.rs":"efcc4e8472ee06de82b122017cca4e87898034c98bc9b593110b2a4f8a557e26","src/functions.rs":"1bec1b1ac5c38d3db527880ab5b06005f567a52bba7b98b1ec0fdf64f7d0a68b","src/lib.rs":"3d22aaedf17669d9ca5f50c7ff892e7d874d257369fa40b49ed582409ee94455","src/tests.rs":"b7257ef2bff4321ac03095af9b4015fc9a88d2cddddb94ca8ae8f7516b19e7f1","src/types.rs":"797b99955b4fa30ad373ee435076c6d251978bb6ae724cc9a082020fb8f984fc"},"package":"c20593a99fe08068cbe2b59001527f36021d6ad53ac5f2d8793fcf2fe94015a0"}
|
||||
|
|
@ -1,39 +1,39 @@
|
|||
# Copyright 2017 Marcus Heese
|
||||
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
# When uploading crates to the registry Cargo will automatically
|
||||
# "normalize" Cargo.toml files for maximal compatibility
|
||||
# with all versions of Cargo and also rewrite `path` dependencies
|
||||
# to registry (e.g., crates.io) dependencies
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# If you believe there's an error in this file please file an
|
||||
# issue against the rust-lang/cargo repository. If you're
|
||||
# editing this file be aware that the upstream Cargo.toml
|
||||
# will likely look very different (and much more reasonable)
|
||||
|
||||
[package]
|
||||
name = "pkcs11"
|
||||
version = "0.4.1"
|
||||
authors = ["Marcus Heese <marcus.heese@gmail.com>"]
|
||||
exclude = ["pkcs11-docs/**"]
|
||||
description = "Rust PKCS#11 Library"
|
||||
#documentation = "https://github.com/mheese/rust-pkcs11"
|
||||
homepage = "https://github.com/mheese/rust-pkcs11"
|
||||
repository = "https://github.com/mheese/rust-pkcs11"
|
||||
#readme = "..."
|
||||
keywords = ["pkcs11", "cryptoki"]
|
||||
categories = ["external-ffi-bindings", "cryptography", "hardware-support"]
|
||||
license = "Apache-2.0"
|
||||
exclude = [
|
||||
"pkcs11-docs/**",
|
||||
]
|
||||
repository = "https://github.com/mheese/rust-pkcs11"
|
||||
[dependencies.libloading]
|
||||
version = "^0.5"
|
||||
|
||||
[dependencies]
|
||||
libloading = "^0.4"
|
||||
num-bigint = "^0.2"
|
||||
#libc = "0.2.33"
|
||||
[dependencies.num-bigint]
|
||||
version = "^0.2"
|
||||
[dev-dependencies.hex]
|
||||
version = "^0.3"
|
||||
|
||||
[dev-dependencies]
|
||||
num-traits = "^0.1"
|
||||
hex = "^0.3"
|
||||
serial_test = "~0.1"
|
||||
serial_test_derive = "~0.1"
|
||||
[dev-dependencies.num-traits]
|
||||
version = "^0.1"
|
||||
|
||||
[dev-dependencies.serial_test]
|
||||
version = "~0.1"
|
||||
|
||||
[dev-dependencies.serial_test_derive]
|
||||
version = "~0.1"
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче