From 8c40c2ef3527fbcf22f11a517422b371b4626852 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sun, 29 Jun 2014 13:36:02 -0700 Subject: [PATCH] Update for * -> *const change --- crypto/hash.rs | 40 +++++++++++------------ crypto/hmac.rs | 8 ++--- crypto/pkcs5.rs | 4 +-- crypto/pkey.rs | 44 ++++++++++++------------- crypto/symm.rs | 8 ++--- ssl/ffi.rs | 86 ++++++++++++++++++++++++------------------------- ssl/mod.rs | 38 +++++++++++----------- 7 files changed, 114 insertions(+), 114 deletions(-) diff --git a/crypto/hash.rs b/crypto/hash.rs index d03b0317..1a1b6e8a 100644 --- a/crypto/hash.rs +++ b/crypto/hash.rs @@ -14,12 +14,12 @@ pub enum HashType { #[allow(dead_code)] #[allow(non_camel_case_types)] pub struct EVP_MD_CTX { - digest: *EVP_MD, - engine: *libc::c_void, + digest: *mut EVP_MD, + engine: *mut libc::c_void, flags: libc::c_ulong, - md_data: *libc::c_void, - pctx: *EVP_PKEY_CTX, - update: *libc::c_void + md_data: *mut libc::c_void, + pctx: *mut EVP_PKEY_CTX, + update: *mut libc::c_void } #[allow(non_camel_case_types)] @@ -30,22 +30,22 @@ pub struct EVP_PKEY_CTX; #[link(name = "crypto")] extern { - fn EVP_MD_CTX_create() -> *EVP_MD_CTX; - fn EVP_MD_CTX_destroy(ctx: *EVP_MD_CTX); + fn EVP_MD_CTX_create() -> *mut EVP_MD_CTX; + fn EVP_MD_CTX_destroy(ctx: *mut EVP_MD_CTX); - fn EVP_md5() -> *EVP_MD; - fn EVP_sha1() -> *EVP_MD; - fn EVP_sha224() -> *EVP_MD; - fn EVP_sha256() -> *EVP_MD; - fn EVP_sha384() -> *EVP_MD; - fn EVP_sha512() -> *EVP_MD; + fn EVP_md5() -> *const EVP_MD; + fn EVP_sha1() -> *const EVP_MD; + fn EVP_sha224() -> *const EVP_MD; + fn EVP_sha256() -> *const EVP_MD; + fn EVP_sha384() -> *const EVP_MD; + fn EVP_sha512() -> *const EVP_MD; - fn EVP_DigestInit(ctx: *EVP_MD_CTX, typ: *EVP_MD); - fn EVP_DigestUpdate(ctx: *EVP_MD_CTX, data: *u8, n: c_uint); - fn EVP_DigestFinal(ctx: *EVP_MD_CTX, res: *mut u8, n: *u32); + fn EVP_DigestInit(ctx: *mut EVP_MD_CTX, typ: *const EVP_MD); + fn EVP_DigestUpdate(ctx: *mut EVP_MD_CTX, data: *const u8, n: c_uint); + fn EVP_DigestFinal(ctx: *mut EVP_MD_CTX, res: *mut u8, n: *mut u32); } -pub fn evpmd(t: HashType) -> (*EVP_MD, uint) { +pub fn evpmd(t: HashType) -> (*const EVP_MD, uint) { unsafe { match t { MD5 => (EVP_md5(), 16u), @@ -60,8 +60,8 @@ pub fn evpmd(t: HashType) -> (*EVP_MD, uint) { #[allow(dead_code)] pub struct Hasher { - evp: *EVP_MD, - ctx: *EVP_MD_CTX, + evp: *const EVP_MD, + ctx: *mut EVP_MD_CTX, len: uint, } @@ -90,7 +90,7 @@ impl Hasher { pub fn final(&self) -> Vec { unsafe { let mut res = Vec::from_elem(self.len, 0u8); - EVP_DigestFinal(self.ctx, res.as_mut_ptr(), ptr::null()); + EVP_DigestFinal(self.ctx, res.as_mut_ptr(), ptr::mut_null()); res } } diff --git a/crypto/hmac.rs b/crypto/hmac.rs index d9e53c99..16be0f29 100644 --- a/crypto/hmac.rs +++ b/crypto/hmac.rs @@ -20,7 +20,7 @@ use crypto::hash; #[allow(dead_code)] #[allow(non_camel_case_types)] pub struct HMAC_CTX { - md: *hash::EVP_MD, + md: *mut hash::EVP_MD, md_ctx: hash::EVP_MD_CTX, i_ctx: hash::EVP_MD_CTX, o_ctx: hash::EVP_MD_CTX, @@ -31,8 +31,8 @@ pub struct HMAC_CTX { #[link(name = "crypto")] extern { fn HMAC_CTX_init(ctx: *mut HMAC_CTX); - fn HMAC_Init_ex(ctx: *mut HMAC_CTX, key: *u8, keylen: c_int, md: *hash::EVP_MD, imple: *ENGINE); - fn HMAC_Update(ctx: *mut HMAC_CTX, input: *u8, len: c_uint); + fn HMAC_Init_ex(ctx: *mut HMAC_CTX, key: *const u8, keylen: c_int, md: *const hash::EVP_MD, imple: *const ENGINE); + fn HMAC_Update(ctx: *mut HMAC_CTX, input: *const u8, len: c_uint); fn HMAC_Final(ctx: *mut HMAC_CTX, output: *mut u8, len: *mut c_uint); } @@ -55,7 +55,7 @@ pub fn HMAC(ht: hash::HashType, key: &[u8]) -> HMAC { HMAC_Init_ex(&mut ctx, key.as_ptr(), key.len() as c_int, - evp, 0 as *_); + evp, 0 as *const _); HMAC { ctx: ctx, len: mdlen } } diff --git a/crypto/pkcs5.rs b/crypto/pkcs5.rs index 06fc1bb9..b795d84a 100644 --- a/crypto/pkcs5.rs +++ b/crypto/pkcs5.rs @@ -2,8 +2,8 @@ use libc::c_int; #[link(name = "crypto")] extern { - fn PKCS5_PBKDF2_HMAC_SHA1(pass: *u8, passlen: c_int, - salt: *u8, saltlen: c_int, + fn PKCS5_PBKDF2_HMAC_SHA1(pass: *const u8, passlen: c_int, + salt: *const u8, saltlen: c_int, iter: c_int, keylen: c_int, out: *mut u8) -> c_int; } diff --git a/crypto/pkey.rs b/crypto/pkey.rs index 6c0b4e83..5f617fa7 100644 --- a/crypto/pkey.rs +++ b/crypto/pkey.rs @@ -5,34 +5,34 @@ use std::ptr; use crypto::hash::{HashType, MD5, SHA1, SHA224, SHA256, SHA384, SHA512}; #[allow(non_camel_case_types)] -pub type EVP_PKEY = *libc::c_void; +pub type EVP_PKEY = *mut libc::c_void; #[allow(non_camel_case_types)] -pub type RSA = *libc::c_void; +pub type RSA = *mut libc::c_void; #[link(name = "crypto")] extern { - fn EVP_PKEY_new() -> *EVP_PKEY; - fn EVP_PKEY_free(k: *EVP_PKEY); - fn EVP_PKEY_assign(pkey: *EVP_PKEY, typ: c_int, key: *c_char) -> c_int; - fn EVP_PKEY_get1_RSA(k: *EVP_PKEY) -> *RSA; + fn EVP_PKEY_new() -> *mut EVP_PKEY; + fn EVP_PKEY_free(k: *mut EVP_PKEY); + fn EVP_PKEY_assign(pkey: *mut EVP_PKEY, typ: c_int, key: *const c_char) -> c_int; + fn EVP_PKEY_get1_RSA(k: *mut EVP_PKEY) -> *mut RSA; - fn i2d_PublicKey(k: *EVP_PKEY, buf: **mut u8) -> c_int; - fn d2i_PublicKey(t: c_int, k: **EVP_PKEY, buf: **u8, len: c_uint) -> *EVP_PKEY; - fn i2d_PrivateKey(k: *EVP_PKEY, buf: **mut u8) -> c_int; - fn d2i_PrivateKey(t: c_int, k: **EVP_PKEY, buf: **u8, len: c_uint) -> *EVP_PKEY; + fn i2d_PublicKey(k: *mut EVP_PKEY, buf: *const *mut u8) -> c_int; + fn d2i_PublicKey(t: c_int, k: *const *mut EVP_PKEY, buf: *const *const u8, len: c_uint) -> *mut EVP_PKEY; + fn i2d_PrivateKey(k: *mut EVP_PKEY, buf: *const *mut u8) -> c_int; + fn d2i_PrivateKey(t: c_int, k: *const *mut EVP_PKEY, buf: *const *const u8, len: c_uint) -> *mut EVP_PKEY; - fn RSA_generate_key(modsz: c_uint, e: c_uint, cb: *u8, cbarg: *u8) -> *RSA; - fn RSA_size(k: *RSA) -> c_uint; + fn RSA_generate_key(modsz: c_uint, e: c_uint, cb: *const u8, cbarg: *const u8) -> *mut RSA; + fn RSA_size(k: *mut RSA) -> c_uint; - fn RSA_public_encrypt(flen: c_uint, from: *u8, to: *mut u8, k: *RSA, + fn RSA_public_encrypt(flen: c_uint, from: *const u8, to: *mut u8, k: *mut RSA, pad: c_int) -> c_int; - fn RSA_private_decrypt(flen: c_uint, from: *u8, to: *mut u8, k: *RSA, + fn RSA_private_decrypt(flen: c_uint, from: *const u8, to: *mut u8, k: *mut RSA, pad: c_int) -> c_int; - fn RSA_sign(t: c_int, m: *u8, mlen: c_uint, sig: *mut u8, siglen: *mut c_uint, - k: *RSA) -> c_int; - fn RSA_verify(t: c_int, m: *u8, mlen: c_uint, sig: *u8, siglen: c_uint, - k: *RSA) -> c_int; + fn RSA_sign(t: c_int, m: *const u8, mlen: c_uint, sig: *mut u8, siglen: *mut c_uint, + k: *mut RSA) -> c_int; + fn RSA_verify(t: c_int, m: *const u8, mlen: c_uint, sig: *const u8, siglen: c_uint, + k: *mut RSA) -> c_int; } enum Parts { @@ -74,7 +74,7 @@ fn openssl_hash_nid(hash: HashType) -> c_int { } pub struct PKey { - evp: *EVP_PKEY, + evp: *mut EVP_PKEY, parts: Parts, } @@ -89,7 +89,7 @@ impl PKey { } } - fn _tostr(&self, f: unsafe extern "C" fn(*EVP_PKEY, **mut u8) -> c_int) -> Vec { + fn _tostr(&self, f: unsafe extern "C" fn(*mut EVP_PKEY, *const *mut u8) -> c_int) -> Vec { unsafe { let len = f(self.evp, ptr::null()); if len < 0 as c_int { return vec!(); } @@ -102,9 +102,9 @@ impl PKey { } } - fn _fromstr(&mut self, s: &[u8], f: unsafe extern "C" fn(c_int, **EVP_PKEY, **u8, c_uint) -> *EVP_PKEY) { + fn _fromstr(&mut self, s: &[u8], f: unsafe extern "C" fn(c_int, *const *mut EVP_PKEY, *const *const u8, c_uint) -> *mut EVP_PKEY) { unsafe { - let evp = ptr::null(); + let evp = ptr::mut_null(); f(6 as c_int, &evp, &s.as_ptr(), s.len() as c_uint); self.evp = evp; } diff --git a/crypto/symm.rs b/crypto/symm.rs index dbdb4b5c..8d8f651c 100644 --- a/crypto/symm.rs +++ b/crypto/symm.rs @@ -2,10 +2,10 @@ use libc::{c_int, c_uint}; use libc; #[allow(non_camel_case_types)] -pub type EVP_CIPHER_CTX = *libc::c_void; +pub type EVP_CIPHER_CTX = *mut libc::c_void; #[allow(non_camel_case_types)] -pub type EVP_CIPHER = *libc::c_void; +pub type EVP_CIPHER = *mut libc::c_void; #[link(name = "crypto")] extern { @@ -26,9 +26,9 @@ extern { fn EVP_rc4() -> EVP_CIPHER; fn EVP_CipherInit(ctx: EVP_CIPHER_CTX, evp: EVP_CIPHER, - key: *u8, iv: *u8, mode: c_int); + key: *const u8, iv: *const u8, mode: c_int); fn EVP_CipherUpdate(ctx: EVP_CIPHER_CTX, outbuf: *mut u8, - outlen: &mut c_uint, inbuf: *u8, inlen: c_int); + outlen: &mut c_uint, inbuf: *const u8, inlen: c_int); fn EVP_CipherFinal(ctx: EVP_CIPHER_CTX, res: *mut u8, len: &mut c_int); } diff --git a/ssl/ffi.rs b/ssl/ffi.rs index 7d6dd275..585c3555 100644 --- a/ssl/ffi.rs +++ b/ssl/ffi.rs @@ -12,16 +12,16 @@ pub type X509 = c_void; pub type X509_NAME = c_void; pub type CRYPTO_EX_DATA = c_void; -pub type CRYPTO_EX_new = extern "C" fn(parent: *c_void, ptr: *c_void, - ad: *CRYPTO_EX_DATA, idx: c_int, - argl: c_long, argp: *c_void) -> c_int; -pub type CRYPTO_EX_dup = extern "C" fn(to: *CRYPTO_EX_DATA, - from: *CRYPTO_EX_DATA, from_d: *c_void, - idx: c_int, argl: c_long, argp: *c_void) +pub type CRYPTO_EX_new = extern "C" fn(parent: *mut c_void, ptr: *mut c_void, + ad: *const CRYPTO_EX_DATA, idx: c_int, + argl: c_long, argp: *const c_void) -> c_int; +pub type CRYPTO_EX_dup = extern "C" fn(to: *mut CRYPTO_EX_DATA, + from: *mut CRYPTO_EX_DATA, from_d: *mut c_void, + idx: c_int, argl: c_long, argp: *mut c_void) -> c_int; -pub type CRYPTO_EX_free = extern "C" fn(parent: *c_void, ptr: *c_void, - ad: *CRYPTO_EX_DATA, idx: c_int, - argl: c_long, argp: *c_void); +pub type CRYPTO_EX_free = extern "C" fn(parent: *mut c_void, ptr: *mut c_void, + ad: *mut CRYPTO_EX_DATA, idx: c_int, + argl: c_long, argp: *mut c_void); pub static CRYPTO_LOCK: c_int = 1; @@ -103,7 +103,7 @@ extern "C" { pub fn CRYPTO_num_locks() -> c_int; pub fn CRYPTO_set_locking_callback(func: extern "C" fn(mode: c_int, n: c_int, - file: *c_char, + file: *const c_char, line: c_int)); pub fn ERR_get_error() -> c_ulong; @@ -111,50 +111,50 @@ extern "C" { pub fn SSL_library_init() -> c_int; #[cfg(sslv2)] - pub fn SSLv2_method() -> *SSL_METHOD; - pub fn SSLv3_method() -> *SSL_METHOD; - pub fn TLSv1_method() -> *SSL_METHOD; - pub fn SSLv23_method() -> *SSL_METHOD; + pub fn SSLv2_method() -> *const SSL_METHOD; + pub fn SSLv3_method() -> *const SSL_METHOD; + pub fn TLSv1_method() -> *const SSL_METHOD; + pub fn SSLv23_method() -> *const SSL_METHOD; - pub fn SSL_CTX_new(method: *SSL_METHOD) -> *SSL_CTX; - pub fn SSL_CTX_free(ctx: *SSL_CTX); - pub fn SSL_CTX_set_verify(ctx: *SSL_CTX, mode: c_int, - verify_callback: Option c_int>); - pub fn SSL_CTX_load_verify_locations(ctx: *SSL_CTX, CAfile: *c_char, - CApath: *c_char) -> c_int; - pub fn SSL_CTX_get_ex_new_index(argl: c_long, argp: *c_void, + pub fn SSL_CTX_new(method: *const SSL_METHOD) -> *mut SSL_CTX; + pub fn SSL_CTX_free(ctx: *mut SSL_CTX); + pub fn SSL_CTX_set_verify(ctx: *mut SSL_CTX, mode: c_int, + verify_callback: Option c_int>); + pub fn SSL_CTX_load_verify_locations(ctx: *mut SSL_CTX, CAfile: *const c_char, + CApath: *const c_char) -> c_int; + pub fn SSL_CTX_get_ex_new_index(argl: c_long, argp: *const c_void, new_func: Option, dup_func: Option, free_func: Option) -> c_int; - pub fn SSL_CTX_set_ex_data(ctx: *SSL_CTX, idx: c_int, data: *c_void) + pub fn SSL_CTX_set_ex_data(ctx: *mut SSL_CTX, idx: c_int, data: *mut c_void) -> c_int; - pub fn SSL_CTX_get_ex_data(ctx: *SSL_CTX, idx: c_int) -> *c_void; + pub fn SSL_CTX_get_ex_data(ctx: *mut SSL_CTX, idx: c_int) -> *mut c_void; - pub fn X509_STORE_CTX_get_ex_data(ctx: *X509_STORE_CTX, idx: c_int) - -> *c_void; - pub fn X509_STORE_CTX_get_current_cert(ct: *X509_STORE_CTX) -> *X509; - pub fn X509_STORE_CTX_get_error(ctx: *X509_STORE_CTX) -> c_int; + pub fn X509_STORE_CTX_get_ex_data(ctx: *mut X509_STORE_CTX, idx: c_int) + -> *mut c_void; + pub fn X509_STORE_CTX_get_current_cert(ct: *mut X509_STORE_CTX) -> *mut X509; + pub fn X509_STORE_CTX_get_error(ctx: *mut X509_STORE_CTX) -> c_int; - pub fn X509_get_subject_name(x: *X509) -> *X509_NAME; + pub fn X509_get_subject_name(x: *mut X509) -> *mut X509_NAME; - pub fn SSL_new(ctx: *SSL_CTX) -> *SSL; - pub fn SSL_free(ssl: *SSL); - pub fn SSL_set_bio(ssl: *SSL, rbio: *BIO, wbio: *BIO); - pub fn SSL_get_rbio(ssl: *SSL) -> *BIO; - pub fn SSL_get_wbio(ssl: *SSL) -> *BIO; - pub fn SSL_connect(ssl: *SSL) -> c_int; - pub fn SSL_get_error(ssl: *SSL, ret: c_int) -> c_int; - pub fn SSL_read(ssl: *SSL, buf: *c_void, num: c_int) -> c_int; - pub fn SSL_write(ssl: *SSL, buf: *c_void, num: c_int) -> c_int; + pub fn SSL_new(ctx: *mut SSL_CTX) -> *mut SSL; + pub fn SSL_free(ssl: *mut SSL); + pub fn SSL_set_bio(ssl: *mut SSL, rbio: *mut BIO, wbio: *mut BIO); + pub fn SSL_get_rbio(ssl: *mut SSL) -> *mut BIO; + pub fn SSL_get_wbio(ssl: *mut SSL) -> *mut BIO; + pub fn SSL_connect(ssl: *mut SSL) -> c_int; + pub fn SSL_get_error(ssl: *mut SSL, ret: c_int) -> c_int; + pub fn SSL_read(ssl: *mut SSL, buf: *mut c_void, num: c_int) -> c_int; + pub fn SSL_write(ssl: *mut SSL, buf: *const c_void, num: c_int) -> c_int; pub fn SSL_get_ex_data_X509_STORE_CTX_idx() -> c_int; - pub fn SSL_get_SSL_CTX(ssl: *SSL) -> *SSL_CTX; + pub fn SSL_get_SSL_CTX(ssl: *mut SSL) -> *mut SSL_CTX; - pub fn BIO_s_mem() -> *BIO_METHOD; - pub fn BIO_new(type_: *BIO_METHOD) -> *BIO; - pub fn BIO_free_all(a: *BIO); - pub fn BIO_read(b: *BIO, buf: *c_void, len: c_int) -> c_int; - pub fn BIO_write(b: *BIO, buf: *c_void, len: c_int) -> c_int; + pub fn BIO_s_mem() -> *const BIO_METHOD; + pub fn BIO_new(type_: *const BIO_METHOD) -> *mut BIO; + pub fn BIO_free_all(a: *mut BIO); + pub fn BIO_read(b: *mut BIO, buf: *mut c_void, len: c_int) -> c_int; + pub fn BIO_write(b: *mut BIO, buf: *const c_void, len: c_int) -> c_int; } #[cfg(target_os = "win32")] diff --git a/ssl/mod.rs b/ssl/mod.rs index 8687ca05..9a4e5415 100644 --- a/ssl/mod.rs +++ b/ssl/mod.rs @@ -58,7 +58,7 @@ pub enum SslMethod { } impl SslMethod { - unsafe fn to_raw(&self) -> *ffi::SSL_METHOD { + unsafe fn to_raw(&self) -> *const ffi::SSL_METHOD { match *self { #[cfg(sslv2)] Sslv2 => ffi::SSLv2_method(), @@ -77,7 +77,7 @@ pub enum SslVerifyMode { SslVerifyNone = ffi::SSL_VERIFY_NONE } -extern fn locking_function(mode: c_int, n: c_int, _file: *c_char, +extern fn locking_function(mode: c_int, n: c_int, _file: *const c_char, _line: c_int) { unsafe { let mutex = (*MUTEXES).get_mut(n as uint); @@ -90,7 +90,7 @@ extern fn locking_function(mode: c_int, n: c_int, _file: *c_char, } } -extern fn raw_verify(preverify_ok: c_int, x509_ctx: *ffi::X509_STORE_CTX) +extern fn raw_verify(preverify_ok: c_int, x509_ctx: *mut ffi::X509_STORE_CTX) -> c_int { unsafe { let idx = ffi::SSL_get_ex_data_X509_STORE_CTX_idx(); @@ -114,7 +114,7 @@ pub type VerifyCallback = fn(preverify_ok: bool, /// An SSL context object pub struct SslContext { - ctx: *ffi::SSL_CTX + ctx: *mut ffi::SSL_CTX } impl Drop for SslContext { @@ -129,7 +129,7 @@ impl SslContext { init(); let ctx = unsafe { ffi::SSL_CTX_new(method.to_raw()) }; - if ctx == ptr::null() { + if ctx == ptr::mut_null() { return Err(SslError::get()); } @@ -172,7 +172,7 @@ impl SslContext { } pub struct X509StoreContext { - ctx: *ffi::X509_STORE_CTX + ctx: *mut ffi::X509_STORE_CTX } impl X509StoreContext { @@ -196,7 +196,7 @@ impl X509StoreContext { /// A public key certificate pub struct X509<'ctx> { ctx: &'ctx X509StoreContext, - x509: *ffi::X509 + x509: *mut ffi::X509 } impl<'ctx> X509<'ctx> { @@ -209,7 +209,7 @@ impl<'ctx> X509<'ctx> { #[allow(dead_code)] pub struct X509Name<'x> { x509: &'x X509<'x>, - name: *ffi::X509_NAME + name: *mut ffi::X509_NAME } pub enum X509NameFormat { @@ -295,7 +295,7 @@ make_validation_error!(X509_V_OK, ) struct Ssl { - ssl: *ffi::SSL + ssl: *mut ffi::SSL } impl Drop for Ssl { @@ -307,18 +307,18 @@ impl Drop for Ssl { impl Ssl { fn try_new(ctx: &SslContext) -> Result { let ssl = unsafe { ffi::SSL_new(ctx.ctx) }; - if ssl == ptr::null() { + if ssl == ptr::mut_null() { return Err(SslError::get()); } let ssl = Ssl { ssl: ssl }; let rbio = unsafe { ffi::BIO_new(ffi::BIO_s_mem()) }; - if rbio == ptr::null() { + if rbio == ptr::mut_null() { return Err(SslError::get()); } let wbio = unsafe { ffi::BIO_new(ffi::BIO_s_mem()) }; - if wbio == ptr::null() { + if wbio == ptr::mut_null() { unsafe { ffi::BIO_free_all(rbio) } return Err(SslError::get()); } @@ -335,8 +335,8 @@ impl Ssl { unsafe { self.wrap_bio(ffi::SSL_get_wbio(self.ssl)) } } - fn wrap_bio<'a>(&'a self, bio: *ffi::BIO) -> MemBioRef<'a> { - assert!(bio != ptr::null()); + fn wrap_bio<'a>(&'a self, bio: *mut ffi::BIO) -> MemBioRef<'a> { + assert!(bio != ptr::mut_null()); MemBioRef { ssl: self, bio: MemBio { @@ -351,12 +351,12 @@ impl Ssl { } fn read(&self, buf: &mut [u8]) -> c_int { - unsafe { ffi::SSL_read(self.ssl, buf.as_ptr() as *c_void, + unsafe { ffi::SSL_read(self.ssl, buf.as_ptr() as *mut c_void, buf.len() as c_int) } } fn write(&self, buf: &[u8]) -> c_int { - unsafe { ffi::SSL_write(self.ssl, buf.as_ptr() as *c_void, + unsafe { ffi::SSL_write(self.ssl, buf.as_ptr() as *const c_void, buf.len() as c_int) } } @@ -399,7 +399,7 @@ impl<'ssl> MemBioRef<'ssl> { } struct MemBio { - bio: *ffi::BIO, + bio: *mut ffi::BIO, owned: bool } @@ -416,7 +416,7 @@ impl Drop for MemBio { impl MemBio { fn read(&self, buf: &mut [u8]) -> Option { let ret = unsafe { - ffi::BIO_read(self.bio, buf.as_ptr() as *c_void, + ffi::BIO_read(self.bio, buf.as_ptr() as *mut c_void, buf.len() as c_int) }; @@ -429,7 +429,7 @@ impl MemBio { fn write(&self, buf: &[u8]) { let ret = unsafe { - ffi::BIO_write(self.bio, buf.as_ptr() as *c_void, + ffi::BIO_write(self.bio, buf.as_ptr() as *const c_void, buf.len() as c_int) }; assert_eq!(buf.len(), ret as uint);