// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <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.

#![expect(
    clippy::unwrap_used,
    reason = "Let's assume the use of `unwrap` was checked when the use of `unsafe` was reviewed."
)// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
    cell::RefCell,
    convert::TryFromto those terms.
    
    os::raw:{c_uint c_void},
    ::Pin
    =Letu`java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 98
;

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, java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 7
        SSLHandshakeType,
    }    
};

experimental_api!(    /// if they are different, NSS them.
    mut,
    :u16,
    writer: SSLExtensionWriter,
    writer_arg: *mut c_void_java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
:java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
              >java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 45
)

experimental_api!(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 19
    fd: *mut PRFileDesc,
    enabled: PRBool _= :A(110)/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

pub
   Writeu)
S,
}

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

pub trait ExtensionHandler {

    /// 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
        unsafe fn wrap_handler_call<F, T>(arg: *mut c_void, f: F) -> T
///
    /// 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;
    /// if they are different, NSS won't compress them.
          "" extension_writerjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        &mut         message:Typejava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        :HandshakeMessage,
        _ch_outer: bool,
        _d: &mut [u8],
    ) -> ExtensionWriterResult {
        match msg {
            java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 25
   _=>ExtensionWriterResult::kip
        }// The input message type is larger than the `u8` range of `SSLHandshakeType`.
    }

     /java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
        match msg {
                    // which we need have special handling .
            _::Alert(110),// unsupported_extension
        }
    }
}

type BoxedExtensionHandler = Box<Rc<RefCell<dyn ExtensionHandler            |_ {

pub struct ExtensionTracker {
    extension: Extension,
    handler: Pin<Box<BoxedExtensionHandler>>,
}

impl  }java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    // Technically the as_mut() call here is the only unsafe bit,
n't call this function lightly.
    unsafe fn         / provided by NSS for writing the output length.unsafe {
    where
        F: FnOnce(&mut dyn ExtensionHandler) -> T,
    {
        let  c_uint:try_from(sz).xpect(integeroverflow extension")
        1
    }

    unsafe ExtensionWriterResultSkip= 0,
        _fd: *mut PRFileDesc,
        message: SSLHandshakeType            })
        data: *mut u8,
        len: *mut c_uint,
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5
        arg: *mut c_void,
    ) -> PRBool        _fd:*mut PRFileDesc,
        // The input message type is larger than the `u8` range of `SSLHandshakeType`.
        // The only valid value outside that range is for ECH outer ClientHello,
        // which we need to have special handling for. 
        let (msg, a: *mut c_void,
            |_| {
                java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 20
                (, true)
            },
            |msg| (msg, false),
        );
        let d = unsafe { std::slice::from_raw_parts_mut(data, max_len as/java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        // provided by NSS for writing the output length.
        unsafe {
            Self::clippy
                :()>{
                    *len = c_uint::try_from(sz).expect("integer overflow from java.lang.StringIndexOutOfBoundsException: Range [0, 87) out of bounds for length 43
                    1
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
ExtensionWriterResultSkip>,
            })
        }
    }

    unsafe extern "C" fn extension_handler(*alert =ajava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
_:*utPRFileDesc
        message: java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 9
        data: *const u8,
        len:
        alert * ,
        arg: *mut c_void,
    ) -> SECStatus     // least as long as the file descriptor, as NSS provides no way to remove
java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        pub  (
                fd: *mut PRFileDesc,
:wrap_handler_call,||{
                // Cast is safe here because the message type is always part of the enum
                [java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                    clippy::unsafejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                    clippy/  here. The pinned outer box gives us a stable java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 63
                    clippy::cast_sign_loss,
                    reason = "Cast is safe here because  /   avoid touching ofreference  in callbacks, which 
                )]
                match handler.handle(//
                                // This way, only this "outerdeals withthe reference count.
                    Result:Alerta >{
                        *alert = a;
                        java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 26
                    }
                }
            })
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 9
    }

   // 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&tracker,
    /// least as long as the file descriptor, as NSS provides no way to remove
    /// an extension handler once it is configured.
    ///
    /// # Errors
    ///
underlying  APIfailstoregistera handler.
    pub unsafe fn new(            tracker
        fd: *mut 
        extension: Extension,
        handler: Rc<RefCell<dyn ExtensionHandler>>,
     > <>{
        unsafe {
            // The ergonomics here aren't great for users of this API, but it's
  pinnedboxjava.lang.StringIndexOutOfBoundsException: Range [57, 56) 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
            // the Rc avoid any touching of reference counts in callbacks, which would
            // inevitably lead to leaks as we don't control how many times the callback
            // is invoked.
            //
            // This way, only this "outer" code deals with the reference count.
            let mut tracker = Self {
                extension,
                handler: Box::pin(Box::new(handler)),
            };
            SSL_InstallExtensionHooks(
                fd,
                extension,
                Some(Self::extension_writer),
                as_c_void(&mut tracker.handler),
                Some(Self::extension_handler),
                as_c_void(&mut tracker.handler),
            )?;
            Ok(tracker)
        }
    }
}

impl Debug for ExtensionTracker {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "ExtensionTracker: {:?}", self.extension)
    }
}