Add PKey::private_key_from_pem_cb

use libc::{c_int, c_uint, c_ulong};

use libc::{c_int, c_uint, c_ulong, c_char, c_void};

use std::io;

use std::io::prelude::*;

use std::iter::repeat;

use std::mem;

use std::panic::catch_unwind;

use std::ptr;

use std::slice;

use bio::MemBio;

use crypto::HashTypeInternals;

        }

    }

    /// Read a private key from PEM, supplying a password callback to be invoked if the private key

    /// is encrypted.

    ///

    /// The callback will be passed the password buffer and should return the number of characters

    /// placed into the buffer.

    pub fn private_key_from_pem_cb<R, F>(reader: &mut R, mut pass_cb: F) -> Result<PKey, SslError>

        where R: Read, F: FnMut(&mut [i8]) -> usize

    {

        extern "C" fn user_cb_wrapper<F>(buf: *mut c_char,

                                         size: c_int,

                                         _rwflag: c_int,

                                         user_cb: *mut c_void)

                                         -> c_int

                                         where F: FnMut(&mut [i8]) -> usize {

            let result = catch_unwind(|| {

                // build a `i8` slice to pass to the user callback

                let pass_slice = unsafe { slice::from_raw_parts_mut(buf, size as usize) };

                let callback = unsafe { &mut *(user_cb as *mut F) };

                callback(pass_slice)

            });

            if let Ok(len) = result {

                return len as c_int;

            } else {

                return 0;

            }

        }

        let mut mem_bio = try!(MemBio::new());

        try!(io::copy(reader, &mut mem_bio).map_err(StreamError));

        unsafe {

            let evp = try_ssl_null!(ffi::PEM_read_bio_PrivateKey(mem_bio.get_handle(),

                                                                 ptr::null_mut(),

                                                                 Some(user_cb_wrapper::<F>),

                                                                 &mut pass_cb as *mut _ as *mut c_void));

            Ok(PKey {

                evp: evp as *mut ffi::EVP_PKEY,

                parts: Parts::Both,

            })

        }

    }

    /// Reads public key from PEM, takes ownership of handle

    pub fn public_key_from_pem<R>(reader: &mut R) -> Result<PKey, SslError>

        where R: Read