libcoap 4.3.5-develop-1ba3158
Loading...
Searching...
No Matches
coap_subscribe.c
Go to the documentation of this file.
1/* coap_subscribe.c -- subscription handling for CoAP
2 * see RFC7641
3 *
4 * Copyright (C) 2010-2019,2022-2025 Olaf Bergmann <bergmann@tzi.org>
5 *
6 * SPDX-License-Identifier: BSD-2-Clause
7 *
8 * This file is part of the CoAP library libcoap. Please see
9 * README for terms of use.
10 */
11
17#include "coap3/coap_libcoap_build.h"
18
19#ifndef min
20#define min(a,b) ((a) < (b) ? (a) : (b))
21#endif
22
23int
24coap_observe_persist_is_supported(void) {
25#if COAP_SERVER_SUPPORT && COAP_WITH_OBSERVE_PERSIST
26 return 1;
27#else /* ! (COAP_SERVER_SUPPORT && COAP_WITH_OBSERVE_PERSIST) */
28 return 0;
29#endif /* ! (COAP_SERVER_SUPPORT && COAP_WITH_OBSERVE_PERSIST) */
30}
31
32#if COAP_SERVER_SUPPORT
33void
34coap_subscription_init(coap_subscription_t *s) {
35 assert(s);
36 memset(s, 0, sizeof(coap_subscription_t));
37}
38
39void
40coap_persist_track_funcs(coap_context_t *context,
41 coap_observe_added_t observe_added,
42 coap_observe_deleted_t observe_deleted,
43 coap_track_observe_value_t track_observe_value,
44 coap_dyn_resource_added_t dyn_resource_added,
45 coap_resource_deleted_t resource_deleted,
46 uint32_t save_freq,
47 void *user_data) {
48 context->observe_added = observe_added;
49 context->observe_deleted = observe_deleted;
50 context->observe_user_data = user_data;
51 context->observe_save_freq = save_freq ? save_freq : 1;
52 context->track_observe_value = track_observe_value;
53 context->dyn_resource_added = dyn_resource_added;
54 context->resource_deleted = resource_deleted;
55}
56
57COAP_API coap_subscription_t *
58coap_persist_observe_add(coap_context_t *context,
59 coap_proto_t e_proto,
60 const coap_address_t *e_listen_addr,
61 const coap_addr_tuple_t *s_addr_info,
62 const coap_bin_const_t *raw_packet,
63 const coap_bin_const_t *oscore_info) {
64 coap_subscription_t *subs;
65
66 coap_lock_lock(context, return NULL);
67 subs = coap_persist_observe_add_lkd(context,
68 e_proto,
69 e_listen_addr,
70 s_addr_info,
71 raw_packet,
72 oscore_info);
73 coap_lock_unlock(context);
74 return subs;
75}
76
77coap_subscription_t *
78coap_persist_observe_add_lkd(coap_context_t *context,
79 coap_proto_t e_proto,
80 const coap_address_t *e_listen_addr,
81 const coap_addr_tuple_t *s_addr_info,
82 const coap_bin_const_t *raw_packet,
83 const coap_bin_const_t *oscore_info) {
84 coap_session_t *session = NULL;
85 const uint8_t *data;
86 size_t data_len;
87 coap_pdu_t *pdu = NULL;
88#if COAP_CONSTRAINED_STACK
89 /* e_packet can be protected by global_lock if needed */
90 static coap_packet_t e_packet;
91#else /* ! COAP_CONSTRAINED_STACK */
92 coap_packet_t e_packet;
93#endif /* ! COAP_CONSTRAINED_STACK */
94 coap_packet_t *packet = &e_packet;
95 coap_tick_t now;
96 coap_string_t *uri_path = NULL;
97 coap_opt_iterator_t opt_iter;
98 coap_opt_t *observe;
99 int observe_action;
100 coap_resource_t *r;
101 coap_subscription_t *s;
102 coap_endpoint_t *ep;
103
104 coap_lock_check_locked(context);
105 if (e_listen_addr == NULL || s_addr_info == NULL || raw_packet == NULL)
106 return NULL;
107
108 /* Will be creating a local 'open' session */
109 if (e_proto != COAP_PROTO_UDP)
110 return NULL;
111
112 ep = context->endpoint;
113 while (ep) {
114 if (ep->proto == e_proto &&
115 memcmp(e_listen_addr, &ep->bind_addr, sizeof(ep->bind_addr)) == 0)
116 break;
117 ep = ep->next;
118 }
119 if (!ep) {
120 if (COAP_LOG_WARN <= coap_get_log_level()) {
121#ifndef INET6_ADDRSTRLEN
122#define INET6_ADDRSTRLEN 40
123#endif
124 unsigned char addr_str[INET6_ADDRSTRLEN + 8];
125
126 if (coap_print_addr(e_listen_addr, addr_str, INET6_ADDRSTRLEN + 8)) {
127 coap_log_warn("coap_persist_observe_add: Endpoint %s not defined\n",
128 addr_str);
129 }
130 }
131 return NULL;
132 }
133
134 /* Build up packet */
135 memcpy(&packet->addr_info, s_addr_info, sizeof(packet->addr_info));
136 packet->ifindex = 0;
137 memcpy(&packet->payload, &raw_packet->s, sizeof(packet->payload));
138 packet->length = raw_packet->length;
139
140 data = raw_packet->s;
141 data_len = raw_packet->length;
142 if (data_len < 4)
143 goto malformed;
144
145 /* Get the session */
146
147 coap_ticks(&now);
148 session = coap_endpoint_get_session(ep, packet, now);
149 if (session == NULL)
150 goto fail;
151 /* Need max space incase PDU is updated with updated token, huge size etc. */
152 pdu = coap_pdu_init(0, 0, 0, 0);
153 if (!pdu)
154 goto fail;
155
156 if (!coap_pdu_parse(session->proto, data, data_len, pdu)) {
157 goto malformed;
158 }
159 pdu->max_size = pdu->used_size;
160
161 if (pdu->code != COAP_REQUEST_CODE_GET &&
162 pdu->code != COAP_REQUEST_CODE_FETCH)
163 goto malformed;
164
165 observe = coap_check_option(pdu, COAP_OPTION_OBSERVE, &opt_iter);
166 if (observe == NULL)
167 goto malformed;
168 observe_action = coap_decode_var_bytes(coap_opt_value(observe),
169 coap_opt_length(observe));
170 if (observe_action != COAP_OBSERVE_ESTABLISH)
171 goto malformed;
172
173 /* Get the resource */
174
175 uri_path = coap_get_uri_path(pdu);
176 if (!uri_path)
177 goto malformed;
178
179 r = coap_get_resource_from_uri_path_lkd(session->context,
180 (coap_str_const_t *)uri_path);
181 if (r == NULL) {
182 coap_log_warn("coap_persist_observe_add: resource '%s' not defined\n",
183 uri_path->s);
184 goto fail;
185 }
186 if (!r->observable) {
187 coap_log_warn("coap_persist_observe_add: resource '%s' not observable\n",
188 uri_path->s);
189 goto fail;
190 }
191 coap_delete_string(uri_path);
192 uri_path = NULL;
193
194 /* Create / update subscription for observing */
195 /* Now set up the subscription */
196 s = coap_add_observer(r, session, &pdu->actual_token, pdu);
197 if (s == NULL)
198 goto fail;
199
200#if COAP_OSCORE_SUPPORT
201 if (oscore_info) {
202 coap_log_debug("persist: OSCORE association being updated\n");
203 /*
204 * Need to track the association used for tracking this observe, done as
205 * a CBOR array. Written in coap_add_observer().
206 *
207 * If an entry is null, then use nil, else a set of bytes
208 *
209 * Currently tracking 5 items
210 * recipient_id
211 * id_context
212 * aad (from oscore_association_t)
213 * partial_iv (from oscore_association_t)
214 * nonce (from oscore_association_t)
215 */
216 oscore_ctx_t *osc_ctx;
217 const uint8_t *info_buf = oscore_info->s;
218 size_t info_buf_len = oscore_info->length;
219 size_t ret = 0;
220 coap_bin_const_t oscore_key_id;
221 coap_bin_const_t partial_iv;
222 coap_bin_const_t aad;
223 coap_bin_const_t id_context;
224 coap_bin_const_t nonce;
225 int have_aad = 0;
226 int have_partial_iv = 0;
227 int have_id_context = 0;
228 int have_nonce = 0;
229
230 ret = oscore_cbor_get_next_element(&info_buf, &info_buf_len);
231 if (ret != CBOR_ARRAY)
232 goto oscore_fail;
233 if (oscore_cbor_get_element_size(&info_buf, &info_buf_len) != 5)
234 goto oscore_fail;
235
236 /* recipient_id */
237 ret = oscore_cbor_get_next_element(&info_buf, &info_buf_len);
238 if (ret != CBOR_BYTE_STRING)
239 goto oscore_fail;
240 oscore_key_id.length = oscore_cbor_get_element_size(&info_buf,
241 &info_buf_len);
242 oscore_key_id.s = info_buf;
243 info_buf += oscore_key_id.length;
244
245 /* id_context */
246 ret = oscore_cbor_get_next_element(&info_buf, &info_buf_len);
247 if (ret == CBOR_BYTE_STRING) {
248 id_context.length = oscore_cbor_get_element_size(&info_buf,
249 &info_buf_len);
250 id_context.s = info_buf;
251 info_buf += id_context.length;
252 have_id_context = 1;
253 } else if (ret == CBOR_SIMPLE_VALUE &&
254 oscore_cbor_get_element_size(&info_buf,
255 &info_buf_len) == CBOR_NULL) {
256 } else
257 goto oscore_fail;
258
259 /* aad */
260 ret = oscore_cbor_get_next_element(&info_buf, &info_buf_len);
261 if (ret == CBOR_BYTE_STRING) {
262 aad.length = oscore_cbor_get_element_size(&info_buf, &info_buf_len);
263 aad.s = info_buf;
264 info_buf += aad.length;
265 have_aad = 1;
266 } else if (ret == CBOR_SIMPLE_VALUE &&
267 oscore_cbor_get_element_size(&info_buf,
268 &info_buf_len) == CBOR_NULL) {
269 } else
270 goto oscore_fail;
271
272 /* partial_iv */
273 ret = oscore_cbor_get_next_element(&info_buf, &info_buf_len);
274 if (ret == CBOR_BYTE_STRING) {
275 partial_iv.length = oscore_cbor_get_element_size(&info_buf,
276 &info_buf_len);
277 partial_iv.s = info_buf;
278 info_buf += partial_iv.length;
279 have_partial_iv = 1;
280 } else if (ret == CBOR_SIMPLE_VALUE &&
281 oscore_cbor_get_element_size(&info_buf,
282 &info_buf_len) == CBOR_NULL) {
283 } else
284 goto oscore_fail;
285
286 /* nonce */
287 ret = oscore_cbor_get_next_element(&info_buf, &info_buf_len);
288 if (ret == CBOR_BYTE_STRING) {
289 nonce.length = oscore_cbor_get_element_size(&info_buf,
290 &info_buf_len);
291 nonce.s = info_buf;
292 info_buf += nonce.length;
293 have_nonce = 1;
294 } else if (ret == CBOR_SIMPLE_VALUE &&
295 oscore_cbor_get_element_size(&info_buf,
296 &info_buf_len) == CBOR_NULL) {
297 } else
298 goto oscore_fail;
299
300 osc_ctx = oscore_find_context(session->context, oscore_key_id,
301 have_id_context ? &id_context : NULL, NULL,
302 &session->recipient_ctx);
303 if (osc_ctx) {
304 session->oscore_encryption = 1;
305 oscore_new_association(session, pdu, &pdu->actual_token,
306 session->recipient_ctx,
307 have_aad ? &aad : NULL,
308 have_nonce ? &nonce : NULL,
309 have_partial_iv ? &partial_iv : NULL,
310 1);
311 coap_log_debug("persist: OSCORE association added\n");
312 oscore_log_hex_value(COAP_LOG_OSCORE, "partial_iv",
313 have_partial_iv ? &partial_iv : NULL);
314 }
315 }
316oscore_fail:
317#else /* ! COAP_OSCORE_SUPPORT */
318 (void)oscore_info;
319#endif /* ! COAP_OSCORE_SUPPORT */
320 coap_delete_pdu_lkd(pdu);
321 return s;
322
323malformed:
324 coap_log_warn("coap_persist_observe_add: discard malformed PDU\n");
325fail:
326 coap_delete_string(uri_path);
327 coap_delete_pdu_lkd(pdu);
328 return NULL;
329}
330
331#if COAP_WITH_OBSERVE_PERSIST
332#include <stdio.h>
333
334/*
335 * read in active observe entry.
336 */
337static int
338coap_op_observe_read(FILE *fp, coap_subscription_t **observe_key,
339 coap_proto_t *e_proto, coap_address_t *e_listen_addr,
340 coap_addr_tuple_t *s_addr_info,
341 coap_bin_const_t **raw_packet, coap_bin_const_t **oscore_info) {
342 ssize_t size;
343 coap_binary_t *scratch = NULL;
344
345 assert(fp && observe_key && e_proto && e_listen_addr && s_addr_info &&
346 raw_packet && oscore_info);
347
348 *raw_packet = NULL;
349 *oscore_info = NULL;
350
351 if (fread(observe_key, sizeof(*observe_key), 1, fp) == 1) {
352 /* New record 'key proto listen addr_info len raw_packet len oscore' */
353 if (fread(e_proto, sizeof(*e_proto), 1, fp) != 1)
354 goto fail;
355 if (fread(e_listen_addr, sizeof(*e_listen_addr), 1, fp) != 1)
356 goto fail;
357 if (fread(s_addr_info, sizeof(*s_addr_info), 1, fp) != 1)
358 goto fail;
359 if (fread(&size, sizeof(size), 1, fp) != 1)
360 goto fail;
361 if (size < 0 || size > 0x10000)
362 goto fail;
363 scratch = coap_new_binary(size);
364 if ((scratch) == NULL)
365 goto fail;
366 if (fread(scratch->s, scratch->length, 1, fp) != 1)
367 goto fail;
368 *raw_packet = (coap_bin_const_t *)scratch;
369 scratch = NULL;
370 if (fread(&size, sizeof(size), 1, fp) != 1)
371 goto fail;
372 /* If size == -1, then no oscore information */
373 if (size == -1)
374 return 1;
375 else if (size < 0 || size > 0x10000)
376 goto fail;
377 else {
378 scratch = coap_new_binary(size);
379 if (scratch == NULL)
380 goto fail;
381 if (fread(scratch->s, scratch->length, 1, fp) != 1)
382 goto fail;
383 *oscore_info = (coap_bin_const_t *)scratch;
384 }
385 return 1;
386 }
387fail:
388 coap_delete_bin_const(*raw_packet);
389 coap_delete_binary(scratch);
390
391 *observe_key = NULL;
392 memset(e_proto, 0, sizeof(*e_proto));
393 memset(e_listen_addr, 0, sizeof(*e_listen_addr));
394 memset(s_addr_info, 0, sizeof(*s_addr_info));
395 *raw_packet = NULL;
396 return 0;
397}
398
399/*
400 * write out active observe entry.
401 */
402static int
403coap_op_observe_write(FILE *fp, coap_subscription_t *observe_key,
404 coap_proto_t e_proto, coap_address_t e_listen_addr,
405 coap_addr_tuple_t s_addr_info,
406 coap_bin_const_t *raw_packet, coap_bin_const_t *oscore_info) {
407 if (fwrite(&observe_key, sizeof(observe_key), 1, fp) != 1)
408 goto fail;
409 if (fwrite(&e_proto, sizeof(e_proto), 1, fp) != 1)
410 goto fail;
411 if (fwrite(&e_listen_addr, sizeof(e_listen_addr),
412 1, fp) != 1)
413 goto fail;
414 if (fwrite(&s_addr_info, sizeof(s_addr_info), 1, fp) != 1)
415 goto fail;
416 if (fwrite(&raw_packet->length, sizeof(raw_packet->length), 1, fp) != 1)
417 goto fail;
418 if (fwrite(raw_packet->s, raw_packet->length, 1, fp) != 1)
419 goto fail;
420 if (oscore_info) {
421 if (fwrite(&oscore_info->length, sizeof(oscore_info->length), 1, fp) != 1)
422 goto fail;
423 if (fwrite(oscore_info->s, oscore_info->length, 1, fp) != 1)
424 goto fail;
425 } else {
426 ssize_t not_defined = -1;
427
428 if (fwrite(&not_defined, sizeof(not_defined), 1, fp) != 1)
429 goto fail;
430 }
431 return 1;
432fail:
433 return 0;
434}
435
436/*
437 * This should be called before coap_persist_track_funcs() to prevent
438 * coap_op_observe_added() getting unnecessarily called.
439 * It should be called after init_resources() and coap_op_resource_load_disk()
440 * so that all the resources are in place.
441 */
442static void
443coap_op_observe_load_disk(coap_context_t *ctx) {
444 FILE *fp_orig = fopen((const char *)ctx->observe_save_file->s, "r");
445 FILE *fp_new = NULL;
446 coap_subscription_t *observe_key = NULL;
447 coap_proto_t e_proto;
448 coap_address_t e_listen_addr;
449 coap_addr_tuple_t s_addr_info;
450 coap_bin_const_t *raw_packet = NULL;
451 coap_bin_const_t *oscore_info = NULL;
452 char *new = NULL;
453
454 if (fp_orig == NULL)
455 goto fail;
456
457 new = coap_malloc_type(COAP_STRING, ctx->observe_save_file->length + 5);
458 if (!new)
459 goto fail;
460
461 strcpy(new, (const char *)ctx->observe_save_file->s);
462 strcat(new, ".tmp");
463 fp_new = fopen(new, "w+");
464 if (fp_new == NULL)
465 goto fail;
466
467 /* Go through and load oscore entry, updating key on the way */
468 while (1) {
469 if (!coap_op_observe_read(fp_orig, &observe_key, &e_proto, &e_listen_addr,
470 &s_addr_info, &raw_packet, &oscore_info))
471 break;
472 coap_log_debug("persist: New session/observe being created\n");
473 observe_key = coap_persist_observe_add_lkd(ctx, e_proto,
474 &e_listen_addr,
475 &s_addr_info,
476 raw_packet,
477 oscore_info);
478 if (observe_key) {
479 if (!coap_op_observe_write(fp_new, observe_key, e_proto, e_listen_addr,
480 s_addr_info, raw_packet, oscore_info))
481 goto fail;
482 }
483 coap_delete_bin_const(raw_packet);
484 raw_packet = NULL;
485 coap_delete_bin_const(oscore_info);
486 oscore_info = NULL;
487 }
488 coap_delete_bin_const(raw_packet);
489 raw_packet = NULL;
490 coap_delete_bin_const(oscore_info);
491 oscore_info = NULL;
492
493 if (fflush(fp_new) == EOF)
494 goto fail;
495 fclose(fp_new);
496 fclose(fp_orig);
497 /* Either old or new is in place */
498 if (rename(new, (const char *)ctx->observe_save_file->s) == -1) {
499 coap_log_warn("rename %s -> %s: failed: %s (%d)\n",
500 new, (const char *)ctx->observe_save_file->s,
501 coap_socket_strerror(), errno);
502 }
503 coap_free_type(COAP_STRING, new);
504 return;
505
506fail:
507 coap_delete_bin_const(raw_packet);
508 coap_delete_bin_const(oscore_info);
509 if (fp_new)
510 fclose(fp_new);
511 if (fp_orig)
512 fclose(fp_orig);
513 if (new) {
514 (void)remove(new);
515 }
516 coap_free_type(COAP_STRING, new);
517 return;
518}
519
520/*
521 * client has registered a new observe subscription request.
522 */
523static int
524coap_op_observe_added(coap_session_t *session,
525 coap_subscription_t *a_observe_key,
526 coap_proto_t a_e_proto, coap_address_t *a_e_listen_addr,
527 coap_addr_tuple_t *a_s_addr_info,
528 coap_bin_const_t *a_raw_packet,
529 coap_bin_const_t *a_oscore_info, void *user_data) {
530 FILE *fp_orig = fopen((const char *)session->context->observe_save_file->s,
531 "r");
532 FILE *fp_new = NULL;
533 coap_subscription_t *observe_key = NULL;
534 coap_proto_t e_proto;
535 coap_address_t e_listen_addr;
536 coap_addr_tuple_t s_addr_info;
537 coap_bin_const_t *raw_packet = NULL;
538 coap_bin_const_t *oscore_info = NULL;
539 char *new = NULL;
540
541 (void)user_data;
542
543 new = coap_malloc_type(COAP_STRING,
544 session->context->observe_save_file->length + 5);
545 if (!new)
546 goto fail;
547
548 strcpy(new, (const char *)session->context->observe_save_file->s);
549 strcat(new, ".tmp");
550 fp_new = fopen(new, "w+");
551 if (fp_new == NULL)
552 goto fail;
553
554 /* Go through and delete observe entry if it exists */
555 while (fp_orig) {
556 if (!coap_op_observe_read(fp_orig, &observe_key, &e_proto, &e_listen_addr,
557 &s_addr_info, &raw_packet, &oscore_info))
558 break;
559 if (observe_key != a_observe_key) {
560 if (!coap_op_observe_write(fp_new, observe_key, e_proto, e_listen_addr,
561 s_addr_info, raw_packet, oscore_info))
562 goto fail;
563 }
564 coap_delete_bin_const(raw_packet);
565 raw_packet = NULL;
566 coap_delete_bin_const(oscore_info);
567 oscore_info = NULL;
568 }
569 coap_delete_bin_const(raw_packet);
570 raw_packet = NULL;
571 coap_delete_bin_const(oscore_info);
572 oscore_info = NULL;
573
574 /* Add in new entry to the end */
575 if (!coap_op_observe_write(fp_new, a_observe_key, a_e_proto, *a_e_listen_addr,
576 *a_s_addr_info, a_raw_packet, a_oscore_info))
577 goto fail;
578
579 if (fflush(fp_new) == EOF)
580 goto fail;
581 fclose(fp_new);
582 if (fp_orig)
583 fclose(fp_orig);
584 /* Either old or new is in place */
585 (void)rename(new, (const char *)session->context->observe_save_file->s);
586 coap_free_type(COAP_STRING, new);
587 return 1;
588
589fail:
590 coap_delete_bin_const(raw_packet);
591 coap_delete_bin_const(oscore_info);
592 if (fp_new)
593 fclose(fp_new);
594 if (fp_orig)
595 fclose(fp_orig);
596 if (new) {
597 (void)remove(new);
598 }
599 coap_free_type(COAP_STRING, new);
600 return 0;
601}
602
603/*
604 * client has de-registered a observe subscription request.
605 */
606static int
607coap_op_observe_deleted(coap_session_t *session,
608 coap_subscription_t *d_observe_key,
609 void *user_data) {
610 FILE *fp_orig = fopen((const char *)session->context->observe_save_file->s,
611 "r");
612 FILE *fp_new = NULL;
613 coap_subscription_t *observe_key = NULL;
614 coap_proto_t e_proto;
615 coap_address_t e_listen_addr;
616 coap_addr_tuple_t s_addr_info;
617 coap_bin_const_t *raw_packet = NULL;
618 coap_bin_const_t *oscore_info = NULL;
619 char *new = NULL;
620
621 (void)user_data;
622
623 if (fp_orig == NULL)
624 goto fail;
625 new = coap_malloc_type(COAP_STRING,
626 session->context->observe_save_file->length + 5);
627 if (!new)
628 goto fail;
629
630 strcpy(new, (const char *)session->context->observe_save_file->s);
631 strcat(new, ".tmp");
632 fp_new = fopen(new, "w+");
633 if (fp_new == NULL)
634 goto fail;
635
636 /* Go through and locate observe entry to delete and not copy it across */
637 while (1) {
638 if (!coap_op_observe_read(fp_orig, &observe_key, &e_proto, &e_listen_addr,
639 &s_addr_info, &raw_packet, &oscore_info))
640 break;
641 if (observe_key != d_observe_key) {
642 if (!coap_op_observe_write(fp_new, observe_key, e_proto, e_listen_addr,
643 s_addr_info, (coap_bin_const_t *)raw_packet,
644 (coap_bin_const_t *)oscore_info))
645 goto fail;
646 }
647 coap_delete_bin_const(raw_packet);
648 raw_packet = NULL;
649 coap_delete_bin_const(oscore_info);
650 oscore_info = NULL;
651 }
652 coap_delete_bin_const(raw_packet);
653 raw_packet = NULL;
654 coap_delete_bin_const(oscore_info);
655 oscore_info = NULL;
656
657 if (fflush(fp_new) == EOF)
658 goto fail;
659 fclose(fp_new);
660 fclose(fp_orig);
661 /* Either old or new is in place */
662 (void)rename(new, (const char *)session->context->observe_save_file->s);
663 coap_free_type(COAP_STRING, new);
664 return 1;
665
666fail:
667 coap_delete_bin_const(raw_packet);
668 coap_delete_bin_const(oscore_info);
669 if (fp_new)
670 fclose(fp_new);
671 if (fp_orig)
672 fclose(fp_orig);
673 if (new) {
674 (void)remove(new);
675 }
676 coap_free_type(COAP_STRING, new);
677 return 0;
678}
679
680/*
681 * This should be called before coap_persist_track_funcs() to prevent
682 * coap_op_obs_cnt_track_observe() getting unnecessarily called.
683 * Should be called after coap_op_dyn_resource_load_disk() to make sure that
684 * all the resources are in the right place.
685 */
686static void
687coap_op_obs_cnt_load_disk(coap_context_t *context) {
688 FILE *fp = fopen((const char *)context->obs_cnt_save_file->s, "r");
689 char buf[1500];
690
691 if (fp == NULL)
692 return;
693
694 while (fgets(buf, sizeof(buf), fp) != NULL) {
695 char *cp = strchr(buf, ' ');
696 coap_str_const_t resource_key;
697 uint32_t observe_num;
698 coap_resource_t *r;
699
700 if (!cp)
701 break;
702
703 *cp = '\000';
704 cp++;
705 observe_num = atoi(cp);
706 /*
707 * Need to assume 0 .. (context->observe_save_freq-1) have in addition
708 * been sent so need to round up to latest possible send value
709 */
710 observe_num = ((observe_num + context->observe_save_freq) /
711 context->observe_save_freq) *
712 context->observe_save_freq - 1;
713 resource_key.s = (uint8_t *)buf;
714 resource_key.length = strlen(buf);
715 r = coap_get_resource_from_uri_path_lkd(context, &resource_key);
716 if (r) {
717 coap_log_debug("persist: Initial observe number being updated\n");
718 coap_persist_set_observe_num(r, observe_num);
719 }
720 }
721 fclose(fp);
722}
723
724/*
725 * Called when the observe value of a resource has been changed, but limited
726 * to be called every context->context->observe_save_freq to reduce update
727 * overheads.
728 */
729static int
730coap_op_obs_cnt_track_observe(coap_context_t *context,
731 coap_str_const_t *resource_name,
732 uint32_t n_observe_num,
733 void *user_data) {
734 FILE *fp_orig = fopen((const char *)context->obs_cnt_save_file->s, "r");
735 FILE *fp_new = NULL;
736 char buf[1500];
737 char *new = NULL;
738
739 (void)user_data;
740
741 new = coap_malloc_type(COAP_STRING, context->obs_cnt_save_file->length + 5);
742 if (!new)
743 goto fail;
744
745 strcpy(new, (const char *)context->obs_cnt_save_file->s);
746 strcat(new, ".tmp");
747 fp_new = fopen(new, "w+");
748 if (fp_new == NULL)
749 goto fail;
750
751 /* Go through and locate resource entry to update */
752 while (fp_orig && fgets(buf, sizeof(buf), fp_orig) != NULL) {
753 char *cp = strchr(buf, ' ');
754 uint32_t observe_num;
755 coap_bin_const_t resource_key;
756
757 if (!cp)
758 break;
759
760 *cp = '\000';
761 cp++;
762 observe_num = atoi(cp);
763 resource_key.s = (uint8_t *)buf;
764 resource_key.length = strlen(buf);
765 if (!coap_binary_equal(resource_name, &resource_key)) {
766 if (fprintf(fp_new, "%s %u\n", resource_key.s, observe_num) < 0)
767 goto fail;
768 }
769 }
770 if (fprintf(fp_new, "%s %u\n", resource_name->s, n_observe_num) < 0)
771 goto fail;
772 if (fflush(fp_new) == EOF)
773 goto fail;
774 fclose(fp_new);
775 if (fp_orig)
776 fclose(fp_orig);
777 /* Either old or new is in place */
778 (void)rename(new, (const char *)context->obs_cnt_save_file->s);
779 coap_free_type(COAP_STRING, new);
780 return 1;
781
782fail:
783 if (fp_new)
784 fclose(fp_new);
785 if (fp_orig)
786 fclose(fp_orig);
787 if (new) {
788 (void)remove(new);
789 }
790 coap_free_type(COAP_STRING, new);
791 return 0;
792}
793
794/*
795 * Called when a resource has been deleted.
796 */
797static int
798coap_op_obs_cnt_deleted(coap_context_t *context,
799 coap_str_const_t *resource_name) {
800 FILE *fp_orig = fopen((const char *)context->obs_cnt_save_file->s, "r");
801 FILE *fp_new = NULL;
802 char buf[1500];
803 char *new = NULL;
804
805 if (fp_orig == NULL)
806 goto fail;
807 new = coap_malloc_type(COAP_STRING, context->obs_cnt_save_file->length + 5);
808 if (!new)
809 goto fail;
810
811 strcpy(new, (const char *)context->obs_cnt_save_file->s);
812 strcat(new, ".tmp");
813 fp_new = fopen(new, "w+");
814 if (fp_new == NULL)
815 goto fail;
816
817 /* Go through and locate resource entry to delete */
818 while (fgets(buf, sizeof(buf), fp_orig) != NULL) {
819 char *cp = strchr(buf, ' ');
820 uint32_t observe_num;
821 coap_bin_const_t resource_key;
822
823 if (!cp)
824 break;
825
826 *cp = '\000';
827 cp++;
828 observe_num = atoi(cp);
829 resource_key.s = (uint8_t *)buf;
830 resource_key.length = strlen(buf);
831 if (!coap_binary_equal(resource_name, &resource_key)) {
832 if (fprintf(fp_new, "%s %u\n", resource_key.s, observe_num) < 0)
833 goto fail;
834 }
835 }
836 if (fflush(fp_new) == EOF)
837 goto fail;
838 fclose(fp_new);
839 fclose(fp_orig);
840 /* Either old or new is in place */
841 (void)rename(new, (const char *)context->obs_cnt_save_file->s);
842 coap_free_type(COAP_STRING, new);
843 return 1;
844
845fail:
846 if (fp_new)
847 fclose(fp_new);
848 if (fp_orig)
849 fclose(fp_orig);
850 if (new) {
851 (void)remove(new);
852 }
853 coap_free_type(COAP_STRING, new);
854 return 0;
855}
856
857/*
858 * read in dynamic resource entry, allocating name & raw_packet
859 * which need to be freed off by caller.
860 */
861static int
862coap_op_dyn_resource_read(FILE *fp, coap_proto_t *e_proto,
863 coap_string_t **name,
864 coap_binary_t **raw_packet) {
865 ssize_t size;
866
867 *name = NULL;
868 *raw_packet = NULL;
869
870 if (fread(e_proto, sizeof(*e_proto), 1, fp) == 1) {
871 /* New record 'proto len resource_name len raw_packet' */
872 if (fread(&size, sizeof(size), 1, fp) != 1)
873 goto fail;
874 if (size < 0 || size > 0x10000)
875 goto fail;
876 *name = coap_new_string(size);
877 if (!(*name))
878 goto fail;
879 if (fread((*name)->s, size, 1, fp) != 1)
880 goto fail;
881 if (fread(&size, sizeof(size), 1, fp) != 1)
882 goto fail;
883 if (size < 0 || size > 0x10000)
884 goto fail;
885 *raw_packet = coap_new_binary(size);
886 if (!(*raw_packet))
887 goto fail;
888 if (fread((*raw_packet)->s, size, 1, fp) != 1)
889 goto fail;
890 return 1;
891 }
892fail:
893 return 0;
894}
895
896/*
897 * write out dynamic resource entry.
898 */
899static int
900coap_op_dyn_resource_write(FILE *fp, coap_proto_t e_proto,
901 coap_str_const_t *name,
902 coap_bin_const_t *raw_packet) {
903 if (fwrite(&e_proto, sizeof(e_proto), 1, fp) != 1)
904 goto fail;
905 if (fwrite(&name->length, sizeof(name->length), 1, fp) != 1)
906 goto fail;
907 if (fwrite(name->s, name->length, 1, fp) != 1)
908 goto fail;
909 if (fwrite(&raw_packet->length, sizeof(raw_packet->length), 1, fp) != 1)
910 goto fail;
911 if (fwrite(raw_packet->s, raw_packet->length, 1, fp) != 1)
912 goto fail;
913 return 1;
914fail:
915 return 0;
916}
917
918/*
919 * This should be called before coap_persist_track_funcs() to prevent
920 * coap_op_dyn_resource_added() getting unnecessarily called.
921 *
922 * Each record 'proto len resource_name len raw_packet'
923 */
924static void
925coap_op_dyn_resource_load_disk(coap_context_t *ctx) {
926 FILE *fp_orig = NULL;
927 coap_proto_t e_proto;
928 coap_string_t *name = NULL;
929 coap_binary_t *raw_packet = NULL;
930 coap_resource_t *r;
931 coap_session_t *session = NULL;
932 coap_pdu_t *request = NULL;
933 coap_pdu_t *response = NULL;
934 coap_string_t *query = NULL;
935
936 if (!ctx->unknown_resource)
937 return;
938
939 fp_orig = fopen((const char *)ctx->dyn_resource_save_file->s, "r");
940 if (fp_orig == NULL)
941 return;
942 session = (coap_session_t *)coap_malloc_type(COAP_SESSION,
943 sizeof(coap_session_t));
944 if (!session)
945 goto fail;
946 memset(session, 0, sizeof(coap_session_t));
947 session->context = ctx;
948
949 /* Go through and create each dynamic resource if it does not exist*/
950 while (1) {
951 if (!coap_op_dyn_resource_read(fp_orig, &e_proto, &name, &raw_packet))
952 break;
953 r = coap_get_resource_from_uri_path_lkd(ctx, (coap_str_const_t *)name);
954 if (!r) {
955 /* Create the new resource using the application logic */
956
957 coap_log_debug("persist: dynamic resource being re-created\n");
958 /*
959 * Need max space incase PDU is updated with updated token,
960 * huge size etc.
961 * */
962 request = coap_pdu_init(0, 0, 0, 0);
963 if (!request)
964 goto fail;
965
966 session->proto = e_proto;
967 if (!coap_pdu_parse(session->proto, raw_packet->s,
968 raw_packet->length, request)) {
969 goto fail;
970 }
971 if (!ctx->unknown_resource->handler[request->code-1])
972 goto fail;
973 response = coap_pdu_init(0, 0, 0, 0);
974 if (!response)
975 goto fail;
976 query = coap_get_query(request);
977 /* Call the application handler to set up this dynamic resource */
978 coap_lock_callback_release(ctx,
979 ctx->unknown_resource->handler[request->code-1](ctx->unknown_resource,
980 session, request,
981 query, response),
982 /* context is being freed off */
983 goto fail);
984 coap_delete_string(query);
985 query = NULL;
986 coap_delete_pdu_lkd(request);
987 request = NULL;
988 coap_delete_pdu_lkd(response);
989 response = NULL;
990 }
991 coap_delete_string(name);
992 coap_delete_binary(raw_packet);
993 }
994fail:
995 coap_delete_string(name);
996 coap_delete_binary(raw_packet);
997 coap_delete_string(query);
998 coap_delete_pdu_lkd(request);
999 coap_delete_pdu_lkd(response);
1000 fclose(fp_orig);
1001 coap_free_type(COAP_SESSION, session);
1002}
1003
1004/*
1005 * Server has set up a new dynamic resource against a request for an unknown
1006 * resource.
1007 */
1008static int
1009coap_op_dyn_resource_added(coap_session_t *session,
1010 coap_str_const_t *resource_name,
1011 coap_bin_const_t *packet,
1012 void *user_data) {
1013 FILE *fp_orig;
1014 FILE *fp_new = NULL;
1015 char *new = NULL;
1016 coap_context_t *context = session->context;
1017 coap_string_t *name = NULL;
1018 coap_binary_t *raw_packet = NULL;
1019 coap_proto_t e_proto;
1020
1021 (void)user_data;
1022
1023 fp_orig = fopen((const char *)context->dyn_resource_save_file->s, "a");
1024 if (fp_orig == NULL)
1025 return 0;
1026
1027 new = coap_malloc_type(COAP_STRING,
1028 context->dyn_resource_save_file->length + 5);
1029 if (!new)
1030 goto fail;
1031
1032 strcpy(new, (const char *)context->dyn_resource_save_file->s);
1033 strcat(new, ".tmp");
1034 fp_new = fopen(new, "w+");
1035 if (fp_new == NULL)
1036 goto fail;
1037
1038 /* Go through and locate duplicate resource to delete */
1039 while (1) {
1040 if (!coap_op_dyn_resource_read(fp_orig, &e_proto, &name, &raw_packet))
1041 break;
1042 if (!coap_string_equal(resource_name, name)) {
1043 /* Copy across non-matching entry */
1044 if (!coap_op_dyn_resource_write(fp_new, e_proto, (coap_str_const_t *)name,
1045 (coap_bin_const_t *)raw_packet))
1046 break;
1047 }
1048 coap_delete_string(name);
1049 name = NULL;
1050 coap_delete_binary(raw_packet);
1051 raw_packet = NULL;
1052 }
1053 coap_delete_string(name);
1054 coap_delete_binary(raw_packet);
1055 /* Add new entry to the end */
1056 if (!coap_op_dyn_resource_write(fp_new, session->proto,
1057 resource_name, packet))
1058 goto fail;
1059
1060 if (fflush(fp_new) == EOF)
1061 goto fail;
1062 fclose(fp_new);
1063 fclose(fp_orig);
1064 /* Either old or new is in place */
1065 (void)rename(new, (const char *)context->dyn_resource_save_file->s);
1066 coap_free_type(COAP_STRING, new);
1067 return 1;
1068
1069fail:
1070 if (fp_new)
1071 fclose(fp_new);
1072 if (fp_orig)
1073 fclose(fp_orig);
1074 if (new) {
1075 (void)remove(new);
1076 }
1077 coap_free_type(COAP_STRING, new);
1078 return 0;
1079}
1080
1081/*
1082 * Server has deleted a resource
1083 */
1084static int
1085coap_op_resource_deleted(coap_context_t *context,
1086 coap_str_const_t *resource_name,
1087 void *user_data) {
1088 FILE *fp_orig = NULL;
1089 FILE *fp_new = NULL;
1090 char *new = NULL;
1091 coap_proto_t e_proto;
1092 coap_string_t *name = NULL;
1093 coap_binary_t *raw_packet = NULL;
1094 (void)user_data;
1095
1096 coap_op_obs_cnt_deleted(context, resource_name);
1097
1098 fp_orig = fopen((const char *)context->dyn_resource_save_file->s, "r");
1099 if (fp_orig == NULL)
1100 return 1;
1101
1102 new = coap_malloc_type(COAP_STRING,
1103 context->dyn_resource_save_file->length + 5);
1104 if (!new)
1105 goto fail;
1106
1107 strcpy(new, (const char *)context->dyn_resource_save_file->s);
1108 strcat(new, ".tmp");
1109 fp_new = fopen(new, "w+");
1110 if (fp_new == NULL)
1111 goto fail;
1112
1113 /* Go through and locate resource to delete and not copy it across */
1114 while (1) {
1115 if (!coap_op_dyn_resource_read(fp_orig, &e_proto, &name, &raw_packet))
1116 break;
1117 if (!coap_string_equal(resource_name, name)) {
1118 /* Copy across non-matching entry */
1119 if (!coap_op_dyn_resource_write(fp_new, e_proto, (coap_str_const_t *)name,
1120 (coap_bin_const_t *)raw_packet))
1121 break;
1122 }
1123 coap_delete_string(name);
1124 name = NULL;
1125 coap_delete_binary(raw_packet);
1126 raw_packet = NULL;
1127 }
1128 coap_delete_string(name);
1129 coap_delete_binary(raw_packet);
1130
1131 if (fflush(fp_new) == EOF)
1132 goto fail;
1133 fclose(fp_new);
1134 fclose(fp_orig);
1135 /* Either old or new is in place */
1136 (void)rename(new, (const char *)context->dyn_resource_save_file->s);
1137 coap_free_type(COAP_STRING, new);
1138 return 1;
1139
1140fail:
1141 if (fp_new)
1142 fclose(fp_new);
1143 if (fp_orig)
1144 fclose(fp_orig);
1145 if (new) {
1146 (void)remove(new);
1147 }
1148 coap_free_type(COAP_STRING, new);
1149 return 0;
1150}
1151
1152COAP_API int
1153coap_persist_startup(coap_context_t *context,
1154 const char *dyn_resource_save_file,
1155 const char *observe_save_file,
1156 const char *obs_cnt_save_file,
1157 uint32_t save_freq) {
1158 int ret;
1159
1160 coap_lock_lock(context, return 0);
1161 ret = coap_persist_startup_lkd(context,
1162 dyn_resource_save_file,
1163 observe_save_file,
1164 obs_cnt_save_file,
1165 save_freq);
1166 coap_lock_unlock(context);
1167 return ret;
1168}
1169
1170int
1171coap_persist_startup_lkd(coap_context_t *context,
1172 const char *dyn_resource_save_file,
1173 const char *observe_save_file,
1174 const char *obs_cnt_save_file,
1175 uint32_t save_freq) {
1176 coap_lock_check_locked(context);
1177 if (dyn_resource_save_file) {
1178 context->dyn_resource_save_file =
1179 coap_new_bin_const((const uint8_t *)dyn_resource_save_file,
1180 strlen(dyn_resource_save_file));
1181 if (!context->dyn_resource_save_file)
1182 return 0;
1183 coap_op_dyn_resource_load_disk(context);
1184 context->dyn_resource_added = coap_op_dyn_resource_added;
1185 context->resource_deleted = coap_op_resource_deleted;
1186 }
1187 if (obs_cnt_save_file) {
1188 context->obs_cnt_save_file =
1189 coap_new_bin_const((const uint8_t *)obs_cnt_save_file,
1190 strlen(obs_cnt_save_file));
1191 if (!context->obs_cnt_save_file)
1192 return 0;
1193 context->observe_save_freq = save_freq ? save_freq : 1;
1194 coap_op_obs_cnt_load_disk(context);
1195 context->track_observe_value = coap_op_obs_cnt_track_observe;
1196 context->resource_deleted = coap_op_resource_deleted;
1197 }
1198 if (observe_save_file) {
1199 context->observe_save_file =
1200 coap_new_bin_const((const uint8_t *)observe_save_file,
1201 strlen(observe_save_file));
1202 if (!context->observe_save_file)
1203 return 0;
1204 coap_op_observe_load_disk(context);
1205 context->observe_added = coap_op_observe_added;
1206 context->observe_deleted = coap_op_observe_deleted;
1207 }
1208 return 1;
1209}
1210
1211void
1212coap_persist_cleanup(coap_context_t *context) {
1213 coap_delete_bin_const(context->dyn_resource_save_file);
1214 coap_delete_bin_const(context->obs_cnt_save_file);
1215 coap_delete_bin_const(context->observe_save_file);
1216 context->dyn_resource_save_file = NULL;
1217 context->obs_cnt_save_file = NULL;
1218 context->observe_save_file = NULL;
1219
1220 /* Close down any tracking */
1221 coap_persist_track_funcs(context, NULL, NULL, NULL, NULL,
1222 NULL, 0, NULL);
1223}
1224
1225COAP_API void
1226coap_persist_stop(coap_context_t *context) {
1227 if (!context)
1228 return;
1229 coap_lock_lock(context, return);
1230 coap_persist_stop_lkd(context);
1231 coap_lock_unlock(context);
1232}
1233
1234void
1235coap_persist_stop_lkd(coap_context_t *context) {
1236 if (context == NULL)
1237 return;
1238 coap_lock_check_locked(context);
1239 context->observe_no_clear = 1;
1240 coap_persist_cleanup(context);
1241}
1242#else /* ! COAP_WITH_OBSERVE_PERSIST */
1243COAP_API int
1244coap_persist_startup(coap_context_t *context,
1245 const char *dyn_resource_save_file,
1246 const char *observe_save_file,
1247 const char *obs_cnt_save_file,
1248 uint32_t save_freq) {
1249 (void)context;
1250 (void)dyn_resource_save_file;
1251 (void)observe_save_file;
1252 (void)obs_cnt_save_file;
1253 (void)save_freq;
1254 return 0;
1255}
1256
1257COAP_API void
1258coap_persist_stop(coap_context_t *context) {
1259 context->observe_no_clear = 1;
1260 /* Close down any tracking */
1261 coap_persist_track_funcs(context, NULL, NULL, NULL, NULL,
1262 NULL, 0, NULL);
1263}
1264
1265#endif /* ! COAP_WITH_OBSERVE_PERSIST */
1266
1267#endif /* COAP_SERVER_SUPPORT */
INET6_ADDRSTRLEN
#define INET6_ADDRSTRLEN
Definition coap_debug.c:232
coap_socket_strerror
const char * coap_socket_strerror(void)
Definition coap_io.c:2291
coap_libcoap_build.h
Library specific build wrapper for coap_internal.h.
COAP_API
#define COAP_API
Definition coap_libcoap_build.h:41
COAP_SESSION
@ COAP_SESSION
Definition coap_mem.h:51
COAP_STRING
@ COAP_STRING
Definition coap_mem.h:39
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_tick_t
uint64_t coap_tick_t
This data type represents internal timer ticks with COAP_TICKS_PER_SECOND resolution.
Definition coap_time.h:143
coap_get_resource_from_uri_path_lkd
coap_resource_t * coap_get_resource_from_uri_path_lkd(coap_context_t *context, coap_str_const_t *uri_path)
Returns the resource identified by the unique string uri_path.
coap_ticks
void coap_ticks(coap_tick_t *)
Returns the current value of an internal tick counter.
coap_decode_var_bytes
unsigned int coap_decode_var_bytes(const uint8_t *buf, size_t len)
Decodes multiple-length byte sequences.
Definition coap_encode.c:38
coap_lock_callback_release
#define coap_lock_callback_release(c, func, failed)
Dummy for no thread-safe code.
Definition coap_threadsafe_internal.h:535
coap_lock_unlock
#define coap_lock_unlock(c)
Dummy for no thread-safe code.
Definition coap_threadsafe_internal.h:476
coap_lock_lock
#define coap_lock_lock(c, failed)
Dummy for no thread-safe code.
Definition coap_threadsafe_internal.h:464
coap_lock_check_locked
#define coap_lock_check_locked(c)
Dummy for no thread-safe code.
Definition coap_threadsafe_internal.h:490
coap_log_debug
#define coap_log_debug(...)
Definition coap_debug.h:120
coap_get_log_level
coap_log_t coap_get_log_level(void)
Get the current logging level.
Definition coap_debug.c:101
coap_print_addr
size_t coap_print_addr(const coap_address_t *addr, unsigned char *buf, size_t len)
Print the address into the defined buffer.
Definition coap_debug.c:239
coap_log_warn
#define coap_log_warn(...)
Definition coap_debug.h:102
COAP_LOG_OSCORE
@ COAP_LOG_OSCORE
Definition coap_debug.h:59
COAP_LOG_WARN
@ COAP_LOG_WARN
Definition coap_debug.h:55
coap_persist_observe_add
COAP_API coap_subscription_t * coap_persist_observe_add(coap_context_t *context, coap_proto_t e_proto, const coap_address_t *e_listen_addr, const coap_addr_tuple_t *s_addr_info, const coap_bin_const_t *raw_packet, const coap_bin_const_t *oscore_info)
Set up an active subscription for an observe that was previously active over a coap-server inadvertan...
coap_dyn_resource_added_t
int(* coap_dyn_resource_added_t)(coap_session_t *session, coap_str_const_t *resource_name, coap_bin_const_t *raw_packet, void *user_data)
Callback handler definition called when a dynamic resource is getting created, as defined in coap_per...
Definition coap_subscribe.h:149
coap_persist_set_observe_num
void coap_persist_set_observe_num(coap_resource_t *resource, uint32_t observe_num)
Sets the current observe number value.
coap_resource_deleted_t
int(* coap_resource_deleted_t)(coap_context_t *context, coap_str_const_t *resource_name, void *user_data)
Callback handler definition called when resource is removed, as defined in coap_persist_track_funcs()...
Definition coap_subscribe.h:168
coap_observe_added_t
int(* coap_observe_added_t)(coap_session_t *session, coap_subscription_t *observe_key, coap_proto_t e_proto, coap_address_t *e_listen_addr, coap_addr_tuple_t *s_addr_info, coap_bin_const_t *raw_packet, coap_bin_const_t *oscore_info, void *user_data)
Callback handler definition called when a new observe has been set up, as defined in coap_persist_tra...
Definition coap_subscribe.h:92
COAP_OBSERVE_ESTABLISH
#define COAP_OBSERVE_ESTABLISH
The value COAP_OBSERVE_ESTABLISH in a GET/FETCH request option COAP_OPTION_OBSERVE indicates a new ob...
Definition coap_subscribe.h:33
coap_persist_stop
COAP_API void coap_persist_stop(coap_context_t *context)
Stop tracking persist information, leaving the current persist information in the files defined in co...
coap_persist_track_funcs
void coap_persist_track_funcs(coap_context_t *context, coap_observe_added_t observe_added, coap_observe_deleted_t observe_deleted, coap_track_observe_value_t track_observe_value, coap_dyn_resource_added_t dyn_resource_added, coap_resource_deleted_t resource_deleted, uint32_t save_freq, void *user_data)
Set up callbacks to handle persist tracking so on a coap-server inadvertent restart,...
coap_track_observe_value_t
int(* coap_track_observe_value_t)(coap_context_t *context, coap_str_const_t *resource_name, uint32_t observe_num, void *user_data)
Callback handler definition called when an observe unsolicited response is being sent,...
Definition coap_subscribe.h:131
coap_observe_deleted_t
int(* coap_observe_deleted_t)(coap_session_t *session, coap_subscription_t *observe_key, void *user_data)
Callback handler definition called when an observe is being removed, as defined in coap_persist_track...
Definition coap_subscribe.h:112
coap_persist_startup
COAP_API int coap_persist_startup(coap_context_t *context, const char *dyn_resource_save_file, const char *observe_save_file, const char *obs_cnt_save_file, uint32_t save_freq)
Start up persist tracking using the libcoap module.
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_check_option
coap_opt_t * coap_check_option(const coap_pdu_t *pdu, coap_option_num_t number, coap_opt_iterator_t *oi)
Retrieves the first option of number number from pdu.
Definition coap_option.c:199
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
CBOR_BYTE_STRING
#define CBOR_BYTE_STRING
Definition oscore_cbor.h:62
oscore_cbor_get_element_size
size_t oscore_cbor_get_element_size(const uint8_t **buffer, size_t *buf_len)
Definition oscore_cbor.c:240
CBOR_NULL
#define CBOR_NULL
Definition oscore_cbor.h:72
CBOR_SIMPLE_VALUE
#define CBOR_SIMPLE_VALUE
Definition oscore_cbor.h:67
oscore_cbor_get_next_element
uint8_t oscore_cbor_get_next_element(const uint8_t **buffer, size_t *buf_len)
Definition oscore_cbor.c:227
CBOR_ARRAY
#define CBOR_ARRAY
Definition oscore_cbor.h:64
oscore_new_association
int oscore_new_association(coap_session_t *session, coap_pdu_t *sent_pdu, coap_bin_const_t *token, oscore_recipient_ctx_t *recipient_ctx, coap_bin_const_t *aad, coap_bin_const_t *nonce, coap_bin_const_t *partial_iv, int is_observe)
Definition oscore_context.c:687
oscore_log_hex_value
void oscore_log_hex_value(coap_log_t level, const char *name, coap_bin_const_t *value)
Definition oscore_context.c:235
oscore_find_context
oscore_ctx_t * oscore_find_context(const coap_context_t *c_context, const coap_bin_const_t rcpkey_id, const coap_bin_const_t *ctxkey_id, uint8_t *oscore_r2, oscore_recipient_ctx_t **recipient_ctx)
oscore_find_context - Locate recipient context (and hence OSCORE context)
Definition oscore_context.c:185
coap_delete_pdu_lkd
void coap_delete_pdu_lkd(coap_pdu_t *pdu)
Dispose of an CoAP PDU and free off associated storage.
Definition coap_pdu.c:190
coap_proto_t
coap_proto_t
CoAP protocol types.
Definition coap_pdu.h:312
coap_pdu_parse
int coap_pdu_parse(coap_proto_t proto, const uint8_t *data, size_t length, coap_pdu_t *pdu)
Parses data into the CoAP PDU structure given in result.
Definition coap_pdu.c:1462
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:99
COAP_OPTION_OBSERVE
#define COAP_OPTION_OBSERVE
Definition coap_pdu.h:123
COAP_PROTO_UDP
@ COAP_PROTO_UDP
Definition coap_pdu.h:314
COAP_REQUEST_CODE_GET
@ COAP_REQUEST_CODE_GET
Definition coap_pdu.h:329
COAP_REQUEST_CODE_FETCH
@ COAP_REQUEST_CODE_FETCH
Definition coap_pdu.h:333
coap_endpoint_get_session
coap_session_t * coap_endpoint_get_session(coap_endpoint_t *endpoint, const coap_packet_t *packet, coap_tick_t now)
Lookup the server session for the packet received on an endpoint, or create a new one.
coap_delete_bin_const
void coap_delete_bin_const(coap_bin_const_t *s)
Deletes the given const binary data and releases any memory allocated.
Definition coap_str.c:120
coap_new_binary
coap_binary_t * coap_new_binary(size_t size)
Returns a new binary object with at least size bytes storage allocated.
Definition coap_str.c:77
coap_new_bin_const
coap_bin_const_t * coap_new_bin_const(const uint8_t *data, size_t size)
Take the specified byte array (text) and create a coap_bin_const_t * Returns a new const binary objec...
Definition coap_str.c:110
coap_delete_binary
void coap_delete_binary(coap_binary_t *s)
Deletes the given coap_binary_t object and releases any memory allocated.
Definition coap_str.c:105
coap_binary_equal
#define coap_binary_equal(binary1, binary2)
Compares the two binary data for equality.
Definition coap_str.h:211
coap_string_equal
#define coap_string_equal(string1, string2)
Compares the two strings for equality.
Definition coap_str.h:197
coap_new_string
coap_string_t * coap_new_string(size_t size)
Returns a new string object with at least size+1 bytes storage allocated.
Definition coap_str.c:21
coap_delete_string
void coap_delete_string(coap_string_t *s)
Deletes the given string and releases any memory allocated.
Definition coap_str.c:46
coap_persist_stop_lkd
void coap_persist_stop_lkd(coap_context_t *context)
Stop tracking persist information, leaving the current persist information in the files defined in co...
coap_persist_cleanup
void coap_persist_cleanup(coap_context_t *context)
Close down persist tracking, releasing any memory used.
coap_persist_observe_add_lkd
coap_subscription_t * coap_persist_observe_add_lkd(coap_context_t *context, coap_proto_t e_proto, const coap_address_t *e_listen_addr, const coap_addr_tuple_t *s_addr_info, const coap_bin_const_t *raw_packet, const coap_bin_const_t *oscore_info)
Set up an active subscription for an observe that was previously active over a coap-server inadvertan...
coap_subscription_init
void coap_subscription_init(coap_subscription_t *)
coap_add_observer
coap_subscription_t * coap_add_observer(coap_resource_t *resource, coap_session_t *session, const coap_bin_const_t *token, const coap_pdu_t *pdu)
Adds the specified peer as observer for resource.
coap_persist_startup_lkd
int coap_persist_startup_lkd(coap_context_t *context, const char *dyn_resource_save_file, const char *observe_save_file, const char *obs_cnt_save_file, uint32_t save_freq)
Start up persist tracking using the libcoap module.
coap_observe_persist_is_supported
int coap_observe_persist_is_supported(void)
Check whether Observe Persist is available.
Definition coap_subscribe.c:24
coap_get_uri_path
coap_string_t * coap_get_uri_path(const coap_pdu_t *request)
Extract uri_path string from request PDU.
Definition coap_uri.c:990
coap_get_query
coap_string_t * coap_get_query(const coap_pdu_t *request)
Extract query string from request PDU according to escape rules in 6.5.8.
Definition coap_uri.c:939
coap_addr_tuple_t
Definition coap_io.h:55
coap_address_t
Multi-purpose address abstraction.
Definition coap_address.h:146
coap_bin_const_t
CoAP binary data definition with const data.
Definition coap_str.h:64
coap_bin_const_t::length
size_t length
length of binary data
Definition coap_str.h:65
coap_bin_const_t::s
const uint8_t * s
read-only binary data
Definition coap_str.h:66
coap_binary_t
CoAP binary data definition.
Definition coap_str.h:56
coap_binary_t::length
size_t length
length of binary data
Definition coap_str.h:57
coap_binary_t::s
uint8_t * s
binary data
Definition coap_str.h:58
coap_context_t
The CoAP stack's global state is stored in a coap_context_t object.
Definition coap_net_internal.h:50
coap_context_t::observe_added
coap_observe_added_t observe_added
Called when there is a new observe subscription request.
Definition coap_net_internal.h:113
coap_context_t::dyn_resource_added
coap_dyn_resource_added_t dyn_resource_added
Callback to save dynamic resource when created.
Definition coap_net_internal.h:122
coap_context_t::observe_user_data
void * observe_user_data
App provided data for use in observe_added or observe_deleted.
Definition coap_net_internal.h:117
coap_context_t::track_observe_value
coap_track_observe_value_t track_observe_value
Callback to save observe value when updated.
Definition coap_net_internal.h:120
coap_context_t::endpoint
coap_endpoint_t * endpoint
the endpoints used for listening
Definition coap_net_internal.h:76
coap_context_t::observe_save_freq
uint32_t observe_save_freq
How frequently to update observe value.
Definition coap_net_internal.h:119
coap_context_t::observe_no_clear
uint8_t observe_no_clear
Observe 4.04 not to be sent on deleting resource.
Definition coap_net_internal.h:192
coap_context_t::observe_deleted
coap_observe_deleted_t observe_deleted
Called when there is a observe subscription de-register request.
Definition coap_net_internal.h:115
coap_context_t::unknown_resource
coap_resource_t * unknown_resource
can be used for handling unknown resources
Definition coap_net_internal.h:55
coap_context_t::resource_deleted
coap_resource_deleted_t resource_deleted
Invoked when resource is deleted.
Definition coap_net_internal.h:124
coap_endpoint_t
Abstraction of virtual endpoint that can be attached to coap_context_t.
Definition coap_session_internal.h:244
coap_endpoint_t::next
struct coap_endpoint_t * next
Definition coap_session_internal.h:245
coap_endpoint_t::bind_addr
coap_address_t bind_addr
local interface address
Definition coap_session_internal.h:251
coap_endpoint_t::proto
coap_proto_t proto
protocol used on this interface
Definition coap_session_internal.h:247
coap_opt_iterator_t
Iterator to run through PDU options.
Definition coap_option.h:168
coap_packet_t
Definition coap_io_internal.h:225
coap_packet_t::length
size_t length
length of payload
Definition coap_io_internal.h:228
coap_packet_t::addr_info
coap_addr_tuple_t addr_info
local and remote addresses
Definition coap_io_internal.h:226
coap_packet_t::payload
unsigned char * payload
payload
Definition coap_io_internal.h:229
coap_packet_t::ifindex
int ifindex
the interface index
Definition coap_io_internal.h:227
coap_pdu_t
structure for CoAP PDUs
Definition coap_pdu_internal.h:135
coap_pdu_t::max_size
size_t max_size
maximum size for token, options and payload, or zero for variable size pdu
Definition coap_pdu_internal.h:154
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:137
coap_pdu_t::actual_token
coap_bin_const_t actual_token
Actual token in pdu.
Definition coap_pdu_internal.h:149
coap_pdu_t::used_size
size_t used_size
used bytes of storage for token, options and payload
Definition coap_pdu_internal.h:152
coap_resource_t
Abstraction of resource that can be attached to coap_context_t.
Definition coap_resource_internal.h:53
coap_resource_t::handler
coap_method_handler_t handler[7]
Used to store handlers for the seven coap methods GET, POST, PUT, DELETE, FETCH, PATCH and IPATCH.
Definition coap_resource_internal.h:70
coap_resource_t::observable
unsigned int observable
can be observed
Definition coap_resource_internal.h:57
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::proto
coap_proto_t proto
protocol used
Definition coap_session_internal.h:69
coap_session_t::context
coap_context_t * context
session's context
Definition coap_session_internal.h:87
coap_str_const_t
CoAP string data definition with const data.
Definition coap_str.h:46
coap_str_const_t::s
const uint8_t * s
read-only string data
Definition coap_str.h:48
coap_str_const_t::length
size_t length
length of string
Definition coap_str.h:47
coap_string_t
CoAP string data definition.
Definition coap_str.h:38
coap_string_t::s
uint8_t * s
string data
Definition coap_str.h:40
coap_subscription_t
Number of notifications that may be sent non-confirmable before a confirmable message is sent to dete...
Definition coap_subscribe_internal.h:56
oscore_ctx_t
Definition oscore_context.h:84