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

Merge pull request #486 from sfackler/ref-overhaul 

Use actual references for Ref types
This commit is contained in:
Steven Fackler 2016-10-21 20:50:56 -07:00 committed by GitHub
parent cc65318cc4 6f1a3f2834
commit 7267cbeae8
10 changed files with 272 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
openssl/src/asn1.rs
View File

@ -1,20 +1,48 @@
use libc::c_long;
use std::{ptr, fmt};
use std::marker::PhantomData;
use std::ops::Deref;
use ffi;
use opaque::Opaque;
use {cvt, cvt_p};
use bio::MemBio;
use error::ErrorStack;
/// A borrowed Asn1Time
pub struct Asn1TimeRef(Opaque);
impl Asn1TimeRef {
/// Creates a new `Asn1TimeRef` wrapping the provided handle.
pub unsafe fn from_ptr<'a>(handle: *mut ffi::ASN1_TIME) -> &'a Asn1TimeRef {
&*(handle as *mut _)
}
/// Returns the raw handle
pub fn as_ptr(&self) -> *mut ffi::ASN1_TIME {
self as *const _ as *mut _
}
}
impl fmt::Display for Asn1TimeRef {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mem_bio = try!(MemBio::new());
let as_str = unsafe {
try!(cvt(ffi::ASN1_TIME_print(mem_bio.as_ptr(), self.as_ptr())));
String::from_utf8_unchecked(mem_bio.get_buf().to_owned())
};
write!(f, "{}", as_str)
}
}
/// Corresponds to the ASN.1 structure Time defined in RFC5280
pub struct Asn1Time(Asn1TimeRef<'static>);
pub struct Asn1Time(*mut ffi::ASN1_TIME);
impl Asn1Time {
/// Wraps existing ASN1_TIME and takes ownership
pub unsafe fn from_ptr(handle: *mut ffi::ASN1_TIME) -> Asn1Time {
Asn1Time(Asn1TimeRef::from_ptr(handle))
Asn1Time(handle)
}
fn from_period(period: c_long) -> Result<Asn1Time, ErrorStack> {
@ -33,36 +61,12 @@ impl Asn1Time {
}
impl Deref for Asn1Time {
type Target = Asn1TimeRef<'static>;
type Target = Asn1TimeRef;
fn deref(&self) -> &Asn1TimeRef<'static> {
&self.0
}
}
/// A borrowed Asn1Time
pub struct Asn1TimeRef<'a>(*mut ffi::ASN1_TIME, PhantomData<&'a ()>);
impl<'a> Asn1TimeRef<'a> {
/// Creates a new `Asn1TimeRef` wrapping the provided handle.
pub unsafe fn from_ptr(handle: *mut ffi::ASN1_TIME) -> Asn1TimeRef<'a> {
Asn1TimeRef(handle, PhantomData)
}
/// Returns the raw handle
pub fn as_ptr(&self) -> *mut ffi::ASN1_TIME {
self.0
}
}
impl<'a> fmt::Display for Asn1TimeRef<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mem_bio = try!(MemBio::new());
let as_str = unsafe {
try!(cvt(ffi::ASN1_TIME_print(mem_bio.as_ptr(), self.0)));
String::from_utf8_unchecked(mem_bio.get_buf().to_owned())
};
write!(f, "{}", as_str)
fn deref(&self) -> &Asn1TimeRef {
unsafe {
Asn1TimeRef::from_ptr(self.0)
}
}
}

174
openssl/src/bn.rs
View File

@ -3,11 +3,11 @@ use libc::{c_int, c_void};
use std::cmp::Ordering;
use std::ffi::{CStr, CString};
use std::{fmt, ptr};
use std::marker::PhantomData;
use std::ops::{Add, Div, Mul, Neg, Rem, Shl, Shr, Sub, Deref, DerefMut};
use {cvt, cvt_p, cvt_n};
use error::ErrorStack;
use opaque::Opaque;
/// Specifies the desired properties of a randomly generated `BigNum`.
#[derive(Copy, Clone)]
@ -41,6 +41,10 @@ impl BnCtx {
}
}
pub fn as_ptr(&self) -> *mut ffi::BN_CTX {
self.0
}
/// Places the result of `a * b` in `r`.
pub fn mul(&mut self,
r: &mut BigNumRef,
@ -48,7 +52,7 @@ impl BnCtx {
b: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_mul(r.0, a.0, b.0, self.0)).map(|_| ())
cvt(ffi::BN_mul(r.as_ptr(), a.as_ptr(), b.as_ptr(), self.as_ptr())).map(|_| ())
}
}
@ -60,11 +64,11 @@ impl BnCtx {
b: &BigNumRef)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_div(dv.map(|b| b.0).unwrap_or(ptr::null_mut()),
rem.map(|b| b.0).unwrap_or(ptr::null_mut()),
a.0,
b.0,
self.0))
cvt(ffi::BN_div(dv.map(|b| b.as_ptr()).unwrap_or(ptr::null_mut()),
rem.map(|b| b.as_ptr()).unwrap_or(ptr::null_mut()),
a.as_ptr(),
b.as_ptr(),
self.as_ptr()))
.map(|_| ())
}
}
@ -72,7 +76,7 @@ impl BnCtx {
/// Places the result of `a²` in `r`.
pub fn sqr(&mut self, r: &mut BigNumRef, a: &BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_sqr(r.as_ptr(), a.as_ptr(), self.0)).map(|_| ())
cvt(ffi::BN_sqr(r.as_ptr(), a.as_ptr(), self.as_ptr())).map(|_| ())
}
}
@ -159,7 +163,7 @@ impl BnCtx {
a: &BigNumRef,
n: &BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt_p(ffi::BN_mod_inverse(r.0, a.0, n.0, self.0)).map(|_| ())
cvt_p(ffi::BN_mod_inverse(r.as_ptr(), a.as_ptr(), n.as_ptr(), self.as_ptr())).map(|_| ())
}
}
@ -169,7 +173,7 @@ impl BnCtx {
a: &BigNumRef,
b: &BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_gcd(r.0, a.0, b.0, self.0)).map(|_| ())
cvt(ffi::BN_gcd(r.as_ptr(), a.as_ptr(), b.as_ptr(), self.as_ptr())).map(|_| ())
}
}
@ -180,7 +184,7 @@ impl BnCtx {
/// Returns `true` if `p` is prime with an error probability of less than `0.25 ^ checks`.
pub fn is_prime(&mut self, p: &BigNumRef, checks: i32) -> Result<bool, ErrorStack> {
unsafe {
cvt_n(ffi::BN_is_prime_ex(p.0, checks.into(), self.0, ptr::null_mut())).map(|r| r != 0)
cvt_n(ffi::BN_is_prime_ex(p.as_ptr(), checks.into(), self.as_ptr(), ptr::null_mut())).map(|r| r != 0)
}
}
@ -198,9 +202,9 @@ impl BnCtx {
checks: i32,
do_trial_division: bool) -> Result<bool, ErrorStack> {
unsafe {
cvt_n(ffi::BN_is_prime_fasttest_ex(p.0,
cvt_n(ffi::BN_is_prime_fasttest_ex(p.as_ptr(),
checks.into(),
self.0,
self.as_ptr(),
do_trial_division as c_int,
ptr::null_mut()))
.map(|r| r != 0)
@ -220,7 +224,7 @@ impl BnCtx {
odd: bool)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_rand(r.0, bits.into(), prop as c_int, odd as c_int)).map(|_| ())
cvt(ffi::BN_rand(r.as_ptr(), bits.into(), prop as c_int, odd as c_int)).map(|_| ())
}
}
@ -231,45 +235,52 @@ impl BnCtx {
odd: bool)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_pseudo_rand(r.0, bits.into(), prop as c_int, odd as c_int)).map(|_| ())
cvt(ffi::BN_pseudo_rand(r.as_ptr(), bits.into(), prop as c_int, odd as c_int)).map(|_| ())
}
}
}
/// A borrowed, signed, arbitrary-precision integer.
#[derive(Copy, Clone)]
pub struct BigNumRef<'a>(*mut ffi::BIGNUM, PhantomData<&'a ()>);
pub struct BigNumRef(Opaque);
impl<'a> BigNumRef<'a> {
pub unsafe fn from_ptr(handle: *mut ffi::BIGNUM) -> BigNumRef<'a> {
BigNumRef(handle, PhantomData)
impl BigNumRef {
pub unsafe fn from_ptr<'a>(handle: *mut ffi::BIGNUM) -> &'a BigNumRef {
&*(handle as *mut _)
}
pub unsafe fn from_ptr_mut<'a>(handle: *mut ffi::BIGNUM) -> &'a mut BigNumRef {
&mut *(handle as *mut _)
}
pub fn as_ptr(&self) -> *mut ffi::BIGNUM {
self as *const _ as *mut _
}
/// Adds a `u32` to `self`.
pub fn add_word(&mut self, w: u32) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_add_word(self.0, w as ffi::BN_ULONG)).map(|_| ())
cvt(ffi::BN_add_word(self.as_ptr(), w as ffi::BN_ULONG)).map(|_| ())
}
}
/// Subtracts a `u32` from `self`.
pub fn sub_word(&mut self, w: u32) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_sub_word(self.0, w as ffi::BN_ULONG)).map(|_| ())
cvt(ffi::BN_sub_word(self.as_ptr(), w as ffi::BN_ULONG)).map(|_| ())
}
}
/// Multiplies a `u32` by `self`.
pub fn mul_word(&mut self, w: u32) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_mul_word(self.0, w as ffi::BN_ULONG)).map(|_| ())
cvt(ffi::BN_mul_word(self.as_ptr(), w as ffi::BN_ULONG)).map(|_| ())
}
}
/// Divides `self` by a `u32`, returning the remainder.
pub fn div_word(&mut self, w: u32) -> Result<u64, ErrorStack> {
unsafe {
let r = ffi::BN_div_word(self.0, w.into());
let r = ffi::BN_div_word(self.as_ptr(), w.into());
if r == ffi::BN_ULONG::max_value() {
Err(ErrorStack::get())
} else {
@ -281,7 +292,7 @@ impl<'a> BigNumRef<'a> {
/// Returns the result of `self` modulo `w`.
pub fn mod_word(&self, w: u32) -> Result<u64, ErrorStack> {
unsafe {
let r = ffi::BN_mod_word(self.0, w.into());
let r = ffi::BN_mod_word(self.as_ptr(), w.into());
if r == ffi::BN_ULONG::max_value() {
Err(ErrorStack::get())
} else {
@ -294,14 +305,14 @@ impl<'a> BigNumRef<'a> {
/// number less than `self` in `rnd`.
pub fn rand_in_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_rand_range(self.0, rnd.0)).map(|_| ())
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 BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_pseudo_rand_range(self.0, rnd.0)).map(|_| ())
cvt(ffi::BN_pseudo_rand_range(self.as_ptr(), rnd.as_ptr())).map(|_| ())
}
}
@ -310,7 +321,7 @@ impl<'a> BigNumRef<'a> {
/// When setting a bit outside of `self`, it is expanded.
pub fn set_bit(&mut self, n: i32) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_set_bit(self.0, n.into())).map(|_| ())
cvt(ffi::BN_set_bit(self.as_ptr(), n.into())).map(|_| ())
}
}
@ -319,14 +330,14 @@ impl<'a> BigNumRef<'a> {
/// When clearing a bit outside of `self`, an error is returned.
pub fn clear_bit(&mut self, n: i32) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_clear_bit(self.0, n.into())).map(|_| ())
cvt(ffi::BN_clear_bit(self.as_ptr(), n.into())).map(|_| ())
}
}
/// Returns `true` if the `n`th bit of `self` is set to 1, `false` otherwise.
pub fn is_bit_set(&self, n: i32) -> bool {
unsafe {
ffi::BN_is_bit_set(self.0, n.into()) == 1
ffi::BN_is_bit_set(self.as_ptr(), n.into()) == 1
}
}
@ -335,62 +346,62 @@ impl<'a> BigNumRef<'a> {
/// An error occurs if `self` is already shorter than `n` bits.
pub fn mask_bits(&mut self, n: i32) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_mask_bits(self.0, n.into())).map(|_| ())
cvt(ffi::BN_mask_bits(self.as_ptr(), n.into())).map(|_| ())
}
}
/// Places `self << 1` in `r`.
pub fn lshift1(&self, r: &mut BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_lshift1(r.0, self.0)).map(|_| ())
cvt(ffi::BN_lshift1(r.as_ptr(), self.as_ptr())).map(|_| ())
}
}
/// Places `self >> 1` in `r`.
pub fn rshift1(&self, r: &mut BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_rshift1(r.0, self.0)).map(|_| ())
cvt(ffi::BN_rshift1(r.as_ptr(), self.as_ptr())).map(|_| ())
}
}
/// Places `self + b` in `r`.
pub fn add(&self, r: &mut BigNumRef, b: &BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_add(r.0, self.0, b.0)).map(|_| ())
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 BigNumRef, b: &BigNumRef) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_sub(r.0, self.0, b.0)).map(|_| ())
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 BigNumRef, b: i32) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_lshift(r.0, self.0, b.into())).map(|_| ())
cvt(ffi::BN_lshift(r.as_ptr(), self.as_ptr(), b.into())).map(|_| ())
}
}
/// Places `self >> n` in `r`.
pub fn rshift(&self, r: &mut BigNumRef, n: i32) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_rshift(r.0, self.0, n.into())).map(|_| ())
cvt(ffi::BN_rshift(r.as_ptr(), self.as_ptr(), n.into())).map(|_| ())
}
}
pub fn to_owned(&self) -> Result<BigNum, ErrorStack> {
unsafe {
cvt_p(ffi::BN_dup(self.0)).map(|b| BigNum::from_ptr(b))
cvt_p(ffi::BN_dup(self.as_ptr())).map(|b| BigNum::from_ptr(b))
}
}
/// Sets the sign of `self`.
pub fn set_negative(&mut self, negative: bool) {
unsafe {
ffi::BN_set_negative(self.0, negative as c_int)
ffi::BN_set_negative(self.as_ptr(), negative as c_int)
}
}
@ -406,14 +417,7 @@ impl<'a> BigNumRef<'a> {
/// ```
pub fn ucmp(&self, oth: &BigNumRef) -> Ordering {
unsafe {
let res = ffi::BN_ucmp(self.as_ptr(), oth.as_ptr());
if res < 0 {
Ordering::Less
} else if res > 0 {
Ordering::Greater
} else {
Ordering::Equal
}
ffi::BN_ucmp(self.as_ptr(), oth.as_ptr()).cmp(&0)
}
}
@ -441,10 +445,6 @@ impl<'a> BigNumRef<'a> {
(self.num_bits() + 7) / 8
}
pub fn as_ptr(&self) -> *mut ffi::BIGNUM {
self.0
}
/// Returns a big-endian byte vector representation of the absolute value of `self`.
///
/// `self` can be recreated by using `new_from_slice`.
@ -510,7 +510,7 @@ impl<'a> BigNumRef<'a> {
/// Additionally, it implements the standard operators (`std::ops`), which
/// perform unchecked arithmetic, unwrapping the returned `Result` of the
/// checked operations.
pub struct BigNum(BigNumRef<'static>);
pub struct BigNum(*mut ffi::BIGNUM);
impl BigNum {
/// Creates a new `BigNum` with the value 0.
@ -550,7 +550,7 @@ impl BigNum {
}
pub unsafe fn from_ptr(handle: *mut ffi::BIGNUM) -> BigNum {
BigNum(BigNumRef::from_ptr(handle))
BigNum(handle)
}
/// Creates a new `BigNum` from an unsigned, big-endian encoded number of arbitrary length.
@ -584,11 +584,11 @@ impl BigNum {
rem: Option<&BigNumRef>)
-> Result<(), ErrorStack> {
unsafe {
cvt(ffi::BN_generate_prime_ex(r.0,
cvt(ffi::BN_generate_prime_ex(r.as_ptr(),
bits as c_int,
safe as c_int,
add.map(|n| n.0).unwrap_or(ptr::null_mut()),
rem.map(|n| n.0).unwrap_or(ptr::null_mut()),
add.map(|n| n.as_ptr()).unwrap_or(ptr::null_mut()),
rem.map(|n| n.as_ptr()).unwrap_or(ptr::null_mut()),
ptr::null_mut()))
.map(|_| ())
}
@ -602,26 +602,30 @@ impl Drop for BigNum {
}
impl Deref for BigNum {
type Target = BigNumRef<'static>;
type Target = BigNumRef;
fn deref(&self) -> &BigNumRef<'static> {
&self.0
fn deref(&self) -> &BigNumRef {
unsafe {
BigNumRef::from_ptr(self.0)
}
}
}
impl DerefMut for BigNum {
fn deref_mut(&mut self) -> &mut BigNumRef<'static> {
&mut self.0
fn deref_mut(&mut self) -> &mut BigNumRef {
unsafe {
BigNumRef::from_ptr_mut(self.0)
}
}
}
impl AsRef<BigNumRef<'static>> for BigNum {
fn as_ref(&self) -> &BigNumRef<'static> {
impl AsRef<BigNumRef> for BigNum {
fn as_ref(&self) -> &BigNumRef {
self.deref()
}
}
impl<'a> fmt::Debug for BigNumRef<'a> {
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),
@ -639,7 +643,7 @@ impl fmt::Debug for BigNum {
}
}
impl<'a> fmt::Display for BigNumRef<'a> {
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),
@ -657,19 +661,19 @@ impl fmt::Display for BigNum {
}
}
impl<'a, 'b> PartialEq<BigNumRef<'b>> for BigNumRef<'a> {
impl PartialEq<BigNumRef> for BigNumRef {
fn eq(&self, oth: &BigNumRef) -> bool {
self.cmp(oth) == Ordering::Equal
}
}
impl<'a> PartialEq<BigNum> for BigNumRef<'a> {
impl PartialEq<BigNum> for BigNumRef {
fn eq(&self, oth: &BigNum) -> bool {
self.eq(oth.deref())
}
}
impl<'a> Eq for BigNumRef<'a> {}
impl Eq for BigNumRef {}
impl PartialEq for BigNum {
fn eq(&self, oth: &BigNum) -> bool {
@ -677,7 +681,7 @@ impl PartialEq for BigNum {
}
}
impl<'a> PartialEq<BigNumRef<'a>> for BigNum {
impl PartialEq<BigNumRef> for BigNum {
fn eq(&self, oth: &BigNumRef) -> bool {
self.deref().eq(oth)
}
@ -685,19 +689,19 @@ impl<'a> PartialEq<BigNumRef<'a>> for BigNum {
impl Eq for BigNum {}
impl<'a, 'b> PartialOrd<BigNumRef<'b>> for BigNumRef<'a> {
impl PartialOrd<BigNumRef> for BigNumRef {
fn partial_cmp(&self, oth: &BigNumRef) -> Option<Ordering> {
Some(self.cmp(oth))
}
}
impl<'a> PartialOrd<BigNum> for BigNumRef<'a> {
impl PartialOrd<BigNum> for BigNumRef {
fn partial_cmp(&self, oth: &BigNum) -> Option<Ordering> {
Some(self.cmp(oth.deref()))
}
}
impl<'a> Ord for BigNumRef<'a> {
impl Ord for BigNumRef {
fn cmp(&self, oth: &BigNumRef) -> Ordering {
unsafe { ffi::BN_cmp(self.as_ptr(), oth.as_ptr()).cmp(&0) }
}
@ -709,7 +713,7 @@ impl PartialOrd for BigNum {
}
}
impl<'a> PartialOrd<BigNumRef<'a>> for BigNum {
impl PartialOrd<BigNumRef> for BigNum {
fn partial_cmp(&self, oth: &BigNumRef) -> Option<Ordering> {
self.deref().partial_cmp(oth)
}
@ -723,7 +727,7 @@ impl Ord for BigNum {
macro_rules! delegate {
($t:ident, $m:ident) => {
impl<'a, 'b> $t<&'b BigNum> for &'a BigNumRef<'a> {
impl<'a, 'b> $t<&'b BigNum> for &'a BigNumRef {
type Output = BigNum;
fn $m(self, oth: &BigNum) -> BigNum {
@ -731,7 +735,7 @@ macro_rules! delegate {
}
}
impl<'a, 'b> $t<&'b BigNumRef<'b>> for &'a BigNum {
impl<'a, 'b> $t<&'b BigNumRef> for &'a BigNum {
type Output = BigNum;
fn $m(self, oth: &BigNumRef) -> BigNum {
@ -749,7 +753,7 @@ macro_rules! delegate {
}
}
impl<'a, 'b> Add<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
impl<'a, 'b> Add<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn add(self, oth: &BigNumRef) -> BigNum {
@ -761,7 +765,7 @@ impl<'a, 'b> Add<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
delegate!(Add, add);
impl<'a, 'b> Sub<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
impl<'a, 'b> Sub<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn sub(self, oth: &BigNumRef) -> BigNum {
@ -773,7 +777,7 @@ impl<'a, 'b> Sub<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
delegate!(Sub, sub);
impl<'a, 'b> Mul<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
impl<'a, 'b> Mul<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn mul(self, oth: &BigNumRef) -> BigNum {
@ -786,10 +790,10 @@ impl<'a, 'b> Mul<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
delegate!(Mul, mul);
impl<'a, 'b> Div<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
impl<'a, 'b> Div<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn div(self, oth: &'b BigNumRef<'b>) -> BigNum {
fn div(self, oth: &'b BigNumRef) -> BigNum {
let mut ctx = BnCtx::new().unwrap();
let mut dv = BigNum::new().unwrap();
ctx.div(Some(&mut dv), None, self, oth).unwrap();
@ -799,10 +803,10 @@ impl<'a, 'b> Div<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
delegate!(Div, div);
impl<'a, 'b> Rem<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
impl<'a, 'b> Rem<&'b BigNumRef> for &'a BigNumRef {
type Output = BigNum;
fn rem(self, oth: &'b BigNumRef<'b>) -> BigNum {
fn rem(self, oth: &'b BigNumRef) -> BigNum {
let mut ctx = BnCtx::new().unwrap();
let mut rem = BigNum::new().unwrap();
ctx.div(None, Some(&mut rem), self, oth).unwrap();
@ -812,7 +816,7 @@ impl<'a, 'b> Rem<&'b BigNumRef<'b>> for &'a BigNumRef<'a> {
delegate!(Rem, rem);
impl<'a> Shl<i32> for &'a BigNumRef<'a> {
impl<'a> Shl<i32> for &'a BigNumRef {
type Output = BigNum;
fn shl(self, n: i32) -> BigNum {
@ -830,7 +834,7 @@ impl<'a> Shl<i32> for &'a BigNum {
}
}
impl<'a> Shr<i32> for &'a BigNumRef<'a> {
impl<'a> Shr<i32> for &'a BigNumRef {
type Output = BigNum;
fn shr(self, n: i32) -> BigNum {
@ -848,7 +852,7 @@ impl<'a> Shr<i32> for &'a BigNum {
}
}
impl<'a> Neg for &'a BigNumRef<'a> {
impl<'a> Neg for &'a BigNumRef {
type Output = BigNum;
fn neg(self) -> BigNum {

6
openssl/src/crypto/dsa.rs
View File

@ -155,7 +155,7 @@ impl DSA {
self.0
}
pub fn p<'a>(&'a self) -> Option<BigNumRef<'a>> {
pub fn p(&self) -> Option<&BigNumRef> {
unsafe {
let p = compat::pqg(self.0)[0];
if p.is_null() {
@ -166,7 +166,7 @@ impl DSA {
}
}
pub fn q<'a>(&'a self) -> Option<BigNumRef<'a>> {
pub fn q(&self) -> Option<&BigNumRef> {
unsafe {
let q = compat::pqg(self.0)[1];
if q.is_null() {
@ -177,7 +177,7 @@ impl DSA {
}
}
pub fn g<'a>(&'a self) -> Option<BigNumRef<'a>> {
pub fn g(&self) -> Option<&BigNumRef> {
unsafe {
let g = compat::pqg(self.0)[2];
if g.is_null() {

10
openssl/src/crypto/rsa.rs
View File

@ -267,7 +267,7 @@ impl RSA {
self.0
}
pub fn n<'a>(&'a self) -> Option<BigNumRef<'a>> {
pub fn n(&self) -> Option<&BigNumRef> {
unsafe {
let n = compat::key(self.0)[0];
if n.is_null() {
@ -278,7 +278,7 @@ impl RSA {
}
}
pub fn d<'a>(&self) -> Option<BigNumRef<'a>> {
pub fn d(&self) -> Option<&BigNumRef> {
unsafe {
let d = compat::key(self.0)[2];
if d.is_null() {
@ -289,7 +289,7 @@ impl RSA {
}
}
pub fn e<'a>(&'a self) -> Option<BigNumRef<'a>> {
pub fn e(&self) -> Option<&BigNumRef> {
unsafe {
let e = compat::key(self.0)[1];
if e.is_null() {
@ -300,7 +300,7 @@ impl RSA {
}
}
pub fn p<'a>(&'a self) -> Option<BigNumRef<'a>> {
pub fn p(&self) -> Option<&BigNumRef> {
unsafe {
let p = compat::factors(self.0)[0];
if p.is_null() {
@ -311,7 +311,7 @@ impl RSA {
}
}
pub fn q<'a>(&'a self) -> Option<BigNumRef<'a>> {
pub fn q(&self) -> Option<&BigNumRef> {
unsafe {
let q = compat::factors(self.0)[1];
if q.is_null() {

1
openssl/src/lib.rs
View File

@ -32,6 +32,7 @@ pub mod nid;
pub mod ssl;
pub mod version;
pub mod x509;
mod opaque;
pub fn cvt_p<T>(r: *mut T) -> Result<*mut T, ErrorStack> {
if r.is_null() {

6
openssl/src/opaque.rs Normal file
View File

@ -0,0 +1,6 @@
use std::cell::UnsafeCell;
/// This is intended to be used as the inner type for types designed to be pointed to by references
/// 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<()>);

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

@ -26,6 +26,7 @@ use x509::{X509StoreContext, X509FileType, X509, X509Ref, X509VerifyError};
use x509::verify::X509VerifyParamRef;
use crypto::pkey::PKey;
use error::ErrorStack;
use opaque::Opaque;
pub mod error;
mod bio;
@ -210,9 +211,9 @@ extern fn raw_sni<F>(ssl: *mut ffi::SSL, al: *mut c_int, _arg: *mut c_void) -> c
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 mut ssl = SslRef::from_ptr(ssl);
let ssl = SslRef::from_ptr_mut(ssl);
match callback(&mut ssl) {
match callback(ssl) {
Ok(()) => ffi::SSL_TLSEXT_ERR_OK,
Err(SniError::Fatal(e)) => {
*al = e;
@ -335,15 +336,19 @@ pub enum SniError {
}
/// A borrowed SSL context object.
pub struct SslContextRef<'a>(*mut ffi::SSL_CTX, PhantomData<&'a ()>);
pub struct SslContextRef(Opaque);
impl<'a> SslContextRef<'a> {
pub unsafe fn from_ptr(ctx: *mut ffi::SSL_CTX) -> SslContextRef<'a> {
SslContextRef(ctx, PhantomData)
impl SslContextRef {
pub unsafe fn from_ptr<'a>(ctx: *mut ffi::SSL_CTX) -> &'a SslContextRef {
&*(ctx as *mut _)
}
pub unsafe fn from_ptr_mut<'a>(ctx: *mut ffi::SSL_CTX) -> &'a mut SslContextRef {
&mut *(ctx as *mut _)
}
pub fn as_ptr(&self) -> *mut ffi::SSL_CTX {
self.0
self as *const _ as *mut _
}
/// Configures the certificate verification method for new connections.
@ -626,7 +631,7 @@ impl<'a> SslContextRef<'a> {
}
/// An owned SSL context object.
pub struct SslContext(SslContextRef<'static>);
pub struct SslContext(*mut ffi::SSL_CTX);
unsafe impl Send for SslContext {}
unsafe impl Sync for SslContext {}
@ -654,16 +659,20 @@ impl Drop for SslContext {
}
impl Deref for SslContext {
type Target = SslContextRef<'static>;
type Target = SslContextRef;
fn deref(&self) -> &SslContextRef<'static> {
&self.0
fn deref(&self) -> &SslContextRef {
unsafe {
SslContextRef::from_ptr(self.0)
}
}
}
impl DerefMut for SslContext {
fn deref_mut(&mut self) -> &mut SslContextRef<'static> {
&mut self.0
fn deref_mut(&mut self) -> &mut SslContextRef {
unsafe {
SslContextRef::from_ptr_mut(self.0)
}
}
}
@ -683,11 +692,11 @@ impl SslContext {
}
pub unsafe fn from_ptr(ctx: *mut ffi::SSL_CTX) -> SslContext {
SslContext(SslContextRef::from_ptr(ctx))
SslContext(ctx)
}
pub fn as_ptr(&self) -> *mut ffi::SSL_CTX {
(**self).as_ptr()
self.0
}
}
@ -700,16 +709,21 @@ pub struct CipherBits {
pub algorithm: i32,
}
pub struct SslCipher<'a> {
cipher: *const ffi::SSL_CIPHER,
ph: PhantomData<&'a ()>,
}
pub struct SslCipherRef(Opaque);
impl SslCipherRef {
pub unsafe fn from_ptr<'a>(ptr: *const ffi::SSL_CIPHER) -> &'a SslCipherRef {
&*(ptr as *const _)
}
pub fn as_ptr(&self) -> *const ffi::SSL_CIPHER {
self as *const _ as *const _
}
impl<'a> SslCipher<'a> {
/// Returns the name of cipher.
pub fn name(&self) -> &'static str {
let name = unsafe {
let ptr = ffi::SSL_CIPHER_get_name(self.cipher);
let ptr = ffi::SSL_CIPHER_get_name(self.as_ptr());
CStr::from_ptr(ptr as *const _)
};
@ -719,7 +733,7 @@ impl<'a> SslCipher<'a> {
/// Returns the SSL/TLS protocol version that first defined the cipher.
pub fn version(&self) -> &'static str {
let version = unsafe {
let ptr = ffi::SSL_CIPHER_get_version(self.cipher);
let ptr = ffi::SSL_CIPHER_get_version(self.as_ptr());
CStr::from_ptr(ptr as *const _)
};
@ -730,7 +744,7 @@ impl<'a> SslCipher<'a> {
pub fn bits(&self) -> CipherBits {
unsafe {
let mut algo_bits = 0;
let secret_bits = ffi::SSL_CIPHER_get_bits(self.cipher, &mut algo_bits);
let secret_bits = ffi::SSL_CIPHER_get_bits(self.as_ptr(), &mut algo_bits);
CipherBits {
secret: secret_bits.into(),
algorithm: algo_bits.into(),
@ -743,7 +757,7 @@ impl<'a> SslCipher<'a> {
unsafe {
// SSL_CIPHER_description requires a buffer of at least 128 bytes.
let mut buf = [0; 128];
let desc_ptr = ffi::SSL_CIPHER_description(self.cipher, buf.as_mut_ptr(), 128);
let desc_ptr = ffi::SSL_CIPHER_description(self.as_ptr(), buf.as_mut_ptr(), 128);
if !desc_ptr.is_null() {
String::from_utf8(CStr::from_ptr(desc_ptr as *const _).to_bytes().to_vec()).ok()
@ -754,12 +768,12 @@ impl<'a> SslCipher<'a> {
}
}
pub struct SslRef<'a>(*mut ffi::SSL, PhantomData<&'a ()>);
pub struct SslRef(Opaque);
unsafe impl<'a> Send for SslRef<'a> {}
unsafe impl<'a> Sync for SslRef<'a> {}
unsafe impl Send for SslRef {}
unsafe impl Sync for SslRef {}
impl<'a> fmt::Debug for SslRef<'a> {
impl fmt::Debug for SslRef {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let mut builder = fmt.debug_struct("SslRef");
builder.field("state", &self.state_string_long());
@ -770,13 +784,17 @@ impl<'a> fmt::Debug for SslRef<'a> {
}
}
impl<'a> SslRef<'a> {
pub unsafe fn from_ptr(ssl: *mut ffi::SSL) -> SslRef<'a> {
SslRef(ssl, PhantomData)
impl SslRef {
pub unsafe fn from_ptr<'a>(ssl: *mut ffi::SSL) -> &'a SslRef {
&*(ssl as *mut _)
}
pub unsafe fn from_ptr_mut<'a>(ssl: *mut ffi::SSL) -> &'a mut SslRef {
&mut *(ssl as *mut _)
}
pub fn as_ptr(&self) -> *mut ffi::SSL {
self.0
self as *const _ as *mut _
}
fn get_raw_rbio(&self) -> *mut ffi::BIO {
@ -823,17 +841,14 @@ impl<'a> SslRef<'a> {
}
}
pub fn current_cipher(&self) -> Option<SslCipher<'a>> {
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(SslCipher {
cipher: ptr,
ph: PhantomData,
})
Some(SslCipherRef::from_ptr(ptr))
}
}
}
@ -965,13 +980,15 @@ impl<'a> SslRef<'a> {
}
/// Returns the server's name for the current connection
pub fn servername(&self) -> Option<String> {
let name = unsafe { ffi::SSL_get_servername(self.as_ptr(), ffi::TLSEXT_NAMETYPE_host_name) };
if name == ptr::null() {
return None;
}
pub fn servername(&self) -> Option<&str> {
unsafe {
let name = ffi::SSL_get_servername(self.as_ptr(), ffi::TLSEXT_NAMETYPE_host_name);
if name == ptr::null() {
return None;
}
unsafe { String::from_utf8(CStr::from_ptr(name as *const _).to_bytes().to_vec()).ok() }
Some(str::from_utf8(CStr::from_ptr(name as *const _).to_bytes()).unwrap())
}
}
/// Changes the context corresponding to the current connection.
@ -982,7 +999,7 @@ impl<'a> SslRef<'a> {
}
/// Returns the context corresponding to the current connection
pub fn ssl_context(&self) -> SslContextRef<'a> {
pub fn ssl_context(&self) -> &SslContextRef {
unsafe {
let ssl_ctx = ffi::SSL_get_SSL_CTX(self.as_ptr());
SslContextRef::from_ptr(ssl_ctx)
@ -993,21 +1010,21 @@ impl<'a> SslRef<'a> {
///
/// 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 self) -> X509VerifyParamRef<'a> {
pub fn param_mut(&mut self) -> &mut X509VerifyParamRef {
unsafe {
X509VerifyParamRef::from_ptr(ffi::SSL_get0_param(self.as_ptr()))
X509VerifyParamRef::from_ptr_mut(ffi::SSL_get0_param(self.as_ptr()))
}
}
/// Returns the result of X509 certificate verification.
pub fn verify_result(&self) -> Option<X509VerifyError> {
unsafe {
X509VerifyError::from_raw(ffi::SSL_get_verify_result(self.0))
X509VerifyError::from_raw(ffi::SSL_get_verify_result(self.as_ptr()))
}
}
}
pub struct Ssl(SslRef<'static>);
pub struct Ssl(*mut ffi::SSL);
impl fmt::Debug for Ssl {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
@ -1027,16 +1044,20 @@ impl Drop for Ssl {
}
impl Deref for Ssl {
type Target = SslRef<'static>;
type Target = SslRef;
fn deref(&self) -> &SslRef<'static> {
&self.0
fn deref(&self) -> &SslRef {
unsafe {
SslRef::from_ptr(self.0)
}
}
}
impl DerefMut for Ssl {
fn deref_mut(&mut self) -> &mut SslRef<'static> {
&mut self.0
fn deref_mut(&mut self) -> &mut SslRef {
unsafe {
SslRef::from_ptr_mut(self.0)
}
}
}
@ -1049,7 +1070,7 @@ impl Ssl {
}
pub unsafe fn from_ptr(ssl: *mut ffi::SSL) -> Ssl {
Ssl(SslRef::from_ptr(ssl))
Ssl(ssl)
}
/// Creates an SSL/TLS client operating over the provided stream.

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

@ -479,7 +479,7 @@ fn test_pending() {
fn test_state() {
let (_s, tcp) = Server::new();
let ctx = SslContext::new(SslMethod::tls()).unwrap();
let mut stream = Ssl::new(&ctx).unwrap().connect(tcp).unwrap();
let stream = Ssl::new(&ctx).unwrap().connect(tcp).unwrap();
assert_eq!(stream.ssl().state_string(), "SSLOK ");
assert_eq!(stream.ssl().state_string_long(),
"SSL negotiation finished successfully");
@ -1053,8 +1053,8 @@ fn valid_hostname() {
ctx.set_verify(SSL_VERIFY_PEER);
let mut ssl = Ssl::new(&ctx).unwrap();
ssl.param().set_hostflags(X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
ssl.param().set_host("google.com").unwrap();
ssl.param_mut().set_hostflags(X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
ssl.param_mut().set_host("google.com").unwrap();
let s = TcpStream::connect("google.com:443").unwrap();
let mut socket = ssl.connect(s).unwrap();
@ -1077,8 +1077,8 @@ fn invalid_hostname() {
ctx.set_verify(SSL_VERIFY_PEER);
let mut ssl = Ssl::new(&ctx).unwrap();
ssl.param().set_hostflags(X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
ssl.param().set_host("foobar.com").unwrap();
ssl.param_mut().set_hostflags(X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
ssl.param_mut().set_host("foobar.com").unwrap();
let s = TcpStream::connect("google.com:443").unwrap();
assert!(ssl.connect(s).is_err());

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

@ -18,9 +18,10 @@ use bio::{MemBio, MemBioSlice};
use crypto::hash::MessageDigest;
use crypto::pkey::PKey;
use crypto::rand::rand_bytes;
use error::ErrorStack;
use ffi;
use nid::Nid;
use error::ErrorStack;
use opaque::Opaque;
#[cfg(ossl10x)]
use ffi::{
@ -106,7 +107,7 @@ impl X509StoreContext {
}
}
pub fn current_cert<'a>(&'a self) -> Option<X509Ref<'a>> {
pub fn current_cert<'a>(&'a self) -> Option<&'a X509Ref> {
unsafe {
let ptr = ffi::X509_STORE_CTX_get_current_cert(self.ctx);
if ptr.is_null() {
@ -389,27 +390,29 @@ impl X509Generator {
}
/// A borrowed public key certificate.
pub struct X509Ref<'a>(*mut ffi::X509, PhantomData<&'a ()>);
pub struct X509Ref(Opaque);
impl<'a> X509Ref<'a> {
impl X509Ref {
/// Creates a new `X509Ref` wrapping the provided handle.
pub unsafe fn from_ptr(x509: *mut ffi::X509) -> X509Ref<'a> {
X509Ref(x509, PhantomData)
pub unsafe fn from_ptr<'a>(x509: *mut ffi::X509) -> &'a X509Ref {
&*(x509 as *mut _)
}
pub fn as_ptr(&self) -> *mut ffi::X509 {
self.0
self as *const _ as *mut _
}
pub fn subject_name<'b>(&'b self) -> X509Name<'b> {
let name = unsafe { ffi::X509_get_subject_name(self.0) };
X509Name(name, PhantomData)
pub fn subject_name(&self) -> &X509NameRef {
unsafe {
let name = ffi::X509_get_subject_name(self.as_ptr());
X509NameRef::from_ptr(name)
}
}
/// Returns this certificate's SAN entries, if they exist.
pub fn subject_alt_names(&self) -> Option<GeneralNames> {
unsafe {
let stack = ffi::X509_get_ext_d2i(self.0,
let stack = ffi::X509_get_ext_d2i(self.as_ptr(),
Nid::SubjectAltName as c_int,
ptr::null_mut(),
ptr::null_mut());
@ -425,7 +428,7 @@ impl<'a> X509Ref<'a> {
pub fn public_key(&self) -> Result<PKey, ErrorStack> {
unsafe {
let pkey = try!(cvt_p(ffi::X509_get_pubkey(self.0)));
let pkey = try!(cvt_p(ffi::X509_get_pubkey(self.as_ptr())));
Ok(PKey::from_ptr(pkey))
}
}
@ -436,25 +439,25 @@ impl<'a> X509Ref<'a> {
let evp = hash_type.as_ptr();
let mut len = ffi::EVP_MAX_MD_SIZE;
let mut buf = vec![0u8; len as usize];
try!(cvt(ffi::X509_digest(self.0, evp, buf.as_mut_ptr() as *mut _, &mut len)));
try!(cvt(ffi::X509_digest(self.as_ptr(), evp, buf.as_mut_ptr() as *mut _, &mut len)));
buf.truncate(len as usize);
Ok(buf)
}
}
/// Returns certificate Not After validity period.
pub fn not_after<'b>(&'b self) -> Asn1TimeRef<'b> {
pub fn not_after<'a>(&'a self) -> &'a Asn1TimeRef {
unsafe {
let date = compat::X509_get_notAfter(self.0);
let date = compat::X509_get_notAfter(self.as_ptr());
assert!(!date.is_null());
Asn1TimeRef::from_ptr(date)
}
}
/// Returns certificate Not Before validity period.
pub fn not_before<'b>(&'b self) -> Asn1TimeRef<'b> {
pub fn not_before<'a>(&'a self) -> &'a Asn1TimeRef {
unsafe {
let date = compat::X509_get_notBefore(self.0);
let date = compat::X509_get_notBefore(self.as_ptr());
assert!(!date.is_null());
Asn1TimeRef::from_ptr(date)
}
@ -464,7 +467,7 @@ impl<'a> X509Ref<'a> {
pub fn to_pem(&self) -> Result<Vec<u8>, ErrorStack> {
let mem_bio = try!(MemBio::new());
unsafe {
try!(cvt(ffi::PEM_write_bio_X509(mem_bio.as_ptr(), self.0)));
try!(cvt(ffi::PEM_write_bio_X509(mem_bio.as_ptr(), self.as_ptr())));
}
Ok(mem_bio.get_buf().to_owned())
}
@ -473,19 +476,19 @@ impl<'a> X509Ref<'a> {
pub fn to_der(&self) -> Result<Vec<u8>, ErrorStack> {
let mem_bio = try!(MemBio::new());
unsafe {
ffi::i2d_X509_bio(mem_bio.as_ptr(), self.0);
ffi::i2d_X509_bio(mem_bio.as_ptr(), self.as_ptr());
}
Ok(mem_bio.get_buf().to_owned())
}
}
/// An owned public key certificate.
pub struct X509(X509Ref<'static>);
pub struct X509(*mut ffi::X509);
impl X509 {
/// Returns a new `X509`, taking ownership of the handle.
pub unsafe fn from_ptr(x509: *mut ffi::X509) -> X509 {
X509(X509Ref::from_ptr(x509))
X509(x509)
}
/// Reads a certificate from DER.
@ -512,10 +515,12 @@ impl X509 {
}
impl Deref for X509 {
type Target = X509Ref<'static>;
type Target = X509Ref;
fn deref(&self) -> &X509Ref<'static> {
&self.0
fn deref(&self) -> &X509Ref {
unsafe {
X509Ref::from_ptr(self.0)
}
}
}
@ -534,17 +539,25 @@ impl Drop for X509 {
}
}
pub struct X509Name<'x>(*mut ffi::X509_NAME, PhantomData<&'x ()>);
pub struct X509NameRef(Opaque);
impl X509NameRef {
pub unsafe fn from_ptr<'a>(ptr: *mut ffi::X509_NAME) -> &'a X509NameRef {
&*(ptr as *mut _)
}
pub fn as_ptr(&self) -> *mut ffi::X509_NAME {
self as *const _ as *mut _
}
impl<'x> X509Name<'x> {
pub fn text_by_nid(&self, nid: Nid) -> Option<SslString> {
unsafe {
let loc = ffi::X509_NAME_get_index_by_NID(self.0, nid as c_int, -1);
let loc = ffi::X509_NAME_get_index_by_NID(self.as_ptr(), nid as c_int, -1);
if loc == -1 {
return None;
}
let ne = ffi::X509_NAME_get_entry(self.0, loc);
let ne = ffi::X509_NAME_get_entry(self.as_ptr(), loc);
if ne.is_null() {
return None;
}

18
openssl/src/x509/verify.rs
View File

@ -2,12 +2,12 @@
//!
//! Requires the `v102` or `v110` features and OpenSSL 1.0.2 or 1.1.0.
use std::marker::PhantomData;
use libc::c_uint;
use ffi;
use cvt;
use error::ErrorStack;
use opaque::Opaque;
bitflags! {
pub flags X509CheckFlags: c_uint {
@ -23,22 +23,26 @@ bitflags! {
}
}
pub struct X509VerifyParamRef<'a>(*mut ffi::X509_VERIFY_PARAM, PhantomData<&'a mut ()>);
pub struct X509VerifyParamRef(Opaque);
impl<'a> X509VerifyParamRef<'a> {
pub unsafe fn from_ptr(ptr: *mut ffi::X509_VERIFY_PARAM) -> X509VerifyParamRef<'a> {
X509VerifyParamRef(ptr, PhantomData)
impl X509VerifyParamRef {
pub unsafe fn from_ptr_mut<'a>(ptr: *mut ffi::X509_VERIFY_PARAM) -> &'a mut X509VerifyParamRef {
&mut *(ptr as *mut _)
}
pub fn as_ptr(&self) -> *mut ffi::X509_VERIFY_PARAM {
self as *const _ as *mut _
}
pub fn set_hostflags(&mut self, hostflags: X509CheckFlags) {
unsafe {
ffi::X509_VERIFY_PARAM_set_hostflags(self.0, hostflags.bits);
ffi::X509_VERIFY_PARAM_set_hostflags(self.as_ptr(), hostflags.bits);
}
}
pub fn set_host(&mut self, host: &str) -> Result<(), ErrorStack> {
unsafe {
cvt(ffi::X509_VERIFY_PARAM_set1_host(self.0,
cvt(ffi::X509_VERIFY_PARAM_set1_host(self.as_ptr(),
host.as_ptr() as *const _,
host.len()))
.map(|_| ())