coap_proxy_internal.h

Go to the documentation of this file.

/*
 * coap_proxy_internal.h -- Proxy functions for libcoap
 *
 * Copyright (C) 2024-2026 Jon Shallow <supjps-libcoap@jpshallow.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * This file is part of the CoAP library libcoap. Please see README for terms
 * of use.
 */

 
#ifndef COAP_PROXY_INTERNAL_H_
#define COAP_PROXY_INTERNAL_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if COAP_PROXY_SUPPORT
 
/*  Client <--> Proxy-Server | Proxy-Client <--> Server */
 
typedef struct coap_proxy_cache_t {
  UT_hash_handle hh;            
  coap_cache_key_t cache_req;   
  coap_pdu_t *req_pdu;          
  coap_pdu_t *rsp_pdu;          
  coap_tick_t expire;           
  uint64_t etag;                
  unsigned ref;                 
} coap_proxy_cache_t;
 
typedef struct coap_proxy_req_t {
  struct coap_proxy_req_t *next;
  coap_pdu_t *pdu;              
  coap_resource_t *resource;    
  coap_session_t *incoming;     
  coap_bin_const_t *token_used; 
  coap_cache_key_t *cache_key;  
  coap_proxy_cache_t *proxy_cache; 
  coap_mid_t mid;               
  unsigned doing_observe;       
} coap_proxy_req_t;
 
struct coap_proxy_entry_t {
  coap_session_t *ongoing;    
  coap_session_t *incoming;   
  coap_proxy_req_t *proxy_req; 
  coap_proxy_cache_t *rsp_cache; /* Response cache list */
  uint8_t *uri_host_keep;     
  coap_uri_t uri;             
  int track_client_session;   
  coap_mid_t mid;             
  coap_tick_t req_start_ticks; 
  coap_tick_t idle_timeout_ticks; 
  coap_tick_t last_used;      
};
 
typedef enum {
  COAP_PROXY_SUBS_ALL,
  COAP_PROXY_SUBS_TOKEN,
  COAP_PROXY_SUBS_MID,
} coap_proxy_subs_delete_t;

void coap_proxy_cleanup(coap_context_t *context);

int coap_proxy_check_timeouts(coap_context_t *context, coap_tick_t now,
                              coap_tick_t *tim_rem);

int coap_proxy_remove_association(coap_session_t *session, coap_pdu_code_t failure_code);

int coap_proxy_forward_request_lkd(coap_session_t *session,
                                   const coap_pdu_t *request,
                                   coap_pdu_t *response,
                                   coap_resource_t *resource,
                                   coap_cache_key_t *cache_key,
                                   coap_proxy_server_list_t *server_list);

coap_response_t coap_proxy_forward_response_lkd(coap_session_t *session,
                                                const coap_pdu_t *received,
                                                coap_cache_key_t **cache_key);

coap_session_t *coap_new_client_session_proxy_lkd(coap_context_t *context,
                                                  coap_proxy_server_list_t *server_list);
 

coap_proxy_entry_t *coap_proxy_fwd_add_client_session_lkd(coap_session_t *session,
                                                          const char *use_ip,
                                                          uint16_t use_port,
                                                          coap_proxy_server_list_t *server_list);
coap_mid_t coap_proxy_local_write(coap_session_t *session, coap_pdu_t *pdu);

struct coap_proxy_req_t *coap_proxy_map_outgoing_request(coap_session_t *ongoing,
                                                         const coap_pdu_t *received,
                                                         coap_proxy_entry_t **proxy_entry);

void coap_proxy_process_incoming(coap_session_t *session,
                                 coap_pdu_t *rcvd, void *body_free,
                                 coap_proxy_req_t *proxy_req,
                                 coap_proxy_entry_t *proxy_entry);

void coap_proxy_del_req(coap_proxy_entry_t *proxy_entry,  coap_proxy_req_t *proxy_req);

void coap_delete_proxy_subscriber(coap_session_t *session, coap_bin_const_t *token,
                                  coap_mid_t mid, coap_proxy_subs_delete_t type);

void coap_proxy_log_entry(coap_session_t *incoming, const coap_pdu_t *pdu,
                          coap_bin_const_t *upstream_token, const char *type);
 
#define PROXY_CACHE_ADD(e, obj) \
  HASH_ADD(hh, (e), cache_req, sizeof((obj)->cache_req), (obj))
 
#define PROXY_CACHE_DELETE(e, obj) \
  HASH_DELETE(hh, (e), (obj))
 
#define PROXY_CACHE_ITER(e, el, rtmp)  \
  HASH_ITER(hh, (e), el, rtmp)
 
#define PROXY_CACHE_ITER_SAFE(e, el, rtmp) \
  for ((el) = (e); (el) && ((rtmp) = (el)->hh.next, 1); (el) = (rtmp))
 
#define PROXY_CACHE_FIND(e, k, res) {                     \
    HASH_FIND(hh, (e), (k), sizeof(*k), (res)); \
  }
 
#endif /* COAP_PROXY_SUPPORT */
 
#ifdef __cplusplus
}
#endif
 
#endif /* COAP_PROXY_INTERNAL_H_ */