get_handle -> handle

7 files changed, 28 insertions, 28 deletions

diff --git a/openssl/src/asn1/mod.rs b/openssl/src/asn1/mod.rs
index 202909ec..39273cb8 100644
--- a/openssl/src/asn1/mod.rs
+++ b/openssl/src/asn1/mod.rs
@@ -33,7 +33,7 @@ impl Asn1Time {
     }
 
     /// Returns raw handle
-    pub unsafe fn get_handle(&self) -> *mut ffi::ASN1_TIME {
+    pub unsafe fn handle(&self) -> *mut ffi::ASN1_TIME {
         return self.handle;
     }
 }
diff --git a/openssl/src/bio.rs b/openssl/src/bio.rs
index 841aca0e..7adcc4e6 100644
--- a/openssl/src/bio.rs
+++ b/openssl/src/bio.rs
@@ -28,7 +28,7 @@ impl<'a> MemBioSlice<'a> {
         Ok(MemBioSlice(bio, PhantomData))
     }
 
-    pub fn get_handle(&self) -> *mut ffi::BIO {
+    pub fn handle(&self) -> *mut ffi::BIO {
         self.0
     }
 }
@@ -53,7 +53,7 @@ impl MemBio {
         Ok(MemBio(bio))
     }
 
-    pub fn get_handle(&self) -> *mut ffi::BIO {
+    pub fn handle(&self) -> *mut ffi::BIO {
         self.0
     }
 
diff --git a/openssl/src/crypto/dsa.rs b/openssl/src/crypto/dsa.rs
index de35893b..40702627 100644
--- a/openssl/src/crypto/dsa.rs
+++ b/openssl/src/crypto/dsa.rs
@@ -73,7 +73,7 @@ impl DSA {
         let mem_bio = try!(MemBioSlice::new(buf));
 
         unsafe {
-            let dsa = try_ssl_null!(ffi::PEM_read_bio_DSAPrivateKey(mem_bio.get_handle(),
+            let dsa = try_ssl_null!(ffi::PEM_read_bio_DSAPrivateKey(mem_bio.handle(),
                                                                     ptr::null_mut(),
                                                                     None,
                                                                     ptr::null_mut()));
@@ -97,7 +97,7 @@ impl DSA {
 
         unsafe {
             let cb_ptr = &mut cb as *mut _ as *mut c_void;
-            let dsa = try_ssl_null!(ffi::PEM_read_bio_DSAPrivateKey(mem_bio.get_handle(),
+            let dsa = try_ssl_null!(ffi::PEM_read_bio_DSAPrivateKey(mem_bio.handle(),
                                                                     ptr::null_mut(),
                                                                     Some(invoke_passwd_cb::<F>),
                                                                     cb_ptr));
@@ -114,7 +114,7 @@ impl DSA {
         let mem_bio = try!(MemBio::new());
 
         unsafe {
-            try_ssl!(ffi::PEM_write_bio_DSAPrivateKey(mem_bio.get_handle(), self.0,
+            try_ssl!(ffi::PEM_write_bio_DSAPrivateKey(mem_bio.handle(), self.0,
                                               ptr::null(), ptr::null_mut(), 0,
                                               None, ptr::null_mut()))
         };
@@ -129,7 +129,7 @@ impl DSA {
 
         let mem_bio = try!(MemBioSlice::new(buf));
         unsafe {
-            let dsa = try_ssl_null!(ffi::PEM_read_bio_DSA_PUBKEY(mem_bio.get_handle(),
+            let dsa = try_ssl_null!(ffi::PEM_read_bio_DSA_PUBKEY(mem_bio.handle(),
                                                                  ptr::null_mut(),
                                                                  None,
                                                                  ptr::null_mut()));
@@ -140,7 +140,7 @@ impl DSA {
     /// Writes an DSA public key as PEM formatted data
     pub fn public_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack> {
         let mem_bio = try!(MemBio::new());
-        unsafe { try_ssl!(ffi::PEM_write_bio_DSA_PUBKEY(mem_bio.get_handle(), self.0)) };
+        unsafe { try_ssl!(ffi::PEM_write_bio_DSA_PUBKEY(mem_bio.handle(), self.0)) };
         Ok(mem_bio.get_buf().to_owned())
     }
 
diff --git a/openssl/src/crypto/pkey.rs b/openssl/src/crypto/pkey.rs
index 9f72464b..e554f3b2 100644
--- a/openssl/src/crypto/pkey.rs
+++ b/openssl/src/crypto/pkey.rs
@@ -77,7 +77,7 @@ impl PKey {
     pub fn private_key_from_pem(buf: &[u8]) -> Result<PKey, ErrorStack> {
         let mem_bio = try!(MemBioSlice::new(buf));
         unsafe {
-            let evp = try_ssl_null!(ffi::PEM_read_bio_PrivateKey(mem_bio.get_handle(),
+            let evp = try_ssl_null!(ffi::PEM_read_bio_PrivateKey(mem_bio.handle(),
                                                                  ptr::null_mut(),
                                                                  None,
                                                                  ptr::null_mut()));
@@ -100,7 +100,7 @@ impl PKey {
         let mut cb = CallbackState::new(pass_cb);
         let mem_bio = try!(MemBioSlice::new(buf));
         unsafe {
-            let evp = try_ssl_null!(ffi::PEM_read_bio_PrivateKey(mem_bio.get_handle(),
+            let evp = try_ssl_null!(ffi::PEM_read_bio_PrivateKey(mem_bio.handle(),
                                                                  ptr::null_mut(),
                                                                  Some(invoke_passwd_cb::<F>),
                                                                  &mut cb as *mut _ as *mut c_void));
@@ -116,7 +116,7 @@ impl PKey {
     pub fn public_key_from_pem(buf: &[u8]) -> Result<PKey, ErrorStack> {
         let mem_bio = try!(MemBioSlice::new(buf));
         unsafe {
-            let evp = try_ssl_null!(ffi::PEM_read_bio_PUBKEY(mem_bio.get_handle(),
+            let evp = try_ssl_null!(ffi::PEM_read_bio_PUBKEY(mem_bio.handle(),
                                                              ptr::null_mut(),
                                                              None,
                                                              ptr::null_mut()));
@@ -266,7 +266,7 @@ impl PKey {
     pub fn write_pem(&self) -> Result<Vec<u8>, ErrorStack> {
         let mem_bio = try!(MemBio::new());
         unsafe {
-            try_ssl!(ffi::PEM_write_bio_PrivateKey(mem_bio.get_handle(),
+            try_ssl!(ffi::PEM_write_bio_PrivateKey(mem_bio.handle(),
                                                    self.evp,
                                                    ptr::null(),
                                                    ptr::null_mut(),
@@ -281,7 +281,7 @@ impl PKey {
     /// Stores public key as a PEM
     pub fn write_pub_pem(&self) -> Result<Vec<u8>, ErrorStack> {
         let mem_bio = try!(MemBio::new());
-        unsafe { try_ssl!(ffi::PEM_write_bio_PUBKEY(mem_bio.get_handle(), self.evp)) }
+        unsafe { try_ssl!(ffi::PEM_write_bio_PUBKEY(mem_bio.handle(), self.evp)) }
         Ok(mem_bio.get_buf().to_owned())
     }
 
diff --git a/openssl/src/crypto/rsa.rs b/openssl/src/crypto/rsa.rs
index 226b2aab..5c70c8ea 100644
--- a/openssl/src/crypto/rsa.rs
+++ b/openssl/src/crypto/rsa.rs
@@ -64,7 +64,7 @@ impl RSA {
     pub fn private_key_from_pem(buf: &[u8]) -> Result<RSA, ErrorStack> {
         let mem_bio = try!(MemBioSlice::new(buf));
         unsafe {
-            let rsa = try_ssl_null!(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.get_handle(),
+            let rsa = try_ssl_null!(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.handle(),
                                                                     ptr::null_mut(),
                                                                     None,
                                                                     ptr::null_mut()));
@@ -81,7 +81,7 @@ impl RSA {
 
         unsafe {
             let cb_ptr = &mut cb as *mut _ as *mut c_void;
-            let rsa = try_ssl_null!(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.get_handle(),
+            let rsa = try_ssl_null!(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.handle(),
                                                                     ptr::null_mut(),
                                                                     Some(invoke_passwd_cb::<F>),
                                                                     cb_ptr));
@@ -95,7 +95,7 @@ impl RSA {
         let mem_bio = try!(MemBio::new());
 
         unsafe {
-            try_ssl!(ffi::PEM_write_bio_RSAPrivateKey(mem_bio.get_handle(),
+            try_ssl!(ffi::PEM_write_bio_RSAPrivateKey(mem_bio.handle(),
                                              self.0,
                                              ptr::null(),
                                              ptr::null_mut(),
@@ -110,7 +110,7 @@ impl RSA {
     pub fn public_key_from_pem(buf: &[u8]) -> Result<RSA, ErrorStack> {
         let mem_bio = try!(MemBioSlice::new(buf));
         unsafe {
-            let rsa = try_ssl_null!(ffi::PEM_read_bio_RSA_PUBKEY(mem_bio.get_handle(),
+            let rsa = try_ssl_null!(ffi::PEM_read_bio_RSA_PUBKEY(mem_bio.handle(),
                                                                  ptr::null_mut(),
                                                                  None,
                                                                  ptr::null_mut()));
@@ -123,7 +123,7 @@ impl RSA {
         let mem_bio = try!(MemBio::new());
 
         unsafe {
-            try_ssl!(ffi::PEM_write_bio_RSA_PUBKEY(mem_bio.get_handle(), self.0))
+            try_ssl!(ffi::PEM_write_bio_RSA_PUBKEY(mem_bio.handle(), self.0))
         };
 
         Ok(mem_bio.get_buf().to_owned())
diff --git a/openssl/src/dh/mod.rs b/openssl/src/dh/mod.rs
index df6f1b0a..6a5bd9c4 100644
--- a/openssl/src/dh/mod.rs
+++ b/openssl/src/dh/mod.rs
@@ -19,7 +19,7 @@ impl DH {
     pub fn from_pem(buf: &[u8]) -> Result<DH, ErrorStack> {
         let mem_bio = try!(MemBioSlice::new(buf));
         let dh = unsafe {
-            ffi::PEM_read_bio_DHparams(mem_bio.get_handle(), ptr::null_mut(), None, ptr::null_mut())
+            ffi::PEM_read_bio_DHparams(mem_bio.handle(), ptr::null_mut(), None, ptr::null_mut())
         };
         try_ssl_null!(dh);
         Ok(DH(dh))
diff --git a/openssl/src/x509/mod.rs b/openssl/src/x509/mod.rs
index f81c74a1..82448212 100644
--- a/openssl/src/x509/mod.rs
+++ b/openssl/src/x509/mod.rs
@@ -325,11 +325,11 @@ impl X509Generator {
             let not_before = try!(Asn1Time::days_from_now(0));
             let not_after = try!(Asn1Time::days_from_now(self.days));
 
-            try_ssl!(ffi::X509_set_notBefore(x509.handle(), mem::transmute(not_before.get_handle())));
+            try_ssl!(ffi::X509_set_notBefore(x509.handle(), mem::transmute(not_before.handle())));
             // If prev line succeded - ownership should go to cert
             mem::forget(not_before);
 
-            try_ssl!(ffi::X509_set_notAfter(x509.handle(), mem::transmute(not_after.get_handle())));
+            try_ssl!(ffi::X509_set_notAfter(x509.handle(), mem::transmute(not_after.handle())));
             // If prev line succeded - ownership should go to cert
             mem::forget(not_after);
 
@@ -463,7 +463,7 @@ impl<'a> X509Ref<'a> {
     pub fn write_pem(&self) -> Result<Vec<u8>, ErrorStack> {
         let mem_bio = try!(MemBio::new());
         unsafe {
-            try_ssl!(ffi::PEM_write_bio_X509(mem_bio.get_handle(), self.0));
+            try_ssl!(ffi::PEM_write_bio_X509(mem_bio.handle(), self.0));
         }
         Ok(mem_bio.get_buf().to_owned())
     }
@@ -472,7 +472,7 @@ impl<'a> X509Ref<'a> {
     pub fn save_der(&self) -> Result<Vec<u8>, ErrorStack> {
         let mem_bio = try!(MemBio::new());
         unsafe {
-            ffi::i2d_X509_bio(mem_bio.get_handle(), self.0);
+            ffi::i2d_X509_bio(mem_bio.handle(), self.0);
         }
         Ok(mem_bio.get_buf().to_owned())
     }
@@ -491,7 +491,7 @@ impl X509 {
     pub fn from_pem(buf: &[u8]) -> Result<X509, ErrorStack> {
         let mem_bio = try!(MemBioSlice::new(buf));
         unsafe {
-            let handle = try_ssl_null!(ffi::PEM_read_bio_X509(mem_bio.get_handle(),
+            let handle = try_ssl_null!(ffi::PEM_read_bio_X509(mem_bio.handle(),
                                                               ptr::null_mut(),
                                                               None,
                                                               ptr::null_mut()));
@@ -572,7 +572,7 @@ impl X509Req {
         X509Req { handle: handle }
     }
 
-    pub fn get_handle(&self) -> *mut ffi::X509_REQ {
+    pub fn handle(&self) -> *mut ffi::X509_REQ {
         self.handle
     }
 
@@ -580,7 +580,7 @@ impl X509Req {
     pub fn from_pem(buf: &[u8]) -> Result<X509Req, ErrorStack> {
         let mem_bio = try!(MemBioSlice::new(buf));
         unsafe {
-            let handle = try_ssl_null!(ffi::PEM_read_bio_X509_REQ(mem_bio.get_handle(),
+            let handle = try_ssl_null!(ffi::PEM_read_bio_X509_REQ(mem_bio.handle(),
                                                                   ptr::null_mut(),
                                                                   None,
                                                                   ptr::null_mut()));
@@ -591,7 +591,7 @@ impl X509Req {
     /// Writes CSR as PEM
     pub fn write_pem(&self) -> Result<Vec<u8>, ErrorStack> {
         let mem_bio = try!(MemBio::new());
-        if unsafe { ffi::PEM_write_bio_X509_REQ(mem_bio.get_handle(), self.handle) } != 1 {
+        if unsafe { ffi::PEM_write_bio_X509_REQ(mem_bio.handle(), self.handle) } != 1 {
             return Err(ErrorStack::get());
         }
         Ok(mem_bio.get_buf().to_owned())
@@ -601,7 +601,7 @@ impl X509Req {
     pub fn save_der(&self) -> Result<Vec<u8>, ErrorStack> {
         let mem_bio = try!(MemBio::new());
         unsafe {
-            ffi::i2d_X509_REQ_bio(mem_bio.get_handle(), self.handle);
+            ffi::i2d_X509_REQ_bio(mem_bio.handle(), self.handle);
         }
         Ok(mem_bio.get_buf().to_owned())
     }