min
/
boring2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update for * -> *const change

This commit is contained in:
Steven Fackler 2014-06-29 13:36:02 -07:00
parent bfd8fa2d4c
commit 8c40c2ef35
7 changed files with 114 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
crypto/hash.rs
View File

@ -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<u8> {
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
}
}

8
crypto/hmac.rs
View File

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

4
crypto/pkcs5.rs
View File

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

44
crypto/pkey.rs
View File

@ -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<u8> {
fn _tostr(&self, f: unsafe extern "C" fn(*mut EVP_PKEY, *const *mut u8) -> c_int) -> Vec<u8> {
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;
}

8
crypto/symm.rs
View File

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

86
ssl/ffi.rs
View File

@ -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<extern fn(c_int, *X509_STORE_CTX) -> 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<extern fn(c_int, *mut X509_STORE_CTX) -> 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<CRYPTO_EX_new>,
dup_func: Option<CRYPTO_EX_dup>,
free_func: Option<CRYPTO_EX_free>)
-> 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")]

38
ssl/mod.rs
View File

@ -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<Ssl, SslError> {
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<uint> {
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);