1 files changed, 31 insertions, 40 deletions

diff --git a/openssl/src/dh/mod.rs b/openssl/src/dh/mod.rs
index d2f26c3f..78dcb778 100644
--- a/openssl/src/dh/mod.rs
+++ b/openssl/src/dh/mod.rs
@@ -1,78 +1,71 @@
 use ffi;
-use std::io;
-use std::io::prelude::*;
-use ssl::error::{SslError, StreamError};
-use bio::MemBio;
+use error::ErrorStack;
+use bio::MemBioSlice;
+use std::ptr;
+
+#[cfg(feature = "dh_from_params")]
 use bn::BigNum;
+#[cfg(feature = "dh_from_params")]
 use std::mem;
-use std::ptr;
 
 pub struct DH(*mut ffi::DH);
 
 impl DH {
-    pub fn from_params(p: BigNum, g: BigNum, q: BigNum) -> Result<DH, SslError> {
-        let dh = try_ssl_null!(unsafe { ffi::DH_new_from_params(p.raw(), g.raw(), q.raw()) });
+    /// Requires the `dh_from_params` feature.
+    #[cfg(feature = "dh_from_params")]
+    pub fn from_params(p: BigNum, g: BigNum, q: BigNum) -> Result<DH, ErrorStack> {
+        let dh = unsafe {
+            try_ssl_null!(::c_helpers::rust_DH_new_from_params(p.as_ptr(), g.as_ptr(), q.as_ptr()))
+        };
         mem::forget(p);
         mem::forget(g);
         mem::forget(q);
         Ok(DH(dh))
     }
 
-    pub fn from_pem<R>(reader: &mut R) -> Result<DH, SslError>
-        where R: Read
-    {
-        let mut mem_bio = try!(MemBio::new());
-        try!(io::copy(reader, &mut mem_bio).map_err(StreamError));
+    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.as_ptr(), ptr::null_mut(), None, ptr::null_mut())
         };
         try_ssl_null!(dh);
         Ok(DH(dh))
     }
 
     #[cfg(feature = "rfc5114")]
-    pub fn get_1024_160() -> Result<DH, SslError> {
+    pub fn get_1024_160() -> Result<DH, ErrorStack> {
         let dh = try_ssl_null!(unsafe { ffi::DH_get_1024_160() });
         Ok(DH(dh))
     }
 
     #[cfg(feature = "rfc5114")]
-    pub fn get_2048_224() -> Result<DH, SslError> {
+    pub fn get_2048_224() -> Result<DH, ErrorStack> {
         let dh = try_ssl_null!(unsafe { ffi::DH_get_2048_224() });
         Ok(DH(dh))
     }
 
     #[cfg(feature = "rfc5114")]
-    pub fn get_2048_256() -> Result<DH, SslError> {
+    pub fn get_2048_256() -> Result<DH, ErrorStack> {
         let dh = try_ssl_null!(unsafe { ffi::DH_get_2048_256() });
         Ok(DH(dh))
     }
 
-    pub unsafe fn raw(&self) -> *mut ffi::DH {
+    pub unsafe fn as_ptr(&self) -> *mut ffi::DH {
         let DH(n) = *self;
         n
     }
-
-    pub unsafe fn raw_ptr(&self) -> *const *mut ffi::DH {
-        let DH(ref n) = *self;
-        n
-    }
 }
 
 impl Drop for DH {
     fn drop(&mut self) {
         unsafe {
-            if !self.raw().is_null() {
-                ffi::DH_free(self.raw())
-            }
+            ffi::DH_free(self.as_ptr())
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::fs::File;
-    use std::path::Path;
     use super::DH;
     use bn::BigNum;
     use ssl::SslContext;
@@ -81,18 +74,19 @@ mod tests {
     #[test]
     #[cfg(feature = "rfc5114")]
     fn test_dh_rfc5114() {
-        let ctx = SslContext::new(Sslv23).unwrap();
+        let mut ctx = SslContext::new(Sslv23).unwrap();
         let dh1 = DH::get_1024_160().unwrap();
-        ctx.set_tmp_dh(dh1).unwrap();
+        ctx.set_tmp_dh(&dh1).unwrap();
         let dh2 = DH::get_2048_224().unwrap();
-        ctx.set_tmp_dh(dh2).unwrap();
+        ctx.set_tmp_dh(&dh2).unwrap();
         let dh3 = DH::get_2048_256().unwrap();
-        ctx.set_tmp_dh(dh3).unwrap();
+        ctx.set_tmp_dh(&dh3).unwrap();
     }
 
     #[test]
+    #[cfg(feature = "dh_from_params")]
     fn test_dh() {
-        let ctx = SslContext::new(Sslv23).unwrap();
+        let mut ctx = SslContext::new(Sslv23).unwrap();
         let p = BigNum::from_hex_str("87A8E61DB4B6663CFFBBD19C651959998CEEF608660DD0F25D2CEED4435\
                                       E3B00E00DF8F1D61957D4FAF7DF4561B2AA3016C3D91134096FAA3BF429\
                                       6D830E9A7C209E0C6497517ABD5A8A9D306BCF67ED91F9E6725B4758C02\
@@ -117,17 +111,14 @@ mod tests {
                                       5FBD3")
                     .unwrap();
         let dh = DH::from_params(p, g, q).unwrap();
-        ctx.set_tmp_dh(dh).unwrap();
+        ctx.set_tmp_dh(&dh).unwrap();
     }
 
     #[test]
     fn test_dh_from_pem() {
-        let ctx = SslContext::new(Sslv23).unwrap();
-        let pem_path = Path::new("test/dhparams.pem");
-        let mut file = File::open(&pem_path)
-                           .ok()
-                           .expect("Failed to open `test/dhparams.pem`");
-        let dh = DH::from_pem(&mut file).ok().expect("Failed to load PEM");
-        ctx.set_tmp_dh(dh).unwrap();
+        let mut ctx = SslContext::new(Sslv23).unwrap();
+        let params = include_bytes!("../../test/dhparams.pem");
+        let dh = DH::from_pem(params).ok().expect("Failed to load PEM");
+        ctx.set_tmp_dh(&dh).unwrap();
     }
 }