libcoap 4.3.2rc2

coap_cache.c
Go to the documentation of this file.
1/* coap_cache.c -- Caching of CoAP requests
2*
3* Copyright (C) 2020-2023 Olaf Bergmann <bergmann@tzi.org>
4*
5 * SPDX-License-Identifier: BSD-2-Clause
6 *
7* This file is part of the CoAP library libcoap. Please see
8* README for terms of use.
9*/
10
16#include "coap3/coap_internal.h"
17
18#if COAP_SERVER_SUPPORT
19/* Determines if the given option_type denotes an option type that can
20 * be used as CacheKey. Options that can be cache keys are not Unsafe
21 * and not marked explicitly as NoCacheKey. */
22 static int
23is_cache_key(uint16_t option_type, size_t cache_ignore_count,
24 const uint16_t *cache_ignore_options) {
25 size_t i;
26
27 /* https://rfc-editor.org/rfc/rfc7252#section-5.4.6 Nocachekey definition */
28 if ((option_type & 0x1e) == 0x1c)
29 return 0;
30 /*
31 * https://rfc-editor.org/rfc/rfc7641#section-2 Observe is not a
32 * part of the cache-key.
33 */
34 if (option_type == COAP_OPTION_OBSERVE)
35 return 0;
36
37 /* Check for option user has defined as not part of cache-key */
38 for (i = 0; i < cache_ignore_count; i++) {
39 if (cache_ignore_options[i] == option_type) {
40 return 0;
41 }
42 }
43
44 return 1;
45}
46
47 int
48 coap_cache_ignore_options(coap_context_t *ctx,
49 const uint16_t *options,
50 size_t count) {
51 if (ctx->cache_ignore_options) {
52 coap_free_type(COAP_STRING, ctx->cache_ignore_options);
53 }
54 if (count) {
55 assert(options);
56 ctx->cache_ignore_options = coap_malloc_type(COAP_STRING, count * sizeof(options[0]));
57 if (ctx->cache_ignore_options) {
58 memcpy(ctx->cache_ignore_options, options, count * sizeof(options[0]));
59 ctx->cache_ignore_count = count;
60 } else {
61 coap_log_warn("Unable to create cache_ignore_options\n");
62 return 0;
63 }
64 } else {
65 ctx->cache_ignore_options = NULL;
66 ctx->cache_ignore_count = count;
67 }
68 return 1;
69}
70
71 coap_cache_key_t *
72 coap_cache_derive_key_w_ignore(const coap_session_t *session,
73 const coap_pdu_t *pdu,
74 coap_cache_session_based_t session_based,
75 const uint16_t *cache_ignore_options,
76 size_t cache_ignore_count) {
77 coap_opt_t *option;
78 coap_opt_iterator_t opt_iter;
79 coap_digest_ctx_t *dctx;
80 coap_digest_t digest;
81 coap_cache_key_t *cache_key;
82
83 if (!coap_option_iterator_init(pdu, &opt_iter, COAP_OPT_ALL)) {
84 return NULL;
85 }
86
87 dctx = coap_digest_setup();
88 if (!dctx)
89 return NULL;
90
91 if (session_based == COAP_CACHE_IS_SESSION_BASED) {
92 /* Include the session ptr */
93 if (!coap_digest_update(dctx, (const uint8_t *)&session, sizeof(session))) {
94 goto update_fail;
95 }
96 }
97 while ((option = coap_option_next(&opt_iter))) {
98 if (is_cache_key(opt_iter.number, cache_ignore_count,
99 cache_ignore_options)) {
100 if (!coap_digest_update(dctx, (const uint8_t *)&opt_iter.number,
101 sizeof(opt_iter.number))) {
102 goto update_fail;
103 }
104 if (!coap_digest_update(dctx, coap_opt_value(option),
105 coap_opt_length(option))) {
106 goto update_fail;
107 }
108 }
109 }
110
111 /* The body of a FETCH payload is part of the cache key,
112 * see https://rfc-editor.org/rfc/rfc8132#section-2 */
113 if (pdu->code == COAP_REQUEST_CODE_FETCH) {
114 size_t len;
115 const uint8_t *data;
116 if (coap_get_data(pdu, &len, &data)) {
117 if (!coap_digest_update(dctx, data, len)) {
118 goto update_fail;
119 }
120 }
121 }
122
123 if (!coap_digest_final(dctx, &digest)) {
124 /* coap_digest_final() is guaranteed to free off dctx no matter what */
125 return NULL;
126 }
127 cache_key = coap_malloc_type(COAP_CACHE_KEY, sizeof(coap_cache_key_t));
128 if (cache_key) {
129 memcpy(cache_key->key, digest.key, sizeof(cache_key->key));
130 }
131 return cache_key;
132update_fail:
133 coap_digest_free(dctx);
134 return NULL;
135}
136
137 coap_cache_key_t *
138 coap_cache_derive_key(const coap_session_t *session,
139 const coap_pdu_t *pdu,
140 coap_cache_session_based_t session_based) {
141 return coap_cache_derive_key_w_ignore(session, pdu, session_based,
142 session->context->cache_ignore_options,
143 session->context->cache_ignore_count);
144}
145
146 void
147 coap_delete_cache_key(coap_cache_key_t *cache_key) {
148 coap_free_type(COAP_CACHE_KEY, cache_key);
149}
150
151 coap_cache_entry_t *
152 coap_new_cache_entry(coap_session_t *session, const coap_pdu_t *pdu,
153 coap_cache_record_pdu_t record_pdu,
154 coap_cache_session_based_t session_based,
155 unsigned int idle_timeout) {
156 coap_cache_entry_t *entry = coap_malloc_type(COAP_CACHE_ENTRY,
157 sizeof(coap_cache_entry_t));
158 if (!entry) {
159 return NULL;
160 }
161
162 memset(entry, 0, sizeof(coap_cache_entry_t));
163 entry->session = session;
164 if (record_pdu == COAP_CACHE_RECORD_PDU) {
165 entry->pdu = coap_pdu_init(pdu->type, pdu->code, pdu->mid, pdu->alloc_size);
166 if (entry->pdu) {
167 if (!coap_pdu_resize(entry->pdu, pdu->alloc_size)) {
168 coap_delete_pdu(entry->pdu);
169 coap_free_type(COAP_CACHE_ENTRY, entry);
170 return NULL;
171 }
172 /* Need to get the appropriate data across */
173 memcpy(entry->pdu, pdu, offsetof(coap_pdu_t, token));
174 memcpy(entry->pdu->token, pdu->token, pdu->used_size);
175 /* And adjust all the pointers etc. */
176 entry->pdu->data = entry->pdu->token + (pdu->data - pdu->token);
177 }
178 }
179 entry->cache_key = coap_cache_derive_key(session, pdu, session_based);
180 if (!entry->cache_key) {
181 coap_free_type(COAP_CACHE_ENTRY, entry);
182 return NULL;
183 }
184 entry->idle_timeout = idle_timeout;
185 if (idle_timeout > 0) {
186 coap_ticks(&entry->expire_ticks);
187 entry->expire_ticks += idle_timeout * COAP_TICKS_PER_SECOND;
188 }
189
190 HASH_ADD(hh, session->context->cache, cache_key[0], sizeof(coap_cache_key_t), entry);
191 return entry;
192}
193
194 coap_cache_entry_t *
195 coap_cache_get_by_key(coap_context_t *ctx, const coap_cache_key_t *cache_key) {
196 coap_cache_entry_t *cache_entry = NULL;
197
198 assert(cache_key);
199 if (cache_key) {
200 HASH_FIND(hh, ctx->cache, cache_key, sizeof(coap_cache_key_t), cache_entry);
201 }
202 if (cache_entry && cache_entry->idle_timeout > 0) {
203 coap_ticks(&cache_entry->expire_ticks);
204 cache_entry->expire_ticks += cache_entry->idle_timeout * COAP_TICKS_PER_SECOND;
205 }
206 return cache_entry;
207}
208
209 coap_cache_entry_t *
210 coap_cache_get_by_pdu(coap_session_t *session,
211 const coap_pdu_t *request,
212 coap_cache_session_based_t session_based) {
213 coap_cache_key_t *cache_key = coap_cache_derive_key(session, request, session_based);
214 coap_cache_entry_t *cache_entry;
215
216 if (!cache_key)
217 return NULL;
218
219 cache_entry = coap_cache_get_by_key(session->context, cache_key);
220 coap_delete_cache_key(cache_key);
221 if (cache_entry && cache_entry->idle_timeout > 0) {
222 coap_ticks(&cache_entry->expire_ticks);
223 cache_entry->expire_ticks += cache_entry->idle_timeout * COAP_TICKS_PER_SECOND;
224 }
225 return cache_entry;
226}
227
228 void
229 coap_delete_cache_entry(coap_context_t *ctx, coap_cache_entry_t *cache_entry) {
230
231 assert(cache_entry);
232
233 if (cache_entry) {
234 HASH_DELETE(hh, ctx->cache, cache_entry);
235 }
236 if (cache_entry->pdu) {
237 coap_delete_pdu(cache_entry->pdu);
238 }
239 coap_delete_cache_key(cache_entry->cache_key);
240 if (cache_entry->callback && cache_entry->app_data) {
241 cache_entry->callback(cache_entry->app_data);
242 }
243 coap_free_type(COAP_CACHE_ENTRY, cache_entry);
244}
245
246 const coap_pdu_t *
247 coap_cache_get_pdu(const coap_cache_entry_t *cache_entry) {
248 return cache_entry->pdu;
249}
250
251 void
252 coap_cache_set_app_data(coap_cache_entry_t *cache_entry,
253 void *data,
254 coap_cache_app_data_free_callback_t callback) {
255 cache_entry->app_data = data;
256 cache_entry->callback = callback;
257}
258
259 void *
260 coap_cache_get_app_data(const coap_cache_entry_t *cache_entry) {
261 return cache_entry->app_data;
262}
263
264 void
265 coap_expire_cache_entries(coap_context_t *ctx) {
266 coap_tick_t now;
267 coap_cache_entry_t *cp, *ctmp;
268
269 coap_ticks(&now);
270 HASH_ITER(hh, ctx->cache, cp, ctmp) {
271 if (cp->idle_timeout > 0) {
272 if (cp->expire_ticks <= now) {
273 coap_delete_cache_entry(ctx, cp);
274 }
275 }
276 }
277}
278
279#endif /* ! COAP_SERVER_SUPPORT */
coap_internal.h
Pulls together all the internal only header files.
COAP_CACHE_KEY
@ COAP_CACHE_KEY
Definition: coap_mem.h:52
COAP_CACHE_ENTRY
@ COAP_CACHE_ENTRY
Definition: coap_mem.h:53
COAP_STRING
@ COAP_STRING
Definition: coap_mem.h:38
coap_malloc_type
void * coap_malloc_type(coap_memory_tag_t type, size_t size)
Allocates a chunk of size bytes and returns a pointer to the newly allocated memory.
coap_free_type
void coap_free_type(coap_memory_tag_t type, void *p)
Releases the memory that was allocated by coap_malloc_type().
coap_opt_t
uint8_t coap_opt_t
Use byte-oriented access methods here because sliding a complex struct coap_opt_t over the data buffe...
Definition: coap_option.h:26
coap_digest_free
void coap_digest_free(coap_digest_ctx_t *digest_ctx)
Free off coap_digest_ctx_t.
coap_digest_final
int coap_digest_final(coap_digest_ctx_t *digest_ctx, coap_digest_t *digest_buffer)
Finalize the coap_digest information into the provided digest_buffer.
coap_digest_update
int coap_digest_update(coap_digest_ctx_t *digest_ctx, const uint8_t *data, size_t data_len)
Update the coap_digest information with the next chunk of data.
coap_digest_ctx_t
void coap_digest_ctx_t
Definition: coap_cache_internal.h:61
coap_expire_cache_entries
void coap_expire_cache_entries(coap_context_t *context)
Expire coap_cache_entry_t entries.
coap_digest_setup
coap_digest_ctx_t * coap_digest_setup(void)
Initialize a coap_digest.
coap_delete_cache_entry
void coap_delete_cache_entry(coap_context_t *context, coap_cache_entry_t *cache_entry)
Remove a cache-entry from the hash list and free off all the appropriate contents apart from app_data...
coap_delete_cache_key
void coap_delete_cache_key(coap_cache_key_t *cache_key)
Delete the cache-key.
coap_cache_derive_key
coap_cache_key_t * coap_cache_derive_key(const coap_session_t *session, const coap_pdu_t *pdu, coap_cache_session_based_t session_based)
Calculates a cache-key for the given CoAP PDU.
coap_cache_record_pdu_t
coap_cache_record_pdu_t
Definition: coap_cache.h:42
coap_cache_app_data_free_callback_t
void(* coap_cache_app_data_free_callback_t)(void *data)
Callback to free off the app data when the cache-entry is being deleted / freed off.
Definition: coap_cache.h:35
coap_cache_get_pdu
const coap_pdu_t * coap_cache_get_pdu(const coap_cache_entry_t *cache_entry)
Returns the PDU information stored in the coap_cache entry.
coap_cache_get_by_pdu
coap_cache_entry_t * coap_cache_get_by_pdu(coap_session_t *session, const coap_pdu_t *pdu, coap_cache_session_based_t session_based)
Searches for a cache-entry corresponding to pdu.
coap_cache_ignore_options
int coap_cache_ignore_options(coap_context_t *context, const uint16_t *options, size_t count)
Define the CoAP options that are not to be included when calculating the cache-key.
coap_cache_derive_key_w_ignore
coap_cache_key_t * coap_cache_derive_key_w_ignore(const coap_session_t *session, const coap_pdu_t *pdu, coap_cache_session_based_t session_based, const uint16_t *ignore_options, size_t ignore_count)
Calculates a cache-key for the given CoAP PDU.
coap_new_cache_entry
coap_cache_entry_t * coap_new_cache_entry(coap_session_t *session, const coap_pdu_t *pdu, coap_cache_record_pdu_t record_pdu, coap_cache_session_based_t session_based, unsigned int idle_time)
Create a new cache-entry hash keyed by cache-key derived from the PDU.
coap_cache_get_app_data
void * coap_cache_get_app_data(const coap_cache_entry_t *cache_entry)
Returns any application-specific data that has been stored with cache_entry using the function coap_c...
coap_cache_get_by_key
coap_cache_entry_t * coap_cache_get_by_key(coap_context_t *context, const coap_cache_key_t *cache_key)
Searches for a cache-entry identified by cache_key.
coap_cache_set_app_data
void coap_cache_set_app_data(coap_cache_entry_t *cache_entry, void *data, coap_cache_app_data_free_callback_t callback)
Stores data with the given cache entry.
coap_cache_session_based_t
coap_cache_session_based_t
Definition: coap_cache.h:37
COAP_CACHE_RECORD_PDU
@ COAP_CACHE_RECORD_PDU
Definition: coap_cache.h:44
COAP_CACHE_IS_SESSION_BASED
@ COAP_CACHE_IS_SESSION_BASED
Definition: coap_cache.h:39
coap_tick_t
uint64_t coap_tick_t
This data type represents internal timer ticks with COAP_TICKS_PER_SECOND resolution.
Definition: coap_time.h:144
COAP_TICKS_PER_SECOND
#define COAP_TICKS_PER_SECOND
Use ms resolution on POSIX systems.
Definition: coap_time.h:159
coap_ticks
void coap_ticks(coap_tick_t *)
Returns the current value of an internal tick counter.
coap_log_warn
#define coap_log_warn(...)
Definition: coap_debug.h:102
coap_option_next
coap_opt_t * coap_option_next(coap_opt_iterator_t *oi)
Updates the iterator oi to point to the next option.
Definition: coap_option.c:153
coap_opt_length
uint32_t coap_opt_length(const coap_opt_t *opt)
Returns the length of the given option.
Definition: coap_option.c:212
coap_option_iterator_init
coap_opt_iterator_t * coap_option_iterator_init(const coap_pdu_t *pdu, coap_opt_iterator_t *oi, const coap_opt_filter_t *filter)
Initializes the given option iterator oi to point to the beginning of the pdu's option list.
Definition: coap_option.c:117
COAP_OPT_ALL
#define COAP_OPT_ALL
Pre-defined filter that includes all options.
Definition: coap_option.h:108
coap_opt_value
const uint8_t * coap_opt_value(const coap_opt_t *opt)
Returns a pointer to the value of the given option.
Definition: coap_option.c:249
coap_pdu_resize
int coap_pdu_resize(coap_pdu_t *pdu, size_t new_size)
Dynamically grows the size of pdu to new_size.
Definition: coap_pdu.c:245
coap_delete_pdu
void coap_delete_pdu(coap_pdu_t *pdu)
Dispose of an CoAP PDU and frees associated storage.
Definition: coap_pdu.c:163
coap_get_data
int coap_get_data(const coap_pdu_t *pdu, size_t *len, const uint8_t **data)
Retrieves the length and data pointer of specified PDU.
Definition: coap_pdu.c:797
coap_pdu_init
coap_pdu_t * coap_pdu_init(coap_pdu_type_t type, coap_pdu_code_t code, coap_mid_t mid, size_t size)
Creates a new CoAP PDU with at least enough storage space for the given size maximum message size.
Definition: coap_pdu.c:97
COAP_OPTION_OBSERVE
#define COAP_OPTION_OBSERVE
Definition: coap_pdu.h:119
COAP_REQUEST_CODE_FETCH
@ COAP_REQUEST_CODE_FETCH
Definition: coap_pdu.h:325
coap_cache_entry_t
Definition: coap_cache_internal.h:41
coap_cache_entry_t::session
coap_session_t * session
Definition: coap_cache_internal.h:44
coap_cache_entry_t::callback
coap_cache_app_data_free_callback_t callback
Definition: coap_cache_internal.h:49
coap_cache_entry_t::expire_ticks
coap_tick_t expire_ticks
Definition: coap_cache_internal.h:47
coap_cache_entry_t::app_data
void * app_data
Definition: coap_cache_internal.h:46
coap_cache_entry_t::idle_timeout
unsigned int idle_timeout
Definition: coap_cache_internal.h:48
coap_cache_entry_t::cache_key
coap_cache_key_t * cache_key
Definition: coap_cache_internal.h:43
coap_cache_entry_t::pdu
coap_pdu_t * pdu
Definition: coap_cache_internal.h:45
coap_cache_key_t
Definition: coap_cache_internal.h:37
coap_cache_key_t::key
uint8_t key[32]
Definition: coap_cache_internal.h:38
coap_context_t
The CoAP stack's global state is stored in a coap_context_t object.
Definition: coap_net_internal.h:49
coap_context_t::cache_ignore_options
uint16_t * cache_ignore_options
CoAP options to ignore when creating a cache-key.
Definition: coap_net_internal.h:166
coap_context_t::cache_ignore_count
size_t cache_ignore_count
The number of CoAP options to ignore when creating a cache-key.
Definition: coap_net_internal.h:168
coap_context_t::cache
coap_cache_entry_t * cache
CoAP cache-entry cache.
Definition: coap_net_internal.h:165
coap_digest_t
Definition: coap_cache_internal.h:33
coap_digest_t::key
uint8_t key[32]
Definition: coap_cache_internal.h:34
coap_opt_iterator_t
Iterator to run through PDU options.
Definition: coap_option.h:168
coap_opt_iterator_t::number
coap_option_num_t number
decoded option number
Definition: coap_option.h:170
coap_pdu_t
structure for CoAP PDUs
Definition: coap_pdu_internal.h:119
coap_pdu_t::token
uint8_t * token
first byte of token (or extended length bytes prefix), if any, or options
Definition: coap_pdu_internal.h:139
coap_pdu_t::code
coap_pdu_code_t code
request method (value 1–31) or response code (value 64-255)
Definition: coap_pdu_internal.h:121
coap_pdu_t::data
uint8_t * data
first byte of payload, if any
Definition: coap_pdu_internal.h:141
coap_pdu_t::mid
coap_mid_t mid
message id, if any, in regular host byte order
Definition: coap_pdu_internal.h:123
coap_pdu_t::used_size
size_t used_size
used bytes of storage for token, options and payload
Definition: coap_pdu_internal.h:135
coap_pdu_t::alloc_size
size_t alloc_size
allocated storage for token, options and payload
Definition: coap_pdu_internal.h:133
coap_pdu_t::type
coap_pdu_type_t type
message type
Definition: coap_pdu_internal.h:120
coap_session_t
Abstraction of virtual session that can be attached to coap_context_t (client) or coap_endpoint_t (se...
Definition: coap_session_internal.h:68
coap_session_t::context
coap_context_t * context
session's context
Definition: coap_session_internal.h:86