Cast correctly c_char raw pointers (fixes build on ARM sfackler#314)

Author: operutka

openssl/src/bn/mod.rs

@@ -89,15 +89,15 @@ impl BigNum {
     pub fn from_dec_str(s: &str) -> Result<BigNum, SslError> {
         BigNum::new().and_then(|v| unsafe {
             let c_str = CString::new(s.as_bytes()).unwrap();
-            try_ssl!(ffi::BN_dec2bn(v.raw_ptr(), c_str.as_ptr()));
+            try_ssl!(ffi::BN_dec2bn(v.raw_ptr(), c_str.as_ptr() as *const _));
             Ok(v)
         })
     }
 
     pub fn from_hex_str(s: &str) -> Result<BigNum, SslError> {
         BigNum::new().and_then(|v| unsafe {
             let c_str = CString::new(s.as_bytes()).unwrap();
-            try_ssl!(ffi::BN_hex2bn(v.raw_ptr(), c_str.as_ptr()));
+            try_ssl!(ffi::BN_hex2bn(v.raw_ptr(), c_str.as_ptr() as *const _));
             Ok(v)
         })
     }
@@ -421,7 +421,7 @@ impl BigNum {
         unsafe {
             let buf = ffi::BN_bn2dec(self.raw());
             assert!(!buf.is_null());
-            let str = String::from_utf8(CStr::from_ptr(buf).to_bytes().to_vec()).unwrap();
+            let str = String::from_utf8(CStr::from_ptr(buf as *const _).to_bytes().to_vec()).unwrap();
             ffi::CRYPTO_free(buf as *mut c_void);
             str
         }
@@ -431,7 +431,7 @@ impl BigNum {
         unsafe {
             let buf = ffi::BN_bn2hex(self.raw());
             assert!(!buf.is_null());
-            let str = String::from_utf8(CStr::from_ptr(buf).to_bytes().to_vec()).unwrap();
+            let str = String::from_utf8(CStr::from_ptr(buf as *const _).to_bytes().to_vec()).unwrap();
             ffi::CRYPTO_free(buf as *mut c_void);
             str
         }

openssl/src/ssl/error.rs

@@ -117,21 +117,24 @@ pub enum OpensslError {
 
 fn get_lib(err: c_ulong) -> String {
     unsafe {
-        let bytes = CStr::from_ptr(ffi::ERR_lib_error_string(err)).to_bytes().to_vec();
+        let cstr = ffi::ERR_lib_error_string(err);
+        let bytes = CStr::from_ptr(cstr as *const _).to_bytes().to_vec();
         String::from_utf8(bytes).unwrap()
     }
 }
 
 fn get_func(err: c_ulong) -> String {
     unsafe {
-        let bytes = CStr::from_ptr(ffi::ERR_func_error_string(err)).to_bytes().to_vec();
+        let cstr = ffi::ERR_func_error_string(err);
+        let bytes = CStr::from_ptr(cstr as *const _).to_bytes().to_vec();
         String::from_utf8(bytes).unwrap()
     }
 }
 
 fn get_reason(err: c_ulong) -> String {
     unsafe {
-        let bytes = CStr::from_ptr(ffi::ERR_reason_error_string(err)).to_bytes().to_vec();
+        let cstr = ffi::ERR_reason_error_string(err);
+        let bytes = CStr::from_ptr(cstr as *const _).to_bytes().to_vec();
         String::from_utf8(bytes).unwrap()
     }
 }

openssl/src/ssl/mod.rs

@@ -533,7 +533,7 @@ impl SslContext {
         let file = CString::new(file.as_ref().as_os_str().to_str().expect("invalid utf8")).unwrap();
         wrap_ssl_result(
             unsafe {
-                ffi::SSL_CTX_load_verify_locations(self.ctx, file.as_ptr(), ptr::null())
+                ffi::SSL_CTX_load_verify_locations(self.ctx, file.as_ptr() as *const _, ptr::null())
             })
     }
 
@@ -543,7 +543,7 @@ impl SslContext {
         let file = CString::new(file.as_ref().as_os_str().to_str().expect("invalid utf8")).unwrap();
         wrap_ssl_result(
             unsafe {
-                ffi::SSL_CTX_use_certificate_file(self.ctx, file.as_ptr(), file_type as c_int)
+                ffi::SSL_CTX_use_certificate_file(self.ctx, file.as_ptr() as *const _, file_type as c_int)
             })
     }
 
@@ -553,7 +553,7 @@ impl SslContext {
         let file = CString::new(file.as_ref().as_os_str().to_str().expect("invalid utf8")).unwrap();
         wrap_ssl_result(
             unsafe {
-                ffi::SSL_CTX_use_certificate_chain_file(self.ctx, file.as_ptr(), file_type as c_int)
+                ffi::SSL_CTX_use_certificate_chain_file(self.ctx, file.as_ptr() as *const _, file_type as c_int)
             })
     }
 
@@ -580,7 +580,7 @@ impl SslContext {
         let file = CString::new(file.as_ref().as_os_str().to_str().expect("invalid utf8")).unwrap();
         wrap_ssl_result(
             unsafe {
-                ffi::SSL_CTX_use_PrivateKey_file(self.ctx, file.as_ptr(), file_type as c_int)
+                ffi::SSL_CTX_use_PrivateKey_file(self.ctx, file.as_ptr() as *const _, file_type as c_int)
             })
     }
 
@@ -604,7 +604,7 @@ impl SslContext {
         wrap_ssl_result(
             unsafe {
                 let cipher_list = CString::new(cipher_list).unwrap();
-                ffi::SSL_CTX_set_cipher_list(self.ctx, cipher_list.as_ptr())
+                ffi::SSL_CTX_set_cipher_list(self.ctx, cipher_list.as_ptr() as *const _)
             })
     }
 
@@ -791,7 +791,7 @@ impl Ssl {
     pub fn state_string(&self) -> &'static str {
         let state = unsafe {
             let ptr = ffi::SSL_state_string(self.ssl);
-            CStr::from_ptr(ptr)
+            CStr::from_ptr(ptr as *const _)
         };
 
         str::from_utf8(state.to_bytes()).unwrap()
@@ -800,7 +800,7 @@ impl Ssl {
     pub fn state_string_long(&self) -> &'static str {
         let state = unsafe {
             let ptr = ffi::SSL_state_string_long(self.ssl);
-            CStr::from_ptr(ptr)
+            CStr::from_ptr(ptr as *const _)
         };
 
         str::from_utf8(state.to_bytes()).unwrap()
@@ -809,7 +809,7 @@ impl Ssl {
     /// Sets the host name to be used with SNI (Server Name Indication).
     pub fn set_hostname(&self, hostname: &str) -> Result<(), SslError> {
         let cstr = CString::new(hostname).unwrap();
-        let ret = unsafe { ffi_extras::SSL_set_tlsext_host_name(self.ssl, cstr.as_ptr()) };
+        let ret = unsafe { ffi_extras::SSL_set_tlsext_host_name(self.ssl, cstr.as_ptr() as *const _) };
 
         // For this case, 0 indicates failure.
         if ret == 0 {
@@ -897,7 +897,7 @@ impl Ssl {
 
         let meth = unsafe { ffi::SSL_COMP_get_name(ptr) };
         let s = unsafe {
-            String::from_utf8(CStr::from_ptr(meth).to_bytes().to_vec()).unwrap()
+            String::from_utf8(CStr::from_ptr(meth as *const _).to_bytes().to_vec()).unwrap()
         };
 
         Some(s)

openssl/src/x509/mod.rs

@@ -50,7 +50,7 @@ impl Deref for SslString {
 impl SslString {
     unsafe fn new(buf: *const c_char) -> SslString {
         SslString {
-            s: str::from_utf8(CStr::from_ptr(buf).to_bytes()).unwrap()
+            s: str::from_utf8(CStr::from_ptr(buf as *const _).to_bytes()).unwrap()
         }
     }
 }
@@ -284,8 +284,8 @@ impl X509Generator {
         lift_ssl!(unsafe {
             let key = CString::new(key.as_bytes()).unwrap();
             let value = CString::new(value.as_bytes()).unwrap();
-            ffi::X509_NAME_add_entry_by_txt(name, key.as_ptr(), ffi::MBSTRING_UTF8,
-                                            value.as_ptr(), value_len, -1, 0)
+            ffi::X509_NAME_add_entry_by_txt(name, key.as_ptr() as *const _, ffi::MBSTRING_UTF8,
+                                            value.as_ptr() as *const _, value_len, -1, 0)
         })
     }