Module openssl::asn1
+
+ [−]
+
+ [src]
+Structs
+| Asn1Time | ++ + | +
| Asn1Time | ++ + | +
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct Asn1Time {
+ // some fields omitted
+}impl Asn1Timefn new(handle: *mut ASN1_TIME) -> Asn1TimeWraps existing ASN1_TIME and takes ownership
+fn days_from_now(days: u32) -> Result<Asn1Time, SslError>Creates a new time on specified interval in days from now
+unsafe fn get_handle(&self) -> *mut ASN1_TIMEReturns raw handle
+impl Drop for Asn1Timefn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| MemBio | ++ + | +
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct MemBio {
+ // some fields omitted
+}impl MemBiofn new() -> Result<MemBio, SslError>Creates a new owned memory based BIO
+fn borrowed(bio: *mut BIO) -> MemBioReturns a "borrow", i.e. it has no ownership
+unsafe fn unwrap(self) -> *mut BIOConsumes current bio and returns wrapped value +Note that data ownership is lost and +should be managed manually
+unsafe fn get_handle(&self) -> *mut BIOTemporarily gets wrapped value
+fn set_eof(&self, eof: bool)Sets the BIO's EOF state.
+impl Drop for MemBiofn drop(&mut self)impl Read for MemBiofn read(&mut self, buf: &mut [u8]) -> Result<usize>fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>fn by_ref(&mut self) -> &mut Selffn bytes(self) -> Bytes<Self>fn chars(self) -> Chars<Self>fn chain<R>(self, next: R) -> Chain<Self, R> where R: Readfn take(self, limit: u64) -> Take<Self>fn tee<W>(self, out: W) -> Tee<Self, W> where W: Writeimpl Write for MemBiofn write(&mut self, buf: &[u8]) -> Result<usize>fn flush(&mut self) -> Result<()>fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>fn by_ref(&mut self) -> &mut Selffn broadcast<W>(self, other: W) -> Broadcast<Self, W> where W: Write
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum RNGProperty {
+ MsbMaybeZero,
+ MsbOne,
+ TwoMsbOne,
+}MsbMaybeZero | |
MsbOne | |
TwoMsbOne |
impl Clone for RNGPropertyfn clone(&self) -> RNGPropertyfn clone_from(&mut self, source: &Self)impl Copy for RNGProperty
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| unchecked | ++ + | +
| BigNum | ++ + | +
| RNGProperty | ++ + | +
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct BigNum(_);
impl BigNumfn new() -> Result<BigNum, SslError>fn new_from(n: u64) -> Result<BigNum, SslError>fn from_dec_str(s: &str) -> Result<BigNum, SslError>fn from_hex_str(s: &str) -> Result<BigNum, SslError>fn new_from_slice(n: &[u8]) -> Result<BigNum, SslError>fn checked_sqr(&self) -> Result<BigNum, SslError>fn checked_nnmod(&self, n: &BigNum) -> Result<BigNum, SslError>fn checked_mod_add(&self, a: &BigNum, n: &BigNum) -> Result<BigNum, SslError>fn checked_mod_sub(&self, a: &BigNum, n: &BigNum) -> Result<BigNum, SslError>fn checked_mod_mul(&self, a: &BigNum, n: &BigNum) -> Result<BigNum, SslError>fn checked_mod_sqr(&self, n: &BigNum) -> Result<BigNum, SslError>fn checked_exp(&self, p: &BigNum) -> Result<BigNum, SslError>fn checked_mod_exp(&self, p: &BigNum, n: &BigNum) -> Result<BigNum, SslError>fn checked_mod_inv(&self, n: &BigNum) -> Result<BigNum, SslError>fn add_word(&mut self, w: c_ulong) -> Result<(), SslError>fn sub_word(&mut self, w: c_ulong) -> Result<(), SslError>fn mul_word(&mut self, w: c_ulong) -> Result<(), SslError>fn div_word(&mut self, w: c_ulong) -> Result<c_ulong, SslError>fn mod_word(&self, w: c_ulong) -> Result<c_ulong, SslError>fn checked_gcd(&self, a: &BigNum) -> Result<BigNum, SslError>fn checked_generate_prime(bits: i32, safe: bool, add: Option<&BigNum>, rem: Option<&BigNum>) -> Result<BigNum, SslError>fn is_prime(&self, checks: i32) -> Result<bool, SslError>fn is_prime_fast(&self, checks: i32, do_trial_division: bool) -> Result<bool, SslError>fn checked_new_random(bits: i32, prop: RNGProperty, odd: bool) -> Result<BigNum, SslError>fn checked_new_pseudo_random(bits: i32, prop: RNGProperty, odd: bool) -> Result<BigNum, SslError>fn checked_rand_in_range(&self) -> Result<BigNum, SslError>fn checked_pseudo_rand_in_range(&self) -> Result<BigNum, SslError>fn set_bit(&mut self, n: i32) -> Result<(), SslError>fn clear_bit(&mut self, n: i32) -> Result<(), SslError>fn is_bit_set(&self, n: i32) -> boolfn mask_bits(&mut self, n: i32) -> Result<(), SslError>fn checked_shl1(&self) -> Result<BigNum, SslError>fn checked_shr1(&self) -> Result<BigNum, SslError>fn checked_add(&self, a: &BigNum) -> Result<BigNum, SslError>fn checked_sub(&self, a: &BigNum) -> Result<BigNum, SslError>fn checked_mul(&self, a: &BigNum) -> Result<BigNum, SslError>fn checked_div(&self, a: &BigNum) -> Result<BigNum, SslError>fn checked_mod(&self, a: &BigNum) -> Result<BigNum, SslError>fn checked_shl(&self, a: &i32) -> Result<BigNum, SslError>fn checked_shr(&self, a: &i32) -> Result<BigNum, SslError>fn negate(&mut self)fn abs_cmp(&self, oth: BigNum) -> Orderingfn is_negative(&self) -> boolfn num_bits(&self) -> i32fn num_bytes(&self) -> i32fn to_vec(&self) -> Vec<u8>fn to_dec_str(&self) -> Stringfn to_hex_str(&self) -> Stringimpl<'a> Add<&'a BigNum> for &'a BigNumimpl<'a> Sub<&'a BigNum> for &'a BigNumimpl<'a> Mul<&'a BigNum> for &'a BigNumimpl<'a> Div<&'a BigNum> for &'a BigNumimpl<'a> Rem<&'a BigNum> for &'a BigNumimpl<'a> Shl<i32> for &'a BigNumimpl<'a> Shr<i32> for &'a BigNumimpl Clone for BigNumfn clone(&self) -> BigNumfn clone_from(&mut self, source: &Self)impl Neg for BigNumimpl Debug for BigNumimpl Eq for BigNumimpl PartialEq for BigNumimpl Ord for BigNumimpl PartialOrd for BigNumfn partial_cmp(&self, oth: &BigNum) -> Option<Ordering>fn lt(&self, other: &Rhs) -> boolfn le(&self, other: &Rhs) -> boolfn gt(&self, other: &Rhs) -> boolfn ge(&self, other: &Rhs) -> boolimpl Drop for BigNumfn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum Type {
+ MD5,
+ SHA1,
+ SHA224,
+ SHA256,
+ SHA384,
+ SHA512,
+ RIPEMD160,
+}Message digest (hash) type.
+MD5 | |
SHA1 | |
SHA224 | |
SHA256 | |
SHA384 | |
SHA512 | |
RIPEMD160 |
impl Typefn md_len(&self) -> usizeReturns the length of the message digest.
+fn evp_md(&self) -> *const EVP_MDInternal interface subject to removal.
+impl Clone for Typefn clone(&self) -> Typefn clone_from(&mut self, source: &Self)impl Copy for Type
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub fn hash(t: Type, data: &[u8]) -> Vec<u8>
Computes the hash of the data with the hash t.
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| Hasher | +
+ Provides message digest (hash) computation. + + |
+
| Type | +
+ Message digest (hash) type. + + |
+
| hash | +
+ Computes the hash of the |
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct Hasher {
+ // some fields omitted
+}Provides message digest (hash) computation.
+ +Calculate a hash in one go.
++use openssl::crypto::hash::{hash, Type}; +let data = b"\x42\xF4\x97\xE0"; +let spec = b"\x7c\x43\x0f\x17\x8a\xef\xdf\x14\x87\xfe\xe7\x14\x4e\x96\x41\xe2"; +let res = hash(Type::MD5, data); +assert_eq!(res, spec); ++ +
Use the Write trait to supply the input in chunks.
+use std::io::prelude::*; +use openssl::crypto::hash::{Hasher, Type}; +let data = [b"\x42\xF4", b"\x97\xE0"]; +let spec = b"\x7c\x43\x0f\x17\x8a\xef\xdf\x14\x87\xfe\xe7\x14\x4e\x96\x41\xe2"; +let mut h = Hasher::new(Type::MD5); +h.write_all(data[0]); +h.write_all(data[1]); +let res = h.finish(); +assert_eq!(res, spec); ++ +
Don't actually use MD5 and SHA-1 hashes, they're not secure anymore.
+ +Don't ever hash passwords, use crypto::pkcs5 or bcrypt/scrypt instead.
impl Hasherfn new(ty: Type) -> HasherCreates a new Hasher with the specified hash type.
fn finish(&mut self) -> Vec<u8>Returns the hash of the data written since creation or
+the last finish and resets the hasher.
impl Write for Hasherfn write(&mut self, buf: &[u8]) -> Result<usize>fn flush(&mut self) -> Result<()>fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>fn by_ref(&mut self) -> &mut Selffn broadcast<W>(self, other: W) -> Broadcast<Self, W> where W: Writeimpl Clone for Hasherfn clone(&self) -> Hasherfn clone_from(&mut self, source: &Self)impl Drop for Hasherfn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub fn hmac(t: Type, key: &[u8], data: &[u8]) -> Vec<u8>
Computes the HMAC of the data with the hash t and key.
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| HMAC | +
+ Provides HMAC computation. + + |
+
| hmac | +
+ Computes the HMAC of the |
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct HMAC {
+ // some fields omitted
+}Provides HMAC computation.
+ +Calculate a HMAC in one go.
++use openssl::crypto::hash::Type; +use openssl::crypto::hmac::hmac; +let key = b"Jefe"; +let data = b"what do ya want for nothing?"; +let spec = b"\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38"; +let res = hmac(Type::MD5, key, data); +assert_eq!(res, spec); ++ +
Use the Write trait to supply the input in chunks.
+use std::io::prelude::*; +use openssl::crypto::hash::Type; +use openssl::crypto::hmac::HMAC; +let key = b"Jefe"; +let data: &[&[u8]] = &[b"what do ya ", b"want for nothing?"]; +let spec = b"\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38"; +let mut h = HMAC::new(Type::MD5, &*key); +h.write_all(data[0]); +h.write_all(data[1]); +let res = h.finish(); +assert_eq!(res, spec); ++
impl HMACfn new(ty: Type, key: &[u8]) -> HMACCreates a new HMAC with the specified hash type using the key.
fn finish(&mut self) -> Vec<u8>Returns the hash of the data written since creation or
+the last finish and resets the hasher.
impl Write for HMACfn write(&mut self, buf: &[u8]) -> Result<usize>fn flush(&mut self) -> Result<()>fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>fn by_ref(&mut self) -> &mut Selffn broadcast<W>(self, other: W) -> Broadcast<Self, W> where W: Writeimpl Clone for HMACfn clone(&self) -> HMACfn clone_from(&mut self, source: &Self)impl Drop for HMACfn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| hash | ++ + | +
| hmac | ++ + | +
| memcmp | ++ + | +
| pkcs5 | ++ + | +
| pkey | ++ + | +
| rand | ++ + | +
| symm | ++ + | +
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub fn eq(a: &[u8], b: &[u8]) -> bool
Returns true iff a and b contain the same bytes.
This operation takes an amount of time dependent on the length of the two +arrays given, but is independent of the contents of a and b.
+ +This function will panic the current task if a and b do not have the same
+length.
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| eq | +
+ Returns |
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub fn pbkdf2_hmac_sha1(pass: &str, salt: &[u8], iter: usize, keylen: usize) -> Vec<u8>
Derives a key from a password and salt using the PBKDF2-HMAC-SHA1 algorithm.
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| pbkdf2_hmac_sha1 | +
+ Derives a key from a password and salt using the PBKDF2-HMAC-SHA1 algorithm. + + |
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum EncryptionPadding {
+ OAEP,
+ PKCS1v15,
+}Type of encryption padding to use.
+OAEP | |
PKCS1v15 |
impl Clone for EncryptionPaddingfn clone(&self) -> EncryptionPaddingfn clone_from(&mut self, source: &Self)impl Copy for EncryptionPadding
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum Parts {
+ Neither,
+ Public,
+ Both,
+}Neither | |
Public | |
Both |
impl Clone for Partsfn clone(&self) -> Partsfn clone_from(&mut self, source: &Self)impl Copy for Parts
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum Role {
+ Encrypt,
+ Decrypt,
+ Sign,
+ Verify,
+}Represents a role an asymmetric key might be appropriate for.
+Encrypt | |
Decrypt | |
Sign | |
Verify |
impl Clone for Rolefn clone(&self) -> Rolefn clone_from(&mut self, source: &Self)impl Copy for Role
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| PKey | ++ + | +
| EncryptionPadding | +
+ Type of encryption padding to use. + + |
+
| Parts | ++ + | +
| Role | +
+ Represents a role an asymmetric key might be appropriate for. + + |
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct PKey {
+ // some fields omitted
+}impl PKeyRepresents a public key, optionally with a private key attached.
+fn new() -> PKeyfn from_handle(handle: *mut EVP_PKEY, parts: Parts) -> PKeyfn private_key_from_pem<R>(reader: &mut R) -> Result<PKey, SslError> where R: ReadReads private key from PEM, takes ownership of handle
+fn gen(&mut self, keysz: usize)fn save_pub(&self) -> Vec<u8>Returns a serialized form of the public key, suitable for load_pub().
+fn load_pub(&mut self, s: &[u8])Loads a serialized form of the public key, as produced by save_pub().
+fn save_priv(&self) -> Vec<u8>Returns a serialized form of the public and private keys, suitable for +load_priv().
+fn load_priv(&mut self, s: &[u8])Loads a serialized form of the public and private keys, as produced by +save_priv().
+fn write_pem<W: Write>(&self, writer: &mut W) -> Result<(), SslError>Stores private key as a PEM
+fn size(&self) -> usizeReturns the size of the public key modulus.
+fn can(&self, r: Role) -> boolReturns whether this pkey object can perform the specified role.
+fn max_data(&self) -> usizeReturns the maximum amount of data that can be encrypted by an encrypt() +call.
+fn encrypt_with_padding(&self, s: &[u8], padding: EncryptionPadding) -> Vec<u8>fn decrypt_with_padding(&self, s: &[u8], padding: EncryptionPadding) -> Vec<u8>fn encrypt(&self, s: &[u8]) -> Vec<u8>Encrypts data using OAEP padding, returning the encrypted data. The +supplied data must not be larger than max_data().
+fn decrypt(&self, s: &[u8]) -> Vec<u8>Decrypts data, expecting OAEP padding, returning the decrypted data.
+fn sign(&self, s: &[u8]) -> Vec<u8>Signs data, using OpenSSL's default scheme and adding sha256 ASN.1 information to the +signature. +The bytes to sign must be the result of a sha256 hashing; +returns the signature.
+fn verify(&self, h: &[u8], s: &[u8]) -> boolVerifies a signature s (using OpenSSL's default scheme and sha256) on the SHA256 hash of a +message. +Returns true if the signature is valid, and false otherwise.
+fn sign_with_hash(&self, s: &[u8], hash: Type) -> Vec<u8>Signs data, using OpenSSL's default scheme and add ASN.1 information for the given hash type to the +signature. +The bytes to sign must be the result of this type of hashing; +returns the signature.
+fn verify_with_hash(&self, h: &[u8], s: &[u8], hash: Type) -> boolunsafe fn get_handle(&self) -> *mut EVP_PKEYfn public_eq(&self, other: &PKey) -> boolimpl Drop for PKeyfn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub fn rand_bytes(len: usize) -> Vec<u8>
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| rand_bytes | ++ + | +
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum Mode {
+ Encrypt,
+ Decrypt,
+}Encrypt | |
Decrypt |
impl Clone for Modefn clone(&self) -> Modefn clone_from(&mut self, source: &Self)impl Copy for Mode
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum Type {
+ AES_128_ECB,
+ AES_128_CBC,
+ AES_256_ECB,
+ AES_256_CBC,
+ RC4_128,
+}AES_128_ECB | |
AES_128_CBC | |
AES_256_ECB | |
AES_256_CBC | |
RC4_128 |
impl Clone for Typefn clone(&self) -> Typefn clone_from(&mut self, source: &Self)impl Copy for Type
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub fn decrypt<T: AsRef<[u8]>>(t: Type, key: &[u8], iv: T, data: &[u8]) -> Vec<u8>
Decrypts data, using the specified crypter type in decrypt mode with the +specified key and iv; returns the resulting (decrypted) data.
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub fn encrypt<T: AsRef<[u8]>>(t: Type, key: &[u8], iv: T, data: &[u8]) -> Vec<u8>
Encrypts data, using the specified crypter type in encrypt mode with the +specified key and iv; returns the resulting (encrypted) data.
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| Crypter | +
+ Represents a symmetric cipher context. + + |
+
| Mode | ++ + | +
| Type | ++ + | +
| decrypt | +
+ Decrypts data, using the specified crypter type in decrypt mode with the +specified key and iv; returns the resulting (decrypted) data. + + |
+
| encrypt | +
+ Encrypts data, using the specified crypter type in encrypt mode with the +specified key and iv; returns the resulting (encrypted) data. + + |
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct Crypter {
+ // some fields omitted
+}Represents a symmetric cipher context.
+impl Crypterfn new(t: Type) -> Crypterfn pad(&self, padding: bool)Enables or disables padding. If padding is disabled, total amount of +data encrypted must be a multiple of block size.
+fn init<T: AsRef<[u8]>>(&self, mode: Mode, key: &[u8], iv: T)Initializes this crypter.
+fn update(&self, data: &[u8]) -> Vec<u8>Update this crypter with more data to encrypt or decrypt. Returns +encrypted or decrypted bytes.
+fn finalize(&self) -> Vec<u8>Finish crypting. Returns the remaining partial block of output, if any.
+impl Drop for Crypterfn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| asn1 | ++ + | +
| bio | ++ + | +
| bn | ++ + | +
| crypto | ++ + | +
| nid | ++ + | +
| ssl | ++ + | +
| x509 | ++ + | +
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum Nid {
+ Undefined,
+ Rsadsi,
+ Pkcs,
+ MD2,
+ MD4,
+ MD5,
+ RC4,
+ RsaEncryption,
+ RSA_MD2,
+ RSA_MD5,
+ PBE_MD2_DES,
+ X500,
+ x509,
+ CN,
+ C,
+ L,
+ ST,
+ O,
+ OU,
+ RSA,
+ Pkcs7,
+ Pkcs7_data,
+ Pkcs7_signedData,
+ Pkcs7_envelopedData,
+ Pkcs7_signedAndEnvelopedData,
+ Pkcs7_digestData,
+ Pkcs7_encryptedData,
+ Pkcs3,
+ DhKeyAgreement,
+ DES_ECB,
+ DES_CFB,
+ DES_CBC,
+ DES_EDE,
+ DES_EDE3,
+ IDEA_CBC,
+ IDEA_ECB,
+ RC2_CBC,
+ RC2_ECB,
+ RC2_CFB,
+ RC2_OFB,
+ SHA,
+ RSA_SHA,
+ DES_EDE_CBC,
+ DES_EDE3_CBC,
+ DES_OFB,
+ IDEA_OFB,
+ Pkcs9,
+ Email,
+ UnstructuredName,
+ ContentType,
+ MessageDigest,
+ SigningTime,
+ CounterSignature,
+ UnstructuredAddress,
+ ExtendedCertificateAttributes,
+ Netscape,
+ NetscapeCertExtention,
+ NetscapeDatatype,
+ DES_EDE_CFB64,
+ DES_EDE3_CFB64,
+ DES_EDE_OFB64,
+ DES_EDE3_OFB64,
+ SHA1,
+ RSA_SHA1,
+ DSA_SHA,
+ DSA_OLD,
+ PBE_SHA1_RC2_64,
+ PBKDF2,
+ DSA_SHA1_OLD,
+ NetscapeCertType,
+ NetscapeBaseUrl,
+ NetscapeRevocationUrl,
+ NetscapeCARevocationUrl,
+ NetscapeRenewalUrl,
+ NetscapeCAPolicyUrl,
+ NetscapeSSLServerName,
+ NetscapeComment,
+ NetscapeCertSequence,
+ DESX_CBC,
+ ID_CE,
+ SubjectKeyIdentifier,
+ KeyUsage,
+ PrivateKeyUsagePeriod,
+ SubjectAltName,
+ IssuerAltName,
+ BasicConstraints,
+ CrlNumber,
+ CertificatePolicies,
+ AuthorityKeyIdentifier,
+ BF_CBC,
+ BF_ECB,
+ BF_OFB,
+ MDC2,
+ RSA_MDC2,
+ RC4_40,
+ RC2_40_CBC,
+ G,
+ S,
+ I,
+ UID,
+ CrlDistributionPoints,
+ RSA_NP_MD5,
+ SN,
+ T,
+ D,
+ CAST5_CBC,
+ CAST5_ECB,
+ CAST5_CFB,
+ CAST5_OFB,
+ PbeWithMD5AndCast5CBC,
+ DSA_SHA1,
+ MD5_SHA1,
+ RSA_SHA1_2,
+ DSA,
+ RIPEMD160,
+ RSA_RIPEMD160,
+ RC5_CBC,
+ RC5_ECB,
+ RC5_CFB,
+ RC5_OFB,
+ RLE,
+ ZLIB,
+ ExtendedKeyUsage,
+ PKIX,
+ ID_KP,
+ ServerAuth,
+ ClientAuth,
+ CodeSigning,
+ EmailProtection,
+ TimeStamping,
+ MsCodeInd,
+ MsCodeCom,
+ MsCtlSigh,
+ MsSGC,
+ MsEFS,
+ NsSGC,
+ DeltaCRL,
+ CRLReason,
+ InvalidityDate,
+ SXNetID,
+ Pkcs12,
+ PBE_SHA1_RC4_128,
+ PBE_SHA1_RC4_40,
+ PBE_SHA1_3DES,
+ PBE_SHA1_2DES,
+ PBE_SHA1_RC2_128,
+ PBE_SHA1_RC2_40,
+ KeyBag,
+ Pkcs8ShroudedKeyBag,
+ CertBag,
+ CrlBag,
+ SecretBag,
+ SafeContentsBag,
+ FriendlyName,
+ LocalKeyID,
+ X509Certificate,
+ SdsiCertificate,
+ X509Crl,
+ PBES2,
+ PBMAC1,
+ HmacWithSha1,
+ ID_QT_CPS,
+ ID_QT_UNOTICE,
+ RC2_64_CBC,
+ SMIMECaps,
+}Undefined | |
Rsadsi | |
Pkcs | |
MD2 | |
MD4 | |
MD5 | |
RC4 | |
RsaEncryption | |
RSA_MD2 | |
RSA_MD5 | |
PBE_MD2_DES | |
X500 | |
x509 | |
CN | |
C | |
L | |
ST | |
O | |
OU | |
RSA | |
Pkcs7 | |
Pkcs7_data | |
Pkcs7_signedData | |
Pkcs7_envelopedData | |
Pkcs7_signedAndEnvelopedData | |
Pkcs7_digestData | |
Pkcs7_encryptedData | |
Pkcs3 | |
DhKeyAgreement | |
DES_ECB | |
DES_CFB | |
DES_CBC | |
DES_EDE | |
DES_EDE3 | |
IDEA_CBC | |
IDEA_ECB | |
RC2_CBC | |
RC2_ECB | |
RC2_CFB | |
RC2_OFB | |
SHA | |
RSA_SHA | |
DES_EDE_CBC | |
DES_EDE3_CBC | |
DES_OFB | |
IDEA_OFB | |
Pkcs9 | |
Email | |
UnstructuredName | |
ContentType | |
MessageDigest | |
SigningTime | |
CounterSignature | |
UnstructuredAddress | |
ExtendedCertificateAttributes | |
Netscape | |
NetscapeCertExtention | |
NetscapeDatatype | |
DES_EDE_CFB64 | |
DES_EDE3_CFB64 | |
DES_EDE_OFB64 | |
DES_EDE3_OFB64 | |
SHA1 | |
RSA_SHA1 | |
DSA_SHA | |
DSA_OLD | |
PBE_SHA1_RC2_64 | |
PBKDF2 | |
DSA_SHA1_OLD | |
NetscapeCertType | |
NetscapeBaseUrl | |
NetscapeRevocationUrl | |
NetscapeCARevocationUrl | |
NetscapeRenewalUrl | |
NetscapeCAPolicyUrl | |
NetscapeSSLServerName | |
NetscapeComment | |
NetscapeCertSequence | |
DESX_CBC | |
ID_CE | |
SubjectKeyIdentifier | |
KeyUsage | |
PrivateKeyUsagePeriod | |
SubjectAltName | |
IssuerAltName | |
BasicConstraints | |
CrlNumber | |
CertificatePolicies | |
AuthorityKeyIdentifier | |
BF_CBC | |
BF_ECB | |
BF_OFB | |
MDC2 | |
RSA_MDC2 | |
RC4_40 | |
RC2_40_CBC | |
G | |
S | |
I | |
UID | |
CrlDistributionPoints | |
RSA_NP_MD5 | |
SN | |
T | |
D | |
CAST5_CBC | |
CAST5_ECB | |
CAST5_CFB | |
CAST5_OFB | |
PbeWithMD5AndCast5CBC | |
DSA_SHA1 | |
MD5_SHA1 | |
RSA_SHA1_2 | |
DSA | |
RIPEMD160 | |
RSA_RIPEMD160 | |
RC5_CBC | |
RC5_ECB | |
RC5_CFB | |
RC5_OFB | |
RLE | |
ZLIB | |
ExtendedKeyUsage | |
PKIX | |
ID_KP | |
ServerAuth | |
ClientAuth | |
CodeSigning | |
EmailProtection | |
TimeStamping | |
MsCodeInd | |
MsCodeCom | |
MsCtlSigh | |
MsSGC | |
MsEFS | |
NsSGC | |
DeltaCRL | |
CRLReason | |
InvalidityDate | |
SXNetID | |
Pkcs12 | |
PBE_SHA1_RC4_128 | |
PBE_SHA1_RC4_40 | |
PBE_SHA1_3DES | |
PBE_SHA1_2DES | |
PBE_SHA1_RC2_128 | |
PBE_SHA1_RC2_40 | |
KeyBag | |
Pkcs8ShroudedKeyBag | |
CertBag | |
CrlBag | |
SecretBag | |
SafeContentsBag | |
FriendlyName | |
LocalKeyID | |
X509Certificate | |
SdsiCertificate | |
X509Crl | |
PBES2 | |
PBMAC1 | |
HmacWithSha1 | |
ID_QT_CPS | |
ID_QT_UNOTICE | |
RC2_64_CBC | |
SMIMECaps |
impl Clone for Nidfn clone(&self) -> Nidfn clone_from(&mut self, source: &Self)impl Copy for Nid
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| Nid | ++ + | +
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_ALL: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_CIPHER_SERVER_PREFERENCE: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_CISCO_ANYCONNECT: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_COOKIE_EXCHANGE: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_LEGACY_SERVER_CONNECT: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_COMPRESSION: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_DTLSV1: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_DTLSV1_2: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_QUERY_MTU: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_SSLV2: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_SSLV3: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_TICKET: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_TLSV1: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_TLSV1_1: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_NO_TLSV1_2: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_SAFARI_ECDHE_ECDSA_BUG: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_SINGLE_DH_USE: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_SINGLE_ECDH_USE: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_SSLEAY_080_CLIENT_DH_BUG: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_TLSEXT_PADDING: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_TLS_BLOCK_PADDING_BUG: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_TLS_D5_BUG: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_OP_TLS_ROLLBACK_BUG: SslContextOptions=$ BitFlags { +bits : $ value }
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_VERIFY_FAIL_IF_NO_PEER_CERT: SslVerifyMode=$ BitFlags { +bits : $ value }
/// Terminate handshake if client did not return a certificate. +/// Use together with SSL_VERIFY_PEER.
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_VERIFY_NONE: SslVerifyMode=$ BitFlags { +bits : $ value }
/// Do not verify the server's certificate
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub const SSL_VERIFY_PEER: SslVerifyMode=$ BitFlags { +bits : $ value }
/// Verify that the server's certificate is trusted
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum MaybeSslStream<S> where S: Read + Write { + Ssl(SslStream<S>), + Normal(S), +}
A utility type to help in cases where the use of SSL is decided at runtime.
+Ssl | A connection using SSL + |
Normal | A connection not using SSL + |
impl<S> MaybeSslStream<S> where S: Read + Writefn get_ref(&self) -> &SReturns a reference to the underlying stream.
+fn get_mut(&mut self) -> &mut SReturns a mutable reference to the underlying stream.
+ +It is inadvisable to read from or write to the underlying stream.
+impl<S> Read for MaybeSslStream<S> where S: Read + Writefn read(&mut self, buf: &mut [u8]) -> Result<usize>fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>fn by_ref(&mut self) -> &mut Selffn bytes(self) -> Bytes<Self>fn chars(self) -> Chars<Self>fn chain<R>(self, next: R) -> Chain<Self, R> where R: Readfn take(self, limit: u64) -> Take<Self>fn tee<W>(self, out: W) -> Tee<Self, W> where W: Writeimpl<S> Write for MaybeSslStream<S> where S: Read + Writefn write(&mut self, buf: &[u8]) -> Result<usize>fn flush(&mut self) -> Result<()>fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>fn by_ref(&mut self) -> &mut Selffn broadcast<W>(self, other: W) -> Broadcast<Self, W> where W: Writeimpl<S: Debug> Debug for MaybeSslStream<S> where S: Read + Write, S: Debug, S: Debug
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum SslMethod {
+ Sslv23,
+ Sslv3,
+ Tlsv1,
+}Determines the SSL method supported
+Sslv23 | Support the SSLv2, SSLv3 and TLSv1 protocols. + |
Sslv3 | Only support the SSLv3 protocol. + |
Tlsv1 | Only support the TLSv1 protocol. + |
impl SslMethodimpl Eq for SslMethodimpl PartialEq for SslMethodimpl Hash for SslMethodfn hash<__H: Hasher>(&self, __arg_0: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasherimpl Debug for SslMethodimpl Clone for SslMethodfn clone(&self) -> SslMethodfn clone_from(&mut self, source: &Self)impl Copy for SslMethod
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum OpensslError {
+ UnknownError {
+ library: String,
+ function: String,
+ reason: String,
+ },
+}An error from the OpenSSL library
+UnknownError | An unknown error +Fields+ +
|
impl Eq for OpensslErrorimpl PartialEq for OpensslErrorfn eq(&self, __arg_0: &OpensslError) -> boolfn ne(&self, __arg_0: &OpensslError) -> boolimpl Clone for OpensslErrorfn clone(&self) -> OpensslErrorfn clone_from(&mut self, source: &Self)impl Debug for OpensslError
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum SslError {
+ StreamError(Error),
+ SslSessionClosed,
+ OpenSslErrors(Vec<OpensslError>),
+}An SSL error
+StreamError | The underlying stream reported an error + |
SslSessionClosed | The SSL session has been closed by the other end + |
OpenSslErrors | An error in the OpenSSL library + |
impl SslErrorfn get() -> SslErrorCreates a new OpenSslErrors with the current contents of the error
+stack.
fn from_error(err: c_ulong) -> SslErrorCreates an SslError from the raw numeric error code.
impl Display for SslErrorimpl Error for SslErrorfn description(&self) -> &strfn cause(&self) -> Option<&Error>impl Debug for SslError
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub use self::SslError::*; |
pub use self::OpensslError::*; |
| OpensslError | +
+ An error from the OpenSSL library + + |
+
| SslError | +
+ An SSL error + + |
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| error | ++ + | +
| Ssl | ++ + | +
| SslContext | +
+ An SSL context object + + |
+
| SslContextOptions | ++ + | +
| SslStream | +
+ A stream wrapper which handles SSL encryption for an underlying stream. + + |
+
| SslVerifyMode | ++ + | +
| MaybeSslStream | +
+ A utility type to help in cases where the use of SSL is decided at runtime. + + |
+
| SslMethod | +
+ Determines the SSL method supported + + |
+
| VerifyCallback | +
+ The signature of functions that can be used to manually verify certificates + + |
+
| VerifyCallbackData | +
+ The signature of functions that can be used to manually verify certificates +when user-data should be carried for all verification process + + |
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct Ssl {
+ // some fields omitted
+}impl Sslfn new(ctx: &SslContext) -> Result<Ssl, SslError>fn set_hostname(&self, hostname: &str) -> Result<(), SslError>Set the host name to be used with SNI (Server Name Indication).
+fn get_peer_certificate(&self) -> Option<X509>fn pending(&self) -> usizepending() takes into account only bytes from the TLS/SSL record that is currently being processed (if any).
+impl Send for Sslimpl Sync for Sslimpl Debug for Sslimpl Drop for Sslfn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct SslContext {
+ // some fields omitted
+}An SSL context object
+impl SslContextfn new(method: SslMethod) -> Result<SslContext, SslError>Creates a new SSL context.
+fn set_verify(&mut self, mode: SslVerifyMode, verify: Option<VerifyCallback>)Configures the certificate verification method for new connections.
+fn set_verify_with_data<T>(&mut self, mode: SslVerifyMode, verify: VerifyCallbackData<T>, data: T) where T: Any + 'staticConfigures the certificate verification method for new connections also +carrying supplied data.
+fn set_verify_depth(&mut self, depth: u32)Sets verification depth
+fn set_read_ahead(&self, m: u32)fn set_CA_file<P: AsRef<Path>>(&mut self, file: P) -> Result<(), SslError>Specifies the file that contains trusted CA certificates.
+fn set_certificate_file<P: AsRef<Path>>(&mut self, file: P, file_type: X509FileType) -> Result<(), SslError>Specifies the file that contains certificate
+fn set_certificate(&mut self, cert: &X509) -> Result<(), SslError>Specifies the certificate
+fn add_extra_chain_cert(&mut self, cert: &X509) -> Result<(), SslError>Adds a certificate to the certificate chain presented together with the +certificate specified using set_certificate()
+fn set_private_key_file<P: AsRef<Path>>(&mut self, file: P, file_type: X509FileType) -> Result<(), SslError>Specifies the file that contains private key
+fn set_private_key(&mut self, key: &PKey) -> Result<(), SslError>Specifies the private key
+fn check_private_key(&mut self) -> Result<(), SslError>Check consistency of private key and certificate
+fn set_cipher_list(&mut self, cipher_list: &str) -> Result<(), SslError>fn set_options(&mut self, option: SslContextOptions) -> SslContextOptionsfn get_options(&mut self) -> SslContextOptionsfn clear_options(&mut self, option: SslContextOptions) -> SslContextOptionsimpl Send for SslContextimpl Sync for SslContextimpl Debug for SslContextimpl Drop for SslContextfn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct SslContextOptions {
+ // some fields omitted
+}impl SslContextOptionsfn empty() -> SslContextOptionsReturns an empty set of flags.
+fn all() -> SslContextOptionsReturns the set containing all flags.
+fn bits(&self) -> c_longReturns the raw value of the flags currently stored.
+fn from_bits(bits: c_long) -> Option<SslContextOptions>Convert from underlying bit representation, unless that +representation contains bits that do not correspond to a flag.
+fn from_bits_truncate(bits: c_long) -> SslContextOptionsConvert from underlying bit representation, dropping any bits +that do not correspond to flags.
+fn is_empty(&self) -> boolReturns true if no flags are currently stored.
fn is_all(&self) -> boolReturns true if all flags are currently set.
fn intersects(&self, other: SslContextOptions) -> boolReturns true if there are flags common to both self and other.
fn contains(&self, other: SslContextOptions) -> boolReturns true all of the flags in other are contained within self.
fn insert(&mut self, other: SslContextOptions)Inserts the specified flags in-place.
+fn remove(&mut self, other: SslContextOptions)Removes the specified flags in-place.
+fn toggle(&mut self, other: SslContextOptions)Toggles the specified flags in-place.
+impl Debug for SslContextOptionsimpl BitOr for SslContextOptionstype Output = SslContextOptionsfn bitor(self, other: SslContextOptions) -> SslContextOptionsimpl BitXor for SslContextOptionstype Output = SslContextOptionsfn bitxor(self, other: SslContextOptions) -> SslContextOptionsimpl BitAnd for SslContextOptionstype Output = SslContextOptionsfn bitand(self, other: SslContextOptions) -> SslContextOptionsimpl Sub for SslContextOptionstype Output = SslContextOptionsfn sub(self, other: SslContextOptions) -> SslContextOptionsimpl Not for SslContextOptionstype Output = SslContextOptionsfn not(self) -> SslContextOptionsimpl Hash for SslContextOptionsfn hash<__H: Hasher>(&self, __arg_0: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasherimpl Ord for SslContextOptionsfn cmp(&self, __arg_0: &SslContextOptions) -> Orderingimpl PartialOrd for SslContextOptionsfn partial_cmp(&self, __arg_0: &SslContextOptions) -> Option<Ordering>fn lt(&self, __arg_0: &SslContextOptions) -> boolfn le(&self, __arg_0: &SslContextOptions) -> boolfn gt(&self, __arg_0: &SslContextOptions) -> boolfn ge(&self, __arg_0: &SslContextOptions) -> boolimpl Clone for SslContextOptionsfn clone(&self) -> SslContextOptionsfn clone_from(&mut self, source: &Self)impl Eq for SslContextOptionsimpl PartialEq for SslContextOptionsfn eq(&self, __arg_0: &SslContextOptions) -> boolfn ne(&self, __arg_0: &SslContextOptions) -> boolimpl Copy for SslContextOptions
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct SslStream<S> {
+ // some fields omitted
+}A stream wrapper which handles SSL encryption for an underlying stream.
+impl SslStream<TcpStream>fn try_clone(&self) -> Result<SslStream<TcpStream>>Create a new independently owned handle to the underlying socket.
+impl<S: Read + Write> SslStream<S>fn new_server_from(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError>fn new_from(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError>Attempts to create a new SSL stream from a given Ssl instance.
fn new(ctx: &SslContext, stream: S) -> Result<SslStream<S>, SslError>Creates a new SSL stream
+fn new_server(ctx: &SslContext, stream: S) -> Result<SslStream<S>, SslError>Creates a new SSL server stream
+fn get_ref(&self) -> &SReturns a reference to the underlying stream.
+fn get_peer_certificate(&self) -> Option<X509>Return the certificate of the peer
+fn get_mut(&mut self) -> &mut SReturns a mutable reference to the underlying stream.
+ +It is inadvisable to read from or write to the underlying stream as it +will most likely desynchronize the SSL session.
+fn get_compression(&self) -> Option<String>Get the compression currently in use. The result will be +either None, indicating no compression is in use, or a string +with the compression name.
+fn pending(&self) -> usizepending() takes into account only bytes from the TLS/SSL record that is currently being processed (if any).
+impl<S> Debug for SslStream<S> where S: Debugimpl<S: Read + Write> Read for SslStream<S>fn read(&mut self, buf: &mut [u8]) -> Result<usize>fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>fn by_ref(&mut self) -> &mut Selffn bytes(self) -> Bytes<Self>fn chars(self) -> Chars<Self>fn chain<R>(self, next: R) -> Chain<Self, R> where R: Readfn take(self, limit: u64) -> Take<Self>fn tee<W>(self, out: W) -> Tee<Self, W> where W: Writeimpl<S: Read + Write> Write for SslStream<S>fn write(&mut self, buf: &[u8]) -> Result<usize>fn flush(&mut self) -> Result<()>fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>fn by_ref(&mut self) -> &mut Selffn broadcast<W>(self, other: W) -> Broadcast<Self, W> where W: Writeimpl<S: Clone> Clone for SslStream<S> where S: Clonefn clone(&self) -> SslStream<S>fn clone_from(&mut self, source: &Self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct SslVerifyMode {
+ // some fields omitted
+}impl SslVerifyModefn empty() -> SslVerifyModeReturns an empty set of flags.
+fn all() -> SslVerifyModeReturns the set containing all flags.
+fn bits(&self) -> i32Returns the raw value of the flags currently stored.
+fn from_bits(bits: i32) -> Option<SslVerifyMode>Convert from underlying bit representation, unless that +representation contains bits that do not correspond to a flag.
+fn from_bits_truncate(bits: i32) -> SslVerifyModeConvert from underlying bit representation, dropping any bits +that do not correspond to flags.
+fn is_empty(&self) -> boolReturns true if no flags are currently stored.
fn is_all(&self) -> boolReturns true if all flags are currently set.
fn intersects(&self, other: SslVerifyMode) -> boolReturns true if there are flags common to both self and other.
fn contains(&self, other: SslVerifyMode) -> boolReturns true all of the flags in other are contained within self.
fn insert(&mut self, other: SslVerifyMode)Inserts the specified flags in-place.
+fn remove(&mut self, other: SslVerifyMode)Removes the specified flags in-place.
+fn toggle(&mut self, other: SslVerifyMode)Toggles the specified flags in-place.
+impl Debug for SslVerifyModeimpl BitOr for SslVerifyModetype Output = SslVerifyModefn bitor(self, other: SslVerifyMode) -> SslVerifyModeimpl BitXor for SslVerifyModetype Output = SslVerifyModefn bitxor(self, other: SslVerifyMode) -> SslVerifyModeimpl BitAnd for SslVerifyModetype Output = SslVerifyModefn bitand(self, other: SslVerifyMode) -> SslVerifyModeimpl Sub for SslVerifyModetype Output = SslVerifyModefn sub(self, other: SslVerifyMode) -> SslVerifyModeimpl Not for SslVerifyModetype Output = SslVerifyModefn not(self) -> SslVerifyModeimpl Hash for SslVerifyModefn hash<__H: Hasher>(&self, __arg_0: &mut __H)fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasherimpl Ord for SslVerifyModefn cmp(&self, __arg_0: &SslVerifyMode) -> Orderingimpl PartialOrd for SslVerifyModefn partial_cmp(&self, __arg_0: &SslVerifyMode) -> Option<Ordering>fn lt(&self, __arg_0: &SslVerifyMode) -> boolfn le(&self, __arg_0: &SslVerifyMode) -> boolfn gt(&self, __arg_0: &SslVerifyMode) -> boolfn ge(&self, __arg_0: &SslVerifyMode) -> boolimpl Clone for SslVerifyModefn clone(&self) -> SslVerifyModefn clone_from(&mut self, source: &Self)impl Eq for SslVerifyModeimpl PartialEq for SslVerifyModefn eq(&self, __arg_0: &SslVerifyMode) -> boolfn ne(&self, __arg_0: &SslVerifyMode) -> boolimpl Copy for SslVerifyMode
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
type VerifyCallback = fn(preverify_ok: bool, x509_ctx: &X509StoreContext) -> bool;
The signature of functions that can be used to manually verify certificates
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
type VerifyCallbackData<T> = fn(preverify_ok: bool, x509_ctx: &X509StoreContext, data: &T) -> bool;
The signature of functions that can be used to manually verify certificates +when user-data should be carried for all verification process
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum ExtKeyUsage {
+ ServerAuth,
+ ClientAuth,
+ CodeSigning,
+ EmailProtection,
+ TimeStamping,
+ MsCodeInd,
+ MsCodeCom,
+ MsCtlSign,
+ MsSgc,
+ MsEfs,
+ NsSgc,
+}ServerAuth | |
ClientAuth | |
CodeSigning | |
EmailProtection | |
TimeStamping | |
MsCodeInd | |
MsCodeCom | |
MsCtlSign | |
MsSgc | |
MsEfs | |
NsSgc |
impl Copy for ExtKeyUsageimpl Clone for ExtKeyUsagefn clone(&self) -> ExtKeyUsagefn clone_from(&mut self, source: &Self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum KeyUsage {
+ DigitalSignature,
+ NonRepudiation,
+ KeyEncipherment,
+ DataEncipherment,
+ KeyAgreement,
+ KeyCertSign,
+ CRLSign,
+ EncipherOnly,
+ DecipherOnly,
+}DigitalSignature | |
NonRepudiation | |
KeyEncipherment | |
DataEncipherment | |
KeyAgreement | |
KeyCertSign | |
CRLSign | |
EncipherOnly | |
DecipherOnly |
impl Copy for KeyUsageimpl Clone for KeyUsagefn clone(&self) -> KeyUsagefn clone_from(&mut self, source: &Self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum X509FileType {
+ PEM,
+ ASN1,
+ Default,
+}PEM | |
ASN1 | |
Default |
impl Clone for X509FileTypefn clone(&self) -> X509FileTypefn clone_from(&mut self, source: &Self)impl Copy for X509FileType
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub enum X509ValidationError {
+ X509UnableToGetIssuerCert,
+ X509UnableToGetCrl,
+ X509UnableToDecryptCertSignature,
+ X509UnableToDecryptCrlSignature,
+ X509UnableToDecodeIssuerPublicKey,
+ X509CertSignatureFailure,
+ X509CrlSignatureFailure,
+ X509CertNotYetValid,
+ X509CertHasExpired,
+ X509CrlNotYetValid,
+ X509CrlHasExpired,
+ X509ErrorInCertNotBeforeField,
+ X509ErrorInCertNotAfterField,
+ X509ErrorInCrlLastUpdateField,
+ X509ErrorInCrlNextUpdateField,
+ X509OutOfMem,
+ X509DepthZeroSelfSignedCert,
+ X509SelfSignedCertInChain,
+ X509UnableToGetIssuerCertLocally,
+ X509UnableToVerifyLeafSignature,
+ X509CertChainTooLong,
+ X509CertRevoked,
+ X509InvalidCA,
+ X509PathLengthExceeded,
+ X509InvalidPurpose,
+ X509CertUntrusted,
+ X509CertRejected,
+ X509SubjectIssuerMismatch,
+ X509AkidSkidMismatch,
+ X509AkidIssuerSerialMismatch,
+ X509KeyusageNoCertsign,
+ X509UnableToGetCrlIssuer,
+ X509UnhandledCriticalExtension,
+ X509KeyusageNoCrlSign,
+ X509UnhandledCriticalCrlExtension,
+ X509InvalidNonCA,
+ X509ProxyPathLengthExceeded,
+ X509KeyusageNoDigitalSignature,
+ X509ProxyCertificatesNotAllowed,
+ X509InvalidExtension,
+ X509InavlidPolicyExtension,
+ X509NoExplicitPolicy,
+ X509DifferentCrlScope,
+ X509UnsupportedExtensionFeature,
+ X509UnnestedResource,
+ X509PermittedVolation,
+ X509ExcludedViolation,
+ X509SubtreeMinmax,
+ X509UnsupportedConstraintType,
+ X509UnsupportedConstraintSyntax,
+ X509UnsupportedNameSyntax,
+ X509CrlPathValidationError,
+ X509ApplicationVerification,
+ X509UnknownError(c_int),
+}X509UnableToGetIssuerCert | |
X509UnableToGetCrl | |
X509UnableToDecryptCertSignature | |
X509UnableToDecryptCrlSignature | |
X509UnableToDecodeIssuerPublicKey | |
X509CertSignatureFailure | |
X509CrlSignatureFailure | |
X509CertNotYetValid | |
X509CertHasExpired | |
X509CrlNotYetValid | |
X509CrlHasExpired | |
X509ErrorInCertNotBeforeField | |
X509ErrorInCertNotAfterField | |
X509ErrorInCrlLastUpdateField | |
X509ErrorInCrlNextUpdateField | |
X509OutOfMem | |
X509DepthZeroSelfSignedCert | |
X509SelfSignedCertInChain | |
X509UnableToGetIssuerCertLocally | |
X509UnableToVerifyLeafSignature | |
X509CertChainTooLong | |
X509CertRevoked | |
X509InvalidCA | |
X509PathLengthExceeded | |
X509InvalidPurpose | |
X509CertUntrusted | |
X509CertRejected | |
X509SubjectIssuerMismatch | |
X509AkidSkidMismatch | |
X509AkidIssuerSerialMismatch | |
X509KeyusageNoCertsign | |
X509UnableToGetCrlIssuer | |
X509UnhandledCriticalExtension | |
X509KeyusageNoCrlSign | |
X509UnhandledCriticalCrlExtension | |
X509InvalidNonCA | |
X509ProxyPathLengthExceeded | |
X509KeyusageNoDigitalSignature | |
X509ProxyCertificatesNotAllowed | |
X509InvalidExtension | |
X509InavlidPolicyExtension | |
X509NoExplicitPolicy | |
X509DifferentCrlScope | |
X509UnsupportedExtensionFeature | |
X509UnnestedResource | |
X509PermittedVolation | |
X509ExcludedViolation | |
X509SubtreeMinmax | |
X509UnsupportedConstraintType | |
X509UnsupportedConstraintSyntax | |
X509UnsupportedNameSyntax | |
X509CrlPathValidationError | |
X509ApplicationVerification | |
X509UnknownError |
impl Clone for X509ValidationErrorfn clone(&self) -> X509ValidationErrorfn clone_from(&mut self, source: &Self)impl Copy for X509ValidationError
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
| SslString | ++ + | +
| X509 | +
+ A public key certificate + + |
+
| X509Generator | +
+ Generator of private key/certificate pairs + + |
+
| X509Name | ++ + | +
| X509NameEntry | ++ + | +
| X509Req | +
+ A certificate signing request + + |
+
| X509StoreContext | ++ + | +
| ExtKeyUsage | ++ + | +
| KeyUsage | ++ + | +
| X509FileType | ++ + | +
| X509ValidationError | ++ + | +
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct SslString {
+ // some fields omitted
+}fn len(&self) -> usizeReturns the length of self in bytes.
+assert_eq!("foo".len(), 3); +assert_eq!("ƒoo".len(), 4); // fancy f! ++
fn is_empty(&self) -> boolfn width(&self, is_cjk: bool) -> usize: use the crates.io unicode-width library instead
Returns a string's displayed width in columns.
+ +Control characters have zero width.
+ +is_cjk determines behavior for characters in the Ambiguous category:
+if is_cjk is
+true, these are 2 columns wide; otherwise, they are 1.
+In CJK locales, is_cjk should be
+true, else it should be false.
+Unicode Standard Annex #11
+recommends that these
+characters be treated as 1 column (i.e., is_cjk = false) if the
+locale is unknown.
fn is_char_boundary(&self, index: usize) -> bool: it is unclear whether this method pulls its weight with the existence of the char_indices iterator or this method may want to be replaced with checked slicing
+Checks that index-th byte lies at the start and/or end of a
+UTF-8 code point sequence.
The start and end of the string (when index == self.len()) are
+considered to be
+boundaries.
Panics if index is greater than self.len().
+let s = "Löwe 老虎 Léopard"; +assert!(s.is_char_boundary(0)); +// start of `老` +assert!(s.is_char_boundary(6)); +assert!(s.is_char_boundary(s.len())); + +// second byte of `ö` +assert!(!s.is_char_boundary(2)); + +// third byte of `老` +assert!(!s.is_char_boundary(8)); ++
fn as_bytes(&self) -> &[u8]fn as_ptr(&self) -> *const u8Returns a raw pointer to the &str's buffer.
The caller must ensure that the string outlives this pointer, and +that it is not +reallocated (e.g. by pushing to the string).
+ ++let s = "Hello"; +let p = s.as_ptr(); ++
unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &strTakes a bytewise slice from a string.
+ +Returns the substring from [begin..end).
Caller must check both UTF-8 character boundaries and the boundaries +of the entire slice as +well.
+ ++let s = "Löwe 老虎 Léopard"; + +unsafe { + assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard"); +} ++
fn slice_chars(&self, begin: usize, end: usize) -> &str: may have yet to prove its worth
+Returns a slice of the string from the character range [begin..end).
That is, start at the begin-th code point of the string and continue
+to the end-th code point. This does not detect or handle edge cases
+such as leaving a combining character as the first code point of the
+string.
Due to the design of UTF-8, this operation is O(end). Use slicing
+syntax if you want to use byte indices rather than codepoint indices.
Panics if begin > end or the either begin or end are beyond the
+last character of the string.
+let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.slice_chars(0, 4), "Löwe"); +assert_eq!(s.slice_chars(5, 7), "老虎"); ++
fn char_range_at(&self, start: usize) -> CharRange: often replaced by char_indices, this method may be removed in favor of just char_at() or eventually removed altogether
+Given a byte position, return the next char and its index.
+ +This can be used to iterate over the Unicode characters of a string.
+ +If i is greater than or equal to the length of the string.
+If i is not the index of the beginning of a valid UTF-8 character.
This example manually iterates through the characters of a string;
+this should normally be
+done by .chars() or .char_indices().
+use std::str::CharRange; + +let s = "中华Việt Nam"; +let mut i = 0; +while i < s.len() { + let CharRange {ch, next} = s.char_range_at(i); + println!("{}: {}", i, ch); + i = next; +} ++ +
This outputs:
+ +0: 中
+3: 华
+6: V
+7: i
+8: ệ
+11: t
+12:
+13: N
+14: a
+15: m
+fn char_range_at_reverse(&self, start: usize) -> CharRange: often replaced by char_indices, this method may be removed in favor of just char_at_reverse() or eventually removed altogether
+Given a byte position, return the previous char and its position.
This function can be used to iterate over a Unicode string in reverse.
+ +Returns 0 for next index if called on start index 0.
+ +If i is greater than the length of the string.
+If i is not an index following a valid UTF-8 character.
This example manually iterates through the characters of a string;
+this should normally be
+done by .chars().rev() or .char_indices().
+use std::str::CharRange; + +let s = "中华Việt Nam"; +let mut i = s.len(); +while i > 0 { + let CharRange {ch, next} = s.char_range_at_reverse(i); + println!("{}: {}", i, ch); + i = next; +} ++ +
This outputs:
+ +16: m
+15: a
+14: N
+13:
+12: t
+11: ệ
+8: i
+7: V
+6: 华
+3: 中
+fn char_at(&self, i: usize) -> char: frequently replaced by the chars() iterator, this method may be removed or possibly renamed in the future; it is normally replaced by chars/char_indices iterators or by getting the first char from a subslice
+Given a byte position, return the char at that position.
If i is greater than or equal to the length of the string.
+If i is not the index of the beginning of a valid UTF-8 character.
+let s = "abπc"; +assert_eq!(s.char_at(1), 'b'); +assert_eq!(s.char_at(2), 'π'); ++
fn char_at_reverse(&self, i: usize) -> char: see char_at for more details, but reverse semantics are also somewhat unclear, especially with which cases generate panics
+Given a byte position, return the char at that position, counting
+from the end.
If i is greater than the length of the string.
+If i is not an index following a valid UTF-8 character.
+let s = "abπc"; +assert_eq!(s.char_at_reverse(1), 'a'); +assert_eq!(s.char_at_reverse(2), 'b'); ++
fn slice_shift_char(&self) -> Option<(char, &str)>: awaiting conventions about shifting and slices and may not be warranted with the existence of the chars and/or char_indices iterators
+Retrieves the first character from a &str and returns it.
This does not allocate a new string; instead, it returns a slice that +points one character +beyond the character that was shifted.
+ +If the slice does not contain any characters, None is returned instead.
+ ++let s = "Löwe 老虎 Léopard"; +let (c, s1) = s.slice_shift_char().unwrap(); + +assert_eq!(c, 'L'); +assert_eq!(s1, "öwe 老虎 Léopard"); + +let (c, s2) = s1.slice_shift_char().unwrap(); + +assert_eq!(c, 'ö'); +assert_eq!(s2, "we 老虎 Léopard"); ++
fn split_at(&self, mid: usize) -> (&str, &str): library is unlikely to be stabilized with the current layout and name, use std::collections instead
+Divide one string slice into two at an index.
+ +The index mid is a byte offset from the start of the string
+that must be on a character boundary.
Return slices &self[..mid] and &self[mid..].
Panics if mid is beyond the last character of the string,
+or if it is not on a character boundary.
+let s = "Löwe 老虎 Léopard"; +let first_space = s.find(' ').unwrap_or(s.len()); +let (a, b) = s.split_at(first_space); + +assert_eq!(a, "Löwe"); +assert_eq!(b, " 老虎 Léopard"); ++
fn chars(&self) -> CharsAn iterator over the codepoints of self.
+let v: Vec<char> = "abc åäö".chars().collect(); + +assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']); ++
fn char_indices(&self) -> CharIndicesAn iterator over the characters of self and their byte offsets.
+let v: Vec<(usize, char)> = "abc".char_indices().collect(); +let b = vec![(0, 'a'), (1, 'b'), (2, 'c')]; + +assert_eq!(v, b); ++
fn bytes(&self) -> BytesAn iterator over the bytes of self.
+let v: Vec<u8> = "bors".bytes().collect(); + +assert_eq!(v, b"bors".to_vec()); ++
fn split_whitespace(&self) -> SplitWhitespaceAn iterator over the non-empty substrings of self which contain no whitespace,
+and which are separated by any amount of whitespace.
+let some_words = " Mary had\ta little \n\t lamb"; +let v: Vec<&str> = some_words.split_whitespace().collect(); + +assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); ++
fn words(&self) -> SplitWhitespace: words() will be removed. Use split_whitespace() instead
+An iterator over the non-empty substrings of self which contain no whitespace,
+and which are separated by any amount of whitespace.
+let some_words = " Mary had\ta little \n\t lamb"; +let v: Vec<&str> = some_words.words().collect(); + +assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); ++
fn lines(&self) -> LinesAn iterator over the lines of a string, separated by \n.
This does not include the empty string after a trailing \n.
+let four_lines = "foo\nbar\n\nbaz"; +let v: Vec<&str> = four_lines.lines().collect(); + +assert_eq!(v, ["foo", "bar", "", "baz"]); ++ +
Leaving off the trailing character:
++let four_lines = "foo\nbar\n\nbaz\n"; +let v: Vec<&str> = four_lines.lines().collect(); + +assert_eq!(v, ["foo", "bar", "", "baz"]); ++
fn lines_any(&self) -> LinesAnyAn iterator over the lines of a string, separated by either
+\n or \r\n.
As with .lines(), this does not include an empty trailing line.
+let four_lines = "foo\r\nbar\n\r\nbaz"; +let v: Vec<&str> = four_lines.lines_any().collect(); + +assert_eq!(v, ["foo", "bar", "", "baz"]); ++ +
Leaving off the trailing character:
++let four_lines = "foo\r\nbar\n\r\nbaz\n"; +let v: Vec<&str> = four_lines.lines_any().collect(); + +assert_eq!(v, ["foo", "bar", "", "baz"]); ++
fn nfd_chars(&self) -> Decompositions: use the crates.io unicode-normalization library instead
Returns an iterator over the string in Unicode Normalization Form D +(canonical decomposition).
+fn nfkd_chars(&self) -> Decompositions: use the crates.io unicode-normalization library instead
Returns an iterator over the string in Unicode Normalization Form KD +(compatibility decomposition).
+fn nfc_chars(&self) -> Recompositions: use the crates.io unicode-normalization library instead
An Iterator over the string in Unicode Normalization Form C +(canonical decomposition followed by canonical composition).
+fn nfkc_chars(&self) -> Recompositions: use the crates.io unicode-normalization library instead
An Iterator over the string in Unicode Normalization Form KC +(compatibility decomposition followed by canonical composition).
+fn graphemes(&self, is_extended: bool) -> Graphemes: use the crates.io unicode-segmentation library instead
Returns an iterator over the grapheme clusters of self.
If is_extended is true, the iterator is over the
+extended grapheme clusters;
+otherwise, the iterator is over the legacy grapheme clusters.
+UAX#29
+recommends extended grapheme cluster boundaries for general processing.
+let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>(); +let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; + +assert_eq!(&gr1[..], b); + +let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>(); +let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; + +assert_eq!(&gr2[..], b); ++
fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices: use the crates.io unicode-segmentation library instead
Returns an iterator over the grapheme clusters of self and their
+byte offsets. See
+graphemes() for more information.
+let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>(); +let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; + +assert_eq!(&gr_inds[..], b); ++
fn utf16_units(&self) -> Utf16Units: this functionality may only be provided by libunicode
+Returns an iterator of u16 over the string encoded as UTF-16.
fn contains<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>Returns true if self contains another &str.
+assert!("bananas".contains("nana")); + +assert!(!"bananas".contains("foobar")); ++
fn starts_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>Returns true if the given &str is a prefix of the string.
+assert!("banana".starts_with("ba")); ++
fn ends_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>Returns true if the given &str is a suffix of the string.
+assert!("banana".ends_with("nana")); ++
fn find<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>Returns the byte index of the first character of self that matches
+the pattern, if it
+exists.
Returns None if it doesn't exist.
The pattern can be a simple &str, char, or a closure that
+determines the
+split.
Simple patterns:
++let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.find('L'), Some(0)); +assert_eq!(s.find('é'), Some(14)); +assert_eq!(s.find("Léopard"), Some(13)); ++ +
More complex patterns with closures:
++let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.find(char::is_whitespace), Some(5)); +assert_eq!(s.find(char::is_lowercase), Some(1)); ++ +
Not finding the pattern:
++let s = "Löwe 老虎 Léopard"; +let x: &[_] = &['1', '2']; + +assert_eq!(s.find(x), None); ++
fn rfind<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>Returns the byte index of the last character of self that
+matches the pattern, if it
+exists.
Returns None if it doesn't exist.
The pattern can be a simple &str, char,
+or a closure that determines the split.
Simple patterns:
++let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.rfind('L'), Some(13)); +assert_eq!(s.rfind('é'), Some(14)); ++ +
More complex patterns with closures:
++let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.rfind(char::is_whitespace), Some(12)); +assert_eq!(s.rfind(char::is_lowercase), Some(20)); ++ +
Not finding the pattern:
++let s = "Löwe 老虎 Léopard"; +let x: &[_] = &['1', '2']; + +assert_eq!(s.rfind(x), None); ++
fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>An iterator over substrings of self, separated by characters
+matched by a pattern.
The pattern can be a simple &str, char, or a closure that
+determines the split. Additional libraries might provide more complex
+patterns like regular expressions.
The returned iterator will be double ended if the pattern allows a
+reverse search and forward/reverse search yields the same elements.
+This is true for, eg, char but not
+for &str.
If the pattern allows a reverse search but its results might differ
+from a forward search, rsplit() can be used.
Simple patterns:
++let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); +assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); + +let v: Vec<&str> = "".split('X').collect(); +assert_eq!(v, [""]); + +let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); +assert_eq!(v, ["lion", "", "tiger", "leopard"]); + +let v: Vec<&str> = "lion::tiger::leopard".split("::").collect(); +assert_eq!(v, ["lion", "tiger", "leopard"]); + +let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect(); +assert_eq!(v, ["abc", "def", "ghi"]); + +let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect(); +assert_eq!(v, ["lion", "tiger", "leopard"]); ++ +
A more complex pattern, using a closure:
++let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect(); +assert_eq!(v, ["abc", "def", "ghi"]); ++ +
If a string contains multiple contiguous separators, you will end up +with empty strings in the output:
++let x = "||||a||b|c".to_string(); +let d: Vec<_> = x.split('|').collect(); + +assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]); ++ +
This can lead to possibly surprising behavior when whitespace is used +as the separator. This code is correct:
++let x = " a b c".to_string(); +let d: Vec<_> = x.split(' ').collect(); + +assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]); ++ +
It does not give you:
++assert_eq!(d, &["a", "b", "c"]); ++
fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>An iterator over substrings of self, separated by characters
+matched by a pattern and yielded in reverse order.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
The returned iterator requires that the pattern supports a +reverse search, +and it will be double ended if a forward/reverse search yields +the same elements.
+ +For iterating from the front, split() can be used.
Simple patterns:
++let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect(); +assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]); + +let v: Vec<&str> = "".rsplit('X').collect(); +assert_eq!(v, [""]); + +let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect(); +assert_eq!(v, ["leopard", "tiger", "", "lion"]); + +let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect(); +assert_eq!(v, ["leopard", "tiger", "lion"]); ++ +
A more complex pattern, using a closure:
++let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect(); +assert_eq!(v, ["ghi", "def", "abc"]); ++
fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where P: Pattern<'a>An iterator over substrings of self, separated by characters
+matched by a pattern.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns
+like regular expressions.
Equivalent to split, except that the trailing substring
+is skipped if empty.
This method can be used for string data that is terminated, +rather than separated by a pattern.
+ +The returned iterator will be double ended if the pattern allows a
+reverse search
+and forward/reverse search yields the same elements. This is true
+for, eg, char but not for &str.
If the pattern allows a reverse search but its results might differ
+from a forward search, rsplit_terminator() can be used.
+let v: Vec<&str> = "A.B.".split_terminator('.').collect(); +assert_eq!(v, ["A", "B"]); + +let v: Vec<&str> = "A..B..".split_terminator(".").collect(); +assert_eq!(v, ["A", "", "B", ""]); ++
fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>An iterator over substrings of self, separated by characters
+matched by a pattern and yielded in reverse order.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Equivalent to split, except that the trailing substring is
+skipped if empty.
This method can be used for string data that is terminated, +rather than separated by a pattern.
+ +The returned iterator requires that the pattern supports a +reverse search, and it will be double ended if a forward/reverse +search yields the same elements.
+ +For iterating from the front, split_terminator() can be used.
+let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect(); +assert_eq!(v, ["B", "A"]); + +let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect(); +assert_eq!(v, ["", "B", "", "A"]); ++
fn splitn<'a, P>(&'a self, count: usize, pat: P) -> SplitN<'a, P> where P: Pattern<'a>An iterator over substrings of self, separated by a pattern,
+restricted to returning
+at most count items.
The last element returned, if any, will contain the remainder of the
+string.
+The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
The returned iterator will not be double ended, because it is +not efficient to support.
+ +If the pattern allows a reverse search, rsplitn() can be used.
Simple patterns:
++let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect(); +assert_eq!(v, ["Mary", "had", "a little lambda"]); + +let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect(); +assert_eq!(v, ["lion", "", "tigerXleopard"]); + +let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect(); +assert_eq!(v, ["abcXdef"]); + +let v: Vec<&str> = "".splitn(1, 'X').collect(); +assert_eq!(v, [""]); ++ +
A more complex pattern, using a closure:
++let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect(); +assert_eq!(v, ["abc", "defXghi"]); ++
fn rsplitn<'a, P>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>An iterator over substrings of self, separated by a pattern,
+starting from the end of the string, restricted to returning
+at most count items.
The last element returned, if any, will contain the remainder of the +string.
+ +The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
The returned iterator will not be double ended, because it is not +efficient to support.
+ +splitn() can be used for splitting from the front.
Simple patterns:
++let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect(); +assert_eq!(v, ["lamb", "little", "Mary had a"]); + +let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect(); +assert_eq!(v, ["leopard", "tiger", "lionX"]); + +let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect(); +assert_eq!(v, ["leopard", "lion::tiger"]); ++ +
A more complex pattern, using a closure:
++let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect(); +assert_eq!(v, ["ghi", "abc1def"]); ++
fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where P: Pattern<'a>An iterator over the matches of a pattern within self.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
The returned iterator will be double ended if the pattern allows
+a reverse search
+and forward/reverse search yields the same elements. This is true
+for, eg, char but not
+for &str.
If the pattern allows a reverse search but its results might differ
+from a forward search, rmatches() can be used.
+let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect(); +assert_eq!(v, ["abc", "abc", "abc"]); + +let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect(); +assert_eq!(v, ["1", "2", "3"]); ++
fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>An iterator over the matches of a pattern within self, yielded in
+reverse order.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
The returned iterator requires that the pattern supports a +reverse search, +and it will be double ended if a forward/reverse search yields +the same elements.
+ +For iterating from the front, matches() can be used.
+let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect(); +assert_eq!(v, ["abc", "abc", "abc"]); + +let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect(); +assert_eq!(v, ["3", "2", "1"]); ++
fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where P: Pattern<'a>: might have its iterator type changed
+An iterator over the start and end indices of the disjoint matches
+of a pattern within self.
For matches of pat within self that overlap, only the indices
+corresponding to the first
+match are returned.
The pattern can be a simple &str, char, or a closure that
+determines
+the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
The returned iterator will be double ended if the pattern allows a
+reverse search
+and forward/reverse search yields the same elements. This is true for,
+eg, char but not
+for &str.
If the pattern allows a reverse search but its results might differ
+from a forward search, rmatch_indices() can be used.
+let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); +assert_eq!(v, [(0, 3), (6, 9), (12, 15)]); + +let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); +assert_eq!(v, [(1, 4), (4, 7)]); + +let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); +assert_eq!(v, [(0, 3)]); // only the first `aba` ++
fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>: might have its iterator type changed
+An iterator over the start and end indices of the disjoint matches of
+a pattern within
+self, yielded in reverse order.
For matches of pat within self that overlap, only the indices
+corresponding to the last
+match are returned.
The pattern can be a simple &str, char, or a closure that
+determines
+the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
The returned iterator requires that the pattern supports a +reverse search, +and it will be double ended if a forward/reverse search yields +the same elements.
+ +For iterating from the front, match_indices() can be used.
+let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect(); +assert_eq!(v, [(12, 15), (6, 9), (0, 3)]); + +let v: Vec<(usize, usize)> = "1abcabc2".rmatch_indices("abc").collect(); +assert_eq!(v, [(4, 7), (1, 4)]); + +let v: Vec<(usize, usize)> = "ababa".rmatch_indices("aba").collect(); +assert_eq!(v, [(2, 5)]); // only the last `aba` ++
fn subslice_offset(&self, inner: &str) -> usize: awaiting convention about comparability of arbitrary slices
+Returns the byte offset of an inner slice relative to an enclosing +outer slice.
+ +Panics if inner is not a direct slice contained within self.
+let string = "a\nb\nc"; +let lines: Vec<&str> = string.lines().collect(); + +assert!(string.subslice_offset(lines[0]) == 0); // &"a" +assert!(string.subslice_offset(lines[1]) == 2); // &"b" +assert!(string.subslice_offset(lines[2]) == 4); // &"c" ++
fn trim(&self) -> &strReturns a &str with leading and trailing whitespace removed.
+let s = " Hello\tworld\t"; +assert_eq!(s.trim(), "Hello\tworld"); ++
fn trim_left(&self) -> &strReturns a &str with leading whitespace removed.
+let s = " Hello\tworld\t"; +assert_eq!(s.trim_left(), "Hello\tworld\t"); ++
fn trim_right(&self) -> &strReturns a &str with trailing whitespace removed.
+let s = " Hello\tworld\t"; +assert_eq!(s.trim_right(), " Hello\tworld"); ++
fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: DoubleEndedSearcher<'a>Returns a string with all pre- and suffixes that match a pattern +repeatedly removed.
+ +The pattern can be a simple char, or a closure that determines
+the split.
Simple patterns:
++assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); +assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar"); + +let x: &[_] = &['1', '2']; +assert_eq!("12foo1bar12".trim_matches(x), "foo1bar"); ++ +
A more complex pattern, using a closure:
++assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar"); ++
fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>Returns a string with all prefixes that match a pattern +repeatedly removed.
+ +The pattern can be a simple &str, char, or a closure that
+determines the split.
+assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); +assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123"); + +let x: &[_] = &['1', '2']; +assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12"); ++
fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>Returns a string with all suffixes that match a pattern +repeatedly removed.
+ +The pattern can be a simple &str, char, or a closure that
+determines the split.
Simple patterns:
++assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); +assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar"); + +let x: &[_] = &['1', '2']; +assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar"); ++ +
A more complex pattern, using a closure:
++assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX"); ++
fn parse<F>(&self) -> Result<F, F::Err> where F: FromStrParses self into the specified type.
Will return Err if it's not possible to parse self into the type.
+assert_eq!("4".parse::<u32>(), Ok(4)); ++ +
Failing:
++assert!("j".parse::<u32>().is_err()); ++
fn replace(&self, from: &str, to: &str) -> StringReplaces all occurrences of one string with another.
+ +replace takes two arguments, a sub-&str to find in self, and a
+second &str to
+replace it with. If the original &str isn't found, no change occurs.
+let s = "this is old"; + +assert_eq!(s.replace("old", "new"), "this is new"); ++ +
When a &str isn't found:
+let s = "this is old"; +assert_eq!(s.replace("cookie monster", "little lamb"), s); ++
fn to_lowercase(&self) -> StringReturns the lowercase equivalent of this string.
+ ++#![feature(str_casing)] + +let s = "HELLO"; +assert_eq!(s.to_lowercase(), "hello"); ++
fn to_uppercase(&self) -> StringReturns the uppercase equivalent of this string.
+ ++#![feature(str_casing)] + +let s = "hello"; +assert_eq!(s.to_uppercase(), "HELLO"); ++
fn escape_default(&self) -> String: return type may change to be an iterator
+Escapes each char in s with char::escape_default.
fn escape_unicode(&self) -> String: return type may change to be an iterator
+Escapes each char in s with char::escape_unicode.
impl<'s> Drop for SslStringfn drop(&mut self)impl Deref for SslStringimpl Display for SslStringimpl Debug for SslString
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct X509<'ctx> {
+ // some fields omitted
+}A public key certificate
+impl<'ctx> X509<'ctx>fn new(handle: *mut X509, owned: bool) -> X509<'ctx>Creates new from handle with desired ownership.
+fn new_in_ctx(handle: *mut X509, ctx: &'ctx X509StoreContext) -> X509<'ctx>Creates a new certificate from context. Doesn't take ownership +of handle.
+fn from_pem<R>(reader: &mut R) -> Result<X509<'ctx>, SslError> where R: ReadReads certificate from PEM, takes ownership of handle
+fn get_handle(&self) -> *mut X509fn subject_name<'a>(&'a self) -> X509Name<'a>fn public_key(&self) -> PKeyfn fingerprint(&self, hash_type: Type) -> Option<Vec<u8>>Returns certificate fingerprint calculated using provided hash
+fn write_pem<W>(&self, writer: &mut W) -> Result<(), SslError> where W: WriteWrites certificate as PEM
+impl<'ctx> Drop for X509<'ctx>fn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct X509Generator {
+ // some fields omitted
+}Generator of private key/certificate pairs
+ ++use std::fs; +use std::fs::File; +use std::io::prelude::*; +use std::path::Path; + +use openssl::crypto::hash::Type; +use openssl::x509::{KeyUsage, X509Generator}; + +let gen = X509Generator::new() + .set_bitlength(2048) + .set_valid_period(365*2) + .set_CN("SuperMegaCorp Inc.") + .set_sign_hash(Type::SHA256) + .set_usage(&[KeyUsage::DigitalSignature]); + +let (cert, pkey) = gen.generate().unwrap(); + +let cert_path = "doc_cert.pem"; +let mut file = File::create(cert_path).unwrap(); +assert!(cert.write_pem(&mut file).is_ok()); + +let pkey_path = "doc_key.pem"; +let mut file = File::create(pkey_path).unwrap(); +assert!(pkey.write_pem(&mut file).is_ok()); ++
impl X509Generatorfn new() -> X509GeneratorCreates a new generator with the following defaults:
+ +bit length: 1024
+ +validity period: 365 days
+ +CN: "rust-openssl"
+ +hash: SHA1
+fn set_bitlength(self, bits: u32) -> X509GeneratorSets desired bit length
+fn set_valid_period(self, days: u32) -> X509GeneratorSets certificate validity period in days since today
+fn set_CN(self, CN: &str) -> X509GeneratorSets Common Name of certificate
+fn set_usage(self, purposes: &[KeyUsage]) -> X509GeneratorSets what for certificate could be used
+fn set_ext_usage(self, purposes: &[ExtKeyUsage]) -> X509GeneratorSets allowed extended usage of certificate
+fn set_sign_hash(self, hash_type: Type) -> X509Generatorfn generate<'a>(&self) -> Result<(X509<'a>, PKey), SslError>Generates a private key and a self-signed certificate and returns them
+fn sign<'a>(&self, p_key: &PKey) -> Result<X509<'a>, SslError>Sets the certificate public-key, then self-sign and return it +Note: That the bit-length of the private key is used (set_bitlength is ignored)
+fn request(&self, p_key: &PKey) -> Result<X509Req, SslError>Obtain a certificate signing request (CSR)
+
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct X509Name<'x> {
+ // some fields omitted
+}impl<'x> X509Name<'x>fn text_by_nid(&self, nid: Nid) -> Option<SslString>
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct X509NameEntry<'x> {
+ // some fields omitted
+}
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct X509Req {
+ // some fields omitted
+}A certificate signing request
+impl X509Reqfn new(handle: *mut X509_REQ) -> X509ReqCreates new from handle
+fn from_pem<R>(reader: &mut R) -> Result<X509Req, SslError> where R: ReadReads CSR from PEM
+fn write_pem<W>(&self, writer: &mut W) -> Result<(), SslError> where W: WriteWrites CSR as PEM
+impl Drop for X509Reqfn drop(&mut self)
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+
pub struct X509StoreContext {
+ // some fields omitted
+}impl X509StoreContextfn new(ctx: *mut X509_STORE_CTX) -> X509StoreContextfn get_error(&self) -> Option<X509ValidationError>fn get_current_cert<'a>(&'a self) -> Option<X509<'a>>
+ Prefix searches with a type followed by a colon (e.g.
+ fn:) to restrict the search to a given type.
+
+ Accepted types are: fn, mod,
+ struct, enum,
+ trait, typedef (or
+ tdef).
+
+ Search functions by type signature (e.g.
+ vec -> usize)
+