pub(crate) fn as_raw_address(&self) -> &coap_address_t {

        &self.0

    }

    fn from(addr: SocketAddr) -> Self {

        match addr {

            SocketAddr::V6(addr) => {

                // addr is a bindgen-type union wrapper, so we can't assign to it directly and have

                // to use a pointer instead.

                // SAFETY: addr is not read before it is assigned properly, assignment cannot fail.

                unsafe {

                    let mut coap_addr = coap_address_t {

                        size: std::mem::size_of::<sockaddr_in6>() as socklen_t,

                        addr: std::mem::zeroed(),

                    };

                    *coap_addr.addr.sin6.as_mut() = sockaddr_in6 {

                        #[cfg(any(

                            target_os = "freebsd",

                            target_os = "dragonfly",

                            target_os = "openbsd",

                            target_os = "netbsd",

                            target_os = "aix",

                            target_os = "haiku",

                            target_os = "hurd",

                            target_os = "espidf",

                        ))]

                        sin6_len: (std::mem::size_of::<sockaddr_in6>() as u8),

                        sin6_family: AF_INET6 as sa_family_t,

                        sin6_port: addr.port().to_be(),

                        sin6_addr: in6_addr {

                            s6_addr: addr.ip().octets(),

                        },

                        sin6_flowinfo: addr.flowinfo(),

                        sin6_scope_id: addr.scope_id(),

                    };

                    CoapAddress(coap_addr)

    }

#[derive(Copy, Clone, FromPrimitive, Debug, PartialEq, Eq, Hash)]

    pub fn from_raw_scheme(scheme: coap_uri_scheme_t) -> CoapUriScheme {

        FromPrimitive::from_u32(scheme as u32).expect("unknown scheme")

    }

    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

        f.write_str(match self {

            CoapUriScheme::Coap => "coap",

    }

    fn from(value: CoapProtocol) -> Self {

        match value {

            CoapProtocol::None | CoapProtocol::Udp => CoapUriScheme::Coap,

            CoapProtocol::Dtls => CoapUriScheme::Coaps,

            CoapProtocol::Tcp => CoapUriScheme::CoapTcp,

    }

/// use libcoap_rs::error::UriParsingError;

///

/// assert_eq!(uri.host(), Some("example.com".as_bytes()));

/// assert_eq!(uri.port(), Some(4711));

/// assert_eq!(uri.path(), Some("foo/bar".as_bytes()));

/// assert_eq!(uri.query(), Some("answer=42".as_bytes()));

/// assert!(!uri.is_proxy());

///

/// ```

///

    /// use libcoap_rs::error::UriParsingError;

    ///     CoapUriScheme::Coap,

    ///     "example.com".as_bytes(),

    ///     4711,

    ///     Some("/foo/bar".as_bytes()),

    ///     Some("?answer=42".as_bytes())

    /// )?;

    ///

    /// assert_eq!(uri.host(), Some("example.com".as_bytes()));

    /// assert_eq!(uri.port(), Some(4711));

    /// assert_eq!(uri.path(), Some("foo/bar".as_bytes()));

    /// assert_eq!(uri.query(), Some("answer=42".as_bytes()));

    /// assert!(!uri.is_proxy());

    ///

    /// ```

    pub fn new(

        scheme: CoapUriScheme,

        host: &[u8],

        port: u16,

        path: Option<&[u8]>,

        query: Option<&[u8]>,

    ) -> Result<CoapUri, UriParsingError> {

        let (uri_str, _, _, _) =

            Self::construct_uri_string_from_parts(scheme, host, port, path.unwrap_or(&[b'/']), query.unwrap_or(&[]))?;

        unsafe { CoapUri::create_parsed_uri(uri_str, coap_split_uri, false) }

    }

    /// use libcoap_rs::error::UriParsingError;

    ///     CoapUriScheme::Coap,

    ///     "example.com".as_bytes(),

    ///     4711,

    ///     Some("/foo/bar".as_bytes()),

    ///     Some("?answer=42".as_bytes())

    /// )?;

    ///

    /// assert_eq!(uri.host(), Some("example.com".as_bytes()));

    /// assert_eq!(uri.port(), Some(4711));

    /// assert_eq!(uri.path(), Some("foo/bar".as_bytes()));

    /// assert_eq!(uri.query(), Some("answer=42".as_bytes()));

    /// assert!(uri.is_proxy());

    ///

    /// ```

    pub fn new_proxy(

        scheme: CoapUriScheme,

        host: &[u8],

        port: u16,

        path: Option<&[u8]>,

        query: Option<&[u8]>,

    ) -> Result<CoapUri, UriParsingError> {

        let (uri_str, _, _, _) =

            Self::construct_uri_string_from_parts(scheme, host, port, path.unwrap_or(&[b'/']), query.unwrap_or(&[]))?;

        unsafe { CoapUri::create_parsed_uri(uri_str, coap_split_proxy_uri, true) }

    }

    /// use libcoap_rs::error::UriParsingError;

    ///     Some("/foo/bar".as_bytes()),

    ///     Some("?answer=42".as_bytes())

    /// )?;

    ///

    /// assert_eq!(uri.host(), None);

    /// assert_eq!(uri.port(), Some(5683));

    /// assert_eq!(uri.path(), Some("foo/bar".as_bytes()));

    /// assert_eq!(uri.query(), Some("answer=42".as_bytes()));

    /// assert!(!uri.is_proxy());

    ///

    /// ```

    pub fn new_relative(path: Option<&[u8]>, query: Option<&[u8]>) -> Result<CoapUri, UriParsingError> {

        CoapUri::new(CoapUriScheme::Coap, &[], 0, path, query)

    }

    /// use libcoap_rs::error::UriParsingError;

    ///

    /// assert_eq!(uri.host(), Some("example.com".as_bytes()));

    /// assert_eq!(uri.port(), Some(4711));

    /// assert_eq!(uri.path(), Some("foo/bar".as_bytes()));

    /// assert_eq!(uri.query(), Some("answer=42".as_bytes()));

    /// assert!(!uri.is_proxy());

    ///

    /// ```

    pub fn try_from_str(uri_str: &str) -> Result<CoapUri, UriParsingError> {

        // SAFETY: coap_split_uri is one of the allowed functions.

        unsafe { CoapUri::create_parsed_uri(CString::new(uri_str)?, coap_split_uri, false) }

    }

    /// use libcoap_rs::error::UriParsingError;

    ///

    /// assert_eq!(uri.host(), Some("example.com".as_bytes()));

    /// assert_eq!(uri.port(), Some(4711));

    /// assert_eq!(uri.path(), Some("foo/bar".as_bytes()));

    /// assert_eq!(uri.query(), Some("answer=42".as_bytes()));

    /// assert!(uri.is_proxy());

    ///

    /// ```

    pub fn try_from_str_proxy(uri_str: &str) -> Result<CoapUri, UriParsingError> {

        // SAFETY: coap_split_proxy_uri is one of the allowed functions.

        unsafe { CoapUri::create_parsed_uri(CString::new(uri_str)?, coap_split_proxy_uri, true) }

    }

    pub fn scheme(&self) -> Option<CoapUriScheme> {

        // URIs can either be absolute or relative. If they are relative, the scheme is also not

        // set (but defaults to CoAP as the default enum value is 0).

        self.host()?;

        Some(CoapUriScheme::from_raw_scheme(self.raw_uri.scheme))

    }

    pub fn host(&self) -> Option<&[u8]> {

        let raw_str = self.raw_uri.host;

        if raw_str.length == 0 {

            return None;

        }

        // SAFETY: After construction the fields of self.raw_uri always reference the corresponding

        //         parts of the underlying string, which is pinned. Therefore, the pointer and

        //         length are valid for the lifetime of this struct.

        Some(unsafe { std::slice::from_raw_parts(raw_str.s, raw_str.length) })

    }

    pub fn port(&self) -> Option<UriPort> {

        match self.raw_uri.port {

            v => Some(v),

    }

    pub fn path(&self) -> Option<&[u8]> {

        let raw_str = self.raw_uri.path;

        if raw_str.s.is_null() {

        }

        // SAFETY: After construction the fields of self.raw_uri always reference the corresponding

        //         parts of the underlying string, which is pinned. Therefore, the pointer and

        //         length are valid for the lifetime of this struct.

        Some(unsafe { std::slice::from_raw_parts(raw_str.s, raw_str.length) })

    }

    pub fn query(&self) -> Option<&[u8]> {

        let raw_str = self.raw_uri.query;

        if raw_str.s.is_null() {

        }

        // SAFETY: After construction the fields of self.raw_uri always reference the corresponding

        //         parts of the underlying string, which is pinned. Therefore, the pointer and

        //         length are valid for the lifetime of this struct.

        Some(unsafe { std::slice::from_raw_parts(raw_str.s, raw_str.length) })

    }

    pub fn is_proxy(&self) -> bool {

        self.is_proxy

    }

    pub fn into_options(self) -> Vec<CoapOption> {

        // TODO this is a lot of copying around, however, fixing that would require an entire

        //      rewrite of the option handling code, so it's better kept for a separate PR.

        // Set size of temporary buffer for option storage.

        // TODO remove when updating minimum libcoap version to 4.3.5, as this buffer is no longer

        //      used there.

        #[cfg(coap_uri_buf_unused)]

        let mut buf = [];

        #[cfg(not(coap_uri_buf_unused))]

        let mut buf = {

            let buf_len =

                // Length of UriHost option (length of host + max. 5 bytes of option header)

                self.host().map(|v| v.len()+5).unwrap_or(0)

                // Length of UriPort option (max. 2 bytes for the port number + max. 5 bytes of

                // option header)

                + self.port().map(|v| 7).unwrap_or(0)

                // Length of path segment

                + self.path().map(|v| v.len()).unwrap_or(0)

                // Length of option headers for path segments.

                // Each path segment has its own header, which can be up to 5 bytes in size.

                + self.path().map(|v| (v.iter().filter(|c| **c as char == '/').count()+1)*5).unwrap_or(0)

                // Length of query segment

                + self.query().map(|v| v.len()).unwrap_or(0)

                // Length of option headers for query segments.

                // Each query segment has its own header, which can be up to 5 bytes in size.

                + self.query().map(|v| (v.iter().filter(|c| **c as char == '?' || **c as char == '&').count()+1)*5).unwrap_or(0);

            vec![0u8; buf_len]

        };

        let mut optlist = std::ptr::null_mut();

        // SAFETY: self.raw_uri is always valid after construction. The destination may be a null

        //         pointer, optlist may be a null pointer at the start (it will be set to a valid

        //         pointer by this call). Buf and create_port_host_opt are set according to the

        //         libcoap documentation.

        if unsafe {

            coap_uri_into_options(

                &self.raw_uri,

                std::ptr::null(),

                &mut optlist,

                1,

                buf.as_mut_ptr(),

                buf.len(),

            )

        } < 0

        }

        let mut out_opts = Vec::new();

        while !optlist.is_null() {

            // SAFETY: coap_uri_into_options should have ensured that optlist is either null or a

            //         valid coap option list. In the former case, we wouldn't be in this loop, in

            //         the latter case calling from_optlist_entry is fine.

            out_opts.push(unsafe {

                CoapOption::from_optlist_entry(optlist.as_ref().expect("self-generated options should always be valid"))

                    .expect("self-generated options should always be valid")

            });

            optlist = unsafe { *optlist }.next;

        }

        unsafe {

            coap_delete_optlist(optlist);

        }

        drop(self);

        out_opts

    }

    fn create_unparsed_uri(uri_str: CString, is_proxy: bool) -> Self {

        let uri_str = Box::pin(CoapUriInner(uri_str, PhantomPinned));

        CoapUri {

            raw_uri: coap_uri_t {

                host: coap_str_const_t {

                    length: 0,

                    s: std::ptr::null(),

                },

                port: 0,

                path: coap_str_const_t {

                    length: 0,

                    s: std::ptr::null(),

                },

                query: coap_str_const_t {

                    length: 0,

                    s: std::ptr::null(),

                },

                scheme: coap_uri_scheme_t::COAP_URI_SCHEME_COAP,

            },

            uri_str,

            is_proxy,

        }

    }

    unsafe fn create_parsed_uri(

        uri_str: CString,

        parsing_fn: unsafe extern "C" fn(*const u8, usize, *mut coap_uri_t) -> c_int,

        is_proxy: bool,

    ) -> Result<CoapUri, UriParsingError> {

        ensure_coap_started();

        let mut uri = Self::create_unparsed_uri(uri_str, is_proxy);

        // SAFETY: The provided pointers to raw_uri and uri_str are valid.

        // Because uri_str is pinned (and its type is not Unpin), the pointer locations are always

        // valid while this object lives, therefore the resulting coap_uri_t remains valid for the

        // entire lifetime of this object too.

        if unsafe {

            parsing_fn(

                uri.uri_str.0.as_ptr() as *const u8,

                libc::strlen(uri.uri_str.0.as_ptr()),

                std::ptr::from_mut(&mut uri.raw_uri),

            )

        } < 0

        }

        Ok(uri)

    }

    fn construct_uri_string_from_parts(

        scheme: CoapUriScheme,

        host: &[u8],

        port: u16,

        path: &[u8],

        query: &[u8],

    ) -> Result<(CString, usize, usize, usize), UriParsingError> {

        let scheme = if !host.is_empty() {

            format!("{}://", scheme)

            String::new()

        let port = if port != 0 { format!(":{}", port) } else { String::new() };

        let parts = [scheme.as_bytes(), host, port.as_bytes(), path, query];

        let uri_str_len = parts.iter().map(|v| v.len()).sum::<usize>();

        let mut uri_str_copy = vec![0u8; uri_str_len];

        let mut cur;

        let mut rest = uri_str_copy.as_mut_slice();

        for part in parts.iter() {

            (cur, rest) = rest.split_at_mut(part.len());

            cur.clone_from_slice(part)

        let host_pos = parts[..1].iter().map(|v| v.len()).sum();

        // The path is index 3 in the parts list

        let path_pos = parts[..3].iter().map(|v| v.len()).sum();

        // The query is index 4 in the parts list

        let query_pos = parts[..4].iter().map(|v| v.len()).sum();

        CString::new(uri_str_copy)

            .map(|v| (v, host_pos, path_pos, query_pos))

            .map_err(UriParsingError::from)

    }

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        Self::try_from_str(s)

    }

#[derive(Copy, Clone, FromPrimitive, PartialEq, Eq, Hash)]

    fn from(raw_proto: coap_proto_t) -> Self {

        <CoapProtocol as FromPrimitive>::from_u32(raw_proto as u32).expect("unknown protocol")

    }