libcoap 4.3.5-develop-19cef11
coap_mem.c
Go to the documentation of this file.
1/* coap_mem.c -- CoAP memory handling
2 *
3 * Copyright (C) 2014--2015,2019--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
16#include "coap3/coap_libcoap_build.h"
17
18#ifndef WITH_LWIP
19#if COAP_MEMORY_TYPE_TRACK
20static int track_counts[COAP_MEM_TAG_LAST];
21static int peak_counts[COAP_MEM_TAG_LAST];
22static int fail_counts[COAP_MEM_TAG_LAST];
23#endif /* COAP_MEMORY_TYPE_TRACK */
24#endif /* ! WITH_LWIP */
25
26#if defined(RIOT_VERSION) && defined(MODULE_MEMARRAY)
27#include <memarray.h>
28
29#undef PACKAGE_NAME
30#undef PACKAGE_STRING
31#undef PACKAGE_TARNAME
32#undef PACKAGE_VERSION
33#include <coap3/coap_session.h>
34#undef PACKAGE_NAME
35#undef PACKAGE_STRING
36#undef PACKAGE_TARNAME
37#undef PACKAGE_VERSION
38
39#include "coap3/coap_session.h"
40#include "coap3/coap_net.h"
41#include "coap3/coap_pdu.h"
42#include "coap3/coap_resource.h"
43
48#ifndef COAP_MAX_STRING_SIZE
49#define COAP_MAX_STRING_SIZE (64U)
50#endif /* COAP_MAX_STRING_SIZE */
51
56#ifndef COAP_MAX_STRINGS
57#define COAP_MAX_STRINGS (16U)
58#endif /* COAP_MAX_STRINGS */
59
64#ifndef COAP_MAX_ENDPOINTS
65#if !COAP_DISABLE_TCP
66#define COAP_MAX_ENDPOINTS (4U)
67#else /* COAP_DISABLE_TCP */
68#define COAP_MAX_ENDPOINTS (2U)
69#endif /* COAP_DISABLE_TCP */
70#endif /* COAP_MAX_ENDPOINTS */
71
76#ifndef COAP_MAX_RESOURCES
77#define COAP_MAX_RESOURCES (8U)
78#endif /* COAP_MAX_RESOURCES */
79
84#ifndef COAP_MAX_ATTRIBUTES
85#define COAP_MAX_ATTRIBUTES \
86 ((COAP_MAX_RESOURCES) * 4U)
87#endif /* COAP_MAX_ATTRIBUTE_STRINGS */
88
95#ifndef COAP_MAX_ATTRIBUTE_STRINGS
96#define COAP_MAX_ATTRIBUTE_STRINGS (COAP_MAX_ATTRIBUTES)
97#endif /* COAP_MAX_ATTRIBUTE_STRINGS */
98
103#ifndef COAP_MAX_ATTRIBUTE_SIZE
104#define COAP_MAX_ATTRIBUTE_SIZE (16U)
105#endif /* COAP_MAX_ATTRIBUTE_SIZE */
106
111#ifndef COAP_MAX_PACKETS
112#define COAP_MAX_PACKETS (4U)
113#endif /* COAP_MAX_PACKETS */
114
119#ifndef COAP_MAX_NODES
120#define COAP_MAX_NODES (COAP_MAX_PACKETS)
121#endif /* COAP_MAX_NODES */
122
127#ifndef COAP_MAX_CONTEXTS
128#define COAP_MAX_CONTEXTS (1U)
129#endif /* COAP_MAX_CONTEXTS */
130
135#ifndef COAP_MAX_PDUS
136#define COAP_MAX_PDUS (4U)
137#endif /* COAP_MAX_PDUS */
138
143#ifndef COAP_MAX_DTLS_SESSIONS
144#define COAP_MAX_DTLS_SESSIONS (2U)
145#endif /* COAP_MAX_CONTEXTS */
146
151#ifndef COAP_MAX_SESSIONS
152#define COAP_MAX_SESSIONS (4U)
153#endif /* COAP_MAX_CONTEXTS */
154
159#ifndef COAP_MAX_OPTIONS
160#define COAP_MAX_OPTIONS (16U)
161#endif /* COAP_MAX_CONTEXTS */
162
167#ifndef COAP_MAX_OPTION_SIZE
168#define COAP_MAX_OPTION_SIZE (16U)
169#endif /* COAP_MAX_OPTION_SIZE */
170
175#ifndef COAP_MAX_CACHE_KEYS
176#define COAP_MAX_CACHE_KEYS (2U)
177#endif /* COAP_MAX_CACHE_KEYS */
178
183#ifndef COAP_MAX_CACHE_ENTRIES
184#define COAP_MAX_CACHE_ENTRIES (2U)
185#endif /* COAP_MAX_CACHE_ENTRIES */
186
191#ifndef COAP_MAX_LG_CRCVS
192#if COAP_CLIENT_SUPPORT
193#define COAP_MAX_LG_CRCVS (1U)
194#else /* ! COAP_CLIENT_SUPPORT */
195#define COAP_MAX_LG_CRCVS (0U)
196#endif /* ! COAP_CLIENT_SUPPORT */
197#endif /* COAP_MAX_LG_CRCVS */
198
203#ifndef COAP_MAX_LG_SRCVS
204#if COAP_SERVER_SUPPORT
205#define COAP_MAX_LG_SRCVS (2U)
206#else /* ! COAP_SERVER_SUPPORT */
207#define COAP_MAX_LG_SRCVS (0U)
208#endif /* ! COAP_SERVER_SUPPORT */
209#endif /* COAP_MAX_LG_SRCVS */
210
215#ifndef COAP_MAX_LG_XMITS
216#if COAP_SERVER_SUPPORT
217#define COAP_MAX_LG_XMITS (2U)
218#else /* ! COAP_SERVER_SUPPORT */
219#define COAP_MAX_LG_XMITS (1U)
220#endif /* ! COAP_SERVER_SUPPORT */
221#endif /* COAP_MAX_LG_XMITS */
222
223/* The memstr is the storage for holding coap_string_t structure
224 * together with its contents. */
225union memstr_t {
226 coap_string_t s;
227 char buf[sizeof(coap_string_t) + COAP_MAX_STRING_SIZE];
228};
229
230/* The attrstr is the storage for holding coap_string_t structures to
231 * serve as attribute names or values. As these are typically short,
232 * they are stored in a different arena than generic strings. */
233union attrstr_t {
234 coap_string_t s;
235 char buf[sizeof(coap_string_t) + COAP_MAX_ATTRIBUTE_SIZE];
236};
237
238static union memstr_t string_storage_data[COAP_MAX_STRINGS];
239static memarray_t string_storage;
240
241#if COAP_SERVER_SUPPORT
242static coap_endpoint_t endpoint_storage_data[COAP_MAX_ENDPOINTS];
243static memarray_t endpoint_storage;
244
245static union attrstr_t attr_storage_data[COAP_MAX_ATTRIBUTE_STRINGS];
246static memarray_t attr_storage;
247
248static coap_attr_t resattr_storage_data[COAP_MAX_ATTRIBUTES];
249static memarray_t resattr_storage;
250#endif /* COAP_SERVER_SUPPORT */
251
252static coap_packet_t pkt_storage_data[COAP_MAX_PACKETS];
253static memarray_t pkt_storage;
254
255static coap_queue_t node_storage_data[COAP_MAX_NODES];
256static memarray_t node_storage;
257
258static coap_context_t context_storage_data[COAP_MAX_CONTEXTS];
259static memarray_t context_storage;
260
261static coap_pdu_t pdu_storage_data[COAP_MAX_PDUS];
262static memarray_t pdu_storage;
263
264/* The pdubuf is the storage for holding the (assembled) PDU data in a
265 * coap_pdu_t structure. */
266union pdubuf_t {
267 void *p; /* try to convince the compiler to word-align this structure */
268 char buf[COAP_DEFAULT_MAX_PDU_RX_SIZE];
269};
270
271static union pdubuf_t pdubuf_storage_data[COAP_MAX_PDUS];
272static memarray_t pdubuf_storage;
273
274#if COAP_SERVER_SUPPORT
275static coap_resource_t resource_storage_data[COAP_MAX_RESOURCES];
276static memarray_t resource_storage;
277#endif /* COAP_SERVER_SUPPORT */
278
279#ifdef COAP_WITH_LIBTINYDTLS
280#undef PACKAGE_BUGREPORT
281#undef PACKAGE_URL
282#include <session.h>
283static session_t dtls_storage_data[COAP_MAX_DTLS_SESSIONS];
284static memarray_t dtls_storage;
285#endif /* COAP_WITH_LIBTINYDTLS */
286
287static coap_session_t session_storage_data[COAP_MAX_SESSIONS];
288static memarray_t session_storage;
289
290/* The optbuf_t is the storage for holding optlist nodes. */
291struct optbuf_t {
292 coap_optlist_t optlist;
293 char optbuf[COAP_MAX_OPTION_SIZE];
294};
295static struct optbuf_t option_storage_data[COAP_MAX_OPTIONS];
296static memarray_t option_storage;
297
298#if COAP_SERVER_SUPPORT
299static coap_cache_key_t cache_key_storage_data[COAP_MAX_CACHE_KEYS];
300static memarray_t cache_key_storage;
301
302static coap_cache_entry_t cache_entry_storage_data[COAP_MAX_CACHE_ENTRIES];
303static memarray_t cache_entry_storage;
304#endif /* COAP_SERVER_SUPPORT */
305
306#if COAP_CLIENT_SUPPORT
307static coap_lg_crcv_t cache_lg_crcv_storage_data[COAP_MAX_LG_CRCVS];
308static memarray_t cache_lg_crcv_storage;
309#endif /* COAP_CLIENT_SUPPORT */
310
311#if COAP_SERVER_SUPPORT
312static coap_lg_srcv_t cache_lg_srcv_storage_data[COAP_MAX_LG_SRCVS];
313static memarray_t cache_lg_srcv_storage;
314
315static coap_lg_xmit_t cache_lg_xmit_storage_data[COAP_MAX_LG_XMITS];
316static memarray_t cache_lg_xmit_storage;
317#endif /* COAP_SERVER_SUPPORT */
318
319#define INIT_STORAGE(Storage, Count) \
320 memarray_init(&(Storage ## _storage), (Storage ## _storage_data), sizeof(Storage ## _storage_data[0]), (Count));
321
322#define STORAGE_PTR(Storage) (&(Storage ## _storage))
323
324void
325coap_memory_init(void) {
326 INIT_STORAGE(string, COAP_MAX_STRINGS);
327#if COAP_SERVER_SUPPORT
328 INIT_STORAGE(endpoint, COAP_MAX_ENDPOINTS);
329 INIT_STORAGE(attr, COAP_MAX_ATTRIBUTE_STRINGS);
330#endif /* COAP_SERVER_SUPPORT */
331 INIT_STORAGE(pkt, COAP_MAX_PACKETS);
332 INIT_STORAGE(node, COAP_MAX_NODES);
333 INIT_STORAGE(context, COAP_MAX_CONTEXTS);
334 INIT_STORAGE(pdu, COAP_MAX_PDUS);
335 INIT_STORAGE(pdubuf, COAP_MAX_PDUS);
336#if COAP_SERVER_SUPPORT
337 INIT_STORAGE(resource, COAP_MAX_RESOURCES);
338 INIT_STORAGE(resattr, COAP_MAX_ATTRIBUTES);
339#endif /* COAP_SERVER_SUPPORT */
340#ifdef COAP_WITH_LIBTINYDTLS
341 INIT_STORAGE(dtls, COAP_MAX_DTLS_SESSIONS);
342#endif
343 INIT_STORAGE(session, COAP_MAX_SESSIONS);
344 INIT_STORAGE(option, COAP_MAX_OPTIONS);
345#if COAP_SERVER_SUPPORT
346 INIT_STORAGE(cache_key, COAP_MAX_CACHE_KEYS);
347 INIT_STORAGE(cache_entry, COAP_MAX_CACHE_ENTRIES);
348#endif /* COAP_SERVER_SUPPORT */
349#if COAP_CLIENT_SUPPORT
350 INIT_STORAGE(cache_lg_crcv, COAP_MAX_LG_CRCVS);
351#endif /* COAP_SERVER_SUPPORT */
352#if COAP_SERVER_SUPPORT
353 INIT_STORAGE(cache_lg_srcv, COAP_MAX_LG_SRCVS);
354 INIT_STORAGE(cache_lg_xmit, COAP_MAX_LG_XMITS);
355#endif /* COAP_SERVER_SUPPORT */
356}
357
358static memarray_t *
359get_container(coap_memory_tag_t type) {
360 switch (type) {
361#if COAP_SERVER_SUPPORT
362 case COAP_ATTRIBUTE_NAME:
363 /* fall through */
364 case COAP_ATTRIBUTE_VALUE:
365 return &attr_storage;
366#endif /* COAP_SERVER_SUPPORT */
367 case COAP_PACKET:
368 return &pkt_storage;
369 case COAP_NODE:
370 return &node_storage;
371 case COAP_CONTEXT:
372 return STORAGE_PTR(context);
373#if COAP_SERVER_SUPPORT
374 case COAP_ENDPOINT:
375 return &endpoint_storage;
376#endif /* COAP_SERVER_SUPPORT */
377 case COAP_PDU:
378 return &pdu_storage;
379 case COAP_PDU_BUF:
380 return &pdubuf_storage;
381#if COAP_SERVER_SUPPORT
382 case COAP_RESOURCE:
383 return &resource_storage;
384 case COAP_RESOURCEATTR:
385 return &resattr_storage;
386#endif /* COAP_SERVER_SUPPORT */
387#ifdef COAP_WITH_LIBTINYDTLS
388 case COAP_DTLS_SESSION:
389 return &dtls_storage;
390#endif
391 case COAP_SESSION:
392 return &session_storage;
393 case COAP_OPTLIST:
394 return &option_storage;
395#if COAP_SERVER_SUPPORT
396 case COAP_CACHE_KEY:
397 return &cache_key_storage;
398 case COAP_CACHE_ENTRY:
399 return &cache_entry_storage;
400#endif /* COAP_SERVER_SUPPORT */
401#if COAP_CLIENT_SUPPORT
402 case COAP_LG_CRCV:
403 return &cache_lg_crcv_storage;
404#endif /* COAP_CLIENT_SUPPORT */
405#if COAP_SERVER_SUPPORT
406 case COAP_LG_SRCV:
407 return &cache_lg_srcv_storage;
408 case COAP_LG_XMIT:
409 return &cache_lg_xmit_storage;
410#endif /* COAP_SERVER_SUPPORT */
411 case COAP_STRING:
412 /* fall through */
413 default:
414 return &string_storage;
415 }
416}
417
418void *
419coap_malloc_type(coap_memory_tag_t type, size_t size) {
420 memarray_t *container = get_container(type);
421 void *ptr;
422 assert(container);
423
424 if (size > container->size) {
425 coap_log_warn("coap_malloc_type: Requested memory exceeds maximum object "
426 "size (type %d, size %zu, max %zd)\n",
427 type, size, container->size);
428 return NULL;
429 }
430
431 ptr = memarray_alloc(container);
432 if (!ptr)
433 coap_log_warn("coap_malloc_type: Failure (no free blocks) for type %d\n",
434 type);
435#if COAP_MEMORY_TYPE_TRACK
436 assert(type < COAP_MEM_TAG_LAST);
437 if (ptr) {
438 track_counts[type]++;
439 if (track_counts[type] > peak_counts[type])
440 peak_counts[type] = track_counts[type];
441 } else {
442 fail_counts[type]++;
443 }
444#endif /* COAP_MEMORY_TYPE_TRACK */
445 return ptr;
446}
447
448void
449coap_free_type(coap_memory_tag_t type, void *object) {
450#if COAP_MEMORY_TYPE_TRACK
451 assert(type < COAP_MEM_TAG_LAST);
452 if (object)
453 track_counts[type]--;
454#endif /* COAP_MEMORY_TYPE_TRACK */
455 if (object != NULL)
456 memarray_free(get_container(type), object);
457}
458
459void *
460coap_realloc_type(coap_memory_tag_t type, void *p, size_t size) {
461 memarray_t *container = get_container(type);
462
463 assert(container);
464 /* The fixed container is all we have to work with */
465 if (p) {
466 if (size > container->size) {
467 coap_log_warn("coap_realloc_type: Requested memory exceeds maximum object "
468 "size (type %d, size %zu, max %zd)\n",
469 type, size, container->size);
470 return NULL;
471 }
472 if (size == 0) {
473 coap_free_type(type, p);
474 return NULL;
475 }
476 return p;
477 }
478 return coap_malloc_type(type, size);
479
480}
481#else /* ! RIOT_VERSION && ! MODULE_MEMARRAY */
482
483#if defined(__ZEPHYR__)
484
485#include <zephyr/kernel.h>
486
487void
488coap_memory_init(void) {
489}
490
491void *
492coap_malloc_type(coap_memory_tag_t type, size_t size) {
493 void *ptr;
494
495 (void)type;
496 ptr = k_malloc(size);
497#if COAP_MEMORY_TYPE_TRACK
498 assert(type < COAP_MEM_TAG_LAST);
499 if (ptr) {
500 track_counts[type]++;
501 if (track_counts[type] > peak_counts[type])
502 peak_counts[type] = track_counts[type];
503 } else {
504 fail_counts[type]++;
505 }
506#endif /* COAP_MEMORY_TYPE_TRACK */
507 return ptr;
508}
509
510void *
511coap_realloc_type(coap_memory_tag_t type, void *p, size_t size) {
512 void *ptr;
513
514 (void)type;
515#if KERNEL_VERSION_NUMBER >= 0x30700
516 ptr = k_realloc(p, size);
517#else /* KERNEL_VERSION_NUMBER < 0x30700 */
518 if (!p) {
519 ptr = k_malloc(size);
520 } else {
521 /* Unfortunately do not know original size of p to take a copy of it */
522 ptr = NULL;
523 }
524#endif /* KERNEL_VERSION_NUMBER < 0x30700 */
525#if COAP_MEMORY_TYPE_TRACK
526 if (ptr) {
527 assert(type < COAP_MEM_TAG_LAST);
528 if (!p)
529 track_counts[type]++;
530 if (track_counts[type] > peak_counts[type])
531 peak_counts[type] = track_counts[type];
532 } else {
533 fail_counts[type]++;
534 }
535#endif /* COAP_MEMORY_TYPE_TRACK */
536 return ptr;
537}
538
539void
540coap_free_type(coap_memory_tag_t type, void *p) {
541 (void)type;
542#if COAP_MEMORY_TYPE_TRACK
543 assert(type < COAP_MEM_TAG_LAST);
544 if (p)
545 track_counts[type]--;
546#endif /* COAP_MEMORY_TYPE_TRACK */
547 k_free(p);
548}
549
550#elif defined(HAVE_MALLOC) || defined(__MINGW32__)
551#include <stdlib.h>
552
553void
554coap_memory_init(void) {
555}
556
557void *
558coap_malloc_type(coap_memory_tag_t type, size_t size) {
559 void *ptr;
560
561 (void)type;
562 ptr = malloc(size);
563#if COAP_MEMORY_TYPE_TRACK
564 assert(type < COAP_MEM_TAG_LAST);
565 if (ptr) {
566 track_counts[type]++;
567 if (track_counts[type] > peak_counts[type])
568 peak_counts[type] = track_counts[type];
569 } else {
570 fail_counts[type]++;
571 }
572#endif /* COAP_MEMORY_TYPE_TRACK */
573 return ptr;
574}
575
576void *
577coap_realloc_type(coap_memory_tag_t type, void *p, size_t size) {
578 void *ptr;
579
580 (void)type;
581 ptr = realloc(p, size);
582#if COAP_MEMORY_TYPE_TRACK
583 if (ptr) {
584 assert(type < COAP_MEM_TAG_LAST);
585 if (!p)
586 track_counts[type]++;
587 if (track_counts[type] > peak_counts[type])
588 peak_counts[type] = track_counts[type];
589 } else {
590 fail_counts[type]++;
591 }
592#endif /* COAP_MEMORY_TYPE_TRACK */
593 return ptr;
594}
595
596void
597coap_free_type(coap_memory_tag_t type, void *p) {
598 (void)type;
599#if COAP_MEMORY_TYPE_TRACK
600 assert(type < COAP_MEM_TAG_LAST);
601 if (p)
602 track_counts[type]--;
603#endif /* COAP_MEMORY_TYPE_TRACK */
604 free(p);
605}
606
607#else /* ! HAVE_MALLOC && !__MINGW32__ && !__ZEPHYR__*/
608
609#ifdef WITH_CONTIKI
610#include "lib/heapmem.h"
611
612void
613coap_memory_init(void) {
614}
615
616void *
617coap_malloc_type(coap_memory_tag_t type, size_t size) {
618 void *ptr = heapmem_alloc(size);
619
620#if COAP_MEMORY_TYPE_TRACK
621 assert(type < COAP_MEM_TAG_LAST);
622 if (ptr) {
623 track_counts[type]++;
624 if (track_counts[type] > peak_counts[type])
625 peak_counts[type] = track_counts[type];
626 } else {
627 fail_counts[type]++;
628 }
629#endif /* COAP_MEMORY_TYPE_TRACK */
630 return ptr;
631}
632
633void *
634coap_realloc_type(coap_memory_tag_t type, void *p, size_t size) {
635 void *ptr = heapmem_realloc(p, size);
636#if COAP_MEMORY_TYPE_TRACK
637 if (ptr) {
638 assert(type < COAP_MEM_TAG_LAST);
639 if (!p)
640 track_counts[type]++;
641 if (track_counts[type] > peak_counts[type])
642 peak_counts[type] = track_counts[type];
643 } else {
644 fail_counts[type]++;
645 }
646#endif /* COAP_MEMORY_TYPE_TRACK */
647 return ptr;
648}
649
650void
651coap_free_type(coap_memory_tag_t type, void *ptr) {
652#if COAP_MEMORY_TYPE_TRACK
653 assert(type < COAP_MEM_TAG_LAST);
654 if (ptr)
655 track_counts[type]--;
656#endif /* COAP_MEMORY_TYPE_TRACK */
657 if (ptr)
658 heapmem_free(ptr);
659}
660
661#endif /* WITH_CONTIKI */
662
663#endif /* ! HAVE_MALLOC */
664
665#endif /* ! RIOT_VERSION */
666
667#ifndef WITH_LWIP
668#define MAKE_CASE(n) case n: name = #n; break
669void
670coap_dump_memory_type_counts(coap_log_t level) {
671#if COAP_MEMORY_TYPE_TRACK
672 int i;
673
674 coap_log(level, "* Memory type counts\n");
675 for (i = 0; i < COAP_MEM_TAG_LAST; i++) {
676 const char *name = "?";
677
678
679 switch (i) {
680 MAKE_CASE(COAP_STRING);
681 MAKE_CASE(COAP_ATTRIBUTE_NAME);
682 MAKE_CASE(COAP_ATTRIBUTE_VALUE);
683 MAKE_CASE(COAP_PACKET);
684 MAKE_CASE(COAP_NODE);
685 MAKE_CASE(COAP_CONTEXT);
686 MAKE_CASE(COAP_ENDPOINT);
687 MAKE_CASE(COAP_PDU);
688 MAKE_CASE(COAP_PDU_BUF);
689 MAKE_CASE(COAP_RESOURCE);
690 MAKE_CASE(COAP_RESOURCEATTR);
691 MAKE_CASE(COAP_DTLS_SESSION);
692 MAKE_CASE(COAP_SESSION);
693 MAKE_CASE(COAP_OPTLIST);
694 MAKE_CASE(COAP_CACHE_KEY);
695 MAKE_CASE(COAP_CACHE_ENTRY);
696 MAKE_CASE(COAP_LG_XMIT);
697 MAKE_CASE(COAP_LG_CRCV);
698 MAKE_CASE(COAP_LG_SRCV);
699 MAKE_CASE(COAP_DIGEST_CTX);
700 MAKE_CASE(COAP_SUBSCRIPTION);
701 MAKE_CASE(COAP_DTLS_CONTEXT);
702 MAKE_CASE(COAP_OSCORE_COM);
703 MAKE_CASE(COAP_OSCORE_SEN);
704 MAKE_CASE(COAP_OSCORE_REC);
705 MAKE_CASE(COAP_OSCORE_EX);
706 MAKE_CASE(COAP_OSCORE_EP);
707 MAKE_CASE(COAP_OSCORE_BUF);
708 MAKE_CASE(COAP_COSE);
709 case COAP_MEM_TAG_LAST:
710 default:
711 break;
712 }
713 coap_log(level, "* %-20s in-use %3d peak %3d failed %2d\n",
714 name, track_counts[i], peak_counts[i], fail_counts[i]);
715 }
716#else /* COAP_MEMORY_TYPE_TRACK */
717 (void)level;
718#endif /* COAP_MEMORY_TYPE_TRACK */
719}
720#endif /* !WITH_LWIP */
coap_libcoap_build.h
Library specific build wrapper for coap_internal.h.
MAKE_CASE
#define MAKE_CASE(n)
Definition: coap_mem.c:668
coap_dump_memory_type_counts
void coap_dump_memory_type_counts(coap_log_t level)
Dumps the current usage of malloc'd memory types.
Definition: coap_mem.c:670
coap_memory_init
void coap_memory_init(void)
Initializes libcoap's memory management.
coap_memory_tag_t
coap_memory_tag_t
Type specifiers for coap_malloc_type().
Definition: coap_mem.h:38
COAP_DTLS_SESSION
@ COAP_DTLS_SESSION
Definition: coap_mem.h:50
COAP_SESSION
@ COAP_SESSION
Definition: coap_mem.h:51
COAP_CACHE_KEY
@ COAP_CACHE_KEY
Definition: coap_mem.h:53
COAP_DIGEST_CTX
@ COAP_DIGEST_CTX
Definition: coap_mem.h:58
COAP_NODE
@ COAP_NODE
Definition: coap_mem.h:43
COAP_OSCORE_COM
@ COAP_OSCORE_COM
Definition: coap_mem.h:61
COAP_DTLS_CONTEXT
@ COAP_DTLS_CONTEXT
Definition: coap_mem.h:60
COAP_OSCORE_EX
@ COAP_OSCORE_EX
Definition: coap_mem.h:64
COAP_CACHE_ENTRY
@ COAP_CACHE_ENTRY
Definition: coap_mem.h:54
COAP_RESOURCE
@ COAP_RESOURCE
Definition: coap_mem.h:48
COAP_RESOURCEATTR
@ COAP_RESOURCEATTR
Definition: coap_mem.h:49
COAP_COSE
@ COAP_COSE
Definition: coap_mem.h:67
COAP_LG_XMIT
@ COAP_LG_XMIT
Definition: coap_mem.h:55
COAP_ATTRIBUTE_VALUE
@ COAP_ATTRIBUTE_VALUE
Definition: coap_mem.h:41
COAP_ENDPOINT
@ COAP_ENDPOINT
Definition: coap_mem.h:45
COAP_CONTEXT
@ COAP_CONTEXT
Definition: coap_mem.h:44
COAP_OPTLIST
@ COAP_OPTLIST
Definition: coap_mem.h:52
COAP_PDU
@ COAP_PDU
Definition: coap_mem.h:46
COAP_LG_CRCV
@ COAP_LG_CRCV
Definition: coap_mem.h:56
COAP_OSCORE_BUF
@ COAP_OSCORE_BUF
Definition: coap_mem.h:66
COAP_MEM_TAG_LAST
@ COAP_MEM_TAG_LAST
Definition: coap_mem.h:68
COAP_OSCORE_SEN
@ COAP_OSCORE_SEN
Definition: coap_mem.h:62
COAP_OSCORE_REC
@ COAP_OSCORE_REC
Definition: coap_mem.h:63
COAP_ATTRIBUTE_NAME
@ COAP_ATTRIBUTE_NAME
Definition: coap_mem.h:40
COAP_OSCORE_EP
@ COAP_OSCORE_EP
Definition: coap_mem.h:65
COAP_LG_SRCV
@ COAP_LG_SRCV
Definition: coap_mem.h:57
COAP_PACKET
@ COAP_PACKET
Definition: coap_mem.h:42
COAP_SUBSCRIPTION
@ COAP_SUBSCRIPTION
Definition: coap_mem.h:59
COAP_STRING
@ COAP_STRING
Definition: coap_mem.h:39
COAP_PDU_BUF
@ COAP_PDU_BUF
Definition: coap_mem.h:47
coap_realloc_type
void * coap_realloc_type(coap_memory_tag_t type, void *p, size_t size)
Reallocates a chunk p of bytes created by coap_malloc_type() or coap_realloc_type() and returns a poi...
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_net.h
CoAP context interface.
coap_pdu.h
Pre-defined constants that reflect defaults for CoAP.
coap_resource.h
Generic resource handling.
coap_session.h
Defines the application visible session information.
coap_log_t
coap_log_t
Logging type.
Definition: coap_debug.h:50
coap_log_warn
#define coap_log_warn(...)
Definition: coap_debug.h:102
coap_log
#define coap_log(level,...)
Logging function.
Definition: coap_debug.h:284
coap_string_t
struct coap_string_t coap_string_t
CoAP string data definition.
coap_attr_t
Limits the number of subscribers for each resource that this server support.
Definition: coap_resource_internal.h:42
coap_cache_entry_t
Definition: coap_cache_internal.h:41
coap_cache_key_t
Definition: coap_cache_internal.h:37
coap_context_t
The CoAP stack's global state is stored in a coap_context_t object.
Definition: coap_net_internal.h:50
coap_endpoint_t
Abstraction of virtual endpoint that can be attached to coap_context_t.
Definition: coap_session_internal.h:237
coap_lg_crcv_t
Structure to hold large body (many blocks) client receive information.
Definition: coap_block_internal.h:176
coap_lg_srcv_t
Structure to hold large body (many blocks) server receive information.
Definition: coap_block_internal.h:209
coap_lg_xmit_t
Structure to hold large body (many blocks) transmission information.
Definition: coap_block_internal.h:146
coap_optlist_t
Representation of chained list of CoAP options to install.
Definition: coap_option.h:325
coap_packet_t
Definition: coap_io_internal.h:225
coap_pdu_t
structure for CoAP PDUs
Definition: coap_pdu_internal.h:135
coap_queue_t
Queue entry.
Definition: coap_net_internal.h:35
coap_resource_t
Abstraction of resource that can be attached to coap_context_t.
Definition: coap_resource_internal.h:53
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_string_t
CoAP string data definition.
Definition: coap_str.h:38