min
/
boring2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #512 from sfackler/no-ref 

Get rid of Ref
This commit is contained in:
Steven Fackler 2016-11-04 18:40:43 -07:00 committed by GitHub
parent 25443d7b48 01ae978db0
commit 1108db74ec
17 changed files with 317 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
openssl/src/asn1.rs
View File

@ -9,11 +9,11 @@ use {cvt, cvt_p};
use bio::MemBio;
use crypto::CryptoString;
use error::ErrorStack;
use types::{OpenSslType, Ref};
use types::{OpenSslType, OpenSslTypeRef};
type_!(Asn1Time, ffi::ASN1_TIME, ffi::ASN1_TIME_free);
type_!(Asn1Time, Asn1TimeRef, ffi::ASN1_TIME, ffi::ASN1_TIME_free);
impl fmt::Display for Ref<Asn1Time> {
impl fmt::Display for Asn1TimeRef {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
unsafe {
let mem_bio = try!(MemBio::new());
@ -39,9 +39,9 @@ impl Asn1Time {
}
}
type_!(Asn1String, ffi::ASN1_STRING, ffi::ASN1_STRING_free);
type_!(Asn1String, Asn1StringRef, ffi::ASN1_STRING, ffi::ASN1_STRING_free);
impl Ref<Asn1String> {
impl Asn1StringRef {
pub fn as_utf8(&self) -> Result<CryptoString, ErrorStack> {
unsafe {
let mut ptr = ptr::null_mut();

178
openssl/src/bn.rs
View File

@ -8,7 +8,7 @@ use std::ops::{Add, Div, Mul, Neg, Rem, Shl, Shr, Sub, Deref};
use {cvt, cvt_p, cvt_n};
use crypto::CryptoString;
use error::ErrorStack;
use types::{Ref, OpenSslType};
use types::{OpenSslType, OpenSslTypeRef};
/// Options for the most significant bits of a randomly generated `BigNum`.
pub struct MsbOption(c_int);
@ -25,7 +25,7 @@ pub const MSB_ONE: MsbOption = MsbOption(0);
/// of bits in the original numbers.
pub const TWO_MSB_ONE: MsbOption = MsbOption(1);
type_!(BigNumContext, ffi::BN_CTX, ffi::BN_CTX_free);
type_!(BigNumContext, BigNumContextRef, ffi::BN_CTX, ffi::BN_CTX_free);
impl BigNumContext {
/// Returns a new `BigNumContext`.
@ -35,19 +35,19 @@ impl BigNumContext {
/// Places the result of `a * b` in `r`.
pub fn mul(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
b: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
b: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_mul(r.as_ptr(), a.as_ptr(), b.as_ptr(), self.as_ptr())).map(|_| ()) }
}
/// Places the result of `a / b` in `dv` and `a mod b` in `rem`.
pub fn div(&mut self,
dv: Option<&mut Ref<BigNum>>,
rem: Option<&mut Ref<BigNum>>,
a: &Ref<BigNum>,
b: &Ref<BigNum>)
dv: Option<&mut BigNumRef>,
rem: Option<&mut BigNumRef>,
a: &BigNumRef,
b: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_div(dv.map(|b| b.as_ptr()).unwrap_or(ptr::null_mut()),
@ -60,25 +60,25 @@ impl BigNumContext {
}
/// Places the result of `a²` in `r`.
pub fn sqr(&mut self, r: &mut Ref<BigNum>, a: &Ref<BigNum>) -> Result<(), ErrorStack> {
pub fn sqr(&mut self, r: &mut BigNumRef, a: &BigNumRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_sqr(r.as_ptr(), a.as_ptr(), self.as_ptr())).map(|_| ()) }
}
/// Places the result of `a mod m` in `r`.
pub fn nnmod(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
m: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
m: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_nnmod(r.as_ptr(), a.as_ptr(), m.as_ptr(), self.0)).map(|_| ()) }
}
/// Places the result of `(a + b) mod m` in `r`.
pub fn mod_add(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
b: &Ref<BigNum>,
m: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
b: &BigNumRef,
m: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_mod_add(r.as_ptr(), a.as_ptr(), b.as_ptr(), m.as_ptr(), self.0)).map(|_| ())
@ -87,10 +87,10 @@ impl BigNumContext {
/// Places the result of `(a - b) mod m` in `r`.
pub fn mod_sub(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
b: &Ref<BigNum>,
m: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
b: &BigNumRef,
m: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_mod_sub(r.as_ptr(), a.as_ptr(), b.as_ptr(), m.as_ptr(), self.0)).map(|_| ())
@ -99,10 +99,10 @@ impl BigNumContext {
/// Places the result of `(a * b) mod m` in `r`.
pub fn mod_mul(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
b: &Ref<BigNum>,
m: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
b: &BigNumRef,
m: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_mod_mul(r.as_ptr(), a.as_ptr(), b.as_ptr(), m.as_ptr(), self.0)).map(|_| ())
@ -111,28 +111,28 @@ impl BigNumContext {
/// Places the result of `a² mod m` in `r`.
pub fn mod_sqr(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
m: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
m: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_mod_sqr(r.as_ptr(), a.as_ptr(), m.as_ptr(), self.0)).map(|_| ()) }
}
/// Places the result of `a^p` in `r`.
pub fn exp(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
p: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
p: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_exp(r.as_ptr(), a.as_ptr(), p.as_ptr(), self.0)).map(|_| ()) }
}
/// Places the result of `a^p mod m` in `r`.
pub fn mod_exp(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
p: &Ref<BigNum>,
m: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
p: &BigNumRef,
m: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_mod_exp(r.as_ptr(), a.as_ptr(), p.as_ptr(), m.as_ptr(), self.0)).map(|_| ())
@ -141,9 +141,9 @@ impl BigNumContext {
/// Places the inverse of `a` modulo `n` in `r`.
pub fn mod_inverse(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
n: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
n: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe {
cvt_p(ffi::BN_mod_inverse(r.as_ptr(), a.as_ptr(), n.as_ptr(), self.as_ptr()))
@ -153,9 +153,9 @@ impl BigNumContext {
/// Places the greatest common denominator of `a` and `b` in `r`.
pub fn gcd(&mut self,
r: &mut Ref<BigNum>,
a: &Ref<BigNum>,
b: &Ref<BigNum>)
r: &mut BigNumRef,
a: &BigNumRef,
b: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_gcd(r.as_ptr(), a.as_ptr(), b.as_ptr(), self.as_ptr())).map(|_| ()) }
}
@ -165,7 +165,7 @@ impl BigNumContext {
/// Performs a Miller-Rabin probabilistic primality test with `checks` iterations.
///
/// Returns `true` if `p` is prime with an error probability of less than `0.25 ^ checks`.
pub fn is_prime(&mut self, p: &Ref<BigNum>, checks: i32) -> Result<bool, ErrorStack> {
pub fn is_prime(&mut self, p: &BigNumRef, checks: i32) -> Result<bool, ErrorStack> {
unsafe {
cvt_n(ffi::BN_is_prime_ex(p.as_ptr(), checks.into(), self.as_ptr(), ptr::null_mut()))
.map(|r| r != 0)
@ -182,7 +182,7 @@ impl BigNumContext {
///
/// Returns `true` if `p` is prime with an error probability of less than `0.25 ^ checks`.
pub fn is_prime_fasttest(&mut self,
p: &Ref<BigNum>,
p: &BigNumRef,
checks: i32,
do_trial_division: bool)
-> Result<bool, ErrorStack> {
@ -197,7 +197,7 @@ impl BigNumContext {
}
}
impl Ref<BigNum> {
impl BigNumRef {
/// Erases the memory used by this `BigNum`, resetting its value to 0.
///
/// This can be used to destroy sensitive data such as keys when they are no longer needed.
@ -246,12 +246,12 @@ impl Ref<BigNum> {
/// Places a cryptographically-secure pseudo-random number nonnegative
/// number less than `self` in `rnd`.
pub fn rand_in_range(&self, rnd: &mut Ref<BigNum>) -> Result<(), ErrorStack> {
pub fn rand_in_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_rand_range(self.as_ptr(), rnd.as_ptr())).map(|_| ()) }
}
/// The cryptographically weak counterpart to `rand_in_range`.
pub fn pseudo_rand_in_range(&self, rnd: &mut Ref<BigNum>) -> Result<(), ErrorStack> {
pub fn pseudo_rand_in_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_pseudo_rand_range(self.as_ptr(), rnd.as_ptr())).map(|_| ()) }
}
@ -282,32 +282,32 @@ impl Ref<BigNum> {
}
/// Places `self << 1` in `r`.
pub fn lshift1(&self, r: &mut Ref<BigNum>) -> Result<(), ErrorStack> {
pub fn lshift1(&self, r: &mut BigNumRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_lshift1(r.as_ptr(), self.as_ptr())).map(|_| ()) }
}
/// Places `self >> 1` in `r`.
pub fn rshift1(&self, r: &mut Ref<BigNum>) -> Result<(), ErrorStack> {
pub fn rshift1(&self, r: &mut BigNumRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_rshift1(r.as_ptr(), self.as_ptr())).map(|_| ()) }
}
/// Places `self + b` in `r`.
pub fn add(&self, r: &mut Ref<BigNum>, b: &Ref<BigNum>) -> Result<(), ErrorStack> {
pub fn add(&self, r: &mut BigNumRef, b: &BigNumRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_add(r.as_ptr(), self.as_ptr(), b.as_ptr())).map(|_| ()) }
}
/// Places `self - b` in `r`.
pub fn sub(&self, r: &mut Ref<BigNum>, b: &Ref<BigNum>) -> Result<(), ErrorStack> {
pub fn sub(&self, r: &mut BigNumRef, b: &BigNumRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_sub(r.as_ptr(), self.as_ptr(), b.as_ptr())).map(|_| ()) }
}
/// Places `self << n` in `r`.
pub fn lshift(&self, r: &mut Ref<BigNum>, b: i32) -> Result<(), ErrorStack> {
pub fn lshift(&self, r: &mut BigNumRef, b: i32) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_lshift(r.as_ptr(), self.as_ptr(), b.into())).map(|_| ()) }
}
/// Places `self >> n` in `r`.
pub fn rshift(&self, r: &mut Ref<BigNum>, n: i32) -> Result<(), ErrorStack> {
pub fn rshift(&self, r: &mut BigNumRef, n: i32) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::BN_rshift(r.as_ptr(), self.as_ptr(), n.into())).map(|_| ()) }
}
@ -330,7 +330,7 @@ impl Ref<BigNum> {
///
/// assert_eq!(s.ucmp(&o), Ordering::Equal);
/// ```
pub fn ucmp(&self, oth: &Ref<BigNum>) -> Ordering {
pub fn ucmp(&self, oth: &BigNumRef) -> Ordering {
unsafe { ffi::BN_ucmp(self.as_ptr(), oth.as_ptr()).cmp(&0) }
}
@ -397,8 +397,8 @@ impl Ref<BigNum> {
pub fn generate_prime(&mut self,
bits: i32,
safe: bool,
add: Option<&Ref<BigNum>>,
rem: Option<&Ref<BigNum>>)
add: Option<&BigNumRef>,
rem: Option<&BigNumRef>)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_generate_prime_ex(self.as_ptr(),
@ -464,7 +464,7 @@ impl Ref<BigNum> {
}
}
type_!(BigNum, ffi::BIGNUM, ffi::BN_free);
type_!(BigNum, BigNumRef, ffi::BIGNUM, ffi::BN_free);
impl BigNum {
/// Creates a new `BigNum` with the value 0.
@ -520,13 +520,13 @@ impl BigNum {
}
}
impl AsRef<Ref<BigNum>> for BigNum {
fn as_ref(&self) -> &Ref<BigNum> {
impl AsRef<BigNumRef> for BigNum {
fn as_ref(&self) -> &BigNumRef {
self.deref()
}
}
impl fmt::Debug for Ref<BigNum> {
impl fmt::Debug for BigNumRef {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.to_dec_str() {
Ok(s) => f.write_str(&s),
@ -544,7 +544,7 @@ impl fmt::Debug for BigNum {
}
}
impl fmt::Display for Ref<BigNum> {
impl fmt::Display for BigNumRef {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.to_dec_str() {
Ok(s) => f.write_str(&s),
@ -562,19 +562,19 @@ impl fmt::Display for BigNum {
}
}
impl PartialEq<Ref<BigNum>> for Ref<BigNum> {
fn eq(&self, oth: &Ref<BigNum>) -> bool {
impl PartialEq<BigNumRef> for BigNumRef {
fn eq(&self, oth: &BigNumRef) -> bool {
self.cmp(oth) == Ordering::Equal
}
}
impl PartialEq<BigNum> for Ref<BigNum> {
impl PartialEq<BigNum> for BigNumRef {
fn eq(&self, oth: &BigNum) -> bool {
self.eq(oth.deref())
}
}
impl Eq for Ref<BigNum> {}
impl Eq for BigNumRef {}
impl PartialEq for BigNum {
fn eq(&self, oth: &BigNum) -> bool {
@ -582,28 +582,28 @@ impl PartialEq for BigNum {
}
}
impl PartialEq<Ref<BigNum>> for BigNum {
fn eq(&self, oth: &Ref<BigNum>) -> bool {
impl PartialEq<BigNumRef> for BigNum {
fn eq(&self, oth: &BigNumRef) -> bool {
self.deref().eq(oth)
}
}
impl Eq for BigNum {}
impl PartialOrd<Ref<BigNum>> for Ref<BigNum> {
fn partial_cmp(&self, oth: &Ref<BigNum>) -> Option<Ordering> {
impl PartialOrd<BigNumRef> for BigNumRef {
fn partial_cmp(&self, oth: &BigNumRef) -> Option<Ordering> {
Some(self.cmp(oth))
}
}
impl PartialOrd<BigNum> for Ref<BigNum> {
impl PartialOrd<BigNum> for BigNumRef {
fn partial_cmp(&self, oth: &BigNum) -> Option<Ordering> {
Some(self.cmp(oth.deref()))
}
}
impl Ord for Ref<BigNum> {
fn cmp(&self, oth: &Ref<BigNum>) -> Ordering {
impl Ord for BigNumRef {
fn cmp(&self, oth: &BigNumRef) -> Ordering {
unsafe { ffi::BN_cmp(self.as_ptr(), oth.as_ptr()).cmp(&0) }
}
}
@ -614,8 +614,8 @@ impl PartialOrd for BigNum {
}
}
impl PartialOrd<Ref<BigNum>> for BigNum {
fn partial_cmp(&self, oth: &Ref<BigNum>) -> Option<Ordering> {
impl PartialOrd<BigNumRef> for BigNum {
fn partial_cmp(&self, oth: &BigNumRef) -> Option<Ordering> {
self.deref().partial_cmp(oth)
}
}
@ -628,7 +628,7 @@ impl Ord for BigNum {
macro_rules! delegate {
($t:ident, $m:ident) => {
impl<'a, 'b> $t<&'b BigNum> for &'a Ref<BigNum> {
impl<'a, 'b> $t<&'b BigNum> for &'a BigNumRef {
type Output = BigNum;
fn $m(self, oth: &BigNum) -> BigNum {
@ -636,10 +636,10 @@ macro_rules! delegate {
}
}
impl<'a, 'b> $t<&'b Ref<BigNum>> for &'a BigNum {
impl<'a, 'b> $t<&'b BigNumRef> for &'a BigNum {
type Output = BigNum;
fn $m(self, oth: &Ref<BigNum>) -> BigNum {
fn $m(self, oth: &BigNumRef) -> BigNum {
$t::$m(self.deref(), oth)
}
}
@ -654,10 +654,10 @@ macro_rules! delegate {
}
}
impl<'a, 'b> Add<&'b Ref<BigNum>> for &'a Ref<BigNum> {
impl<'a, 'b> Add<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn add(self, oth: &Ref<BigNum>) -> BigNum {
fn add(self, oth: &BigNumRef) -> BigNum {
let mut r = BigNum::new().unwrap();
self.add(&mut r, oth).unwrap();
r
@ -666,10 +666,10 @@ impl<'a, 'b> Add<&'b Ref<BigNum>> for &'a Ref<BigNum> {
delegate!(Add, add);
impl<'a, 'b> Sub<&'b Ref<BigNum>> for &'a Ref<BigNum> {
impl<'a, 'b> Sub<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn sub(self, oth: &Ref<BigNum>) -> BigNum {
fn sub(self, oth: &BigNumRef) -> BigNum {
let mut r = BigNum::new().unwrap();
self.sub(&mut r, oth).unwrap();
r
@ -678,10 +678,10 @@ impl<'a, 'b> Sub<&'b Ref<BigNum>> for &'a Ref<BigNum> {
delegate!(Sub, sub);
impl<'a, 'b> Mul<&'b Ref<BigNum>> for &'a Ref<BigNum> {
impl<'a, 'b> Mul<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn mul(self, oth: &Ref<BigNum>) -> BigNum {
fn mul(self, oth: &BigNumRef) -> BigNum {
let mut ctx = BigNumContext::new().unwrap();
let mut r = BigNum::new().unwrap();
ctx.mul(&mut r, self, oth).unwrap();
@ -691,10 +691,10 @@ impl<'a, 'b> Mul<&'b Ref<BigNum>> for &'a Ref<BigNum> {
delegate!(Mul, mul);
impl<'a, 'b> Div<&'b Ref<BigNum>> for &'a Ref<BigNum> {
impl<'a, 'b> Div<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn div(self, oth: &'b Ref<BigNum>) -> BigNum {
fn div(self, oth: &'b BigNumRef) -> BigNum {
let mut ctx = BigNumContext::new().unwrap();
let mut dv = BigNum::new().unwrap();
ctx.div(Some(&mut dv), None, self, oth).unwrap();
@ -704,10 +704,10 @@ impl<'a, 'b> Div<&'b Ref<BigNum>> for &'a Ref<BigNum> {
delegate!(Div, div);
impl<'a, 'b> Rem<&'b Ref<BigNum>> for &'a Ref<BigNum> {
impl<'a, 'b> Rem<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn rem(self, oth: &'b Ref<BigNum>) -> BigNum {
fn rem(self, oth: &'b BigNumRef) -> BigNum {
let mut ctx = BigNumContext::new().unwrap();
let mut rem = BigNum::new().unwrap();
ctx.div(None, Some(&mut rem), self, oth).unwrap();
@ -717,7 +717,7 @@ impl<'a, 'b> Rem<&'b Ref<BigNum>> for &'a Ref<BigNum> {
delegate!(Rem, rem);
impl<'a> Shl<i32> for &'a Ref<BigNum> {
impl<'a> Shl<i32> for &'a BigNumRef {
type Output = BigNum;
fn shl(self, n: i32) -> BigNum {
@ -735,7 +735,7 @@ impl<'a> Shl<i32> for &'a BigNum {
}
}
impl<'a> Shr<i32> for &'a Ref<BigNum> {
impl<'a> Shr<i32> for &'a BigNumRef {
type Output = BigNum;
fn shr(self, n: i32) -> BigNum {
@ -753,7 +753,7 @@ impl<'a> Shr<i32> for &'a BigNum {
}
}
impl<'a> Neg for &'a Ref<BigNum> {
impl<'a> Neg for &'a BigNumRef {
type Output = BigNum;
fn neg(self) -> BigNum {

6
openssl/src/dh.rs
View File

@ -7,11 +7,11 @@ use std::mem;
use {cvt, cvt_p};
use bio::MemBio;
use bn::BigNum;
use types::{OpenSslType, Ref};
use types::OpenSslTypeRef;
type_!(Dh, ffi::DH, ffi::DH_free);
type_!(Dh, DhRef, ffi::DH, ffi::DH_free);
impl Ref<Dh> {
impl DhRef {
/// Encodes the parameters to PEM.
pub fn to_pem(&self) -> Result<Vec<u8>, ErrorStack> {
let mem_bio = try!(MemBio::new());

20
openssl/src/dsa.rs
View File

@ -5,14 +5,14 @@ use std::fmt;
use std::ptr;
use bio::{MemBio, MemBioSlice};
use bn::BigNum;
use bn::BigNumRef;
use {cvt, cvt_p};
use types::Ref;
use types::OpenSslTypeRef;
use util::{CallbackState, invoke_passwd_cb};
type_!(Dsa, ffi::DSA, ffi::DSA_free);
type_!(Dsa, DsaRef, ffi::DSA, ffi::DSA_free);
impl Ref<Dsa> {
impl DsaRef {
/// Writes an DSA private key as unencrypted PEM formatted data
pub fn private_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack> {
assert!(self.has_private_key());
@ -44,35 +44,35 @@ impl Ref<Dsa> {
}
}
pub fn p(&self) -> Option<&Ref<BigNum>> {
pub fn p(&self) -> Option<&BigNumRef> {
unsafe {
let p = compat::pqg(self.as_ptr())[0];
if p.is_null() {
None
} else {
Some(Ref::<BigNum>::from_ptr(p as *mut _))
Some(BigNumRef::from_ptr(p as *mut _))
}
}
}
pub fn q(&self) -> Option<&Ref<BigNum>> {
pub fn q(&self) -> Option<&BigNumRef> {
unsafe {
let q = compat::pqg(self.as_ptr())[1];
if q.is_null() {
None
} else {
Some(Ref::<BigNum>::from_ptr(q as *mut _))
Some(BigNumRef::from_ptr(q as *mut _))
}
}
}
pub fn g(&self) -> Option<&Ref<BigNum>> {
pub fn g(&self) -> Option<&BigNumRef> {
unsafe {
let g = compat::pqg(self.as_ptr())[2];
if g.is_null() {
None
} else {
Some(Ref::<BigNum>::from_ptr(g as *mut _))
Some(BigNumRef::from_ptr(g as *mut _))
}
}
}

2
openssl/src/ec_key.rs
View File

@ -4,7 +4,7 @@ use cvt_p;
use error::ErrorStack;
use nid::Nid;
type_!(EcKey, ffi::EC_KEY, ffi::EC_KEY_free);
type_!(EcKey, EcKeyRef, ffi::EC_KEY, ffi::EC_KEY_free);
impl EcKey {
pub fn new_by_curve_name(nid: Nid) -> Result<EcKey, ErrorStack> {

25
openssl/src/lib.rs
View File

@ -21,19 +21,16 @@ use libc::c_int;
use error::ErrorStack;
macro_rules! type_ {
($n:ident, $c:path, $d:path) => {
($n:ident, $r:ident, $c:path, $d:path) => {
pub struct $n(*mut $c);
unsafe impl ::types::OpenSslType for $n {
impl ::types::OpenSslType for $n {
type CType = $c;
type Ref = $r;
unsafe fn from_ptr(ptr: *mut $c) -> $n {
$n(ptr)
}
fn as_ptr(&self) -> *mut $c {
self.0
}
}
impl Drop for $n {
@ -43,18 +40,24 @@ macro_rules! type_ {
}
impl ::std::ops::Deref for $n {
type Target = ::types::Ref<$n>;
type Target = $r;
fn deref(&self) -> &::types::Ref<$n> {
unsafe { ::types::Ref::from_ptr(self.0) }
fn deref(&self) -> &$r {
unsafe { ::types::OpenSslTypeRef::from_ptr(self.0) }
}
}
impl ::std::ops::DerefMut for $n {
fn deref_mut(&mut self) -> &mut ::types::Ref<$n> {
unsafe { ::types::Ref::from_ptr_mut(self.0) }
fn deref_mut(&mut self) -> &mut $r {
unsafe { ::types::OpenSslTypeRef::from_ptr_mut(self.0) }
}
}
pub struct $r(::util::Opaque);
impl ::types::OpenSslTypeRef for $r {
type CType = $c;
}
}
}

12
openssl/src/pkey.rs
View File

@ -6,14 +6,14 @@ use ffi;
use {cvt, cvt_p};
use bio::{MemBio, MemBioSlice};
use dsa::Dsa;
use rsa::Rsa;
use rsa::{Rsa, RsaRef};
use error::ErrorStack;
use util::{CallbackState, invoke_passwd_cb};
use types::{OpenSslType, Ref};
use types::{OpenSslType, OpenSslTypeRef};
type_!(PKey, ffi::EVP_PKEY, ffi::EVP_PKEY_free);
type_!(PKey, PKeyRef, ffi::EVP_PKEY, ffi::EVP_PKEY_free);
impl Ref<PKey> {
impl PKeyRef {
/// Get a reference to the interal RSA key for direct access to the key components
pub fn rsa(&self) -> Result<Rsa, ErrorStack> {
unsafe {
@ -58,7 +58,7 @@ impl Ref<PKey> {
Ok(mem_bio.get_buf().to_owned())
}
pub fn public_eq(&self, other: &Ref<PKey>) -> bool {
pub fn public_eq(&self, other: &PKeyRef) -> bool {
unsafe { ffi::EVP_PKEY_cmp(self.as_ptr(), other.as_ptr()) == 1 }
}
}
@ -148,7 +148,7 @@ impl PKey {
}
/// Assign an RSA key to this pkey.
pub fn set_rsa(&mut self, rsa: &Ref<Rsa>) -> Result<(), ErrorStack> {
pub fn set_rsa(&mut self, rsa: &RsaRef) -> Result<(), ErrorStack> {
unsafe {
// this needs to be a reference as the set1_RSA ups the reference count
let rsa_ptr = rsa.as_ptr();

28
openssl/src/rsa.rs
View File

@ -5,11 +5,11 @@ use std::mem;
use libc::{c_int, c_void, c_char};
use {cvt, cvt_p, cvt_n};
use bn::BigNum;
use bn::{BigNum, BigNumRef};
use bio::{MemBio, MemBioSlice};
use error::ErrorStack;
use util::{CallbackState, invoke_passwd_cb};
use types::{OpenSslType, Ref};
use types::OpenSslTypeRef;
/// Type of encryption padding to use.
#[derive(Copy, Clone)]
@ -19,9 +19,9 @@ pub const NO_PADDING: Padding = Padding(ffi::RSA_NO_PADDING);
pub const PKCS1_PADDING: Padding = Padding(ffi::RSA_PKCS1_PADDING);
pub const PKCS1_OAEP_PADDING: Padding = Padding(ffi::RSA_PKCS1_OAEP_PADDING);
type_!(Rsa, ffi::RSA, ffi::RSA_free);
type_!(Rsa, RsaRef, ffi::RSA, ffi::RSA_free);
impl Ref<Rsa> {
impl RsaRef {
/// Writes an RSA private key as unencrypted PEM formatted data
pub fn private_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack> {
let mem_bio = try!(MemBio::new());
@ -153,57 +153,57 @@ impl Ref<Rsa> {
}
}
pub fn n(&self) -> Option<&Ref<BigNum>> {
pub fn n(&self) -> Option<&BigNumRef> {
unsafe {
let n = compat::key(self.as_ptr())[0];
if n.is_null() {
None
} else {
Some(Ref::<BigNum>::from_ptr(n as *mut _))
Some(BigNumRef::from_ptr(n as *mut _))
}
}
}
pub fn d(&self) -> Option<&Ref<BigNum>> {
pub fn d(&self) -> Option<&BigNumRef> {
unsafe {
let d = compat::key(self.as_ptr())[2];
if d.is_null() {
None
} else {
Some(Ref::<BigNum>::from_ptr(d as *mut _))
Some(BigNumRef::from_ptr(d as *mut _))
}
}
}
pub fn e(&self) -> Option<&Ref<BigNum>> {
pub fn e(&self) -> Option<&BigNumRef> {
unsafe {
let e = compat::key(self.as_ptr())[1];
if e.is_null() {
None
} else {
Some(Ref::<BigNum>::from_ptr(e as *mut _))
Some(BigNumRef::from_ptr(e as *mut _))
}
}
}
pub fn p(&self) -> Option<&Ref<BigNum>> {
pub fn p(&self) -> Option<&BigNumRef> {
unsafe {
let p = compat::factors(self.as_ptr())[0];
if p.is_null() {
None
} else {
Some(Ref::<BigNum>::from_ptr(p as *mut _))
Some(BigNumRef::from_ptr(p as *mut _))
}
}
}
pub fn q(&self) -> Option<&Ref<BigNum>> {
pub fn q(&self) -> Option<&BigNumRef> {
unsafe {
let q = compat::factors(self.as_ptr())[1];
if q.is_null() {
None
} else {
Some(Ref::<BigNum>::from_ptr(q as *mut _))
Some(BigNumRef::from_ptr(q as *mut _))
}
}
}

12
openssl/src/sign.rs
View File

@ -61,16 +61,16 @@ use std::ptr;
use {cvt, cvt_p};
use hash::MessageDigest;
use pkey::PKey;
use pkey::PKeyRef;
use error::ErrorStack;
use types::Ref;
use types::OpenSslTypeRef;
#[cfg(ossl110)]
use ffi::{EVP_MD_CTX_new, EVP_MD_CTX_free};
#[cfg(any(ossl101, ossl102))]
use ffi::{EVP_MD_CTX_create as EVP_MD_CTX_new, EVP_MD_CTX_destroy as EVP_MD_CTX_free};
pub struct Signer<'a>(*mut ffi::EVP_MD_CTX, PhantomData<&'a Ref<PKey>>);
pub struct Signer<'a>(*mut ffi::EVP_MD_CTX, PhantomData<&'a PKeyRef>);
impl<'a> Drop for Signer<'a> {
fn drop(&mut self) {
@ -81,7 +81,7 @@ impl<'a> Drop for Signer<'a> {
}
impl<'a> Signer<'a> {
pub fn new(type_: MessageDigest, pkey: &'a Ref<PKey>) -> Result<Signer<'a>, ErrorStack> {
pub fn new(type_: MessageDigest, pkey: &'a PKeyRef) -> Result<Signer<'a>, ErrorStack> {
unsafe {
ffi::init();
@ -129,7 +129,7 @@ impl<'a> Write for Signer<'a> {
}
}
pub struct Verifier<'a>(*mut ffi::EVP_MD_CTX, PhantomData<&'a Ref<PKey>>);
pub struct Verifier<'a>(*mut ffi::EVP_MD_CTX, PhantomData<&'a PKeyRef>);
impl<'a> Drop for Verifier<'a> {
fn drop(&mut self) {
@ -140,7 +140,7 @@ impl<'a> Drop for Verifier<'a> {
}
impl<'a> Verifier<'a> {
pub fn new(type_: MessageDigest, pkey: &'a Ref<PKey>) -> Result<Verifier<'a>, ErrorStack> {
pub fn new(type_: MessageDigest, pkey: &'a PKeyRef) -> Result<Verifier<'a>, ErrorStack> {
unsafe {
ffi::init();

33
openssl/src/ssl/connector.rs
View File

@ -4,9 +4,8 @@ use dh::Dh;
use error::ErrorStack;
use ssl::{self, SslMethod, SslContextBuilder, SslContext, Ssl, SSL_VERIFY_PEER, SslStream,
HandshakeError};
use pkey::PKey;
use x509::X509;
use types::Ref;
use pkey::PKeyRef;
use x509::X509Ref;
// Serialized form of DH_get_2048_256
#[cfg(any(ossl101, all(test, any(all(feature = "v102", ossl102), all(feature = "v110", ossl110)))))]
@ -118,12 +117,12 @@ impl SslAcceptorBuilder {
///
/// [docs]: https://wiki.mozilla.org/Security/Server_Side_TLS
pub fn mozilla_intermediate<I>(method: SslMethod,
private_key: &Ref<PKey>,
certificate: &Ref<X509>,
private_key: &PKeyRef,
certificate: &X509Ref,
chain: I)
-> Result<SslAcceptorBuilder, ErrorStack>
where I: IntoIterator,
I::Item: AsRef<Ref<X509>>
I::Item: AsRef<X509Ref>
{
let mut ctx = try!(ctx(method));
let dh = try!(get_dh());
@ -153,12 +152,12 @@ impl SslAcceptorBuilder {
///
/// [docs]: https://wiki.mozilla.org/Security/Server_Side_TLS
pub fn mozilla_modern<I>(method: SslMethod,
private_key: &Ref<PKey>,
certificate: &Ref<X509>,
private_key: &PKeyRef,
certificate: &X509Ref,
chain: I)
-> Result<SslAcceptorBuilder, ErrorStack>
where I: IntoIterator,
I::Item: AsRef<Ref<X509>>
I::Item: AsRef<X509Ref>
{
let mut ctx = try!(ctx(method));
try!(setup_curves(&mut ctx));
@ -171,12 +170,12 @@ impl SslAcceptorBuilder {
}
fn finish_setup<I>(mut ctx: SslContextBuilder,
private_key: &Ref<PKey>,
certificate: &Ref<X509>,
private_key: &PKeyRef,
certificate: &X509Ref,
chain: I)
-> Result<SslAcceptorBuilder, ErrorStack>
where I: IntoIterator,
I::Item: AsRef<Ref<X509>>
I::Item: AsRef<X509Ref>
{
try!(ctx.set_private_key(private_key));
try!(ctx.set_certificate(certificate));
@ -278,13 +277,13 @@ mod verify {
use std::str;
use nid;
use x509::{X509StoreContext, X509, X509Name, GeneralName};
use x509::{X509StoreContextRef, X509Ref, X509NameRef, GeneralName};
use stack::Stack;
use types::Ref;
use types::OpenSslTypeRef;
pub fn verify_callback(domain: &str,
preverify_ok: bool,
x509_ctx: &Ref<X509StoreContext>)
x509_ctx: &X509StoreContextRef)
-> bool {
if !preverify_ok || x509_ctx.error_depth() != 0 {
return preverify_ok;
@ -296,7 +295,7 @@ mod verify {
}
}
fn verify_hostname(domain: &str, cert: &Ref<X509>) -> bool {
fn verify_hostname(domain: &str, cert: &X509Ref) -> bool {
match cert.subject_alt_names() {
Some(names) => verify_subject_alt_names(domain, names),
None => verify_subject_name(domain, &cert.subject_name()),
@ -329,7 +328,7 @@ mod verify {
false
}
fn verify_subject_name(domain: &str, subject_name: &Ref<X509Name>) -> bool {
fn verify_subject_name(domain: &str, subject_name: &X509NameRef) -> bool {
if let Some(pattern) = subject_name.entries_by_nid(nid::COMMONNAME).next() {
let pattern = match str::from_utf8(pattern.data().as_slice()) {
Ok(pattern) => pattern,

82
openssl/src/ssl/mod.rs
View File

@ -90,14 +90,15 @@ use std::marker::PhantomData;
use ffi;
use {init, cvt, cvt_p};
use dh::Dh;
use ec_key::EcKey;
use x509::{X509StoreContext, X509FileType, X509, X509VerifyError};
use dh::DhRef;
use ec_key::EcKeyRef;
use x509::{X509StoreContextRef, X509FileType, X509, X509Ref, X509VerifyError};
#[cfg(any(ossl102, ossl110))]
use verify::X509VerifyParam;
use pkey::PKey;
use verify::X509VerifyParamRef;
use pkey::PKeyRef;
use error::ErrorStack;
use types::{OpenSslType, Ref};
use types::{OpenSslType, OpenSslTypeRef};
use util::Opaque;
mod error;
mod connector;
@ -262,7 +263,7 @@ fn get_new_ssl_idx<T>() -> c_int {
}
extern "C" fn raw_verify<F>(preverify_ok: c_int, x509_ctx: *mut ffi::X509_STORE_CTX) -> c_int
where F: Fn(bool, &Ref<X509StoreContext>) -> bool + Any + 'static + Sync + Send
where F: Fn(bool, &X509StoreContextRef) -> bool + Any + 'static + Sync + Send
{
unsafe {
let idx = ffi::SSL_get_ex_data_X509_STORE_CTX_idx();
@ -271,14 +272,14 @@ extern "C" fn raw_verify<F>(preverify_ok: c_int, x509_ctx: *mut ffi::X509_STORE_
let verify = ffi::SSL_CTX_get_ex_data(ssl_ctx, get_verify_data_idx::<F>());
let verify: &F = &*(verify as *mut F);
let ctx = Ref::from_ptr(x509_ctx);
let ctx = X509StoreContextRef::from_ptr(x509_ctx);
verify(preverify_ok != 0, ctx) as c_int
}
}
extern "C" fn ssl_raw_verify<F>(preverify_ok: c_int, x509_ctx: *mut ffi::X509_STORE_CTX) -> c_int
where F: Fn(bool, &Ref<X509StoreContext>) -> bool + Any + 'static + Sync + Send
where F: Fn(bool, &X509StoreContextRef) -> bool + Any + 'static + Sync + Send
{
unsafe {
let idx = ffi::SSL_get_ex_data_X509_STORE_CTX_idx();
@ -286,20 +287,20 @@ extern "C" fn ssl_raw_verify<F>(preverify_ok: c_int, x509_ctx: *mut ffi::X509_ST
let verify = ffi::SSL_get_ex_data(ssl as *const _, get_ssl_verify_data_idx::<F>());
let verify: &F = &*(verify as *mut F);
let ctx = Ref::from_ptr(x509_ctx);
let ctx = X509StoreContextRef::from_ptr(x509_ctx);
verify(preverify_ok != 0, ctx) as c_int
}
}
extern "C" fn raw_sni<F>(ssl: *mut ffi::SSL, al: *mut c_int, _arg: *mut c_void) -> c_int
where F: Fn(&mut Ref<Ssl>) -> Result<(), SniError> + Any + 'static + Sync + Send
where F: Fn(&mut SslRef) -> Result<(), SniError> + Any + 'static + Sync + Send
{
unsafe {
let ssl_ctx = ffi::SSL_get_SSL_CTX(ssl);
let callback = ffi::SSL_CTX_get_ex_data(ssl_ctx, get_verify_data_idx::<F>());
let callback: &F = &*(callback as *mut F);
let ssl = Ref::from_ptr_mut(ssl);
let ssl = SslRef::from_ptr_mut(ssl);
match callback(ssl) {
Ok(()) => ffi::SSL_TLSEXT_ERR_OK,
@ -463,7 +464,7 @@ impl SslContextBuilder {
/// Configures the certificate verification method for new connections and
/// registers a verification callback.
pub fn set_verify_callback<F>(&mut self, mode: SslVerifyMode, verify: F)
where F: Fn(bool, &Ref<X509StoreContext>) -> bool + Any + 'static + Sync + Send
where F: Fn(bool, &X509StoreContextRef) -> bool + Any + 'static + Sync + Send
{
unsafe {
let verify = Box::new(verify);
@ -479,7 +480,7 @@ impl SslContextBuilder {
/// Obtain the server name with `servername` then set the corresponding context
/// with `set_ssl_context`
pub fn set_servername_callback<F>(&mut self, callback: F)
where F: Fn(&mut Ref<Ssl>) -> Result<(), SniError> + Any + 'static + Sync + Send
where F: Fn(&mut SslRef) -> Result<(), SniError> + Any + 'static + Sync + Send
{
unsafe {
let callback = Box::new(callback);
@ -512,11 +513,11 @@ impl SslContextBuilder {
}
}
pub fn set_tmp_dh(&mut self, dh: &Ref<Dh>) -> Result<(), ErrorStack> {
pub fn set_tmp_dh(&mut self, dh: &DhRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::SSL_CTX_set_tmp_dh(self.as_ptr(), dh.as_ptr()) as c_int).map(|_| ()) }
}
pub fn set_tmp_ecdh(&mut self, key: &Ref<EcKey>) -> Result<(), ErrorStack> {
pub fn set_tmp_ecdh(&mut self, key: &EcKeyRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::SSL_CTX_set_tmp_ecdh(self.as_ptr(), key.as_ptr()) as c_int).map(|_| ()) }
}
@ -584,7 +585,7 @@ impl SslContextBuilder {
}
/// Specifies the certificate
pub fn set_certificate(&mut self, cert: &Ref<X509>) -> Result<(), ErrorStack> {
pub fn set_certificate(&mut self, cert: &X509Ref) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::SSL_CTX_use_certificate(self.as_ptr(), cert.as_ptr())).map(|_| ()) }
}
@ -613,7 +614,7 @@ impl SslContextBuilder {
}
/// Specifies the private key
pub fn set_private_key(&mut self, key: &Ref<PKey>) -> Result<(), ErrorStack> {
pub fn set_private_key(&mut self, key: &PKeyRef) -> Result<(), ErrorStack> {
unsafe { cvt(ffi::SSL_CTX_use_PrivateKey(self.as_ptr(), key.as_ptr())).map(|_| ()) }
}
@ -733,7 +734,7 @@ impl SslContextBuilder {
}
}
type_!(SslContext, ffi::SSL_CTX, ffi::SSL_CTX_free);
type_!(SslContext, SslContextRef, ffi::SSL_CTX, ffi::SSL_CTX_free);
unsafe impl Send for SslContext {}
unsafe impl Sync for SslContext {}
@ -771,19 +772,22 @@ pub struct CipherBits {
pub struct SslCipher(*mut ffi::SSL_CIPHER);
unsafe impl OpenSslType for SslCipher {
impl OpenSslType for SslCipher {
type CType = ffi::SSL_CIPHER;
type Ref = SslCipherRef;
unsafe fn from_ptr(ptr: *mut ffi::SSL_CIPHER) -> SslCipher {
SslCipher(ptr)
}
fn as_ptr(&self) -> *mut ffi::SSL_CIPHER {
self.0
}
}
impl Ref<SslCipher> {
pub struct SslCipherRef(Opaque);
impl OpenSslTypeRef for SslCipherRef {
type CType = ffi::SSL_CIPHER;
}
impl SslCipherRef {
/// Returns the name of cipher.
pub fn name(&self) -> &'static str {
let name = unsafe {
@ -827,9 +831,9 @@ impl Ref<SslCipher> {
}
}
type_!(Ssl, ffi::SSL, ffi::SSL_free);
type_!(Ssl, SslRef, ffi::SSL, ffi::SSL_free);
impl fmt::Debug for Ref<Ssl> {
impl fmt::Debug for SslRef {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let mut builder = fmt.debug_struct("Ssl");
builder.field("state", &self.state_string_long());
@ -840,7 +844,7 @@ impl fmt::Debug for Ref<Ssl> {
}
}
impl Ref<Ssl> {
impl SslRef {
fn get_raw_rbio(&self) -> *mut ffi::BIO {
unsafe { ffi::SSL_get_rbio(self.as_ptr()) }
}
@ -874,7 +878,7 @@ impl Ref<Ssl> {
/// to the certificate chain. It should return `true` if the certificate
/// chain is valid and `false` otherwise.
pub fn set_verify_callback<F>(&mut self, mode: SslVerifyMode, verify: F)
where F: Fn(bool, &Ref<X509StoreContext>) -> bool + Any + 'static + Sync + Send
where F: Fn(bool, &X509StoreContextRef) -> bool + Any + 'static + Sync + Send
{
unsafe {
let verify = Box::new(verify);
@ -885,14 +889,14 @@ impl Ref<Ssl> {
}
}
pub fn current_cipher(&self) -> Option<&Ref<SslCipher>> {
pub fn current_cipher(&self) -> Option<&SslCipherRef> {
unsafe {
let ptr = ffi::SSL_get_current_cipher(self.as_ptr());
if ptr.is_null() {
None
} else {
Some(Ref::from_ptr(ptr as *mut _))
Some(SslCipherRef::from_ptr(ptr as *mut _))
}
}
}
@ -1033,15 +1037,15 @@ impl Ref<Ssl> {
}
/// Changes the context corresponding to the current connection.
pub fn set_ssl_context(&mut self, ctx: &Ref<SslContext>) -> Result<(), ErrorStack> {
pub fn set_ssl_context(&mut self, ctx: &SslContextRef) -> Result<(), ErrorStack> {
unsafe { cvt_p(ffi::SSL_set_SSL_CTX(self.as_ptr(), ctx.as_ptr())).map(|_| ()) }
}
/// Returns the context corresponding to the current connection
pub fn ssl_context(&self) -> &Ref<SslContext> {
pub fn ssl_context(&self) -> &SslContextRef {
unsafe {
let ssl_ctx = ffi::SSL_get_SSL_CTX(self.as_ptr());
Ref::from_ptr(ssl_ctx)
SslContextRef::from_ptr(ssl_ctx)
}
}
@ -1049,13 +1053,13 @@ impl Ref<Ssl> {
///
/// Requires the `v102` or `v110` features and OpenSSL 1.0.2 or 1.1.0.
#[cfg(any(all(feature = "v102", ossl102), all(feature = "v110", ossl110)))]
pub fn param_mut(&mut self) -> &mut Ref<X509VerifyParam> {
pub fn param_mut(&mut self) -> &mut X509VerifyParamRef {
self._param_mut()
}
#[cfg(any(ossl102, ossl110))]
fn _param_mut(&mut self) -> &mut Ref<X509VerifyParam> {
unsafe { Ref::from_ptr_mut(ffi::SSL_get0_param(self.as_ptr())) }
fn _param_mut(&mut self) -> &mut X509VerifyParamRef {
unsafe { X509VerifyParamRef::from_ptr_mut(ffi::SSL_get0_param(self.as_ptr())) }
}
/// Returns the result of X509 certificate verification.
@ -1165,7 +1169,7 @@ impl<S> MidHandshakeSslStream<S> {
}
/// Returns a shared reference to the `Ssl` of the stream.
pub fn ssl(&self) -> &Ref<Ssl> {
pub fn ssl(&self) -> &SslRef {
self.stream.ssl()
}
@ -1347,7 +1351,7 @@ impl<S> SslStream<S> {
}
/// Returns the OpenSSL `Ssl` object associated with this stream.
pub fn ssl(&self) -> &Ref<Ssl> {
pub fn ssl(&self) -> &SslRef {
&self.ssl
}
}

2
openssl/src/ssl/tests/mod.rs
View File

@ -171,7 +171,7 @@ macro_rules! run_test(
use hash::MessageDigest;
use x509::X509StoreContext;
use serialize::hex::FromHex;
use types::Ref;
use types::OpenSslTypeRef;
use super::Server;
#[test]

82
openssl/src/stack.rs
View File

@ -2,10 +2,12 @@ use std::ops::{Deref, DerefMut, Index, IndexMut};
use std::iter;
use std::borrow::Borrow;
use std::convert::AsRef;
use std::marker::PhantomData;
use libc::c_int;
use ffi;
use types::{OpenSslType, Ref};
use types::{OpenSslType, OpenSslTypeRef};
use util::Opaque;
#[cfg(ossl10x)]
use ffi::{sk_pop as OPENSSL_sk_pop,sk_free as OPENSSL_sk_free, sk_num as OPENSSL_sk_num,
@ -55,45 +57,49 @@ impl<T: Stackable> Drop for Stack<T> {
}
}
impl<T: Stackable> AsRef<Ref<Stack<T>>> for Stack<T> {
fn as_ref(&self) -> &Ref<Stack<T>> {
impl<T: Stackable> AsRef<StackRef<T>> for Stack<T> {
fn as_ref(&self) -> &StackRef<T> {
&*self
}
}
impl<T: Stackable> Borrow<Ref<Stack<T>>> for Stack<T> {
fn borrow(&self) -> &Ref<Stack<T>> {
impl<T: Stackable> Borrow<StackRef<T>> for Stack<T> {
fn borrow(&self) -> &StackRef<T> {
&*self
}
}
unsafe impl<T: Stackable> OpenSslType for Stack<T> {
impl<T: Stackable> OpenSslType for Stack<T> {
type CType = T::StackType;
type Ref = StackRef<T>;
unsafe fn from_ptr(ptr: *mut T::StackType) -> Stack<T> {
Stack(ptr)
}
fn as_ptr(&self) -> *mut T::StackType {
self.0
}
}
impl<T: Stackable> Deref for Stack<T> {
type Target = Ref<Stack<T>>;
type Target = StackRef<T>;
fn deref(&self) -> &Ref<Stack<T>> {
unsafe { Ref::from_ptr(self.0) }
fn deref(&self) -> &StackRef<T> {
unsafe { StackRef::from_ptr(self.0) }
}
}
impl<T: Stackable> DerefMut for Stack<T> {
fn deref_mut(&mut self) -> &mut ::types::Ref<Stack<T>> {
unsafe { Ref::from_ptr_mut(self.0) }
fn deref_mut(&mut self) -> &mut StackRef<T> {
unsafe { StackRef::from_ptr_mut(self.0) }
}
}
impl<T: Stackable> Ref<Stack<T>> {
pub struct StackRef<T: Stackable>(Opaque, PhantomData<T>);
impl<T: Stackable> OpenSslTypeRef for StackRef<T> {
type CType = T::StackType;
}
impl<T: Stackable> StackRef<T> {
/// OpenSSL stack types are just a (kinda) typesafe wrapper around
/// a `_STACK` object. We can therefore safely cast it and access
/// the `_STACK` members without having to worry about the real
@ -141,25 +147,25 @@ impl<T: Stackable> Ref<Stack<T>> {
/// Returns a reference to the element at the given index in the
/// stack or `None` if the index is out of bounds
pub fn get(&self, idx: usize) -> Option<&Ref<T>> {
pub fn get(&self, idx: usize) -> Option<&T::Ref> {
unsafe {
if idx >= self.len() {
return None;
}
Some(Ref::from_ptr(self._get(idx)))
Some(T::Ref::from_ptr(self._get(idx)))
}
}
/// Returns a mutable reference to the element at the given index in the
/// stack or `None` if the index is out of bounds
pub fn get_mut(&mut self, idx: usize) -> Option<&mut Ref<T>> {
pub fn get_mut(&mut self, idx: usize) -> Option<&mut T::Ref> {
unsafe {
if idx >= self.len() {
return None;
}
Some(Ref::from_ptr_mut(self._get(idx)))
Some(T::Ref::from_ptr_mut(self._get(idx)))
}
}
@ -168,22 +174,22 @@ impl<T: Stackable> Ref<Stack<T>> {
}
}
impl<T: Stackable> Index<usize> for Ref<Stack<T>> {
type Output = Ref<T>;
impl<T: Stackable> Index<usize> for StackRef<T> {
type Output = T::Ref;
fn index(&self, index: usize) -> &Ref<T> {
fn index(&self, index: usize) -> &T::Ref {
self.get(index).unwrap()
}
}
impl<T: Stackable> IndexMut<usize> for Ref<Stack<T>> {
fn index_mut(&mut self, index: usize) -> &mut Ref<T> {
impl<T: Stackable> IndexMut<usize> for StackRef<T> {
fn index_mut(&mut self, index: usize) -> &mut T::Ref {
self.get_mut(index).unwrap()
}
}
impl<'a, T: Stackable> iter::IntoIterator for &'a Ref<Stack<T>> {
type Item = &'a Ref<T>;
impl<'a, T: Stackable> iter::IntoIterator for &'a StackRef<T> {
type Item = &'a T::Ref;
type IntoIter = Iter<'a, T>;
fn into_iter(self) -> Iter<'a, T> {
@ -191,8 +197,8 @@ impl<'a, T: Stackable> iter::IntoIterator for &'a Ref<Stack<T>> {
}
}
impl<'a, T: Stackable> iter::IntoIterator for &'a mut Ref<Stack<T>> {
type Item = &'a mut Ref<T>;
impl<'a, T: Stackable> iter::IntoIterator for &'a mut StackRef<T> {
type Item = &'a mut T::Ref;
type IntoIter = IterMut<'a, T>;
fn into_iter(self) -> IterMut<'a, T> {
@ -201,7 +207,7 @@ impl<'a, T: Stackable> iter::IntoIterator for &'a mut Ref<Stack<T>> {
}
impl<'a, T: Stackable> iter::IntoIterator for &'a Stack<T> {
type Item = &'a Ref<T>;
type Item = &'a T::Ref;
type IntoIter = Iter<'a, T>;
fn into_iter(self) -> Iter<'a, T> {
@ -210,7 +216,7 @@ impl<'a, T: Stackable> iter::IntoIterator for &'a Stack<T> {
}
impl<'a, T: Stackable> iter::IntoIterator for &'a mut Stack<T> {
type Item = &'a mut Ref<T>;
type Item = &'a mut T::Ref;
type IntoIter = IterMut<'a, T>;
fn into_iter(self) -> IterMut<'a, T> {
@ -221,14 +227,14 @@ impl<'a, T: Stackable> iter::IntoIterator for &'a mut Stack<T> {
/// An iterator over the stack's contents.
pub struct Iter<'a, T: Stackable>
where T: 'a {
stack: &'a Ref<Stack<T>>,
stack: &'a StackRef<T>,
pos: usize,
}
impl<'a, T: Stackable> iter::Iterator for Iter<'a, T> {
type Item = &'a Ref<T>;
type Item = &'a T::Ref;
fn next(&mut self) -> Option<&'a Ref<T>> {
fn next(&mut self) -> Option<&'a T::Ref> {
let n = self.stack.get(self.pos);
if n.is_some() {
@ -250,14 +256,14 @@ impl<'a, T: Stackable> iter::ExactSizeIterator for Iter<'a, T> {
/// A mutable iterator over the stack's contents.
pub struct IterMut<'a, T: Stackable + 'a> {
stack: &'a mut Ref<Stack<T>>,
stack: &'a mut StackRef<T>,
pos: usize,
}
impl<'a, T: Stackable> iter::Iterator for IterMut<'a, T> {
type Item = &'a mut Ref<T>;
type Item = &'a mut T::Ref;
fn next(&mut self) -> Option<&'a mut Ref<T>> {
fn next(&mut self) -> Option<&'a mut T::Ref> {
if self.pos >= self.stack.len() {
None
} else {
@ -267,7 +273,7 @@ impl<'a, T: Stackable> iter::Iterator for IterMut<'a, T> {
// the same object, so we have to use unsafe code for
// mutable iterators.
let n = unsafe {
Some(Ref::from_ptr_mut(self.stack._get(self.pos)))
Some(T::Ref::from_ptr_mut(self.stack._get(self.pos)))
};
self.pos += 1;

33
openssl/src/types.rs
View File

@ -1,39 +1,40 @@
//! Items used by other types.
use std::cell::UnsafeCell;
use std::marker::PhantomData;
/// A type implemented by wrappers over OpenSSL types.
///
/// This should not be implemented by anything outside of this crate; new methods may be added at
/// any time.
pub unsafe trait OpenSslType {
pub trait OpenSslType: Sized {
/// The raw C type.
type CType;
/// The type representing a reference to this type.
type Ref: OpenSslTypeRef<CType = Self::CType>;
/// Constructs an instance of this type from its raw type.
unsafe fn from_ptr(ptr: *mut Self::CType) -> Self;
/// Returns a pointer to its raw type.
fn as_ptr(&self) -> *mut Self::CType;
}
/// A reference to an OpenSSL type.
pub struct Ref<T>(UnsafeCell<()>, PhantomData<T>);
/// A trait implemented by types which reference borrowed OpenSSL types.
///
/// This should not be implemented by anything outside of this crate; new methods may be added at
/// any time.
pub trait OpenSslTypeRef: Sized {
/// The raw C type.
type CType;
impl<T: OpenSslType> Ref<T> {
/// Constructs a shared reference to this type from its raw type.
pub unsafe fn from_ptr<'a>(ptr: *mut T::CType) -> &'a Ref<T> {
/// Constructs a shared instance of this type from its raw type.
unsafe fn from_ptr<'a>(ptr: *mut Self::CType) -> &'a Self {
&*(ptr as *mut _)
}
/// Constructs a mutable reference to this type from its raw type.
pub unsafe fn from_ptr_mut<'a>(ptr: *mut T::CType) -> &'a mut Ref<T> {
/// Constructs a mutable reference of this type from its raw type.
unsafe fn from_ptr_mut<'a>(ptr: *mut Self::CType) -> &'a mut Self {
&mut *(ptr as *mut _)
}
/// Returns a pointer to its raw type.
pub fn as_ptr(&self) -> *mut T::CType {
/// Returns a raw pointer to the wrapped value.
fn as_ptr(&self) -> *mut Self::CType {
self as *const _ as *mut _
}
}

7
openssl/src/util.rs
View File

@ -1,6 +1,6 @@
use libc::{c_int, c_char, c_void};
use std::any::Any;
use std::cell::UnsafeCell;
use std::panic::{self, AssertUnwindSafe};
use std::slice;
@ -60,3 +60,8 @@ pub unsafe extern "C" fn invoke_passwd_cb<F>(buf: *mut c_char,
}
}
}
/// This is intended to be used as the inner type for `FooRef` types converted from raw C pointers.
/// It has an `UnsafeCell` internally to inform the compiler about aliasability and doesn't
/// implement `Copy`, so it can't be dereferenced.
pub struct Opaque(UnsafeCell<()>);

6
openssl/src/verify.rs
View File

@ -3,7 +3,7 @@ use ffi;
use cvt;
use error::ErrorStack;
use types::Ref;
use types::OpenSslTypeRef;
bitflags! {
pub flags X509CheckFlags: c_uint {
@ -19,9 +19,9 @@ bitflags! {
}
}
type_!(X509VerifyParam, ffi::X509_VERIFY_PARAM, ffi::X509_VERIFY_PARAM_free);
type_!(X509VerifyParam, X509VerifyParamRef, ffi::X509_VERIFY_PARAM, ffi::X509_VERIFY_PARAM_free);
impl Ref<X509VerifyParam> {
impl X509VerifyParamRef {
pub fn set_hostflags(&mut self, hostflags: X509CheckFlags) {
unsafe {
ffi::X509_VERIFY_PARAM_set_hostflags(self.as_ptr(), hostflags.bits);

78
openssl/src/x509/mod.rs
View File

@ -11,16 +11,16 @@ use std::slice;
use std::str;
use {cvt, cvt_p};
use asn1::{Asn1String, Asn1Time};
use asn1::{Asn1StringRef, Asn1Time, Asn1TimeRef};
use bio::{MemBio, MemBioSlice};
use hash::MessageDigest;
use pkey::PKey;
use pkey::{PKey, PKeyRef};
use rand::rand_bytes;
use error::ErrorStack;
use ffi;
use nid::Nid;
use types::{OpenSslType, Ref};
use stack::{Stack, Stackable};
use types::{OpenSslType, OpenSslTypeRef};
use stack::{Stack, StackRef, Stackable};
#[cfg(ossl10x)]
use ffi::{X509_set_notBefore, X509_set_notAfter, ASN1_STRING_data, X509_STORE_CTX_get_chain};
@ -51,20 +51,20 @@ pub const X509_FILETYPE_PEM: X509FileType = X509FileType(ffi::X509_FILETYPE_PEM)
pub const X509_FILETYPE_ASN1: X509FileType = X509FileType(ffi::X509_FILETYPE_ASN1);
pub const X509_FILETYPE_DEFAULT: X509FileType = X509FileType(ffi::X509_FILETYPE_DEFAULT);
type_!(X509StoreContext, ffi::X509_STORE_CTX, ffi::X509_STORE_CTX_free);
type_!(X509StoreContext, X509StoreContextRef, ffi::X509_STORE_CTX, ffi::X509_STORE_CTX_free);
impl Ref<X509StoreContext> {
impl X509StoreContextRef {
pub fn error(&self) -> Option<X509VerifyError> {
unsafe { X509VerifyError::from_raw(ffi::X509_STORE_CTX_get_error(self.as_ptr()) as c_long) }
}
pub fn current_cert(&self) -> Option<&Ref<X509>> {
pub fn current_cert(&self) -> Option<&X509Ref> {
unsafe {
let ptr = ffi::X509_STORE_CTX_get_current_cert(self.as_ptr());
if ptr.is_null() {
None
} else {
Some(Ref::from_ptr(ptr))
Some(X509Ref::from_ptr(ptr))
}
}
}
@ -73,7 +73,7 @@ impl Ref<X509StoreContext> {
unsafe { ffi::X509_STORE_CTX_get_error_depth(self.as_ptr()) as u32 }
}
pub fn chain(&self) -> Option<&Ref<Stack<X509>>> {
pub fn chain(&self) -> Option<&StackRef<X509>> {
unsafe {
let chain = X509_STORE_CTX_get_chain(self.as_ptr());
@ -81,7 +81,7 @@ impl Ref<X509StoreContext> {
return None;
}
Some(Ref::from_ptr(chain))
Some(StackRef::from_ptr(chain))
}
}
}
@ -275,7 +275,7 @@ impl X509Generator {
}
/// Sets the certificate public-key, then self-sign and return it
pub fn sign(&self, p_key: &Ref<PKey>) -> Result<X509, ErrorStack> {
pub fn sign(&self, p_key: &PKeyRef) -> Result<X509, ErrorStack> {
ffi::init();
unsafe {
@ -327,7 +327,7 @@ impl X509Generator {
}
/// Obtain a certificate signing request (CSR)
pub fn request(&self, p_key: &Ref<PKey>) -> Result<X509Req, ErrorStack> {
pub fn request(&self, p_key: &PKeyRef) -> Result<X509Req, ErrorStack> {
let cert = match self.sign(p_key) {
Ok(c) => c,
Err(x) => return Err(x),
@ -352,13 +352,13 @@ impl X509Generator {
}
}
type_!(X509, ffi::X509, ffi::X509_free);
type_!(X509, X509Ref, ffi::X509, ffi::X509_free);
impl Ref<X509> {
pub fn subject_name(&self) -> &Ref<X509Name> {
impl X509Ref {
pub fn subject_name(&self) -> &X509NameRef {
unsafe {
let name = ffi::X509_get_subject_name(self.as_ptr());
Ref::from_ptr(name)
X509NameRef::from_ptr(name)
}
}
@ -397,20 +397,20 @@ impl Ref<X509> {
}
/// Returns certificate Not After validity period.
pub fn not_after<'a>(&'a self) -> &'a Ref<Asn1Time> {
pub fn not_after<'a>(&'a self) -> &'a Asn1TimeRef {
unsafe {
let date = compat::X509_get_notAfter(self.as_ptr());
assert!(!date.is_null());
Ref::from_ptr(date)
Asn1TimeRef::from_ptr(date)
}
}
/// Returns certificate Not Before validity period.
pub fn not_before<'a>(&'a self) -> &'a Ref<Asn1Time> {
pub fn not_before<'a>(&'a self) -> &'a Asn1TimeRef {
unsafe {
let date = compat::X509_get_notBefore(self.as_ptr());
assert!(!date.is_null());
Ref::from_ptr(date)
Asn1TimeRef::from_ptr(date)
}
}
@ -433,7 +433,7 @@ impl Ref<X509> {
}
}
impl ToOwned for Ref<X509> {
impl ToOwned for X509Ref {
type Owned = X509;
fn to_owned(&self) -> X509 {
@ -474,14 +474,14 @@ impl Clone for X509 {
}
}
impl AsRef<Ref<X509>> for X509 {
fn as_ref(&self) -> &Ref<X509> {
impl AsRef<X509Ref> for X509 {
fn as_ref(&self) -> &X509Ref {
&*self
}
}
impl Borrow<Ref<X509>> for X509 {
fn borrow(&self) -> &Ref<X509> {
impl Borrow<X509Ref> for X509 {
fn borrow(&self) -> &X509Ref {
&*self
}
}
@ -490,9 +490,9 @@ impl Stackable for X509 {
type StackType = ffi::stack_st_X509;
}
type_!(X509Name, ffi::X509_NAME, ffi::X509_NAME_free);
type_!(X509Name, X509NameRef, ffi::X509_NAME, ffi::X509_NAME_free);
impl Ref<X509Name> {
impl X509NameRef {
pub fn entries_by_nid<'a>(&'a self, nid: Nid) -> X509NameEntries<'a> {
X509NameEntries {
name: self,
@ -503,15 +503,15 @@ impl Ref<X509Name> {
}
pub struct X509NameEntries<'a> {
name: &'a Ref<X509Name>,
name: &'a X509NameRef,
nid: Nid,
loc: c_int,
}
impl<'a> Iterator for X509NameEntries<'a> {
type Item = &'a Ref<X509NameEntry>;
type Item = &'a X509NameEntryRef;
fn next(&mut self) -> Option<&'a Ref<X509NameEntry>> {
fn next(&mut self) -> Option<&'a X509NameEntryRef> {
unsafe {
self.loc = ffi::X509_NAME_get_index_by_NID(self.name.as_ptr(),
self.nid.as_raw(),
@ -524,25 +524,25 @@ impl<'a> Iterator for X509NameEntries<'a> {
let entry = ffi::X509_NAME_get_entry(self.name.as_ptr(), self.loc);
assert!(!entry.is_null());
Some(Ref::from_ptr(entry))
Some(X509NameEntryRef::from_ptr(entry))
}
}
}
type_!(X509NameEntry, ffi::X509_NAME_ENTRY, ffi::X509_NAME_ENTRY_free);
type_!(X509NameEntry, X509NameEntryRef, ffi::X509_NAME_ENTRY, ffi::X509_NAME_ENTRY_free);
impl Ref<X509NameEntry> {
pub fn data(&self) -> &Ref<Asn1String> {
impl X509NameEntryRef {
pub fn data(&self) -> &Asn1StringRef {
unsafe {
let data = ffi::X509_NAME_ENTRY_get_data(self.as_ptr());
Ref::from_ptr(data)
Asn1StringRef::from_ptr(data)
}
}
}
type_!(X509Req, ffi::X509_REQ, ffi::X509_REQ_free);
type_!(X509Req, X509ReqRef, ffi::X509_REQ, ffi::X509_REQ_free);
impl Ref<X509Req> {
impl X509ReqRef {
/// Writes CSR as PEM
pub fn to_pem(&self) -> Result<Vec<u8>, ErrorStack> {
let mem_bio = try!(MemBio::new());
@ -699,9 +699,9 @@ impl X509VerifyError {
}
}
type_!(GeneralName, ffi::GENERAL_NAME, ffi::GENERAL_NAME_free);
type_!(GeneralName, GeneralNameRef, ffi::GENERAL_NAME, ffi::GENERAL_NAME_free);
impl Ref<GeneralName> {
impl GeneralNameRef {
/// Returns the contents of this `GeneralName` if it is a `dNSName`.
pub fn dnsname(&self) -> Option<&str> {
unsafe {