use std::ffi::c_void;
use std::marker::PhantomData;
use std::ptr::NonNull;
use aws_lc_sys::{
ASN1_BIT_STRING_free, ASN1_INTEGER_free, ASN1_STRING_free, ASN1_TIME_free,
BASIC_CONSTRAINTS_free, BIO_free, BN_free, EVP_PKEY_free, EXTENDED_KEY_USAGE_free,
GENERAL_NAMES_free, GENERAL_NAME_free, OPENSSL_sk_pop_free_ex, RSA_free, X509_EXTENSION_free,
X509_NAME_free, X509_REQ_free, X509_STORE_CTX_free, X509_STORE_free, X509_free,
ASN1_BIT_STRING, ASN1_INTEGER, ASN1_STRING, ASN1_TIME, BASIC_CONSTRAINTS, BIGNUM, BIO,
EVP_PKEY, EXTENDED_KEY_USAGE, GENERAL_NAME, GENERAL_NAMES, OPENSSL_STACK, RSA, X509,
X509_EXTENSION, X509_NAME, X509_REQ, X509_STORE, X509_STORE_CTX,
};
use super::{Error, Result};
type Free<T> = unsafe extern "C" fn(*mut T);
pub(super) struct Owned<T> {
pointer: NonNull<T>,
free: Free<T>,
}
impl<T> Owned<T> {
pub(super) unsafe fn from_raw(pointer: *mut T, free: Free<T>) -> Result<Self> {
let pointer = NonNull::new(pointer).ok_or(Error::Allocation)?;
Ok(Self { pointer, free })
}
pub(super) fn as_ptr(&self) -> *mut T {
self.pointer.as_ptr()
}
}
impl<T> Drop for Owned<T> {
fn drop(&mut self) {
unsafe { (self.free)(self.pointer.as_ptr()) };
}
}
macro_rules! owned_handle {
($name:ident, $raw:ty, $free:path) => {
pub(crate) struct $name(Owned<$raw>);
impl $name {
pub(super) unsafe fn from_raw(pointer: *mut $raw) -> Result<Self> {
unsafe { Owned::from_raw(pointer, $free) }.map(Self)
}
pub(super) fn as_ptr(&self) -> *mut $raw {
self.0.as_ptr()
}
}
};
}
owned_handle!(PrivateKey, EVP_PKEY, EVP_PKEY_free);
owned_handle!(PublicKey, EVP_PKEY, EVP_PKEY_free);
unsafe impl Send for PrivateKey {}
unsafe impl Sync for PrivateKey {}
unsafe impl Send for PublicKey {}
unsafe impl Sync for PublicKey {}
owned_handle!(Certificate, X509, X509_free);
owned_handle!(CertificateRequest, X509_REQ, X509_REQ_free);
owned_handle!(DistinguishedName, X509_NAME, X509_NAME_free);
owned_handle!(CertificateStore, X509_STORE, X509_STORE_free);
owned_handle!(CertificateStoreContext, X509_STORE_CTX, X509_STORE_CTX_free);
unsafe extern "C" fn free_bio(pointer: *mut BIO) {
let _ = unsafe { BIO_free(pointer) };
}
owned_handle!(Bio, BIO, free_bio);
owned_handle!(Asn1String, ASN1_STRING, ASN1_STRING_free);
owned_handle!(GeneralName, GENERAL_NAME, GENERAL_NAME_free);
owned_handle!(GeneralNames, GENERAL_NAMES, GENERAL_NAMES_free);
owned_handle!(Extension, X509_EXTENSION, X509_EXTENSION_free);
owned_handle!(Asn1Integer, ASN1_INTEGER, ASN1_INTEGER_free);
owned_handle!(Asn1Time, ASN1_TIME, ASN1_TIME_free);
owned_handle!(BigNumber, BIGNUM, BN_free);
owned_handle!(BitString, ASN1_BIT_STRING, ASN1_BIT_STRING_free);
owned_handle!(BasicConstraints, BASIC_CONSTRAINTS, BASIC_CONSTRAINTS_free);
owned_handle!(Rsa, RSA, RSA_free);
owned_handle!(
ExtendedKeyUsage,
EXTENDED_KEY_USAGE,
EXTENDED_KEY_USAGE_free
);
pub(super) struct Stack<T> {
pointer: NonNull<OPENSSL_STACK>,
free_element: unsafe extern "C" fn(*mut c_void),
_element: PhantomData<T>,
}
impl<T> Stack<T> {
pub(super) unsafe fn from_raw(
pointer: *mut OPENSSL_STACK,
free_element: unsafe extern "C" fn(*mut c_void),
) -> Result<Self> {
let pointer = NonNull::new(pointer).ok_or(Error::Allocation)?;
Ok(Self {
pointer,
free_element,
_element: PhantomData,
})
}
pub(super) fn as_ptr(&self) -> *mut OPENSSL_STACK {
self.pointer.as_ptr()
}
}
unsafe extern "C" fn call_free_element(
free_element: Option<unsafe extern "C" fn(*mut c_void)>,
element: *mut c_void,
) {
if let Some(free_element) = free_element {
unsafe { free_element(element) };
}
}
impl<T> Drop for Stack<T> {
fn drop(&mut self) {
unsafe {
OPENSSL_sk_pop_free_ex(
self.pointer.as_ptr(),
Some(call_free_element),
Some(self.free_element),
);
};
}
}