libcoap 4.3.5rc1
Loading...
Searching...
No Matches
coap_resource.c
Go to the documentation of this file.
1/* coap_resource.c -- generic resource handling
2 *
3 * Copyright (C) 2010--2024 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
17
18#if COAP_SERVER_SUPPORT
19#include <stdio.h>
20
21#ifdef COAP_EPOLL_SUPPORT
22#include <sys/epoll.h>
23#include <sys/timerfd.h>
24#endif /* COAP_EPOLL_SUPPORT */
25
26#ifndef min
27#define min(a,b) ((a) < (b) ? (a) : (b))
28#endif
29
30/* Helper functions for conditional output of character sequences into
31 * a given buffer. The first Offset characters are skipped.
32 */
33
38#define PRINT_WITH_OFFSET(Buf,Offset,Char) \
39 if ((Offset) == 0) { \
40 (*(Buf)++) = (Char); \
41 } else { \
42 (Offset)--; \
43 } \
44
48#define PRINT_COND_WITH_OFFSET(Buf,Bufend,Offset,Char,Result) { \
49 if ((Buf) < (Bufend)) { \
50 PRINT_WITH_OFFSET(Buf,Offset,Char); \
51 } \
52 (Result)++; \
53 }
54
60#define COPY_COND_WITH_OFFSET(Buf,Bufend,Offset,Str,Length,Result) { \
61 size_t i; \
62 for (i = 0; i < (Length); i++) { \
63 PRINT_COND_WITH_OFFSET((Buf), (Bufend), (Offset), (Str)[i], (Result)); \
64 } \
65 }
66
67static int
68match(const coap_str_const_t *text, const coap_str_const_t *pattern,
69 int match_prefix, int match_substring) {
70 assert(text);
71 assert(pattern);
72
73 if (text->length < pattern->length || !pattern->s)
74 return 0;
75
76 if (match_substring) {
77 const uint8_t *next_token = text->s;
78 size_t remaining_length = text->length;
79 while (remaining_length) {
80 size_t token_length;
81 const uint8_t *token = next_token;
82 next_token = (unsigned char *)memchr(token, ' ', remaining_length);
83
84 if (next_token) {
85 token_length = next_token - token;
86 remaining_length -= (token_length + 1);
87 next_token++;
88 } else {
89 token_length = remaining_length;
90 remaining_length = 0;
91 }
92
93 if ((match_prefix || pattern->length == token_length) &&
94 memcmp(token, pattern->s, pattern->length) == 0)
95 return 1;
96 }
97 return 0;
98 }
99
100 return (match_prefix || pattern->length == text->length) &&
101 memcmp(text->s, pattern->s, pattern->length) == 0;
102}
103
105coap_print_wellknown(coap_context_t *context, unsigned char *buf,
106 size_t *buflen, size_t offset,
107 const coap_string_t *query_filter) {
108 coap_print_status_t result;
110 result = coap_print_wellknown_lkd(context, buf, buflen, offset, query_filter);
111 coap_lock_unlock(context);
112 return result;
113}
114
115static coap_str_const_t coap_default_uri_wellknown = {
117 (const uint8_t *)COAP_DEFAULT_URI_WELLKNOWN
118};
119
121coap_print_wellknown_lkd(coap_context_t *context, unsigned char *buf,
122 size_t *buflen, size_t offset,
123 const coap_string_t *query_filter) {
124 coap_print_status_t output_length = 0;
125 unsigned char *p = buf;
126 const uint8_t *bufend = buf + *buflen;
127 size_t left, written = 0;
128 coap_print_status_t result;
129 const size_t old_offset = offset;
130 int subsequent_resource = 0;
131#ifdef WITHOUT_QUERY_FILTER
132 (void)query_filter;
133#else
134 coap_str_const_t resource_param = { 0, NULL }, query_pattern = { 0, NULL };
135 int flags = 0; /* MATCH_SUBSTRING, MATCH_PREFIX, MATCH_URI */
136#define MATCH_URI 0x01
137#define MATCH_PREFIX 0x02
138#define MATCH_SUBSTRING 0x04
139 static const coap_str_const_t _rt_attributes[] = {
140 {2, (const uint8_t *)"rt"},
141 {2, (const uint8_t *)"if"},
142 {3, (const uint8_t *)"rel"},
143 {0, NULL}
144 };
145#endif /* WITHOUT_QUERY_FILTER */
146
147 coap_lock_check_locked(context);
148#ifndef WITHOUT_QUERY_FILTER
149 /* split query filter, if any */
150 if (query_filter) {
151 resource_param.s = query_filter->s;
152 while (resource_param.length < query_filter->length &&
153 resource_param.s[resource_param.length] != '=')
154 resource_param.length++;
155
156 if (resource_param.length < query_filter->length) {
157 const coap_str_const_t *rt_attributes;
158 if (resource_param.length == 4 &&
159 memcmp(resource_param.s, "href", 4) == 0)
160 flags |= MATCH_URI;
161
162 for (rt_attributes = _rt_attributes; rt_attributes->s; rt_attributes++) {
163 if (resource_param.length == rt_attributes->length &&
164 memcmp(resource_param.s, rt_attributes->s, rt_attributes->length) == 0) {
165 flags |= MATCH_SUBSTRING;
166 break;
167 }
168 }
169
170 /* rest is query-pattern */
171 query_pattern.s =
172 query_filter->s + resource_param.length + 1;
173
174 assert((resource_param.length + 1) <= query_filter->length);
175 query_pattern.length =
176 query_filter->length - (resource_param.length + 1);
177
178 if ((query_pattern.s[0] == '/') && ((flags & MATCH_URI) == MATCH_URI)) {
179 query_pattern.s++;
180 query_pattern.length--;
181 }
182
183 if (query_pattern.length &&
184 query_pattern.s[query_pattern.length-1] == '*') {
185 query_pattern.length--;
186 flags |= MATCH_PREFIX;
187 }
188 }
189 }
190#endif /* WITHOUT_QUERY_FILTER */
191
192 RESOURCES_ITER(context->resources, r) {
193
194 if (coap_string_equal(r->uri_path, &coap_default_uri_wellknown)) {
195 /* server app has defined a resource for .well-known/core - ignore */
196 continue;
197 }
198#ifndef WITHOUT_QUERY_FILTER
199 if (resource_param.length) { /* there is a query filter */
200
201 if (flags & MATCH_URI) { /* match resource URI */
202 if (!match(r->uri_path, &query_pattern, (flags & MATCH_PREFIX) != 0,
203 (flags & MATCH_SUBSTRING) != 0))
204 continue;
205 } else { /* match attribute */
206 coap_attr_t *attr;
207 coap_str_const_t unquoted_val;
208 attr = coap_find_attr(r, &resource_param);
209 if (!attr || !attr->value)
210 continue;
211 unquoted_val = *attr->value;
212 if (attr->value->s[0] == '"') { /* if attribute has a quoted value, remove double quotes */
213 unquoted_val.length -= 2;
214 unquoted_val.s += 1;
215 }
216 if (!(match(&unquoted_val, &query_pattern,
217 (flags & MATCH_PREFIX) != 0,
218 (flags & MATCH_SUBSTRING) != 0)))
219 continue;
220 }
221 }
222#endif /* WITHOUT_QUERY_FILTER */
223
224 if (!subsequent_resource) { /* this is the first resource */
225 subsequent_resource = 1;
226 } else {
227 PRINT_COND_WITH_OFFSET(p, bufend, offset, ',', written);
228 }
229
230 left = bufend - p; /* calculate available space */
231 result = coap_print_link(r, p, &left, &offset);
232
233 if (result & COAP_PRINT_STATUS_ERROR) {
234 break;
235 }
236
237 /* coap_print_link() returns the number of characters that
238 * where actually written to p. Now advance to its end. */
239 p += COAP_PRINT_OUTPUT_LENGTH(result);
240 written += left;
241 }
242
243 *buflen = written;
244 output_length = (coap_print_status_t)(p - buf);
245
246 if (output_length > COAP_PRINT_STATUS_MAX) {
248 }
249
250 result = (coap_print_status_t)output_length;
251
252 if (result + old_offset - offset < *buflen) {
253 result |= COAP_PRINT_STATUS_TRUNC;
254 }
255 return result;
256}
257
258static coap_str_const_t null_path_value = {0, (const uint8_t *)""};
259static coap_str_const_t *null_path = &null_path_value;
260
262coap_resource_init(coap_str_const_t *uri_path, int flags) {
264
266 if (r) {
267 memset(r, 0, sizeof(coap_resource_t));
268
269 if (!(flags & COAP_RESOURCE_FLAGS_RELEASE_URI)) {
270 /* Need to take a copy if caller is not providing a release request */
271 if (uri_path)
272 uri_path = coap_new_str_const(uri_path->s, uri_path->length);
273 else
274 uri_path = coap_new_str_const(null_path->s, null_path->length);
275 } else if (!uri_path) {
276 /* Do not expect this, but ... */
277 uri_path = coap_new_str_const(null_path->s, null_path->length);
278 }
279
280 if (uri_path)
281 r->uri_path = uri_path;
282
283 r->flags = flags;
284 r->observe = 2;
285 } else {
286 coap_log_debug("coap_resource_init: no memory left\n");
287 }
288
289 return r;
290}
291
292static const uint8_t coap_unknown_resource_uri[] =
293 "- Unknown -";
294
298
300 if (r) {
301 memset(r, 0, sizeof(coap_resource_t));
302 r->is_unknown = 1;
303 /* Something unlikely to be used, but it shows up in the logs */
304 r->uri_path = coap_new_str_const(coap_unknown_resource_uri, sizeof(coap_unknown_resource_uri)-1);
305 r->flags = flags & ~COAP_RESOURCE_FLAGS_RELEASE_URI;
307 } else {
308 coap_log_debug("coap_resource_unknown_init: no memory left\n");
309 }
310
311 return r;
312}
313
316 return coap_resource_unknown_init2(put_handler, 0);
317}
318
319static const uint8_t coap_proxy_resource_uri[] =
320 "- Proxy URI -";
321
324 size_t host_name_count,
325 const char *host_name_list[], int flags) {
327
328 if (host_name_count == 0) {
329 coap_log_err("coap_resource_proxy_uri_init: Must have one or more host names defined\n");
330 return NULL;
331 }
333 if (r) {
334 size_t i;
335 memset(r, 0, sizeof(coap_resource_t));
336 r->is_proxy_uri = 1;
337 /* Something unlikely to be used, but it shows up in the logs */
338 r->uri_path = coap_new_str_const(coap_proxy_resource_uri, sizeof(coap_proxy_resource_uri)-1);
339 /* Preset all the handlers */
340 for (i = 0; i < (sizeof(r->handler) / sizeof(r->handler[0])); i++) {
341 r->handler[i] = handler;
342 }
343 if (host_name_count) {
344 r->proxy_name_list = coap_malloc_type(COAP_STRING, host_name_count *
345 sizeof(coap_str_const_t *));
346 if (r->proxy_name_list) {
347 for (i = 0; i < host_name_count; i++) {
348 r->proxy_name_list[i] =
349 coap_new_str_const((const uint8_t *)host_name_list[i],
350 strlen(host_name_list[i]));
351 if (!r->proxy_name_list[i]) {
352 coap_log_err("coap_resource_proxy_uri_init: unable to add host name\n");
353 if (i == 0) {
355 r->proxy_name_list = NULL;
356 }
357 break;
358 }
359 }
360 r->proxy_name_count = i;
361 }
362 }
363 r->flags = flags & ~COAP_RESOURCE_FLAGS_RELEASE_URI;
364 } else {
365 coap_log_debug("coap_resource_proxy_uri_init2: no memory left\n");
366 }
367
368 return r;
369}
370
373 size_t host_name_count, const char *host_name_list[]) {
374 return coap_resource_proxy_uri_init2(handler, host_name_count,
375 host_name_list, 0);
376}
377
380 coap_str_const_t *name,
381 coap_str_const_t *val,
382 int flags) {
383 coap_attr_t *attr;
384
385 if (!resource || !name)
386 return NULL;
388
389 if (attr) {
390 if (!(flags & COAP_ATTR_FLAGS_RELEASE_NAME)) {
391 /* Need to take a copy if caller is not providing a release request */
392 name = coap_new_str_const(name->s, name->length);
393 }
394 attr->name = name;
395 if (val) {
396 if (!(flags & COAP_ATTR_FLAGS_RELEASE_VALUE)) {
397 /* Need to take a copy if caller is not providing a release request */
398 val = coap_new_str_const(val->s, val->length);
399 }
400 }
401 attr->value = val;
402
403 attr->flags = flags;
404
405 /* add attribute to resource list */
406 LL_PREPEND(resource->link_attr, attr);
407 } else {
408 coap_log_debug("coap_add_attr: no memory left\n");
409 }
410
411 return attr;
412}
413
416 coap_str_const_t *name) {
417 coap_attr_t *attr;
418
419 if (!resource || !name)
420 return NULL;
421
422 LL_FOREACH(resource->link_attr, attr) {
423 if (attr->name->length == name->length &&
424 memcmp(attr->name->s, name->s, name->length) == 0)
425 return attr;
426 }
427
428 return NULL;
429}
430
433 if (attr)
434 return attr->value;
435 return NULL;
436}
437
438void
440 if (!attr)
441 return;
443 if (attr->value) {
445 }
446
448}
449
450typedef enum coap_deleting_resource_t {
451 COAP_DELETING_RESOURCE,
452 COAP_NOT_DELETING_RESOURCE
453} coap_deleting_resource_t;
454
455static void coap_notify_observers(coap_context_t *context, coap_resource_t *r,
456 coap_deleting_resource_t deleting);
457
458static void
459coap_free_resource(coap_resource_t *resource) {
460 coap_attr_t *attr, *tmp;
461 coap_subscription_t *obs, *otmp;
462
463 assert(resource);
464
465 if (!resource->context->observe_no_clear) {
467 coap_notify_observers(resource->context, resource, COAP_DELETING_RESOURCE);
468 }
469
470 if (resource->context->resource_deleted)
471 resource->context->resource_deleted(resource->context, resource->uri_path,
472 resource->context->observe_user_data);
473
474 if (resource->context->release_userdata && resource->user_data)
475 resource->context->release_userdata(resource->user_data);
476
477 /* delete registered attributes */
478 LL_FOREACH_SAFE(resource->link_attr, attr, tmp) coap_delete_attr(attr);
479
480 /* Either the application provided or libcoap copied - need to delete it */
482
483 /* free all elements from resource->subscribers */
484 LL_FOREACH_SAFE(resource->subscribers, obs, otmp) {
485 if (resource->context->observe_deleted)
486 resource->context->observe_deleted(obs->session, obs,
487 resource->context->observe_user_data);
489 coap_delete_pdu(obs->pdu);
492 }
493 if (resource->proxy_name_count && resource->proxy_name_list) {
494 size_t i;
495
496 for (i = 0; i < resource->proxy_name_count; i++) {
498 }
500 }
501
502 coap_free_type(COAP_RESOURCE, resource);
503}
504
505COAP_API void
507 coap_lock_lock(context, return);
508 coap_add_resource_lkd(context, resource);
509 coap_lock_unlock(context);
510}
511
512void
514 coap_lock_check_locked(context);
515 if (resource->is_unknown) {
516 if (context->unknown_resource)
517 coap_free_resource(context->unknown_resource);
518 context->unknown_resource = resource;
519 } else if (resource->is_proxy_uri) {
520 if (context->proxy_uri_resource)
521 coap_free_resource(context->proxy_uri_resource);
522 context->proxy_uri_resource = resource;
523 } else {
525 resource->uri_path);
526
527 if (r) {
528 coap_log_warn("coap_add_resource: Duplicate uri_path '%*.*s', old resource deleted\n",
529 (int)resource->uri_path->length, (int)resource->uri_path->length,
530 resource->uri_path->s);
531 coap_delete_resource_lkd(context, r);
532 }
533 RESOURCES_ADD(context->resources, resource);
534#if COAP_WITH_OBSERVE_PERSIST
535 if (context->unknown_pdu && context->dyn_resource_save_file &&
536 context->dyn_resource_added && resource->observable) {
537 coap_bin_const_t raw_packet;
538
539 raw_packet.s = context->unknown_pdu->token -
540 context->unknown_pdu->hdr_size;
541 raw_packet.length = context->unknown_pdu->used_size +
542 context->unknown_pdu->hdr_size;
543 context->dyn_resource_added(context->unknown_session, resource->uri_path,
544 &raw_packet, context->observe_user_data);
545 }
546#endif /* COAP_WITH_OBSERVE_PERSIST */
547 }
548 assert(resource->context == NULL);
549 resource->context = context;
550}
551
552COAP_API int
554 int ret;
555
556 if (!resource)
557 return 0;
558
559 context = resource->context;
560 if (context) {
561 coap_lock_lock(context, return 0);
562 ret = coap_delete_resource_lkd(context, resource);
563 coap_lock_unlock(context);
564 } else {
565 ret = coap_delete_resource_lkd(context, resource);
566 }
567 return ret;
568}
569
570/*
571 * Input context is ignored, but param left there to keep API consistent
572 */
573int
575 if (!resource)
576 return 0;
577
578 context = resource->context;
579 if (context) {
580 coap_lock_check_locked(context);
581 }
582
583 if (resource->is_unknown) {
584 if (context && context->unknown_resource == resource) {
585 context->unknown_resource = NULL;
586 }
587 } else if (resource->is_proxy_uri) {
588 if (context && context->proxy_uri_resource == resource) {
589 context->proxy_uri_resource = NULL;
590 }
591 } else if (context) {
592 /* remove resource from list */
593 RESOURCES_DELETE(context->resources, resource);
594 }
595
596 /* and free its allocated memory */
597 coap_free_resource(resource);
598
599 return 1;
600}
601
602void
604 coap_resource_t *res;
605 coap_resource_t *rtmp;
606
607 /* Cannot call RESOURCES_ITER because coap_free_resource() releases
608 * the allocated storage. */
609
610 HASH_ITER(hh, context->resources, res, rtmp) {
611 HASH_DELETE(hh, context->resources, res);
612 coap_free_resource(res);
613 }
614
615 context->resources = NULL;
616
617 if (context->unknown_resource) {
618 coap_free_resource(context->unknown_resource);
619 context->unknown_resource = NULL;
620 }
621 if (context->proxy_uri_resource) {
622 coap_free_resource(context->proxy_uri_resource);
623 context->proxy_uri_resource = NULL;
624 }
625}
626
629 coap_resource_t *result;
630
631 coap_lock_lock(context, return NULL);
632 result = coap_get_resource_from_uri_path_lkd(context, uri_path);
633 coap_lock_unlock(context);
634
635 return result;
636}
637
640 coap_str_const_t *uri_path) {
641 coap_resource_t *result;
642
643 coap_lock_check_locked(context);
644
645 RESOURCES_FIND(context->resources, uri_path, result);
646
647 return result;
648}
649
651coap_print_link(const coap_resource_t *resource,
652 unsigned char *buf, size_t *len, size_t *offset) {
653 unsigned char *p = buf;
654 const uint8_t *bufend = buf + *len;
655 coap_attr_t *attr;
656 coap_print_status_t result = 0;
657 coap_print_status_t output_length = 0;
658 const size_t old_offset = *offset;
659
660 *len = 0;
661 PRINT_COND_WITH_OFFSET(p, bufend, *offset, '<', *len);
662 PRINT_COND_WITH_OFFSET(p, bufend, *offset, '/', *len);
663
664 COPY_COND_WITH_OFFSET(p, bufend, *offset,
665 resource->uri_path->s, resource->uri_path->length, *len);
666
667 PRINT_COND_WITH_OFFSET(p, bufend, *offset, '>', *len);
668
669 LL_FOREACH(resource->link_attr, attr) {
670
671 PRINT_COND_WITH_OFFSET(p, bufend, *offset, ';', *len);
672
673 COPY_COND_WITH_OFFSET(p, bufend, *offset,
674 attr->name->s, attr->name->length, *len);
675
676 if (attr->value && attr->value->s) {
677 PRINT_COND_WITH_OFFSET(p, bufend, *offset, '=', *len);
678
679 COPY_COND_WITH_OFFSET(p, bufend, *offset,
680 attr->value->s, attr->value->length, *len);
681 }
682
683 }
684 if (resource->observable) {
685 COPY_COND_WITH_OFFSET(p, bufend, *offset, ";obs", 4, *len);
686 }
687
688#if COAP_OSCORE_SUPPORT
689 /* If oscore is enabled */
691 COPY_COND_WITH_OFFSET(p, bufend, *offset, ";osc", 4, *len);
692#endif /* COAP_OSCORE_SUPPORT */
693
694 output_length = (coap_print_status_t)(p - buf);
695
696 if (output_length > COAP_PRINT_STATUS_MAX) {
698 }
699
700 result = (coap_print_status_t)output_length;
701
702 if (result + old_offset - *offset < *len) {
703 result |= COAP_PRINT_STATUS_TRUNC;
704 }
705
706 return result;
707}
708
709void
711 coap_request_t method,
712 coap_method_handler_t handler) {
713 coap_register_request_handler(resource, method, handler);
714}
715
716void
718 coap_request_t method,
719 coap_method_handler_t handler) {
720 assert(resource);
721 assert(method > 0 && (size_t)(method-1) <
722 sizeof(resource->handler)/sizeof(coap_method_handler_t));
723 resource->handler[method-1] = handler;
724}
725
728 const coap_bin_const_t *token) {
730
731 assert(resource);
732 assert(session);
733
734 LL_FOREACH(resource->subscribers, s) {
735 if (s->session == session &&
736 (!token || coap_binary_equal(token, &s->pdu->actual_token)))
737 return s;
738 }
739
740 return NULL;
741}
742
743static coap_subscription_t *
744coap_find_observer_cache_key(coap_resource_t *resource, coap_session_t *session,
745 const coap_cache_key_t *cache_key) {
747
748 assert(resource);
749 assert(session);
750
751 LL_FOREACH(resource->subscribers, s) {
752 if (s->session == session
753 && (memcmp(cache_key, s->cache_key, sizeof(coap_cache_key_t)) == 0))
754 return s;
755 }
756
757 return NULL;
758}
759
760/* https://rfc-editor.org/rfc/rfc7641#section-3.6 */
761static const uint16_t cache_ignore_options[] = { COAP_OPTION_ETAG,
763 };
766 coap_session_t *session,
767 const coap_bin_const_t *token,
768 const coap_pdu_t *request) {
770 coap_cache_key_t *cache_key = NULL;
771 size_t len;
772 const uint8_t *data;
773
774 assert(session);
775
776 /* Check if there is already a subscription for this peer. */
777 s = coap_find_observer(resource, session, token);
778 if (!s) {
779 /*
780 * Cannot allow a duplicate to be created for the same query as application
781 * may not be cleaning up duplicates. If duplicate found, then original
782 * observer is deleted and a new one created with the new token
783 */
784 cache_key = coap_cache_derive_key_w_ignore(session, request,
786 cache_ignore_options,
787 sizeof(cache_ignore_options)/sizeof(cache_ignore_options[0]));
788 if (cache_key) {
789 s = coap_find_observer_cache_key(resource, session, cache_key);
790 if (s) {
791 /* Delete old entry with old token */
792 coap_delete_observer(resource, session, &s->pdu->actual_token);
793 s = NULL;
794 }
795 }
796 }
797
798 /* We are done if subscription was found. */
799 if (s) {
800 return s;
801 }
802
803 /* Check if there is already maximum number of subscribers present */
804#if (COAP_RESOURCE_MAX_SUBSCRIBER > 0)
805 uint32_t subscriber_count = 0;
806 LL_COUNT(resource->subscribers, s, subscriber_count);
807 if (subscriber_count >= COAP_RESOURCE_MAX_SUBSCRIBER) {
808 return NULL; /* Signal error */
809 }
810#endif /* COAP_RESOURCE_MAX_SUBSCRIBER */
811
812 /* Create a new subscription */
814
815 if (!s) {
816 coap_delete_cache_key(cache_key);
817 return NULL;
818 }
819
821 s->pdu = coap_pdu_duplicate_lkd(request, session, token->length,
822 token->s, NULL);
823 if (s->pdu == NULL) {
824 coap_delete_cache_key(cache_key);
826 return NULL;
827 }
828 if (coap_get_data(request, &len, &data)) {
829 /* This could be a large bodied FETCH */
830 s->pdu->max_size = 0;
831 coap_add_data(s->pdu, len, data);
832 }
833 if (cache_key == NULL) {
834 cache_key = coap_cache_derive_key_w_ignore(session, request,
836 cache_ignore_options,
837 sizeof(cache_ignore_options)/sizeof(cache_ignore_options[0]));
838 if (cache_key == NULL) {
840 coap_delete_cache_key(cache_key);
842 return NULL;
843 }
844 }
845 s->cache_key = cache_key;
847
848 /* add subscriber to resource */
849 LL_PREPEND(resource->subscribers, s);
850
851 coap_log_debug("create new subscription %p key 0x%02x%02x%02x%02x\n",
852 (void *)s, s->cache_key->key[0], s->cache_key->key[1],
853 s->cache_key->key[2], s->cache_key->key[3]);
854
855 if (session->context->observe_added && session->proto == COAP_PROTO_UDP) {
856 coap_bin_const_t raw_packet;
857 coap_bin_const_t *oscore_info = NULL;
858#if COAP_OSCORE_SUPPORT
859 oscore_association_t *association;
860
861 if (session->recipient_ctx && session->recipient_ctx->recipient_id) {
862 /*
863 * Need to track the association used for tracking this observe, done as
864 * a CBOR array. Read in coap_persist_observe_add().
865 *
866 * If an entry is null, then use nil, else a set of bytes
867 *
868 * Currently tracking 5 items
869 * recipient_id
870 * id_context
871 * aad (from oscore_association_t)
872 * partial_iv (from oscore_association_t)
873 * nonce (from oscore_association_t)
874 */
875 uint8_t info_buffer[60];
876 uint8_t *info_buf = info_buffer;
877 size_t info_len = sizeof(info_buffer);
878 size_t ret = 0;
879 coap_bin_const_t ctoken = { token->length, token->s };
880
881 ret += oscore_cbor_put_array(&info_buf, &info_len, 5);
882 ret += oscore_cbor_put_bytes(&info_buf,
883 &info_len,
884 session->recipient_ctx->recipient_id->s,
885 session->recipient_ctx->recipient_id->length);
886 if (session->recipient_ctx->osc_ctx &&
887 session->recipient_ctx->osc_ctx->id_context) {
888 ret += oscore_cbor_put_bytes(&info_buf,
889 &info_len,
890 session->recipient_ctx->osc_ctx->id_context->s,
891 session->recipient_ctx->osc_ctx->id_context->length);
892 } else {
893 ret += oscore_cbor_put_nil(&info_buf, &info_len);
894 }
895 association = oscore_find_association(session, &ctoken);
896 if (association) {
897 if (association->aad) {
898 ret += oscore_cbor_put_bytes(&info_buf,
899 &info_len,
900 association->aad->s,
901 association->aad->length);
902 } else {
903 ret += oscore_cbor_put_nil(&info_buf, &info_len);
904 }
905 if (association->partial_iv) {
906 ret += oscore_cbor_put_bytes(&info_buf,
907 &info_len,
908 association->partial_iv->s,
909 association->partial_iv->length);
910 } else {
911 ret += oscore_cbor_put_nil(&info_buf, &info_len);
912 }
913 if (association->nonce) {
914 ret += oscore_cbor_put_bytes(&info_buf,
915 &info_len,
916 association->nonce->s,
917 association->nonce->length);
918 } else {
919 ret += oscore_cbor_put_nil(&info_buf, &info_len);
920 }
921 } else {
922 ret += oscore_cbor_put_nil(&info_buf, &info_len);
923 ret += oscore_cbor_put_nil(&info_buf, &info_len);
924 }
925 oscore_info = coap_new_bin_const(info_buffer, ret);
926 }
927#endif /* COAP_OSCORE_SUPPORT */
928
929 /* s->pdu header is not currently encoded */
930 memcpy(s->pdu->token - request->hdr_size,
931 request->token - request->hdr_size, request->hdr_size);
932 raw_packet.s = s->pdu->token - request->hdr_size;
933 raw_packet.length = s->pdu->used_size + request->hdr_size;
934 session->context->observe_added(session, s, session->proto,
935 &session->endpoint->bind_addr,
936 &session->addr_info,
937 &raw_packet,
938 oscore_info,
939 session->context->observe_user_data);
940#if COAP_OSCORE_SUPPORT
941 coap_delete_bin_const(oscore_info);
942#endif /* COAP_OSCORE_SUPPORT */
943 }
944 if (resource->context->track_observe_value) {
945 /* Track last used observe value (as app handler is called) */
946 resource->context->track_observe_value(resource->context,resource->uri_path,
947 resource->observe,
948 resource->context->observe_user_data);
949 }
950
951 return s;
952}
953
954void
956 const coap_bin_const_t *token) {
958
959 RESOURCES_ITER(context->resources, r) {
960 s = coap_find_observer(r, session, token);
961 if (s) {
962 s->fail_cnt = 0;
963 }
964 }
965}
966
967static void
968coap_delete_observer_internal(coap_resource_t *resource, coap_session_t *session,
970 if (!s)
971 return;
972
974 char outbuf[2 * 8 + 1] = "";
975 unsigned int i;
976
977 for (i = 0; i < s->pdu->actual_token.length; i++) {
978 size_t size = strlen(outbuf);
979
980 snprintf(&outbuf[size], sizeof(outbuf)-size, "%02x",
981 s->pdu->actual_token.s[i]);
982 }
983 coap_log_debug("removed subscription %p with token '%s' key 0x%02x%02x%02x%02x\n",
984 (void *)s, outbuf, s->cache_key->key[0], s->cache_key->key[1],
985 s->cache_key->key[2], s-> cache_key->key[3]);
986 }
987 if (session->context->observe_deleted)
988 session->context->observe_deleted(session, s,
989 session->context->observe_user_data);
990
991 if (resource->subscribers) {
992 LL_DELETE(resource->subscribers, s);
997 }
998
999 return;
1000}
1001
1002int
1004 const coap_bin_const_t *token) {
1006
1007 s = coap_find_observer(resource, session, token);
1008 if (s)
1009 coap_delete_observer_internal(resource, session, s);
1010
1011 return s != NULL;
1012}
1013
1014int
1016 const coap_bin_const_t *token, coap_pdu_t *request) {
1018 int ret = 0;
1019
1020 s = coap_find_observer(resource, session, token);
1021 s = NULL;
1022 if (!s) {
1023 /*
1024 * It is possible that the client is using the wrong token.
1025 * An example being a large FETCH spanning multiple blocks.
1026 */
1027 coap_cache_key_t *cache_key;
1028
1029 cache_key = coap_cache_derive_key_w_ignore(session, request,
1031 cache_ignore_options,
1032 sizeof(cache_ignore_options)/sizeof(cache_ignore_options[0]));
1033 if (cache_key) {
1034 s = coap_find_observer_cache_key(resource, session, cache_key);
1035 if (s) {
1036 /* Delete entry with setup token */
1037 ret = coap_delete_observer(resource, session, &s->pdu->actual_token);
1038 }
1039 coap_delete_cache_key(cache_key);
1040 }
1041 } else {
1042 coap_delete_observer_internal(resource, session, s);
1043 ret = 1;
1044 }
1045 return ret;
1046}
1047
1048void
1050 RESOURCES_ITER(context->resources, resource) {
1051 coap_subscription_t *s, *tmp;
1052 LL_FOREACH_SAFE(resource->subscribers, s, tmp) {
1053 if (s->session == session) {
1054 if (context->observe_deleted)
1055 context->observe_deleted(session, s, context->observe_user_data);
1056 assert(resource->subscribers);
1057 LL_DELETE(resource->subscribers, s);
1058 coap_session_release_lkd(session);
1059 coap_delete_pdu(s->pdu);
1062 }
1063 }
1064 }
1065}
1066
1067static void
1068coap_notify_observers(coap_context_t *context, coap_resource_t *r,
1069 coap_deleting_resource_t deleting) {
1071 coap_subscription_t *obs, *otmp;
1072 coap_pdu_t *response;
1073 uint8_t buf[4];
1074 coap_string_t *query;
1075 coap_block_b_t block;
1076 coap_tick_t now;
1077 coap_session_t *obs_session;
1078
1079 if (r->observable && (r->dirty || r->partiallydirty)) {
1080 r->partiallydirty = 0;
1081
1082 LL_FOREACH_SAFE(r->subscribers, obs, otmp) {
1083 obs_session = obs->session;
1084 if (r->dirty == 0 && obs->dirty == 0) {
1085 /*
1086 * running this resource due to partiallydirty, but this observation's
1087 * notification was already enqueued
1088 */
1089 context->observe_pending = 1;
1090 continue;
1091 }
1092 if (obs->session->con_active >= COAP_NSTART(obs->session) &&
1094 (obs->non_cnt >= COAP_OBS_MAX_NON))) {
1095 /* Waiting for the previous unsolicited response to finish */
1096 r->partiallydirty = 1;
1097 obs->dirty = 1;
1098 context->observe_pending = 1;
1099 continue;
1100 }
1101 coap_ticks(&now);
1102 if (obs->session->lg_xmit && obs->session->lg_xmit->last_all_sent == 0 &&
1103 obs->session->lg_xmit->last_obs &&
1104 (obs->session->lg_xmit->last_obs + 2*COAP_TICKS_PER_SECOND) > now) {
1105 /* Waiting for the previous blocked unsolicited response to finish */
1106 r->partiallydirty = 1;
1107 obs->dirty = 1;
1108 context->observe_pending = 1;
1109 continue;
1110 }
1111
1113 obs->dirty = 0;
1114 /* initialize response */
1115 response = coap_pdu_init(COAP_MESSAGE_CON, 0, 0,
1117 if (!response) {
1118 obs->dirty = 1;
1119 r->partiallydirty = 1;
1120 context->observe_pending = 1;
1121 coap_log_debug("coap_check_notify: pdu init failed, resource stays "
1122 "partially dirty\n");
1123 continue;
1124 }
1125
1126 if (!coap_add_token(response, obs->pdu->actual_token.length,
1127 obs->pdu->actual_token.s)) {
1128 obs->dirty = 1;
1129 r->partiallydirty = 1;
1130 context->observe_pending = 1;
1131 coap_log_debug("coap_check_notify: cannot add token, resource stays "
1132 "partially dirty\n");
1133 coap_delete_pdu(response);
1134 continue;
1135 }
1136
1137 obs->pdu->mid = response->mid = coap_new_message_id_lkd(obs->session);
1138 /* A lot of the reliable code assumes type is CON */
1142 obs->non_cnt < COAP_OBS_MAX_NON)) {
1143 response->type = COAP_MESSAGE_NON;
1144 } else {
1145 response->type = COAP_MESSAGE_CON;
1146 }
1147 switch (deleting) {
1148 case COAP_NOT_DELETING_RESOURCE:
1149 /* fill with observer-specific data */
1151 coap_encode_var_safe(buf, sizeof(buf),
1152 r->observe),
1153 buf);
1155 &block)) {
1156 /* Will get updated later (e.g. M bit) if appropriate */
1158 coap_encode_var_safe(buf, sizeof(buf),
1159 ((0 << 4) |
1160 (0 << 3) |
1161 block.aszx)),
1162 buf);
1163 }
1164#if COAP_Q_BLOCK_SUPPORT
1165 else if (coap_get_block_b(obs->session, obs->pdu, COAP_OPTION_Q_BLOCK2,
1166 &block)) {
1167 /* Will get updated later (e.g. M bit) if appropriate */
1169 coap_encode_var_safe(buf, sizeof(buf),
1170 ((0 << 4) |
1171 (0 << 3) |
1172 block.szx)),
1173 buf);
1174 }
1175#endif /* COAP_Q_BLOCK_SUPPORT */
1176
1177 h = r->handler[obs->pdu->code - 1];
1178 assert(h); /* we do not allow subscriptions if no
1179 * GET/FETCH handler is defined */
1180 query = coap_get_query(obs->pdu);
1181 coap_log_debug("Observe PDU presented to app.\n");
1183 coap_log_debug("call custom handler for resource '%*.*s' (4)\n",
1184 (int)r->uri_path->length, (int)r->uri_path->length,
1185 r->uri_path->s);
1187 h(r, obs->session, obs->pdu, query, response),
1188 /* context is being freed off */
1189 return);
1190
1191 /* Check validity of response code */
1192 if (!coap_check_code_class(obs->session, response)) {
1193 coap_log_warn("handle_request: Invalid PDU response code (%d.%02d)\n",
1194 COAP_RESPONSE_CLASS(response->code),
1195 response->code & 0x1f);
1196 coap_delete_pdu(response);
1197 return;
1198 }
1199
1200 /* Check if lg_xmit generated and update PDU code if so */
1201 coap_check_code_lg_xmit(obs->session, obs->pdu, response, r, query);
1202 coap_delete_string(query);
1203 if (COAP_RESPONSE_CLASS(response->code) != 2) {
1205 }
1206 if (COAP_RESPONSE_CLASS(response->code) > 2) {
1208 obs = NULL;
1209 }
1210 break;
1211 case COAP_DELETING_RESOURCE:
1212 default:
1213 /* Don't worry if it does not get there */
1214 response->type = COAP_MESSAGE_NON;
1215 response->code = COAP_RESPONSE_CODE(404);
1216 break;
1217 }
1218
1219 if (obs) {
1220 if (response->type == COAP_MESSAGE_CON ||
1222 obs->non_cnt = 0;
1223 } else {
1224 obs->non_cnt++;
1225 }
1226
1227#if COAP_Q_BLOCK_SUPPORT
1228 if (response->code == COAP_RESPONSE_CODE(205) &&
1230 &block) &&
1231 block.m) {
1232 query = coap_get_query(obs->pdu);
1233 mid = coap_send_q_block2(obs->session, r, query, obs->pdu->code,
1234 block, response, 1);
1235 coap_delete_string(query);
1236 goto finish;
1237 }
1238#endif /* COAP_Q_BLOCK_SUPPORT */
1239 }
1240 mid = coap_send_internal(obs_session, response);
1241
1242#if COAP_Q_BLOCK_SUPPORT
1243finish:
1244#endif /* COAP_Q_BLOCK_SUPPORT */
1245 if (COAP_INVALID_MID == mid && obs) {
1247 coap_log_debug("coap_check_notify: sending failed, resource stays "
1248 "partially dirty\n");
1249 LL_FOREACH(r->subscribers, s) {
1250 if (s == obs) {
1251 /* obs not deleted during coap_send_internal() */
1252 obs->dirty = 1;
1253 break;
1254 }
1255 }
1256 r->partiallydirty = 1;
1257 context->observe_pending = 1;
1258 }
1259 }
1260 }
1261 r->dirty = 0;
1262}
1263
1264COAP_API int
1266 int ret;
1267
1268 coap_lock_lock(r->context, return 0);
1269 ret = coap_resource_notify_observers_lkd(r, query);
1271 return ret;
1272}
1273
1274COAP_API int
1276 const coap_string_t *query) {
1277 int ret;
1278
1279 coap_lock_lock(r->context, return 0);
1280 ret = coap_resource_notify_observers_lkd(r, query);
1282 return ret;
1283}
1284
1285int
1287 const coap_string_t *query COAP_UNUSED) {
1289 if (!r->observable)
1290 return 0;
1291 if (!r->subscribers)
1292 return 0;
1293 r->dirty = 1;
1294
1295 /* Increment value for next Observe use. Observe value must be < 2^24 */
1296 r->observe = (r->observe + 1) & 0xFFFFFF;
1297
1298 assert(r->context);
1299
1300 if (r->context->track_observe_value) {
1301 /* Track last used observe value */
1302 if ((r->observe % r->context->observe_save_freq) == 0)
1304 r->observe,
1306 }
1307
1308 r->context->observe_pending = 1;
1310 return 1;
1311}
1312
1313void
1314coap_resource_set_mode(coap_resource_t *resource, int mode) {
1315 resource->flags = (resource->flags &
1318}
1319
1320void
1321coap_resource_set_userdata(coap_resource_t *resource, void *data) {
1322 resource->user_data = data;
1323}
1324
1325void *
1327 return resource->user_data;
1328}
1329
1330void
1333 context->release_userdata = callback;
1334}
1335
1336void
1338 resource->observable = mode ? 1 : 0;
1339}
1340
1343 if (resource)
1344 return resource->uri_path;
1345 return NULL;
1346}
1347
1348COAP_API void
1350 coap_lock_lock(context, return);
1351 coap_check_notify_lkd(context);
1352 coap_lock_unlock(context);
1353}
1354
1355void
1357
1358 coap_lock_check_locked(context);
1359 if (context->observe_pending) {
1360 context->observe_pending = 0;
1361 RESOURCES_ITER(context->resources, r) {
1362 coap_notify_observers(context, r, COAP_NOT_DELETING_RESOURCE);
1363 }
1364 }
1365}
1366
1367void
1369 uint32_t start_observe_no) {
1370 if (!resource)
1371 return;
1372
1373 resource->observe = start_observe_no & 0xffffff;
1374}
1375
1386static void
1387coap_remove_failed_observers(coap_context_t *context,
1388 coap_resource_t *resource,
1389 coap_session_t *session,
1390 const coap_bin_const_t *token) {
1391 coap_subscription_t *obs, *otmp;
1392
1393 LL_FOREACH_SAFE(resource->subscribers, obs, otmp) {
1394 if (obs->session == session &&
1395 coap_binary_equal(token, &obs->pdu->actual_token)) {
1396 /* count failed notifies and remove when
1397 * COAP_OBS_MAX_FAIL is reached */
1398 obs->fail_cnt++;
1399 if (obs->fail_cnt >= COAP_OBS_MAX_FAIL) {
1400 coap_cancel_all_messages(context, obs->session,
1401 &obs->pdu->actual_token);
1402 coap_delete_observer(resource, session, token);
1403 }
1404 break; /* break loop if observer was found */
1405 }
1406 }
1407}
1408
1409void
1411 coap_session_t *session,
1412 const coap_bin_const_t *token) {
1413
1414 RESOURCES_ITER(context->resources, r) {
1415 coap_remove_failed_observers(context, r, session, token);
1416 }
1417}
1418
1419#endif /* ! COAP_SERVER_SUPPORT */
void coap_update_io_timer(coap_context_t *context, coap_tick_t delay)
Update when to continue with I/O processing, unless packets come in in the meantime.
Definition coap_io.c:494
Library specific build wrapper for coap_internal.h.
#define COAP_API
@ COAP_RESOURCE
Definition coap_mem.h:47
@ COAP_RESOURCEATTR
Definition coap_mem.h:48
@ COAP_SUBSCRIPTION
Definition coap_mem.h:58
@ COAP_STRING
Definition coap_mem.h:38
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.
void coap_free_type(coap_memory_tag_t type, void *p)
Releases the memory that was allocated by coap_malloc_type().
COAP_DEPRECATED COAP_API int coap_resource_set_dirty(coap_resource_t *r, const coap_string_t *query)
#define coap_lock_callback_release(c, func, failed)
#define coap_lock_unlock(c)
#define coap_lock_lock(c, failed)
#define coap_lock_check_locked(c)
void coap_check_code_lg_xmit(const coap_session_t *session, const coap_pdu_t *request, coap_pdu_t *response, const coap_resource_t *resource, const coap_string_t *query)
The function checks that the code in a newly formed lg_xmit created by coap_add_data_large_response_l...
int coap_get_block_b(const coap_session_t *session, const coap_pdu_t *pdu, coap_option_num_t number, coap_block_b_t *block)
Initializes block from pdu.
Definition coap_block.c:58
void coap_delete_cache_key(coap_cache_key_t *cache_key)
Delete the cache-key.
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_CACHE_IS_SESSION_BASED
Definition coap_cache.h:39
uint64_t coap_tick_t
This data type represents internal timer ticks with COAP_TICKS_PER_SECOND resolution.
Definition coap_time.h:143
#define COAP_TICKS_PER_SECOND
Use ms resolution on POSIX systems.
Definition coap_time.h:158
#define RESOURCES_ADD(r, obj)
void coap_delete_all_resources(coap_context_t *context)
Deletes all resources from given context and frees their storage.
coap_print_status_t coap_print_wellknown_lkd(coap_context_t *context, unsigned char *buf, size_t *buflen, size_t offset, const coap_string_t *query_filter)
Prints the names of all known resources for context to buf.
void coap_delete_attr(coap_attr_t *attr)
Deletes an attribute.
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.
void coap_add_resource_lkd(coap_context_t *context, coap_resource_t *resource)
Registers the given resource for context.
#define RESOURCES_FIND(r, k, res)
int coap_delete_resource_lkd(coap_context_t *context, coap_resource_t *resource)
Deletes a resource identified by resource.
#define RESOURCES_DELETE(r, obj)
#define RESOURCES_ITER(r, tmp)
COAP_API coap_resource_t * coap_get_resource_from_uri_path(coap_context_t *context, coap_str_const_t *uri_path)
Returns the resource identified by the unique string uri_path.
#define COAP_RESOURCE_FLAGS_NOTIFY_NON
Observe Notifications will be sent non-confirmable by default.
coap_resource_t * coap_resource_proxy_uri_init(coap_method_handler_t handler, size_t host_name_count, const char *host_name_list[])
Creates a new resource object for handling proxy URIs.
coap_attr_t * coap_add_attr(coap_resource_t *resource, coap_str_const_t *name, coap_str_const_t *value, int flags)
Registers a new attribute with the given resource.
#define COAP_ATTR_FLAGS_RELEASE_VALUE
coap_print_status_t coap_print_link(const coap_resource_t *resource, unsigned char *buf, size_t *len, size_t *offset)
Writes a description of this resource in link-format to given text buffer.
coap_resource_t * coap_resource_proxy_uri_init2(coap_method_handler_t handler, size_t host_name_count, const char *host_name_list[], int flags)
Creates a new resource object for handling proxy URIs with configurable control over multicast reques...
#define COAP_RESOURCE_FLAGS_NOTIFY_NON_ALWAYS
Observe Notifications will always be sent non-confirmable.
#define COAP_ATTR_FLAGS_RELEASE_NAME
void coap_resource_set_mode(coap_resource_t *resource, int mode)
Sets the notification message type of resource resource to given mode.
#define COAP_PRINT_STATUS_TRUNC
void(* coap_method_handler_t)(coap_resource_t *resource, coap_session_t *session, const coap_pdu_t *request, const coap_string_t *query, coap_pdu_t *response)
Definition of message handler function.
void coap_resource_release_userdata_handler(coap_context_t *context, coap_resource_release_userdata_handler_t callback)
Defines the context wide callback to use to when the resource is deleted to release the data held in ...
#define COAP_RESOURCE_FLAGS_OSCORE_ONLY
Define this resource as an OSCORE enabled access only.
COAP_API coap_print_status_t coap_print_wellknown(coap_context_t *context, unsigned char *buf, size_t *buflen, size_t offset, const coap_string_t *query_filter)
Prints the names of all known resources for context to buf.
#define COAP_RESOURCE_FLAGS_NOTIFY_CON
Observe Notifications will be sent confirmable.
COAP_API int coap_delete_resource(coap_context_t *context, coap_resource_t *resource)
Deletes a resource identified by resource.
void coap_register_handler(coap_resource_t *resource, coap_request_t method, coap_method_handler_t handler)
Registers the specified handler as message handler for the request type method.
#define COAP_PRINT_STATUS_MAX
void(* coap_resource_release_userdata_handler_t)(void *user_data)
Definition of release resource user_data callback function.
void coap_register_request_handler(coap_resource_t *resource, coap_request_t method, coap_method_handler_t handler)
Registers the specified handler as message handler for the request type method.
coap_resource_t * coap_resource_init(coap_str_const_t *uri_path, int flags)
Creates a new resource object and initializes the link field to the string uri_path.
void coap_resource_set_userdata(coap_resource_t *resource, void *data)
Sets the user_data.
uint32_t coap_print_status_t
Status word to encode the result of conditional print or copy operations such as coap_print_link().
#define COAP_PRINT_STATUS_ERROR
coap_str_const_t * coap_resource_get_uri_path(coap_resource_t *resource)
Get the uri_path from a resource.
coap_resource_t * coap_resource_unknown_init2(coap_method_handler_t put_handler, int flags)
Creates a new resource object for the unknown resource handler with support for PUT and configurable ...
coap_str_const_t * coap_attr_get_value(coap_attr_t *attribute)
Returns attribute's value.
#define COAP_PRINT_OUTPUT_LENGTH(v)
coap_attr_t * coap_find_attr(coap_resource_t *resource, coap_str_const_t *name)
Returns resource's coap_attr_t object with given name if found, NULL otherwise.
void * coap_resource_get_userdata(coap_resource_t *resource)
Gets the user_data.
COAP_API void coap_add_resource(coap_context_t *context, coap_resource_t *resource)
Registers the given resource for context.
#define COAP_RESOURCE_FLAGS_RELEASE_URI
The URI passed to coap_resource_init() is free'd by coap_delete_resource().
coap_resource_t * coap_resource_unknown_init(coap_method_handler_t put_handler)
Creates a new resource object for the unknown resource handler with support for PUT.
uint16_t coap_new_message_id_lkd(coap_session_t *session)
Returns a new message id and updates session->tx_mid accordingly.
coap_mid_t coap_send_internal(coap_session_t *session, coap_pdu_t *pdu)
Sends a CoAP message to given peer.
Definition coap_net.c:1583
int coap_check_code_class(coap_session_t *session, coap_pdu_t *pdu)
Check whether the pdu contains a valid code class.
Definition coap_net.c:1221
void coap_cancel_all_messages(coap_context_t *context, coap_session_t *session, coap_bin_const_t *token)
Cancels all outstanding messages for session session that have the specified token.
Definition coap_net.c:2555
void coap_ticks(coap_tick_t *)
Returns the current value of an internal tick counter.
unsigned int coap_encode_var_safe(uint8_t *buf, size_t length, unsigned int val)
Encodes multiple-length byte sequences.
Definition coap_encode.c:47
#define coap_log_debug(...)
Definition coap_debug.h:120
coap_log_t coap_get_log_level(void)
Get the current logging level.
Definition coap_debug.c:95
void coap_show_pdu(coap_log_t level, const coap_pdu_t *pdu)
Display the contents of the specified pdu.
Definition coap_debug.c:778
#define coap_log_warn(...)
Definition coap_debug.h:102
#define coap_log_err(...)
Definition coap_debug.h:96
@ COAP_LOG_DEBUG
Definition coap_debug.h:58
void coap_persist_set_observe_num(coap_resource_t *resource, uint32_t observe_num)
Sets the current observe number value.
void coap_resource_set_get_observable(coap_resource_t *resource, int mode)
Set whether a resource is observable.
COAP_API void coap_check_notify(coap_context_t *context)
Checks all known resources to see if they are dirty and then notifies subscribed observers.
COAP_API int coap_resource_notify_observers(coap_resource_t *resource, const coap_string_t *query)
Initiate the sending of an Observe packet for all observers of resource, optionally matching query if...
size_t oscore_cbor_put_nil(uint8_t **buffer, size_t *buf_size)
Definition oscore_cbor.c:59
size_t oscore_cbor_put_bytes(uint8_t **buffer, size_t *buf_size, const uint8_t *bytes, size_t bytes_len)
size_t oscore_cbor_put_array(uint8_t **buffer, size_t *buf_size, size_t elements)
Definition oscore_cbor.c:92
oscore_association_t * oscore_find_association(coap_session_t *session, coap_bin_const_t *token)
int coap_remove_option(coap_pdu_t *pdu, coap_option_num_t number)
Removes (first) option of given number from the pdu.
Definition coap_pdu.c:473
coap_pdu_t * coap_pdu_duplicate_lkd(const coap_pdu_t *old_pdu, coap_session_t *session, size_t token_length, const uint8_t *token, coap_opt_filter_t *drop_options)
Duplicate an existing PDU.
Definition coap_pdu.c:214
size_t coap_add_option_internal(coap_pdu_t *pdu, coap_option_num_t number, size_t len, const uint8_t *data)
Adds option of given number to pdu that is passed as first parameter.
Definition coap_pdu.c:760
#define COAP_OPTION_BLOCK2
Definition coap_pdu.h:137
void coap_delete_pdu(coap_pdu_t *pdu)
Dispose of an CoAP PDU and frees associated storage.
Definition coap_pdu.c:179
int coap_mid_t
coap_mid_t is used to store the CoAP Message ID of a CoAP PDU.
Definition coap_pdu.h:263
coap_request_t
CoAP PDU Request methods.
Definition coap_pdu.h:78
#define COAP_RESPONSE_CODE(N)
Definition coap_pdu.h:160
#define COAP_RESPONSE_CLASS(C)
Definition coap_pdu.h:163
#define COAP_OPTION_OSCORE
Definition coap_pdu.h:126
int coap_add_token(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Adds token of length len to pdu.
Definition coap_pdu.c:340
#define COAP_OPTION_Q_BLOCK2
Definition coap_pdu.h:140
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:856
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
#define COAP_INVALID_MID
Indicates an invalid message id.
Definition coap_pdu.h:266
#define COAP_OPTION_ETAG
Definition coap_pdu.h:121
#define COAP_OPTION_OBSERVE
Definition coap_pdu.h:123
#define COAP_DEFAULT_URI_WELLKNOWN
well-known resources URI
Definition coap_pdu.h:53
int coap_add_data(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Adds given data to the pdu that is passed as first parameter.
Definition coap_pdu.c:825
@ COAP_REQUEST_PUT
Definition coap_pdu.h:81
@ COAP_PROTO_UDP
Definition coap_pdu.h:314
@ COAP_MESSAGE_NON
Definition coap_pdu.h:70
@ COAP_MESSAGE_CON
Definition coap_pdu.h:69
#define COAP_NSTART(s)
size_t coap_session_max_pdu_size_lkd(const coap_session_t *session)
Get maximum acceptable PDU size.
void coap_session_release_lkd(coap_session_t *session)
Decrement reference counter on a session.
coap_session_t * coap_session_reference_lkd(coap_session_t *session)
Increment reference counter on a session.
#define COAP_PROTO_NOT_RELIABLE(p)
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
void coap_delete_str_const(coap_str_const_t *s)
Deletes the given const string and releases any memory allocated.
Definition coap_str.c:61
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
#define coap_binary_equal(binary1, binary2)
Compares the two binary data for equality.
Definition coap_str.h:211
#define coap_string_equal(string1, string2)
Compares the two strings for equality.
Definition coap_str.h:197
coap_str_const_t * coap_new_str_const(const uint8_t *data, size_t size)
Returns a new const string object with at least size+1 bytes storage allocated, and the provided data...
Definition coap_str.c:51
void coap_delete_string(coap_string_t *s)
Deletes the given string and releases any memory allocated.
Definition coap_str.c:46
void coap_check_notify_lkd(coap_context_t *context)
Checks all known resources to see if they are dirty and then notifies subscribed observers.
int coap_delete_observer_request(coap_resource_t *resource, coap_session_t *session, const coap_bin_const_t *token, coap_pdu_t *request)
Removes any subscription for session observer from resource and releases the allocated storage.
int coap_delete_observer(coap_resource_t *resource, coap_session_t *session, const coap_bin_const_t *token)
Removes any subscription for session observer from resource and releases the allocated storage.
coap_subscription_t * coap_find_observer(coap_resource_t *resource, coap_session_t *session, const coap_bin_const_t *token)
Returns a subscription object for given peer.
void coap_delete_observers(coap_context_t *context, coap_session_t *session)
Removes any subscription for session and releases the allocated storage.
void coap_handle_failed_notify(coap_context_t *context, coap_session_t *session, const coap_bin_const_t *token)
Handles a failed observe notify.
int coap_resource_notify_observers_lkd(coap_resource_t *resource, const coap_string_t *query)
Initiate the sending of an Observe packet for all observers of resource, optionally matching query if...
void coap_subscription_init(coap_subscription_t *)
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.
void coap_touch_observer(coap_context_t *context, coap_session_t *session, const coap_bin_const_t *token)
Flags that data is ready to be sent to observers.
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:722
#define COAP_UNUSED
Definition libcoap.h:70
Limits the number of subscribers for each resource that this server support.
coap_str_const_t * value
Value of the attribute (can be NULL)
coap_str_const_t * name
Name of the attribute.
CoAP binary data definition with const data.
Definition coap_str.h:64
size_t length
length of binary data
Definition coap_str.h:65
const uint8_t * s
read-only binary data
Definition coap_str.h:66
Structure of Block options with BERT support.
Definition coap_block.h:51
unsigned int aszx
block size (0-7 including BERT
Definition coap_block.h:55
unsigned int m
1 if more blocks follow, 0 otherwise
Definition coap_block.h:53
unsigned int szx
block size (0-6)
Definition coap_block.h:54
The CoAP stack's global state is stored in a coap_context_t object.
coap_observe_added_t observe_added
Called when there is a new observe subscription request.
coap_resource_t * resources
hash table or list of known resources
coap_dyn_resource_added_t dyn_resource_added
Callback to save dynamic resource when created.
coap_resource_release_userdata_handler_t release_userdata
function to release user_data when resource is deleted
void * observe_user_data
App provided data for use in observe_added or observe_deleted.
coap_track_observe_value_t track_observe_value
Callback to save observe value when updated.
uint8_t observe_pending
Observe response pending.
uint32_t observe_save_freq
How frequently to update observe value.
uint8_t observe_no_clear
Observe 4.04 not to be sent on deleting resource.
coap_resource_t * proxy_uri_resource
can be used for handling proxy URI resources
coap_observe_deleted_t observe_deleted
Called when there is a observe subscription de-register request.
coap_resource_t * unknown_resource
can be used for handling unknown resources
coap_resource_deleted_t resource_deleted
Invoked when resource is deleted.
coap_address_t bind_addr
local interface address
coap_tick_t last_all_sent
Last time all data sent or 0.
coap_tick_t last_obs
Last time used (Observe tracking) or 0.
structure for CoAP PDUs
uint8_t * token
first byte of token (or extended length bytes prefix), if any, or options
size_t max_size
maximum size for token, options and payload, or zero for variable size pdu
coap_pdu_code_t code
request method (value 1–31) or response code (value 64-255)
uint8_t hdr_size
actual size used for protocol-specific header (0 until header is encoded)
coap_bin_const_t actual_token
Actual token in pdu.
coap_mid_t mid
message id, if any, in regular host byte order
size_t used_size
used bytes of storage for token, options and payload
coap_pdu_type_t type
message type
Abstraction of resource that can be attached to coap_context_t.
unsigned int dirty
set to 1 if resource has changed
unsigned int partiallydirty
set to 1 if some subscribers have not yet been notified of the last change
coap_subscription_t * subscribers
list of observers for this resource
void * user_data
This pointer is under user control.
coap_str_const_t ** proxy_name_list
Array valid names this host is known by (proxy support)
coap_str_const_t * uri_path
Request URI Path for this resource.
unsigned int observe
The next value for the Observe option.
coap_context_t * context
Pointer back to the context that 'owns' this resource.
coap_method_handler_t handler[7]
Used to store handlers for the seven coap methods GET, POST, PUT, DELETE, FETCH, PATCH and IPATCH.
unsigned int is_proxy_uri
resource created for proxy URI handler
unsigned int is_unknown
resource created for unknown handler
coap_attr_t * link_attr
attributes to be included with the link format
unsigned int observable
can be observed
size_t proxy_name_count
Count of valid names this host is known by (proxy support)
int flags
zero or more COAP_RESOURCE_FLAGS_* or'd together
Abstraction of virtual session that can be attached to coap_context_t (client) or coap_endpoint_t (se...
coap_lg_xmit_t * lg_xmit
list of large transmissions
coap_endpoint_t * endpoint
session's endpoint
coap_addr_tuple_t addr_info
remote/local address info
coap_proto_t proto
protocol used
uint8_t con_active
Active CON request sent.
coap_context_t * context
session's context
CoAP string data definition with const data.
Definition coap_str.h:46
const uint8_t * s
read-only string data
Definition coap_str.h:48
size_t length
length of string
Definition coap_str.h:47
CoAP string data definition.
Definition coap_str.h:38
uint8_t * s
string data
Definition coap_str.h:40
size_t length
length of string
Definition coap_str.h:39
Number of notifications that may be sent non-confirmable before a confirmable message is sent to dete...
uint8_t dirty
set if the notification temporarily could not be sent (in that case, the resource's partially dirty f...
uint8_t non_cnt
up to 255 non-confirmable notifies allowed
coap_cache_key_t * cache_key
struct coap_session_t * session
subscriber session
uint8_t fail_cnt
up to 255 confirmable notifies can fail
coap_pdu_t * pdu
cache_key to identify requester
coap_bin_const_t * partial_iv
coap_bin_const_t * aad
coap_bin_const_t * nonce