Refactor openssl-sys (93a4e962) · Commits · Public Repositories / Rust Openssl

openssl-sys/src/aes.rs

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		use libc::*;

		pub const AES_ENCRYPT: c_int = 1;
		pub const AES_DECRYPT: c_int = 0;

		pub const AES_MAXNR: c_int = 14;
		pub const AES_BLOCK_SIZE: c_int = 16;

		#[repr(C)]
		pub struct AES_KEY {
		// There is some business with AES_LONG which is there to ensure the values here are 32 bits
		rd_key: [u32; 4 * (AES_MAXNR as usize + 1)],
		rounds: c_int,
		}

		extern "C" {
		pub fn AES_set_encrypt_key(userKey: const c_uchar, bits: c_int, key: mut AES_KEY) -> c_int;
		pub fn AES_set_decrypt_key(userKey: const c_uchar, bits: c_int, key: mut AES_KEY) -> c_int;

		pub fn AES_ige_encrypt(
		in_: *const c_uchar,
		out: *mut c_uchar,
		length: size_t,
		key: *const AES_KEY,
		ivec: *mut c_uchar,
		enc: c_int,
		);
		}

openssl-sys/src/asn1.rs

0 → 100644

+61 −0

Original line number	Diff line number	Diff line
		use libc::*;

		use *;

		pub const V_ASN1_UTCTIME: c_int = 23;
		pub const V_ASN1_GENERALIZEDTIME: c_int = 24;

		pub const MBSTRING_FLAG: c_int = 0x1000;
		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_free(tm: *mut ASN1_TIME);
		pub fn ASN1_TIME_print(b: mut BIO, tm: const ASN1_TIME) -> c_int;

		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;
		}

		cfg_if! {
		if #[cfg(ossl110)] {
		extern "C" {
		pub fn ASN1_STRING_to_UTF8(out: mut mut c_uchar, s: *const ASN1_STRING) -> c_int;
		}
		} else {
		extern "C" {
		pub fn ASN1_STRING_to_UTF8(out: mut mut c_uchar, s: *mut ASN1_STRING) -> c_int;
		}
		}
		}

openssl-sys/src/bio.rs

0 → 100644

+159 −0

Original line number	Diff line number	Diff line
		use libc::*;

		use *;

		pub const BIO_TYPE_NONE: c_int = 0;

		pub const BIO_CTRL_EOF: c_int = 2;
		pub const BIO_CTRL_INFO: c_int = 3;
		pub const BIO_CTRL_FLUSH: c_int = 11;
		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)
		}

		pub unsafe fn BIO_set_retry_write(b: *mut BIO) {
		BIO_set_flags(b, BIO_FLAGS_WRITE \| BIO_FLAGS_SHOULD_RETRY)
		}

		pub unsafe fn BIO_clear_retry_flags(b: *mut BIO) {
		BIO_clear_flags(b, BIO_FLAGS_RWS \| BIO_FLAGS_SHOULD_RETRY)
		}

		pub const BIO_FLAGS_READ: c_int = 0x01;
		pub const BIO_FLAGS_WRITE: c_int = 0x02;
		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(ossl110)] {
		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)
		}

		cfg_if! {
		if #[cfg(ossl110)] {
		extern "C" {
		pub fn BIO_s_file() -> *const BIO_METHOD;
		}
		} else {
		extern "C" {
		pub fn BIO_s_file() -> *mut BIO_METHOD;
		}
		}
		}
		cfg_if! {
		if #[cfg(ossl110)] {
		extern "C" {
		pub fn BIO_new(type_: const BIO_METHOD) -> mut BIO;
		}
		} else {
		extern "C" {
		pub fn BIO_new(type_: mut BIO_METHOD) -> mut BIO;
		}
		}
		}
		extern "C" {
		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);
		}

		cfg_if! {
		if #[cfg(ossl110)] {
		extern "C" {
		pub fn BIO_s_mem() -> *const BIO_METHOD;
		}
		} else {
		extern "C" {
		pub fn BIO_s_mem() -> *mut BIO_METHOD;
		}
		}
		}
		cfg_if! {
		if #[cfg(ossl102)] {
		extern "C" {
		pub fn BIO_new_mem_buf(buf: const c_void, len: c_int) -> mut BIO;
		}
		} else {
		extern "C" {
		pub fn BIO_new_mem_buf(buf: mut 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(
		biom: *mut BIO_METHOD,
		write: unsafe extern "C" fn(mut BIO, const c_char, c_int) -> c_int,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_meth_set_read(
		biom: *mut BIO_METHOD,
		read: unsafe extern "C" fn(mut BIO, mut c_char, c_int) -> c_int,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_meth_set_puts(
		biom: *mut BIO_METHOD,
		read: unsafe extern "C" fn(mut BIO, const c_char) -> c_int,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_meth_set_ctrl(
		biom: *mut BIO_METHOD,
		read: unsafe extern "C" fn(mut BIO, c_int, c_long, mut c_void) -> c_long,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_meth_set_create(
		biom: *mut BIO_METHOD,
		create: unsafe extern "C" fn(*mut BIO) -> c_int,
		) -> c_int;
		#[cfg(any(ossl110, libressl273))]
		pub fn BIO_meth_set_destroy(
		biom: *mut BIO_METHOD,
		destroy: unsafe extern "C" fn(*mut BIO) -> c_int,
		) -> c_int;
		}

openssl-sys/src/bn.rs

0 → 100644

+160 −0

Original line number	Diff line number	Diff line
		use libc::*;

		use *;

		#[cfg(target_pointer_width = "64")]
		pub type BN_ULONG = c_ulonglong;
		#[cfg(target_pointer_width = "32")]
		pub type BN_ULONG = c_uint;

		extern "C" {
		pub fn BN_CTX_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;
		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;
		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;
		}
		}
		}

openssl-sys/src/openssl/mod.rs→openssl-sys/src/cms.rs

+42 −47

Original line number	Diff line number	Diff line
		use libc::{c_int, c_long, c_uchar, c_uint, c_ulong};
		use libc::*;

		#[cfg(not(ossl110))]
		mod v10x;
		#[cfg(not(ossl110))]
		pub use openssl::v10x::*;
		pub enum CMS_ContentInfo {}

		#[cfg(ossl110)]
		mod v110;
		#[cfg(ossl110)]
		pub use openssl::v110::*;

		#[cfg(ossl111)]
		mod v111;
		#[cfg(ossl111)]
		pub use openssl::v111::*;

		#[cfg(ossl102)]
		pub const SSL_CTRL_SET_VERIFY_CERT_STORE: c_int = 106;

		pub const SSL_MODE_SEND_CLIENTHELLO_TIME: c_long = 0x20;
		pub const SSL_MODE_SEND_SERVERHELLO_TIME: c_long = 0x40;
		pub const SSL_MODE_SEND_FALLBACK_SCSV: c_long = 0x80;

		pub const SSL_OP_SAFARI_ECDHE_ECDSA_BUG: c_ulong = 0x00000040;

		pub const SSL_OP_CISCO_ANYCONNECT: c_ulong = 0x00008000;
		pub const SSL_OP_NO_COMPRESSION: c_ulong = 0x00020000;
		pub const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: c_ulong = 0x00040000;
		pub const SSL_OP_NO_SSLv3: c_ulong = 0x02000000;
		#[cfg(ossl102)]
		pub const SSL_OP_NO_DTLSv1: c_ulong = 0x04000000;
		#[cfg(ossl102)]
		pub const SSL_OP_NO_DTLSv1_2: c_ulong = 0x08000000;

		#[cfg(ossl102f)]
		pub const X509_V_ERR_UNSPECIFIED: c_int = 1;
		extern "C" {
		#[cfg(ossl101)]
		pub fn CMS_ContentInfo_free(cms: *mut ::CMS_ContentInfo);
		#[cfg(ossl101)]
		pub fn i2d_CMS_ContentInfo(a: mut ::CMS_ContentInfo, pp: mut *mut c_uchar) -> c_int;
		}

		#[cfg(ossl101)]
		pub const CMS_TEXT: c_uint = 0x1;
		#[cfg(ossl101)]
		pub const CMS_NOCERTS: c_uint = 0x2;
		#[cfg(ossl101)]
		pub const CMS_NO_CONTENT_VERIFY: c_uint = 0x4;
		#[cfg(ossl101)]
		pub const CMS_NO_ATTR_VERIFY: c_uint = 0x8;
		#[cfg(ossl101)]
		pub const CMS_NOSIGS: c_uint = 0x4 \| 0x8;
		#[cfg(ossl101)]
		pub const CMS_NOINTERN: c_uint = 0x10;
		#[cfg(ossl101)]
		pub const CMS_NO_SIGNER_CERT_VERIFY: c_uint = 0x20;
		#[cfg(ossl101)]
		pub const CMS_NOVERIFY: c_uint = 0x20;
		#[cfg(ossl101)]
		pub const CMS_DETACHED: c_uint = 0x40;
		#[cfg(ossl101)]
		pub const CMS_BINARY: c_uint = 0x80;
		#[cfg(ossl101)]
		pub const CMS_NOATTR: c_uint = 0x100;
		#[cfg(ossl101)]
		pub const CMS_NOSMIMECAP: c_uint = 0x200;
		#[cfg(ossl101)]
		pub const CMS_NOOLDMIMETYPE: c_uint = 0x400;
		#[cfg(ossl101)]
		pub const CMS_CRLFEOL: c_uint = 0x800;
		#[cfg(ossl101)]
		pub const CMS_STREAM: c_uint = 0x1000;
		#[cfg(ossl101)]
		pub const CMS_NOCRL: c_uint = 0x2000;
		#[cfg(ossl101)]
		pub const CMS_PARTIAL: c_uint = 0x4000;
		#[cfg(ossl101)]
		pub const CMS_REUSE_DIGEST: c_uint = 0x8000;
		#[cfg(ossl101)]
		pub const CMS_USE_KEYID: c_uint = 0x10000;
		#[cfg(ossl101)]
		pub const CMS_DEBUG_DECRYPT: c_uint = 0x20000;
		#[cfg(ossl102)]
		pub const CMS_KEY_PARAM: c_uint = 0x40000;
		#[cfg(ossl110)]
		pub const CMS_ASCIICRLF: c_uint = 0x80000;

		extern "C" {
		pub fn CMS_decrypt(
		cms: *mut ::CMS_ContentInfo,
		pkey: *mut ::EVP_PKEY,
		cert: *mut ::X509,
		dcont: *mut ::BIO,
		out: *mut ::BIO,
		flags: c_uint,
		) -> c_int;
		#[cfg(ossl101)]
		pub fn SMIME_read_CMS(bio: mut ::BIO, bcont: mut mut ::BIO) -> mut ::CMS_ContentInfo;
		pub fn CMS_ContentInfo_free(cms: *mut ::CMS_ContentInfo);

		#[cfg(ossl101)]
		pub fn CMS_sign(
		signcert: *mut ::X509,
		pkey: *mut ::EVP_PKEY,
		@@ -77,8 +66,14 @@ extern "C" {
		data: *mut ::BIO,
		flags: c_uint,
		) -> *mut ::CMS_ContentInfo;
		pub fn i2d_CMS_ContentInfo(a: mut ::CMS_ContentInfo, pp: mut *mut c_uchar) -> c_int;

		pub fn FIPS_mode_set(onoff: c_int) -> c_int;
		pub fn FIPS_mode() -> c_int;
		#[cfg(ossl101)]
		pub fn CMS_decrypt(
		cms: *mut ::CMS_ContentInfo,
		pkey: *mut ::EVP_PKEY,
		cert: *mut ::X509,
		dcont: *mut ::BIO,
		out: *mut ::BIO,
		flags: c_uint,
		) -> c_int;
		}