pub fn coap_startup_with_feature_checks() {

    // only compile checks if they are available for the given libcoap version.

    #[cfg(feature_checks_available)]

    {

        #[cfg(feature = "af-unix")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_af_unix_is_supported() != 1 } {

            panic!("Required feature \"af-unix\" is not supported by libcoap")

        }

        #[cfg(feature = "async")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_async_is_supported() != 1 } {

            panic!("Required feature \"async\" is not supported by libcoap")

        }

        #[cfg(feature = "client")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_client_is_supported() != 1 } {

        }

        #[cfg(feature = "dtls")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_dtls_is_supported() != 1 } {

        }

        #[cfg(feature = "dtls-cid")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_dtls_cid_is_supported() != 1 } {

            panic!("Required feature \"dtls-cid\" is not supported by libcoap")

        }

        #[cfg(feature = "dtls-psk")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_dtls_psk_is_supported() != 1 } {

        }

        #[cfg(feature = "dtls-pki")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_dtls_pki_is_supported() != 1 } {

            panic!("Required feature \"dtls-pki\" is not supported by libcoap")

        }

        #[cfg(feature = "dtls-pkcs11")]

        // SAFETY: Function is always safe to call.

        if !unsafe { coap_dtls_pkcs11_is_supported() == 1 } {

            panic!("Required feature \"dtls-pkcs11\" is not supported by libcoap")

        }

        #[cfg(feature = "dtls-rpk")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_dtls_rpk_is_supported() != 1 } {

            panic!("Required feature \"dtls-rpk\" is not supported by libcoap")

        }

        #[cfg(feature = "epoll")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_epoll_is_supported() != 1 } {

            panic!("Required feature \"epoll\" is not supported by libcoap")

        }

        #[cfg(feature = "ipv4")]

        // SAFETY: Function is always safe to call.

        if !unsafe { coap_ipv4_is_supported() == 1 } {

            panic!("Required feature \"ipv4\" is not supported by libcoap")

        }

        #[cfg(feature = "ipv6")]

        // SAFETY: Function is always safe to call.

        if !unsafe { coap_ipv6_is_supported() == 1 } {

            panic!("Required feature \"ipv6\" is not supported by libcoap")

        }

        #[cfg(feature = "observe-persist")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_observe_persist_is_supported() != 1 } {

            panic!("Required feature \"ipv4\" is not supported by libcoap")

        }

        #[cfg(feature = "oscore")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_oscore_is_supported() != 1 } {

            panic!("Required feature \"oscore\" is not supported by libcoap")

        }

        #[cfg(feature = "q-block")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_q_block_is_supported() != 1 } {

            panic!("Required feature \"q-block\" is not supported by libcoap")

        }

        #[cfg(feature = "server")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_server_is_supported() != 1 } {

        }

        #[cfg(feature = "tcp")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_tcp_is_supported() != 1 } {

        }

        #[cfg(feature = "thread-safe")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_threadsafe_is_supported() != 1 } {

            panic!("Required feature \"thread-safe\" is not supported by libcoap")

        }

        #[cfg(feature = "tls")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_tls_is_supported() != 1 } {

            panic!("Required feature \"tls\" is not supported by libcoap")

        }

        #[cfg(feature = "websockets")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_ws_is_supported() != 1 } {

            panic!("Required feature \"websockets\" is not supported by libcoap")

        }

        #[cfg(feature = "secure-websockets")]

        // SAFETY: Function is always safe to call.

        if unsafe { coap_wss_is_supported() != 1 } {

            panic!("Required feature \"websockets\" is not supported by libcoap")

        }

    }

    #[cfg(not(feature_checks_available))]

    {

        println!("WARNING: coap_startup_with_feature_checks() could not assert the availability of features because the linked version of libcoap is too old (< 4.3.5rc3)!")

    }

    // SAFETY: Function is always safe to call.

    unsafe { coap_startup() }

}

    fn coap_address_from_socketaddr(addr: &SocketAddr) -> coap_address_t {

        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 {

                        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(),

                    };

                    coap_addr

    }

    unsafe extern "C" fn test_resource_handler(

        _resource: *mut coap_resource_t,

        session: *mut coap_session_t,

        _incoming_pdu: *const coap_pdu_t,

        _query: *const coap_string_t,

        response_pdu: *mut coap_pdu_t,

    ) {

        let mut buf: [u8; 3] = [0; 3];

        coap_add_option(

            response_pdu,

            COAP_OPTION_CONTENT_TYPE as coap_option_num_t,

            coap_encode_var_safe(buf.as_mut_ptr(), buf.len(), COAP_MEDIATYPE_TEXT_PLAIN) as usize,

            buf.as_ptr(),

        );

        coap_add_data(

            response_pdu,

            COAP_TEST_RESOURCE_RESPONSE.len(),

            COAP_TEST_RESOURCE_RESPONSE.as_ptr(),

        );

        coap_set_app_data(coap_session_get_context(session), (&true) as *const bool as *mut c_void);

        coap_pdu_set_code(response_pdu, COAP_RESPONSE_CODE_CONTENT);

    }

    unsafe extern "C" fn test_response_handler(

        session: *mut coap_session_t,

        _sent: *const coap_pdu_t,

        received: *const coap_pdu_t,

        _mid: coap_mid_t,

    ) -> coap_response_t {

        assert_eq!(coap_pdu_get_code(received), COAP_RESPONSE_CODE_CONTENT);

        let mut len: size_t = 0;

        let mut data: *const u8 = std::ptr::null();

        assert_ne!(coap_get_data(received, &mut len, &mut data), 0);

        let data = std::slice::from_raw_parts(data, len);

        assert_eq!(data, COAP_TEST_RESOURCE_RESPONSE.as_bytes());

        coap_set_app_data(coap_session_get_context(session), (&true) as *const bool as *mut c_void);

        return COAP_RESPONSE_OK;

    }

    fn run_coap_test_server(addr: &SocketAddr, barrier: Arc<Barrier>) {

        // SAFETY: Null pointer is a valid parameter here.

        let context = unsafe { coap_new_context(std::ptr::null()) };

        assert!(!context.is_null());

        let address: coap_address_t = coap_address_from_socketaddr(addr);

        // SAFETY: We asserted that context != null, listen_addr is a reference and can therefore not be null.

        let endpoint = unsafe { coap_new_endpoint(context, &address, coap_proto_t::COAP_PROTO_UDP) };

        assert!(!endpoint.is_null());

        let uri = unsafe { coap_new_str_const(COAP_TEST_RESOURCE_URI.as_ptr(), COAP_TEST_RESOURCE_URI.len()) };

        assert!(!uri.is_null());

        let test_resource = unsafe { coap_resource_init(uri, COAP_RESOURCE_FLAGS_RELEASE_URI as c_int) };

        assert!(!test_resource.is_null());

        unsafe {

            coap_register_request_handler(test_resource, COAP_REQUEST_GET, Some(test_resource_handler));

            coap_add_resource(context, test_resource);

            coap_set_app_data(context, (&false) as *const bool as *mut c_void);

        }

        barrier.wait();

            let time_spent_millis = unsafe { coap_io_process(context, 10000) };

            // SAFETY: We are the only ones setting or accessing this value, so we know it is a

            // const bool pointer (we have also set it to *false before and only ever set it to

            // *true afterwards).

            if unsafe { *(coap_get_app_data(context) as *const bool).as_ref().unwrap() } {

                break;

        unsafe {

            coap_free_context(context);

        }

    }

    fn test_coap_client_server_basic() {

        // This will give us a SocketAddress with a port in the local port range automatically

        // assigned by the operating system.

        // Because the UdpSocket goes out of scope, the Port will be free for usage by libcoap.

        // This seems to be the only portable way to get a port number assigned from the operating

        // system, which is necessary here because of potential parallelisation (we can't just use

        // the default CoAP port if multiple tests are run in parallel).

        // It is assumed here that after unbinding the temporary socket, the OS will not reassign

        // this port until we bind it again. This should work in most cases (unless we run on a

        // system with very few free ports), because at least Linux will not reuse port numbers

        // unless necessary, see https://unix.stackexchange.com/a/132524.

        let server_address = UdpSocket::bind("localhost:0")

            .expect("Failed to bind server socket")

            .local_addr()

            .expect("Failed to get server socket address");

        let preparation_barrier = Arc::new(Barrier::new(2));

        let server_address_clone = server_address.clone();

        let preparation_barrier_clone = preparation_barrier.clone();

        let server_thread_handle =

            std::thread::spawn(move || run_coap_test_server(&server_address_clone, preparation_barrier_clone));

        // SAFETY: Null pointer is a valid parameter here.

        let context = unsafe { coap_new_context(std::ptr::null()) };

        assert!(!context.is_null());

        preparation_barrier.wait();

        let server_address = coap_address_from_socketaddr(&server_address);

        // SAFETY: null pointer is valid argument for local_if, server_address is guaranteed to be

        // a correct value (conversion cannot fail), validity of context was asserted before.

        let client_session =

            unsafe { coap_new_client_session(context, std::ptr::null(), &server_address, COAP_PROTO_UDP) };

        // SAFETY: context and client_session were asserted to be valid.

        // Casting *const to *mut is fine because we don't mutate the value pointed to and the

        // pointer is not used by libcoap (the application data pointer is intended to be used by

        // client applications to store and/or modify their own data, which is why it is a mutable

        // pointer in the first place).

        // coap_request_pdu is asserted to be valid before it is used.

        unsafe {

            coap_register_response_handler(context, Some(test_response_handler));

            coap_set_app_data(context, (&false) as *const bool as *mut c_void);

            let coap_request_pdu =

                coap_new_pdu(coap_pdu_type_t::COAP_MESSAGE_NON, COAP_REQUEST_CODE_GET, client_session);

            assert!(!coap_request_pdu.is_null());

            assert_ne!(

                coap_add_option(

                    coap_request_pdu,

                    COAP_OPTION_URI_PATH as coap_option_num_t,

                    COAP_TEST_RESOURCE_URI.len(),

                    COAP_TEST_RESOURCE_URI.as_ptr(),

                ),

                0

            );

            assert_ne!(coap_send(client_session, coap_request_pdu), COAP_INVALID_MID);

            let time_spent_millis = unsafe { coap_io_process(context, 10000) };

            // SAFETY: We are the only ones setting or accessing this value, so we know it is a

            // const bool pointer (we have also set it to *false before and only ever set it to

            // *true afterwards).

            if unsafe { *(coap_get_app_data(context) as *const bool).as_ref().unwrap() } {

                break;

        unsafe {

            coap_free_context(context);

        }

        server_thread_handle.join().expect("Error waiting for server thread");

    }