Update for * -> *const change

7 files changed, 120 insertions, 120 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_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_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_MD_CTX_create() -> *mut EVP_MD_CTX;
+    fn EVP_MD_CTX_destroy(ctx: *mut EVP_MD_CTX);
+
+    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: *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
         }
     }
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<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;
         }
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 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 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: *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 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_get_subject_name(x: *X509) -> *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_CTX_get_ex_data(ctx: *mut SSL_CTX, idx: c_int) -> *mut c_void;
+
+    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: *mut X509) -> *mut X509_NAME;
+
+    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<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);