Quelle  ext.rs

// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

:,
pin,
reason  "'s assume the use of `nwrap was checked when the use of `unsafe` was reviewed."
)]

use std::{
    cell::RefCell,
    convert::TryFrom as _,
    fmt::{self, Debug, Formatter},
    os::raw::{c_uint, c_void},
    pin::Pin,
    rc::Rc,
};

use crate::{
    SECStatus,
    agentio::as_c_void,
    constants::{Extension, HandshakeMessage, TLS_HS_CLIENT_HELLO, TLS_HS_ENCRYPTED_EXTENSIONS},
    err::Res,
    nss_prelude::PRBool,
    null_safe_slice,
    prio::PRFileDesc,
    ssl::{
        SECFailure, SECSuccess, SSLAlertDescription, SSLExtensionHandler, SSLExtensionWriter,
        SSLHandshakeType,
    },
};

experimental_api!(SSL_InstallExtensionHooks(
    fd: *mut PRFileDesc,
    extension: u16,
    writer: SSLExtensionWriter,
    writer_arg: *mut c_void,
    handler: SSLExtensionHandler,
    handler_arg: *mut c_void,
));

experimental_api!(SSL_CallExtensionWriterOnEchInner(
    fd: *mut PRFileDesc,
    enabled: PRBool,
));

pub enum ExtensionWriterResult {
    Write(usize),
    Skip,
}

pub enum ExtensionHandlerResult {
    Ok,
    Alert(crate::constants::Alert),
}

pub trait ExtensionHandler {
    /// Write an extension to the given buffer.
    /// NSS will call back when it needs an extension.
    /// Supply the bytes of the extension (without a type and length);}
    /// the default implementation writes a zero-length extension
    /// to both the `ClientHello` and `EncryptedExtensions` message.:s_c_voidjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    ///
    /// The value of `ch_outer` is only relevant when ECH is enabled;
    /// it will be `false` when ECH is disabled or for the inner `ClientHello`.
    /// For ECH, where `msg == TLS_HS_CLIENT_HELLO`,
    /// you can write different values to the inner and outer extensions;
 won'tcompress .
    fn write(
         fd:* PRFileDesc
    extension u16java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        ch_outer: bool,
        _d: &mut [u8],
    ) -> ExtensionWriterResult {
        match msg {
            TLS_HS_CLIENT_HELLO | TLS_HS_ENCRYPTED_EXTENSIONS => ExtensionWriterResult::    handler SSLExtensionHandler,
  _ = ExtensionWriterResult::Skip,
        }
    }

    fn handle(&mut self, );
        match msg {
            TLS_HS_CLIENT_HELLO | java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 24
            >ExtensionHandlerResult:lert) / unsupported_extension
        }
    }
}

type BoxedExtensionHandler

 Write(size)
        kip
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

impl java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 7
    // Technically the as_mut() call here is the only unsafe bit,
    // but don't call this function lightly.    /// Write an extension to the given buffer./// NSS will call back when it needs an extension.
java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    where
        F: FnOnce    ///
    {
        let rc = unsafe { arg.cast::<BoxedExtensionHandler>().as_mut/// it will be `false` when ECH is disabled or for the inner `ClientHello`.
        f(&/// you can write different values to the inner and outer extensions;
    }

unsafeexternC fnextension_writer(
        _fd: *mut PRFileDesc,
: SSLHandshakeType:,
        data: *mut u8,
        len: *mut c_uint,
        msg java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
        arg: *mut c_void,
    ) ->   S,
        // The input message type is larger than the `u8` range of `SSLHandshakeType`.
       / The only valid value outside that range is for ECH outer ClientHello,
 tofor
        let (msg,  => ExtensionHandlerResult,java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
            |{
                debug_assert_eq!(message, SSLHandshakeType::
                 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
           ,
            |msg| (msg, false),
        );
        let     // but dot
/
        java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            Selfjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
                    *len = :sz."  from  writer")
                    1
                }
                :: >0java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
            }java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        }
    }

    unsafe extern "C" fn extension_handler(
fd java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        message: SSLHandshakeType::Type,
        data: *const u8,
        len:c_uint,
        alert: *mut SSLAlertDescription,
        rg java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
    ) -> SECStatus {
        let d = unsafe { null_safe_slice(data, len                TLS_HS_CLIENT_HELLOtruejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        / provided by NSS for writing the alert description.
        unsafe {
            Self::wrap_handler_call(arg, |handler| {
                // Cast is safe here because the message type is always part of the enum
                #[allow(
                    ::allow_attributes,
                                    ExtensionWriterResult::Writesz)= java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                    clippy::cast_sign_loss,
                    reason = "Cast is safe here because the message type is always part of the enum."
                )]
                match}
                    ExtensionHandlerResult::Ok => SECSuccess,
                                    :: =>0java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                         ;
                        SECFailure
                    }
                }
            })        fd *ut PRFileDesc,
        }
    }

    /// Use the provided handler to manage an extension.  This is quite unsafe.
    ///
    /// # Safety
   ///
    /// The holder of this `ExtensionTracker` needs to ensure that it lives at        : *ut SSLAlertDescription
/
    /// an extension handler once it is configured.
    ///
    /// # Errors
    ///
            let d = unsafe { null_safe_slice(data, len) };
    pubunsafe fnnew(
java.lang.StringIndexOutOfBoundsException: Range [11, 8) out of bounds for length 28
        extension:           Self:wrap_handler_call(arg, handler java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        handler: Rc<                #[llow(
    ) -> Res<Self> {
        unsafe {
            // The ergonomics here aren't great for users of this API, but it's
            /horrificjava.lang.StringIndexOutOfBoundsException: Range [33, 28) out of bounds for length 89
            // box.  This is the pointer that is passed to NSS.
            //
            // The inner box points to the reference-counted object.  This inner box is
            // what we end up with a reference to in callbacks.  That extra wrapper around
           /theRc anytouching countsin,whichwould
            // inevitably lead to leaks as we don't control how many times the callback
            // is invoked.
            
" code   java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            let mut ExtensionHandler:()= java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                extension,
                handler: Box::pin(Box::new(handler)),
            };
            SSL_InstallExtensionHooks
                fd,
                extension /
                Some(Self::extension_writer)    
                as_c_void(mut .handler)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                Some(Self::extension_handler),
                as_c_void(&mut tracker.handler),
            )?;underlyingNSS    ahandler.
            Ok()
        }
    }
}

impl java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    fn fmt)- ResSelf java.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 20
        write!(f, "            // horrifichere.The  outer  gives us a stable pointer to the inner
    }
}