rustup to current master

1 files changed, 24 insertions, 24 deletions

diff --git a/openssl/src/ssl/mod.rs b/openssl/src/ssl/mod.rs
index 35649e24..c9d46ffc 100644
--- a/openssl/src/ssl/mod.rs
+++ b/openssl/src/ssl/mod.rs
@@ -186,7 +186,7 @@ impl fmt::Debug for SslContext {
 
 impl Drop for SslContext {
     fn drop(&mut self) {
-        unsafe { ffi::SSL_CTX_free(self.ctx.0) }
+        unsafe { ffi::SSL_CTX_free(self.ctx.ptr) }
     }
 }
 
@@ -207,11 +207,11 @@ impl SslContext {
     pub fn set_verify(&mut self, mode: SslVerifyMode,
                       verify: Option<VerifyCallback>) {
         unsafe {
-            ffi::SSL_CTX_set_ex_data(self.ctx.0, VERIFY_IDX,
+            ffi::SSL_CTX_set_ex_data(self.ctx.ptr, VERIFY_IDX,
                                      mem::transmute(verify));
             let f: extern fn(c_int, *mut ffi::X509_STORE_CTX) -> c_int =
                                 raw_verify;
-            ffi::SSL_CTX_set_verify(self.ctx.0, mode as c_int, Some(f));
+            ffi::SSL_CTX_set_verify(self.ctx.ptr, mode as c_int, Some(f));
         }
     }
 
@@ -224,20 +224,20 @@ impl SslContext {
                                    data: T) {
         let data = Box::new(data);
         unsafe {
-            ffi::SSL_CTX_set_ex_data(self.ctx.0, VERIFY_IDX,
+            ffi::SSL_CTX_set_ex_data(self.ctx.ptr, VERIFY_IDX,
                                      mem::transmute(Some(verify)));
-            ffi::SSL_CTX_set_ex_data(self.ctx.0, get_verify_data_idx::<T>(),
+            ffi::SSL_CTX_set_ex_data(self.ctx.ptr, get_verify_data_idx::<T>(),
                                      mem::transmute(data));
             let f: extern fn(c_int, *mut ffi::X509_STORE_CTX) -> c_int =
                                 raw_verify_with_data::<T>;
-            ffi::SSL_CTX_set_verify(self.ctx.0, mode as c_int, Some(f));
+            ffi::SSL_CTX_set_verify(self.ctx.ptr, mode as c_int, Some(f));
         }
     }
 
     /// Sets verification depth
     pub fn set_verify_depth(&mut self, depth: u32) {
         unsafe {
-            ffi::SSL_CTX_set_verify_depth(self.ctx.0, depth as c_int);
+            ffi::SSL_CTX_set_verify_depth(self.ctx.ptr, depth as c_int);
         }
     }
 
@@ -247,7 +247,7 @@ impl SslContext {
         wrap_ssl_result(
             unsafe {
                 let file = CString::from_slice(file.as_vec());
-                ffi::SSL_CTX_load_verify_locations(self.ctx.0, file.as_ptr(), ptr::null())
+                ffi::SSL_CTX_load_verify_locations(self.ctx.ptr, file.as_ptr(), ptr::null())
             })
     }
 
@@ -257,7 +257,7 @@ impl SslContext {
         wrap_ssl_result(
             unsafe {
                 let file = CString::from_slice(file.as_vec());
-                ffi::SSL_CTX_use_certificate_file(self.ctx.0, file.as_ptr(), file_type as c_int)
+                ffi::SSL_CTX_use_certificate_file(self.ctx.ptr, file.as_ptr(), file_type as c_int)
             })
     }
 
@@ -267,7 +267,7 @@ impl SslContext {
         wrap_ssl_result(
             unsafe {
                 let file = CString::from_slice(file.as_vec());
-                ffi::SSL_CTX_use_PrivateKey_file(self.ctx.0, file.as_ptr(), file_type as c_int)
+                ffi::SSL_CTX_use_PrivateKey_file(self.ctx.ptr, file.as_ptr(), file_type as c_int)
             })
     }
 
@@ -275,7 +275,7 @@ impl SslContext {
         wrap_ssl_result(
             unsafe {
                 let cipher_list = CString::from_slice(cipher_list.as_bytes());
-                ffi::SSL_CTX_set_cipher_list(self.ctx.0, cipher_list.as_ptr())
+                ffi::SSL_CTX_set_cipher_list(self.ctx.ptr, cipher_list.as_ptr())
             })
     }
 }
@@ -309,13 +309,13 @@ impl fmt::Debug for Ssl {
 
 impl Drop for Ssl {
     fn drop(&mut self) {
-        unsafe { ffi::SSL_free(self.ssl.0) }
+        unsafe { ffi::SSL_free(self.ssl.ptr) }
     }
 }
 
 impl Ssl {
     pub fn new(ctx: &SslContext) -> Result<Ssl, SslError> {
-        let ssl = unsafe { ffi::SSL_new(ctx.ctx.0) };
+        let ssl = unsafe { ffi::SSL_new(ctx.ctx.ptr) };
         if ssl == ptr::null_mut() {
             return Err(SslError::get());
         }
@@ -324,16 +324,16 @@ impl Ssl {
         let rbio = try!(MemBio::new());
         let wbio = try!(MemBio::new());
 
-        unsafe { ffi::SSL_set_bio(ssl.ssl.0, rbio.unwrap(), wbio.unwrap()) }
+        unsafe { ffi::SSL_set_bio(ssl.ssl.ptr, rbio.unwrap(), wbio.unwrap()) }
         Ok(ssl)
     }
 
     fn get_rbio<'a>(&'a self) -> MemBioRef<'a> {
-        unsafe { self.wrap_bio(ffi::SSL_get_rbio(self.ssl.0)) }
+        unsafe { self.wrap_bio(ffi::SSL_get_rbio(self.ssl.ptr)) }
     }
 
     fn get_wbio<'a>(&'a self) -> MemBioRef<'a> {
-        unsafe { self.wrap_bio(ffi::SSL_get_wbio(self.ssl.0)) }
+        unsafe { self.wrap_bio(ffi::SSL_get_wbio(self.ssl.ptr)) }
     }
 
     fn wrap_bio<'a>(&'a self, bio: *mut ffi::BIO) -> MemBioRef<'a> {
@@ -345,25 +345,25 @@ impl Ssl {
     }
 
     fn connect(&self) -> c_int {
-        unsafe { ffi::SSL_connect(self.ssl.0) }
+        unsafe { ffi::SSL_connect(self.ssl.ptr) }
     }
 
     fn accept(&self) -> c_int {
-        unsafe { ffi::SSL_accept(self.ssl.0) }
+        unsafe { ffi::SSL_accept(self.ssl.ptr) }
     }
 
     fn read(&self, buf: &mut [u8]) -> c_int {
-        unsafe { ffi::SSL_read(self.ssl.0, buf.as_ptr() as *mut c_void,
+        unsafe { ffi::SSL_read(self.ssl.ptr, buf.as_ptr() as *mut c_void,
                                buf.len() as c_int) }
     }
 
     fn write_all(&self, buf: &[u8]) -> c_int {
-        unsafe { ffi::SSL_write(self.ssl.0, buf.as_ptr() as *const c_void,
+        unsafe { ffi::SSL_write(self.ssl.ptr, buf.as_ptr() as *const c_void,
                                 buf.len() as c_int) }
     }
 
     fn get_error(&self, ret: c_int) -> LibSslError {
-        let err = unsafe { ffi::SSL_get_error(self.ssl.0, ret) };
+        let err = unsafe { ffi::SSL_get_error(self.ssl.ptr, ret) };
         match FromPrimitive::from_int(err as isize) {
             Some(err) => err,
             None => unreachable!()
@@ -378,7 +378,7 @@ impl Ssl {
                 //          SSL_ctrl(s,SSL_CTRL_SET_TLSEXT_HOSTNAME,TLSEXT_NAMETYPE_host_name,(char *)name)
 
                 let hostname = CString::from_slice(hostname.as_bytes());
-                ffi::SSL_ctrl(self.ssl.0, ffi::SSL_CTRL_SET_TLSEXT_HOSTNAME,
+                ffi::SSL_ctrl(self.ssl.ptr, ffi::SSL_CTRL_SET_TLSEXT_HOSTNAME,
                               ffi::TLSEXT_NAMETYPE_host_name,
                               hostname.as_ptr() as *mut c_void)
         };
@@ -393,7 +393,7 @@ impl Ssl {
 
     pub fn get_peer_certificate(&self) -> Option<X509> {
         unsafe {
-            let ptr = ffi::SSL_get_peer_certificate(self.ssl.0);
+            let ptr = ffi::SSL_get_peer_certificate(self.ssl.ptr);
             if ptr.is_null() {
                 None
             } else {
@@ -534,7 +534,7 @@ impl<S: Stream> SslStream<S> {
     /// either None, indicating no compression is in use, or a string
     /// with the compression name.
     pub fn get_compression(&self) -> Option<String> {
-        let ptr = unsafe { ffi::SSL_get_current_compression(self.ssl.ssl.0) };
+        let ptr = unsafe { ffi::SSL_get_current_compression(self.ssl.ssl.ptr) };
         if ptr == ptr::null() {
             return None;
         }