coap_net_internal.h

Go to the documentation of this file.

/*
 * coap_net_internal.h -- CoAP context internal information
 * exposed to application programming
 *
 * Copyright (C) 2010-2025 Olaf Bergmann <bergmann@tzi.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * This file is part of the CoAP library libcoap. Please see README for terms
 * of use.
 */
 
#ifndef COAP_NET_INTERNAL_H_
#define COAP_NET_INTERNAL_H_
 
#include "coap_internal.h"
#include "coap_subscribe.h"
#include "coap_threadsafe_internal.h"
 
struct coap_queue_t {
  struct coap_queue_t *next;
  coap_tick_t t;                
  unsigned char retransmit_cnt; 
  uint8_t is_mcast;             
  unsigned int timeout;         
  coap_session_t *session;      
  coap_mid_t id;                
  coap_pdu_t *pdu;              
};
 
struct coap_context_t {
  coap_opt_filter_t known_options;
#if COAP_SERVER_SUPPORT
  coap_resource_t *resources; 
  coap_resource_t *unknown_resource; 
  coap_resource_t *proxy_uri_resource; 
  coap_resource_release_userdata_handler_t release_userdata;
#endif /* COAP_SERVER_SUPPORT */
 
#if COAP_ASYNC_SUPPORT
  coap_async_t *async_state;
#endif /* COAP_ASYNC_SUPPORT */
 
  coap_tick_t sendqueue_basetime;
  coap_queue_t *sendqueue;
#if COAP_SERVER_SUPPORT
  coap_endpoint_t *endpoint;      
#endif /* COAP_SERVER_SUPPORT */
#if COAP_CLIENT_SUPPORT
  coap_session_t *sessions;       
#endif /* COAP_CLIENT_SUPPORT */
 
#ifdef WITH_CONTIKI
  struct uip_udp_conn *conn;      
  struct ctimer io_timer;         
#endif /* WITH_CONTIKI */
 
#ifdef WITH_LWIP
  coap_lwip_input_wait_handler_t input_wait; 
  void *input_arg;                
  uint8_t timer_configured;       
#endif /* WITH_LWIP */
#ifdef RIOT_VERSION
  thread_t *selecting_thread;
#endif /* RIOT_VERSION */
#if COAP_OSCORE_SUPPORT
  struct oscore_ctx_t *p_osc_ctx; 
#endif /* COAP_OSCORE_SUPPORT */
 
#if COAP_CLIENT_SUPPORT
  coap_response_handler_t response_handler; 
#endif /* COAP_CLIENT_SUPPORT */
#if COAP_PROXY_SUPPORT
  coap_response_handler_t proxy_response_handler; 
#endif /* COAP_PROXY_SUPPORT */
  coap_nack_handler_t nack_handler; 
  coap_ping_handler_t ping_handler; 
  coap_pong_handler_t pong_handler; 
#if COAP_SERVER_SUPPORT
  coap_observe_added_t observe_added; 
  coap_observe_deleted_t observe_deleted; 
  void *observe_user_data; 
  uint32_t observe_save_freq; 
  coap_track_observe_value_t track_observe_value; 
  coap_dyn_resource_added_t dyn_resource_added; 
  coap_resource_deleted_t resource_deleted; 
#if COAP_WITH_OBSERVE_PERSIST
  coap_bin_const_t *dyn_resource_save_file; 
  coap_bin_const_t *obs_cnt_save_file; 
  coap_bin_const_t *observe_save_file; 
  coap_pdu_t *unknown_pdu;        
  coap_session_t *unknown_session; 
#endif /* COAP_WITH_OBSERVE_PERSIST */
#endif /* COAP_SERVER_SUPPORT */
 
  coap_event_handler_t handle_event;
 
  void *dtls_context;
 
#if COAP_SERVER_SUPPORT
  coap_dtls_spsk_t spsk_setup_data;  
#endif /* COAP_SERVER_SUPPORT */
 
  unsigned int session_timeout;    
  unsigned int max_idle_sessions;  
  unsigned int max_handshake_sessions; 
  unsigned int ping_timeout;           
  uint32_t csm_timeout_ms;         
  uint32_t csm_max_message_size;   
#if COAP_CLIENT_SUPPORT
  unsigned int reconnect_time;     
#endif /* COAP_CLIENT_SUPPORT */
#if COAP_SERVER_SUPPORT
  coap_cache_entry_t *cache;       
  uint16_t *cache_ignore_options;  
  size_t cache_ignore_count;       
#endif /* COAP_SERVER_SUPPORT */
  void *app_data;                  
  coap_app_data_free_callback_t app_cb; 
  uint32_t max_token_size;         
  coap_tick_t next_timeout;        
#ifdef COAP_EPOLL_SUPPORT
  int epfd;                        
  int eptimerfd;                   
#else /* ! COAP_EPOLL_SUPPORT */
#if !defined(RIOT_VERSION) && !defined(WITH_CONTIKI)
  fd_set readfds, writefds, exceptfds; 
  coap_socket_t *sockets[64];      
  unsigned int num_sockets;        
#endif /* ! RIOT_VERSION && ! WITH_CONTIKI */
#endif /* ! COAP_EPOLL_SUPPORT */
#if COAP_SERVER_SUPPORT
  uint8_t observe_pending;         
  uint8_t observe_no_clear;        
  uint8_t mcast_per_resource;      
  uint8_t shutdown_no_send_observe; 
#endif /* COAP_SERVER_SUPPORT */
#if COAP_PROXY_SUPPORT
  coap_proxy_list_t *proxy_list;   
  size_t proxy_list_count;         
#endif /* COAP_PROXY_SUPPORT */
#if COAP_CLIENT_SUPPORT
  uint8_t testing_cids;            
#endif /* COAP_CLIENT_SUPPORT */
  uint32_t block_mode;             
};
 
int coap_insert_node(coap_queue_t **queue, coap_queue_t *node);
 
COAP_API int coap_delete_node(coap_queue_t *node);
 
int coap_delete_node_lkd(coap_queue_t *node);
 
void coap_delete_all(coap_queue_t *queue);
 
coap_queue_t *coap_new_node(void);
 
unsigned int coap_adjust_basetime(coap_context_t *ctx, coap_tick_t now);
 
coap_queue_t *coap_peek_next(coap_context_t *context);
 
coap_queue_t *coap_pop_next(coap_context_t *context);
 
coap_mid_t coap_retransmit(coap_context_t *context, coap_queue_t *node);
 
int coap_handle_dgram(coap_context_t *ctx, coap_session_t *session, uint8_t *data, size_t data_len);
 
int coap_remove_from_queue(coap_queue_t **queue,
                           coap_session_t *session,
                           coap_mid_t id,
                           coap_queue_t **node);
 
coap_mid_t coap_wait_ack(coap_context_t *context, coap_session_t *session,
                         coap_queue_t *node);
 
void coap_cancel_all_messages(coap_context_t *context,
                              coap_session_t *session,
                              coap_bin_const_t *token);
 
void coap_cancel_session_messages(coap_context_t *context,
                                  coap_session_t *session,
                                  coap_nack_reason_t reason);
 
uint16_t coap_new_message_id_lkd(coap_session_t *session);
 
void coap_dispatch(coap_context_t *context, coap_session_t *session,
                   coap_pdu_t *pdu);
 
int coap_option_check_critical(coap_session_t *session,
                               coap_pdu_t *pdu,
                               coap_opt_filter_t *unknown);
 
coap_pdu_t *coap_wellknown_response(coap_context_t *context,
                                    coap_session_t *session,
                                    coap_pdu_t *request);
 
unsigned int coap_calc_timeout(coap_session_t *session, unsigned char r);
 
int coap_check_code_class(coap_session_t *session, coap_pdu_t *pdu);
 
coap_mid_t coap_send_internal(coap_session_t *session, coap_pdu_t *pdu,
                              coap_pdu_t *request_pdu);
 
int coap_client_delay_first(coap_session_t *session);
 
void coap_free_context_lkd(coap_context_t *context);
 
void *coap_context_set_app_data2_lkd(coap_context_t *context, void *data,
                                     coap_app_data_free_callback_t callback);
 
int coap_handle_event_lkd(coap_context_t *context,
                          coap_event_t event,
                          coap_session_t *session);
 
int coap_can_exit_lkd(coap_context_t *context);
 
int coap_join_mcast_group_intf_lkd(coap_context_t *ctx, const char *groupname,
                                   const char *ifname);
 
void coap_register_option_lkd(coap_context_t *ctx, uint16_t type);
 
int coap_context_set_pki_lkd(coap_context_t *context,
                             const coap_dtls_pki_t *setup_data);
 
int coap_context_set_pki_root_cas_lkd(coap_context_t *context,
                                      const char *ca_file,
                                      const char *ca_dir);
 
int coap_context_load_pki_trust_store_lkd(coap_context_t *context);
 
int coap_context_set_psk_lkd(coap_context_t *context, const char *hint,
                             const uint8_t *key, size_t key_len);
 
int coap_context_set_psk2_lkd(coap_context_t *context,
                              coap_dtls_spsk_t *setup_data);
 
void coap_io_do_io_lkd(coap_context_t *ctx, coap_tick_t now);
 
void coap_io_do_epoll_lkd(coap_context_t *ctx, struct epoll_event *events,
                          size_t nevents);
 
int coap_io_pending_lkd(coap_context_t *context);
 
unsigned int coap_io_prepare_epoll_lkd(coap_context_t *ctx, coap_tick_t now);
 
unsigned int coap_io_prepare_io_lkd(coap_context_t *ctx,
                                    coap_socket_t *sockets[],
                                    unsigned int max_sockets,
                                    unsigned int *num_sockets,
                                    coap_tick_t now
                                   );
 
int coap_io_process_lkd(coap_context_t *ctx, uint32_t timeout_ms);
 
int coap_io_process_loop_lkd(coap_context_t *context,
                             coap_io_process_thread_t main_loop_code,
                             void *main_loop_code_arg, uint32_t timeout_ms,
                             uint32_t thread_count);
 
#if !defined(RIOT_VERSION) && !defined(WITH_CONTIKI)
int coap_io_process_with_fds_lkd(coap_context_t *ctx, uint32_t timeout_ms,
                                 int nfds, fd_set *readfds, fd_set *writefds,
                                 fd_set *exceptfds);
#endif /* ! RIOT_VERSION && ! WITH_CONTIKI */
 
/*
 * Get the current libcoap usage of file descriptors that are in a read or write pending state.
 *
 * Note: This function must be called in the locked state.
 *
 * @param context The current CoAP context.
 * @param read_fds Array to populate with file descriptors in the read pending state.
 * @param have_read_fds Updated wth the number of fds found in read pending state.
 * @param max_read_fds Maximum size of read_fds[] array.
 * @param write_fds Array to populate with file descriptors in the write pending state.
 * @param have_write_fds Updated wth the number of fds found in write pending state.
 * @param max_write_fds Maximum size of write_fds[] array.
 * @param rem_timeout_ms Remaining timeout time to next libcoap activity in milli-secs.
 *
 * @return @c 1 if successful, else @c 0 if error.
 */
unsigned int coap_io_get_fds_lkd(coap_context_t *context, coap_fd_t read_fds[],
                                 unsigned int *have_read_fds,
                                 unsigned int max_read_fds,
                                 coap_fd_t write_fds[],
                                 unsigned int *have_write_fds,
                                 unsigned int max_write_fds,
                                 unsigned int *rem_timeout_ms);
 
coap_mid_t coap_send_lkd(coap_session_t *session, coap_pdu_t *pdu);
 
/*
 * Send a request PDU and wait for the response PDU.
 *
 * Note: This function must be called in the locked state.
 *
 * @param session     The CoAP session.
 * @param request_pdu The requesting PDU. If this PDU contains the Observe
 *                    option, the unsolocited responses will get handled by the
 *                    defined response handler. This PDU must be freed off by the
 *                    caller after processing.
 * @param response_pdu If there is a response, the response PDU is put here.
 *                     This PDU must be freed off by the caller after processing.
 * @param timeout_ms Positive maximum number of milliseconds to wait for response
 *                   packet following the request. If there is a large block transfer
 *                   this timeout is for between each request and response.
 *
 * @return 0 or +ve Time in function in ms after successful transfer (which can be
 *                  bigger than timeout_ms).
 *               -1 Invalid timeout parameter
 *               -2 Failed to transmit PDU
 *               -3 Nack or Event handler invoked, cancelling request
 *               -4 coap_io_process returned error (fail to re-lock or select())
 *               -5 Response not received in the given time
 *               -6 Terminated by user
 *               -7 Client mode code not enabled
 */
int coap_send_recv_lkd(coap_session_t *session, coap_pdu_t *request_pdu,
                       coap_pdu_t **response_pdu, uint32_t timeout_ms);
 
coap_mid_t coap_send_error_lkd(coap_session_t *session,
                               const coap_pdu_t *request,
                               coap_pdu_code_t code,
                               coap_opt_filter_t *opts);
 
coap_mid_t coap_send_message_type_lkd(coap_session_t *session, const coap_pdu_t *request,
                                      coap_pdu_type_t type);
 
coap_mid_t coap_send_ack_lkd(coap_session_t *session, const coap_pdu_t *request);
 
coap_mid_t coap_send_rst_lkd(coap_session_t *session, const coap_pdu_t *request);
 
void coap_call_response_handler(coap_session_t *session, coap_pdu_t *sent, coap_pdu_t *rcvd,
                                void *body_free);
 
extern int coap_started;
 
#endif /* COAP_NET_INTERNAL_H_ */