fix build (b7ed1ee8) · Commits · Public Repositories / Rust Openssl

openssl-sys/build/find_normal.rs

+1 −1

Original line number	Diff line number	Diff line
		@@ -231,7 +231,7 @@ fn try_vcpkg() {
		.emit_includes(true)
		.find_package("openssl")
		{
		Ok(lit) => lib,
		Ok(lib) => lib,
		Err(e) => {
		println!("note: vcpkg did not find openssl: {}", e);
		return;

openssl-sys/build/run_bindgen.rs

+19 −4

Original line number	Diff line number	Diff line
		@@ -6,6 +6,7 @@ use std::path::PathBuf;
		const INCLUDES: &str = "
		#include <openssl/crypto.h>
		#include <openssl/stack.h>
		#include <openssl/x509v3.h>
		";

		pub fn run(include_dirs: &[PathBuf]) {
		@@ -21,6 +22,14 @@ pub fn run(include_dirs: &[PathBuf]) {
		// libc is missing pthread_once_t on macOS
		.blocklist_type("CRYPTO_ONCE")
		.blocklist_function("CRYPTO_THREAD_run_once")
		// we don't want to mess with va_list
		.blocklist_function("BIO_vprintf")
		.blocklist_function("BIO_vsnprintf")
		// Maintain compatibility for existing enum definitions
		.rustified_enum("point_conversion_form_t")
		// Maintain compatibility for pre-union definitions
		.blocklist_type("GENERAL_NAME")
		.blocklist_type("EVP_PKEY")
		.layout_tests(false)
		.header_contents("includes.h", INCLUDES);

		@@ -46,12 +55,18 @@ impl ParseCallbacks for OpensslCallbacks {
		MacroParsingBehavior::Ignore
		}

		// Our original definitions of these are wrong (missing the Option layer), so we need to rename to avoid breakage
		fn item_name(&self, original_item_name: &str) -> Option<String> {
		match original_item_name {
		"CRYPTO_EX_new" \| "CRYPTO_EX_dup" \| "CRYPTO_EX_free" => {
		Some(format!("{}2", original_item_name))
		}
		// Our original definitions of these are wrong, so rename to avoid breakage
		"CRYPTO_EX_new"
		\| "CRYPTO_EX_dup"
		\| "CRYPTO_EX_free"
		\| "BIO_meth_set_write"
		\| "BIO_meth_set_read"
		\| "BIO_meth_set_puts"
		\| "BIO_meth_set_ctrl"
		\| "BIO_meth_set_create"
		\| "BIO_meth_set_destroy" => Some(format!("{}__fixed_rust", original_item_name)),
		_ => None,
		}
		}

openssl-sys/src/asn1.rs

+0 −56

Original line number	Diff line number	Diff line
		@@ -37,59 +37,3 @@ pub const MBSTRING_UTF8: c_int = MBSTRING_FLAG;
		pub const MBSTRING_ASC: c_int = MBSTRING_FLAG \| 1;
		pub const MBSTRING_BMP: c_int = MBSTRING_FLAG \| 2;
		pub const MBSTRING_UNIV: c_int = MBSTRING_FLAG \| 4;

		#[repr(C)]
		pub struct ASN1_ENCODING {
		pub enc: *mut c_uchar,
		pub len: c_long,
		pub modified: c_int,
		}

		extern "C" {
		pub fn ASN1_OBJECT_free(x: *mut ASN1_OBJECT);
		}

		stack!(stack_st_ASN1_OBJECT);

		extern "C" {
		pub fn ASN1_STRING_type_new(ty: c_int) -> *mut ASN1_STRING;
		#[cfg(any(ossl110, libressl273))]
		pub fn ASN1_STRING_get0_data(x: const ASN1_STRING) -> const c_uchar;
		#[cfg(any(all(ossl101, not(ossl110)), libressl))]
		pub fn ASN1_STRING_data(x: mut ASN1_STRING) -> mut c_uchar;

		pub fn ASN1_BIT_STRING_free(x: *mut ASN1_BIT_STRING);

		pub fn ASN1_STRING_free(x: *mut ASN1_STRING);
		pub fn ASN1_STRING_length(x: *const ASN1_STRING) -> c_int;

		pub fn ASN1_GENERALIZEDTIME_free(tm: *mut ASN1_GENERALIZEDTIME);
		pub fn ASN1_GENERALIZEDTIME_print(b: mut BIO, tm: const ASN1_GENERALIZEDTIME) -> c_int;
		pub fn ASN1_TIME_new() -> *mut ASN1_TIME;
		#[cfg(ossl102)]
		pub fn ASN1_TIME_diff(
		pday: *mut c_int,
		psec: *mut c_int,
		from: *const ASN1_TIME,
		to: *const ASN1_TIME,
		) -> c_int;
		pub fn ASN1_TIME_free(tm: *mut ASN1_TIME);
		pub fn ASN1_TIME_print(b: mut BIO, tm: const ASN1_TIME) -> c_int;
		pub fn ASN1_TIME_set(from: mut ASN1_TIME, to: time_t) -> mut ASN1_TIME;

		pub fn ASN1_INTEGER_free(x: *mut ASN1_INTEGER);
		pub fn ASN1_INTEGER_get(dest: *const ASN1_INTEGER) -> c_long;
		pub fn ASN1_INTEGER_set(dest: *mut ASN1_INTEGER, value: c_long) -> c_int;
		pub fn BN_to_ASN1_INTEGER(bn: const BIGNUM, ai: mut ASN1_INTEGER) -> *mut ASN1_INTEGER;
		pub fn ASN1_INTEGER_to_BN(ai: const ASN1_INTEGER, bn: mut BIGNUM) -> *mut BIGNUM;

		pub fn ASN1_TIME_set_string(s: mut ASN1_TIME, str: const c_char) -> c_int;
		#[cfg(ossl111)]
		pub fn ASN1_TIME_set_string_X509(s: mut ASN1_TIME, str: const c_char) -> c_int;
		}

		const_ptr_api! {
		extern "C" {
		pub fn ASN1_STRING_to_UTF8(out: mut mut c_uchar, s: #[const_ptr_if(any(ossl110, libressl280))] ASN1_STRING) -> c_int;
		}
		}

openssl-sys/src/bio.rs

+41 −62

Original line number	Diff line number	Diff line
		@@ -10,11 +10,6 @@ pub const BIO_CTRL_FLUSH: c_int = 11;
		pub const BIO_CTRL_DGRAM_QUERY_MTU: c_int = 40;
		pub const BIO_C_SET_BUF_MEM_EOF_RETURN: c_int = 130;

		extern "C" {
		pub fn BIO_set_flags(b: *mut BIO, flags: c_int);
		pub fn BIO_clear_flags(b: *mut BIO, flags: c_int);
		}

		pub unsafe fn BIO_set_retry_read(b: *mut BIO) {
		BIO_set_flags(b, BIO_FLAGS_READ \| BIO_FLAGS_SHOULD_RETRY)
		}
		@@ -33,68 +28,11 @@ pub const BIO_FLAGS_IO_SPECIAL: c_int = 0x04;
		pub const BIO_FLAGS_RWS: c_int = BIO_FLAGS_READ \| BIO_FLAGS_WRITE \| BIO_FLAGS_IO_SPECIAL;
		pub const BIO_FLAGS_SHOULD_RETRY: c_int = 0x08;

		pub type bio_info_cb =
		Option<unsafe extern "C" fn(mut BIO, c_int, const c_char, c_int, c_long, c_long)>;

		cfg_if! {
		if #[cfg(any(ossl110, libressl280))] {
		pub enum BIO_METHOD {}
		} else {
		#[repr(C)]
		pub struct BIO_METHOD {
		pub type_: c_int,
		pub name: *const c_char,
		pub bwrite: Option<unsafe extern "C" fn(mut ::BIO, const c_char, c_int) -> c_int>,
		pub bread: Option<unsafe extern "C" fn(mut ::BIO, mut c_char, c_int) -> c_int>,
		pub bputs: Option<unsafe extern "C" fn(mut ::BIO, const c_char) -> c_int>,
		pub bgets: Option<unsafe extern "C" fn(mut ::BIO, mut c_char, c_int) -> c_int>,
		pub ctrl: Option<unsafe extern "C" fn(mut ::BIO, c_int, c_long, mut c_void) -> c_long>,
		pub create: Option<unsafe extern "C" fn(*mut ::BIO) -> c_int>,
		pub destroy: Option<unsafe extern "C" fn(*mut ::BIO) -> c_int>,
		pub callback_ctrl: Option<unsafe extern "C" fn(*mut ::BIO, c_int, ::bio_info_cb) -> c_long>,
		}
		}
		}

		pub unsafe fn BIO_get_mem_data(b: mut BIO, pp: mut *mut c_char) -> c_long {
		BIO_ctrl(b, BIO_CTRL_INFO, 0, pp as *mut c_void)
		}

		const_ptr_api! {
		extern "C" {
		pub fn BIO_s_file() -> #[const_ptr_if(any(ossl110, libressl280))] BIO_METHOD;
		pub fn BIO_new(type_: #[const_ptr_if(any(ossl110, libressl280))] BIO_METHOD) -> *mut BIO;
		}
		}
		extern "C" {
		#[cfg(not(osslconf = "OPENSSL_NO_STDIO"))]
		pub fn BIO_new_fp(stream: mut FILE, close_flag: c_int) -> mut BIO;
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_set_data(a: mut ::BIO, data: mut c_void);
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_get_data(a: mut ::BIO) -> mut c_void;
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_set_init(a: *mut ::BIO, init: c_int);
		pub fn BIO_write(b: mut BIO, buf: const c_void, len: c_int) -> c_int;
		pub fn BIO_read(b: mut BIO, buf: mut c_void, len: c_int) -> c_int;
		pub fn BIO_ctrl(b: mut BIO, cmd: c_int, larg: c_long, parg: mut c_void) -> c_long;
		pub fn BIO_free_all(b: *mut BIO);
		}

		const_ptr_api! {
		extern "C" {
		pub fn BIO_s_mem() -> #[const_ptr_if(any(ossl110, libressl280))] BIO_METHOD;
		pub fn BIO_new_mem_buf(buf: #[const_ptr_if(any(ossl102, libressl280))] c_void, len: c_int) -> *mut BIO;
		}
		}

		extern "C" {
		pub fn BIO_new_socket(sock: c_int, close_flag: c_int) -> *mut BIO;

		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_meth_new(type_: c_int, name: const c_char) -> mut BIO_METHOD;
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_meth_free(biom: *mut BIO_METHOD);
		// FIXME should wrap in Option
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_meth_set_write(
		@@ -127,3 +65,44 @@ extern "C" {
		destroy: unsafe extern "C" fn(*mut BIO) -> c_int,
		) -> c_int;
		}

		#[allow(clashing_extern_declarations)]
		extern "C" {
		// FIXME should wrap in Option
		#[cfg(any(ossl110, libressl273))]
		#[link_name = "BIO_meth_set_write"]
		pub fn BIO_meth_set_write__fixed_rust(
		biom: *mut BIO_METHOD,
		write: Option<unsafe extern "C" fn(mut BIO, const c_char, c_int) -> c_int>,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		#[link_name = "BIO_meth_set_read"]
		pub fn BIO_meth_set_read__fixed_rust(
		biom: *mut BIO_METHOD,
		read: Option<unsafe extern "C" fn(mut BIO, mut c_char, c_int) -> c_int>,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		#[link_name = "BIO_meth_set_puts"]
		pub fn BIO_meth_set_puts__fixed_rust(
		biom: *mut BIO_METHOD,
		read: Option<unsafe extern "C" fn(mut BIO, const c_char) -> c_int>,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		#[link_name = "BIO_meth_set_ctrl"]
		pub fn BIO_meth_set_ctrl__fixed_rust(
		biom: *mut BIO_METHOD,
		read: Option<unsafe extern "C" fn(mut BIO, c_int, c_long, mut c_void) -> c_long>,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		#[link_name = "BIO_meth_set_create"]
		pub fn BIO_meth_set_create__fixed_rust(
		biom: *mut BIO_METHOD,
		create: Option<unsafe extern "C" fn(*mut BIO) -> c_int>,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		#[link_name = "BIO_meth_set_destroy"]
		pub fn BIO_meth_set_destroy__fixed_rust(
		biom: *mut BIO_METHOD,
		destroy: Option<unsafe extern "C" fn(*mut BIO) -> c_int>,
		) -> c_int;
		}

openssl-sys/src/bn.rs

+0 −162

Original line number	Diff line number	Diff line
		@@ -15,165 +15,3 @@ pub const BN_FLG_STATIC_DATA: c_int = 0x02;
		pub const BN_FLG_CONSTTIME: c_int = 0x04;
		#[cfg(ossl110)]
		pub const BN_FLG_SECURE: c_int = 0x08;

		extern "C" {
		pub fn BN_CTX_new() -> *mut BN_CTX;
		#[cfg(ossl110)]
		pub fn BN_CTX_secure_new() -> *mut BN_CTX;
		pub fn BN_CTX_free(ctx: *mut BN_CTX);
		pub fn BN_rand(r: *mut BIGNUM, bits: c_int, top: c_int, bottom: c_int) -> c_int;
		pub fn BN_pseudo_rand(r: *mut BIGNUM, bits: c_int, top: c_int, bottom: c_int) -> c_int;
		pub fn BN_rand_range(r: mut BIGNUM, range: const BIGNUM) -> c_int;
		pub fn BN_pseudo_rand_range(r: mut BIGNUM, range: const BIGNUM) -> c_int;
		pub fn BN_new() -> *mut BIGNUM;
		#[cfg(ossl110)]
		pub fn BN_secure_new() -> *mut BIGNUM;
		#[cfg(ossl110)]
		pub fn BN_set_flags(b: *mut BIGNUM, n: c_int);
		#[cfg(ossl110)]
		pub fn BN_get_flags(b: *const BIGNUM, n: c_int) -> c_int;
		pub fn BN_num_bits(bn: *const BIGNUM) -> c_int;
		pub fn BN_clear_free(bn: *mut BIGNUM);
		pub fn BN_bin2bn(s: const u8, size: c_int, ret: mut BIGNUM) -> *mut BIGNUM;
		pub fn BN_bn2bin(a: const BIGNUM, to: mut u8) -> c_int;
		#[cfg(ossl110)]
		pub fn BN_bn2binpad(a: const BIGNUM, to: mut u8, tolen: c_int) -> c_int;
		pub fn BN_sub(r: mut BIGNUM, a: const BIGNUM, b: *const BIGNUM) -> c_int;
		pub fn BN_add(r: mut BIGNUM, a: const BIGNUM, b: *const BIGNUM) -> c_int;
		pub fn BN_mul(r: mut BIGNUM, a: const BIGNUM, b: const BIGNUM, ctx: mut BN_CTX) -> c_int;
		pub fn BN_sqr(r: mut BIGNUM, a: const BIGNUM, ctx: *mut BN_CTX) -> c_int;
		pub fn BN_set_negative(bn: *mut BIGNUM, n: c_int);
		#[cfg(ossl110)]
		pub fn BN_is_negative(b: *const ::BIGNUM) -> c_int;

		pub fn BN_div(
		dv: *mut BIGNUM,
		rem: *mut BIGNUM,
		a: *const BIGNUM,
		b: *const BIGNUM,
		ctx: *mut BN_CTX,
		) -> c_int;
		pub fn BN_nnmod(
		rem: *mut BIGNUM,
		a: *const BIGNUM,
		m: *const BIGNUM,
		ctx: *mut BN_CTX,
		) -> c_int;
		pub fn BN_mod_add(
		r: *mut BIGNUM,
		a: *const BIGNUM,
		b: *const BIGNUM,
		m: *const BIGNUM,
		ctx: *mut BN_CTX,
		) -> c_int;
		pub fn BN_mod_sub(
		r: *mut BIGNUM,
		a: *const BIGNUM,
		b: *const BIGNUM,
		m: *const BIGNUM,
		ctx: *mut BN_CTX,
		) -> c_int;
		pub fn BN_mod_mul(
		r: *mut BIGNUM,
		a: *const BIGNUM,
		b: *const BIGNUM,
		m: *const BIGNUM,
		ctx: *mut BN_CTX,
		) -> c_int;
		pub fn BN_mod_sqr(
		r: *mut BIGNUM,
		a: *const BIGNUM,
		m: *const BIGNUM,
		ctx: *mut BN_CTX,
		) -> c_int;

		pub fn BN_mod_word(r: *const BIGNUM, w: BN_ULONG) -> BN_ULONG;
		pub fn BN_div_word(r: *mut BIGNUM, w: BN_ULONG) -> BN_ULONG;
		pub fn BN_mul_word(r: *mut BIGNUM, w: BN_ULONG) -> c_int;
		pub fn BN_add_word(r: *mut BIGNUM, w: BN_ULONG) -> c_int;
		pub fn BN_sub_word(r: *mut BIGNUM, w: BN_ULONG) -> c_int;
		pub fn BN_set_word(bn: *mut BIGNUM, n: BN_ULONG) -> c_int;

		pub fn BN_cmp(a: const BIGNUM, b: const BIGNUM) -> c_int;
		pub fn BN_free(bn: *mut BIGNUM);
		pub fn BN_is_bit_set(a: *const BIGNUM, n: c_int) -> c_int;
		pub fn BN_lshift(r: mut BIGNUM, a: const BIGNUM, n: c_int) -> c_int;
		pub fn BN_lshift1(r: mut BIGNUM, a: const BIGNUM) -> c_int;
		pub fn BN_exp(r: mut BIGNUM, a: const BIGNUM, p: const BIGNUM, ctx: mut BN_CTX) -> c_int;

		pub fn BN_mod_exp(
		r: *mut BIGNUM,
		a: *const BIGNUM,
		p: *const BIGNUM,
		m: *const BIGNUM,
		ctx: *mut BN_CTX,
		) -> c_int;

		pub fn BN_mask_bits(a: *mut BIGNUM, n: c_int) -> c_int;
		pub fn BN_rshift(r: mut BIGNUM, a: const BIGNUM, n: c_int) -> c_int;
		pub fn BN_rshift1(r: mut BIGNUM, a: const BIGNUM) -> c_int;
		pub fn BN_bn2hex(a: const BIGNUM) -> mut c_char;
		pub fn BN_bn2dec(a: const BIGNUM) -> mut c_char;
		pub fn BN_hex2bn(a: mut mut BIGNUM, s: *const c_char) -> c_int;
		pub fn BN_dec2bn(a: mut mut BIGNUM, s: *const c_char) -> c_int;
		pub fn BN_gcd(r: mut BIGNUM, a: const BIGNUM, b: const BIGNUM, ctx: mut BN_CTX) -> c_int;
		pub fn BN_mod_inverse(
		r: *mut BIGNUM,
		a: *const BIGNUM,
		n: *const BIGNUM,
		ctx: *mut BN_CTX,
		) -> *mut BIGNUM;
		pub fn BN_clear(bn: *mut BIGNUM);
		pub fn BN_dup(n: const BIGNUM) -> mut BIGNUM;
		pub fn BN_ucmp(a: const BIGNUM, b: const BIGNUM) -> c_int;
		pub fn BN_set_bit(a: *mut BIGNUM, n: c_int) -> c_int;
		pub fn BN_clear_bit(a: *mut BIGNUM, n: c_int) -> c_int;

		pub fn BN_generate_prime_ex(
		r: *mut BIGNUM,
		bits: c_int,
		safe: c_int,
		add: *const BIGNUM,
		rem: *const BIGNUM,
		cb: *mut BN_GENCB,
		) -> c_int;
		pub fn BN_is_prime_ex(
		p: *const BIGNUM,
		checks: c_int,
		ctx: *mut BN_CTX,
		cb: *mut BN_GENCB,
		) -> c_int;
		pub fn BN_is_prime_fasttest_ex(
		p: *const BIGNUM,
		checks: c_int,
		ctx: *mut BN_CTX,
		do_trial_division: c_int,
		cb: *mut BN_GENCB,
		) -> c_int;
		}

		cfg_if! {
		if #[cfg(ossl110)] {
		extern "C" {
		pub fn BN_get_rfc2409_prime_768(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn BN_get_rfc2409_prime_1024(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn BN_get_rfc3526_prime_1536(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn BN_get_rfc3526_prime_2048(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn BN_get_rfc3526_prime_3072(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn BN_get_rfc3526_prime_4096(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn BN_get_rfc3526_prime_6144(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn BN_get_rfc3526_prime_8192(bn: mut BIGNUM) -> mut BIGNUM;
		}
		} else {
		extern "C" {
		pub fn get_rfc2409_prime_768(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn get_rfc2409_prime_1024(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn get_rfc3526_prime_1536(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn get_rfc3526_prime_2048(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn get_rfc3526_prime_3072(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn get_rfc3526_prime_4096(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn get_rfc3526_prime_6144(bn: mut BIGNUM) -> mut BIGNUM;
		pub fn get_rfc3526_prime_8192(bn: mut BIGNUM) -> mut BIGNUM;
		}
		}
		}