diff --git a/.cargo/config.in b/.cargo/config.in index 42de7461538f..bc8f785b48ba 100644 --- a/.cargo/config.in +++ b/.cargo/config.in @@ -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" diff --git a/Cargo.lock b/Cargo.lock index 23f8a80d43c8..02af914d0899 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -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)" = "" +"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" diff --git a/security/manager/ssl/osclientcerts/Cargo.toml b/security/manager/ssl/osclientcerts/Cargo.toml index e350acc9d228..954d9f425762 100644 --- a/security/manager/ssl/osclientcerts/Cargo.toml +++ b/security/manager/ssl/osclientcerts/Cargo.toml @@ -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] diff --git a/third_party/rust/libloading-0.4.3/.cargo-checksum.json b/third_party/rust/libloading-0.4.3/.cargo-checksum.json deleted file mode 100644 index 28604087b08c..000000000000 --- a/third_party/rust/libloading-0.4.3/.cargo-checksum.json +++ /dev/null @@ -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"} \ No newline at end of file diff --git a/third_party/rust/libloading-0.4.3/Cargo.toml b/third_party/rust/libloading-0.4.3/Cargo.toml deleted file mode 100644 index d6d64ef2764d..000000000000 --- a/third_party/rust/libloading-0.4.3/Cargo.toml +++ /dev/null @@ -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 "] -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" diff --git a/third_party/rust/libloading-0.4.3/LICENSE b/third_party/rust/libloading-0.4.3/LICENSE deleted file mode 100644 index 9137d5607a42..000000000000 --- a/third_party/rust/libloading-0.4.3/LICENSE +++ /dev/null @@ -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. diff --git a/third_party/rust/libloading-0.4.3/README.mkd b/third_party/rust/libloading-0.4.3/README.mkd deleted file mode 100644 index 58f4ad53826e..000000000000 --- a/third_party/rust/libloading-0.4.3/README.mkd +++ /dev/null @@ -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. diff --git a/third_party/rust/libloading-0.4.3/appveyor.yml b/third_party/rust/libloading-0.4.3/appveyor.yml deleted file mode 100644 index 1bded0bd8d6a..000000000000 --- a/third_party/rust/libloading-0.4.3/appveyor.yml +++ /dev/null @@ -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 diff --git a/third_party/rust/libloading-0.4.3/build.rs b/third_party/rust/libloading-0.4.3/build.rs deleted file mode 100644 index be3afba3bb91..000000000000 --- a/third_party/rust/libloading-0.4.3/build.rs +++ /dev/null @@ -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); - } - } -} diff --git a/third_party/rust/libloading-0.4.3/src/changelog.rs b/third_party/rust/libloading-0.4.3/src/changelog.rs deleted file mode 100644 index fedec3010f01..000000000000 --- a/third_party/rust/libloading-0.4.3/src/changelog.rs +++ /dev/null @@ -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::::lift_option() -> Option>` 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` and `os::*::Symbol` now implement `Send` where `T: Send`; -/// * `Symbol` and `os::*::Symbol` 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 for Library` and `impl From 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 {} diff --git a/third_party/rust/libloading-0.4.3/src/lib.rs b/third_party/rust/libloading-0.4.3/src/lib.rs deleted file mode 100644 index 976e3b6cce11..000000000000 --- a/third_party/rust/libloading-0.4.3/src/lib.rs +++ /dev/null @@ -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 { -//! let lib = lib::Library::new("/path/to/liblibrary.so")?; -//! unsafe { -//! let func: lib::Symbol 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 = ::std::io::Result; - -/// 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>(filename: P) -> Result { - 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 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> { - 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 for Library { - fn from(lib: imp::Library) -> Library { - Library(lib) - } -} - -impl From 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, - 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 { - 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(sym: imp::Symbol, _: &'lib L) -> Symbol<'lib, T> { - Symbol { - inner: sym, - pd: marker::PhantomData - } - } -} - -impl<'lib, T> Symbol<'lib, Option> { - /// 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> = 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> { - 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> {} diff --git a/third_party/rust/libloading-0.4.3/src/os/mod.rs b/third_party/rust/libloading-0.4.3/src/os/mod.rs deleted file mode 100644 index ccbc8e977816..000000000000 --- a/third_party/rust/libloading-0.4.3/src/os/mod.rs +++ /dev/null @@ -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 {}); diff --git a/third_party/rust/libloading-0.4.3/src/os/unix/mod.rs b/third_party/rust/libloading-0.4.3/src/os/unix/mod.rs deleted file mode 100644 index 69398a67608e..000000000000 --- a/third_party/rust/libloading-0.4.3/src/os/unix/mod.rs +++ /dev/null @@ -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(closure: F) -> Result> -where F: FnOnce() -> Option { - // 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>(filename: P) -> ::Result { - 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

(filename: Option

, flags: raw::c_int) -> ::Result - where P: AsRef { - 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(&self, symbol: &[u8]) -> ::Result> { - ensure_compatible_types::(); - 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 { - pointer: *mut raw::c_void, - pd: marker::PhantomData -} - -impl Symbol> { - /// Lift Option out of the symbol. - pub fn lift_option(self) -> Option> { - if self.pointer.is_null() { - None - } else { - Some(Symbol { - pointer: self.pointer, - pd: marker::PhantomData, - }) - } - } -} - -unsafe impl Send for Symbol {} -unsafe impl Sync for Symbol {} - -impl Clone for Symbol { - fn clone(&self) -> Symbol { - Symbol { ..*self } - } -} - -impl ::std::ops::Deref for Symbol { - type Target = T; - fn deref(&self) -> &T { - unsafe { - // Additional reference level for a dereference on `deref` return value. - mem::transmute(&self.pointer) - } - } -} - -impl fmt::Debug for Symbol { - 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(); -} diff --git a/third_party/rust/libloading-0.4.3/src/os/windows/mod.rs b/third_party/rust/libloading-0.4.3/src/os/windows/mod.rs deleted file mode 100644 index ae9616dc5304..000000000000 --- a/third_party/rust/libloading-0.4.3/src/os/windows/mod.rs +++ /dev/null @@ -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>(filename: P) -> ::Result { - let wide_filename: Vec = 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(&self, symbol: &[u8]) -> ::Result> { - ensure_compatible_types::(); - 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(&self, ordinal: winapi::WORD) -> ::Result> { - ensure_compatible_types::(); - 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 { - pointer: winapi::FARPROC, - pd: marker::PhantomData -} - -impl Symbol> { - /// Lift Option out of the symbol. - pub fn lift_option(self) -> Option> { - if self.pointer.is_null() { - None - } else { - Some(Symbol { - pointer: self.pointer, - pd: marker::PhantomData, - }) - } - } -} - -unsafe impl Send for Symbol {} -unsafe impl Sync for Symbol {} - -impl Clone for Symbol { - fn clone(&self) -> Symbol { - Symbol { ..*self } - } -} - -impl ::std::ops::Deref for Symbol { - type Target = T; - fn deref(&self) -> &T { - unsafe { - // Additional reference level for a dereference on `deref` return value. - mem::transmute(&self.pointer) - } - } -} - -impl fmt::Debug for Symbol { - 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 { - 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(closure: F) -> Result> -where F: FnOnce() -> Option { - 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 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 winapi::DWORD> = unsafe { - lib.get(b"GetLastError\0").unwrap() - }; - unsafe { - kernel32::SetLastError(42); - assert_eq!(kernel32::GetLastError(), gle()) - } -} diff --git a/third_party/rust/libloading-0.4.3/src/test_helpers.rs b/third_party/rust/libloading-0.4.3/src/test_helpers.rs deleted file mode 100644 index 32f7023188e9..000000000000 --- a/third_party/rust/libloading-0.4.3/src/test_helpers.rs +++ /dev/null @@ -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 -} diff --git a/third_party/rust/libloading-0.4.3/src/util.rs b/third_party/rust/libloading-0.4.3/src/util.rs deleted file mode 100644 index caa95b63df46..000000000000 --- a/third_party/rust/libloading-0.4.3/src/util.rs +++ /dev/null @@ -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 for NullError { - fn from(_: NulError) -> NullError { - NullError - } -} - -impl From for NullError { - fn from(_: FromBytesWithNulError) -> NullError { - NullError - } -} - -impl From 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, 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() { - #[cold] - #[inline(never)] - fn dopanic() { - panic!("value of requested type cannot be dynamically loaded"); - } - if ::std::mem::size_of::() != ::std::mem::size_of::() { - dopanic() - } -} diff --git a/third_party/rust/libloading-0.4.3/tests/functions.rs b/third_party/rust/libloading-0.4.3/tests/functions.rs deleted file mode 100644 index c9bc067eacda..000000000000 --- a/third_party/rust/libloading-0.4.3/tests/functions.rs +++ /dev/null @@ -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 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 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 S> = lib.get(b"test_identity_struct\0").unwrap(); - let f2: Symbol 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> { - l.get::(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 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 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 u32> = lib.get(b"test_get_thread_local\0").unwrap(); - assert_eq!(84, help()); - } - ::std::thread::spawn(move || unsafe { - let help: Symbol u32> = lib.get(b"test_get_thread_local\0").unwrap(); - assert_eq!(0, help()); - }).join().unwrap(); -} diff --git a/third_party/rust/libloading-0.4.3/tests/markers.rs b/third_party/rust/libloading-0.4.3/tests/markers.rs deleted file mode 100644 index 01da108c688d..000000000000 --- a/third_party/rust/libloading-0.4.3/tests/markers.rs +++ /dev/null @@ -1,79 +0,0 @@ -extern crate libloading; - -#[cfg(test)] -fn assert_send() {} -#[cfg(test)] -fn assert_sync() {} - -#[test] -fn check_library_send() { - assert_send::(); -} - -#[cfg(unix)] -#[test] -fn check_unix_library_send() { - assert_send::(); -} - -#[cfg(windows)] -#[test] -fn check_windows_library_send() { - assert_send::(); -} - -#[test] -fn check_library_sync() { - assert_sync::(); -} - -#[cfg(unix)] -#[test] -fn check_unix_library_sync() { - assert_sync::(); -} - -#[cfg(windows)] -#[test] -fn check_windows_library_sync() { - assert_sync::(); -} - -#[test] -fn check_symbol_send() { - assert_send:: ()>>(); - // assert_not_send::>(); -} - -#[cfg(unix)] -#[test] -fn check_unix_symbol_send() { - assert_send:: ()>>(); - // assert_not_send::>(); -} - -#[cfg(windows)] -#[test] -fn check_windows_symbol_send() { - assert_send:: ()>>(); -} - -#[test] -fn check_symbol_sync() { - assert_sync:: ()>>(); - // assert_not_sync::>(); -} - -#[cfg(unix)] -#[test] -fn check_unix_symbol_sync() { - assert_sync:: ()>>(); - // assert_not_sync::>(); -} - -#[cfg(windows)] -#[test] -fn check_windows_symbol_sync() { - assert_sync:: ()>>(); - // assert_not_sync::>(); -} diff --git a/third_party/rust/libloading-0.4.3/tests/nagisa32.dll b/third_party/rust/libloading-0.4.3/tests/nagisa32.dll deleted file mode 100644 index 0a6218ade9c0..000000000000 Binary files a/third_party/rust/libloading-0.4.3/tests/nagisa32.dll and /dev/null differ diff --git a/third_party/rust/libloading-0.4.3/tests/nagisa64.dll b/third_party/rust/libloading-0.4.3/tests/nagisa64.dll deleted file mode 100644 index bacaa4b96941..000000000000 Binary files a/third_party/rust/libloading-0.4.3/tests/nagisa64.dll and /dev/null differ diff --git a/third_party/rust/libloading-0.4.3/tests/windows.rs b/third_party/rust/libloading-0.4.3/tests/windows.rs deleted file mode 100644 index 343aaa1045a2..000000000000 --- a/third_party/rust/libloading-0.4.3/tests/windows.rs +++ /dev/null @@ -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 *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 *const i8>, _> = lib.get_ordinal(2); - r.err().unwrap(); - let r: Result *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(); -} diff --git a/third_party/rust/pkcs11/.cargo-checksum.json b/third_party/rust/pkcs11/.cargo-checksum.json index a6d8546f9235..8f86e37c0d65 100644 --- a/third_party/rust/pkcs11/.cargo-checksum.json +++ b/third_party/rust/pkcs11/.cargo-checksum.json @@ -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} \ No newline at end of file +{"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"} \ No newline at end of file diff --git a/third_party/rust/pkcs11/Cargo.toml b/third_party/rust/pkcs11/Cargo.toml index 8e5e3193a271..7dbaf2819914 100644 --- a/third_party/rust/pkcs11/Cargo.toml +++ b/third_party/rust/pkcs11/Cargo.toml @@ -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 "] +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"