1 /* 2 * pdu.h -- CoAP message structure 3 * 4 * Copyright (C) 2010-2014 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 README for terms 9 * of use. 10 */ 11 12 /** 13 * @file pdu.h 14 * @brief Pre-defined constants that reflect defaults for CoAP 15 */ 16 17 #ifndef COAP_PDU_H_ 18 #define COAP_PDU_H_ 19 20 #include "uri.h" 21 #include "option.h" 22 23 #ifdef WITH_LWIP 24 #include <lwip/pbuf.h> 25 #endif 26 27 #include <stdint.h> 28 29 /** 30 * @defgroup pdu PDU 31 * API functions for PDUs 32 * @{ 33 */ 34 35 #define COAP_DEFAULT_PORT 5683 /* CoAP default UDP/TCP port */ 36 #define COAPS_DEFAULT_PORT 5684 /* CoAP default UDP/TCP port for secure transmission */ 37 #define COAP_DEFAULT_MAX_AGE 60 /* default maximum object lifetime in seconds */ 38 #ifndef COAP_DEFAULT_MTU 39 #define COAP_DEFAULT_MTU 1152 40 #endif /* COAP_DEFAULT_MTU */ 41 42 #ifndef COAP_DEFAULT_HOP_LIMIT 43 #define COAP_DEFAULT_HOP_LIMIT 16 44 #endif /* COAP_DEFAULT_HOP_LIMIT */ 45 46 #define COAP_DEFAULT_SCHEME "coap" /* the default scheme for CoAP URIs */ 47 48 /** well-known resources URI */ 49 #define COAP_DEFAULT_URI_WELLKNOWN ".well-known/core" 50 51 /* CoAP message types */ 52 53 /** 54 * CoAP PDU message type definitions 55 */ 56 typedef enum coap_pdu_type_t { 57 COAP_MESSAGE_CON, /* 0 confirmable message (requires ACK/RST) */ 58 COAP_MESSAGE_NON, /* 1 non-confirmable message (one-shot message) */ 59 COAP_MESSAGE_ACK, /* 2 used to acknowledge confirmable messages */ 60 COAP_MESSAGE_RST /* 3 indicates error in received messages */ 61 } coap_pdu_type_t; 62 63 /** 64 * CoAP PDU Request methods 65 */ 66 typedef enum coap_request_t { 67 COAP_REQUEST_GET = 1, 68 COAP_REQUEST_POST, /* 2 */ 69 COAP_REQUEST_PUT, /* 3 */ 70 COAP_REQUEST_DELETE, /* 4 */ 71 COAP_REQUEST_FETCH, /* 5 RFC 8132 */ 72 COAP_REQUEST_PATCH, /* 6 RFC 8132 */ 73 COAP_REQUEST_IPATCH, /* 7 RFC 8132 */ 74 } coap_request_t; 75 76 /* 77 * CoAP option numbers (be sure to update coap_option_check_critical() and 78 * coap_add_option() when adding options 79 */ 80 81 /* 82 * The C, U, and N flags indicate the properties 83 * Critical, Unsafe, and NoCacheKey, respectively. 84 * If U is set, then N has no meaning as per 85 * https://tools.ietf.org/html/rfc7252#section-5.10 86 * and is set to a -. 87 * 88 * Separately, R is for the options that can be repeated 89 * 90 * The least significant byte of the option is set as followed 91 * as per https://tools.ietf.org/html/rfc7252#section-5.4.6 92 * 93 * 0 1 2 3 4 5 6 7 94 * --+---+---+---+---+---+---+---+ 95 * | NoCacheKey| U | C | 96 * --+---+---+---+---+---+---+---+ 97 * 98 * https://tools.ietf.org/html/rfc8613#section-4 goes on to define E, I and U 99 * properties Encrypted and Integrity Protected, Integrity Protected Only, and 100 * Unprotected respectively. Integrity Protected Only is not currently used. 101 * 102 * An Option is tagged with CUNREIU with any of the letters replaced with _ if 103 * not set, or - for N if U is set (see above) for aiding understanding of the 104 * Option. 105 */ 106 107 #define COAP_OPTION_IF_MATCH 1 /* C__RE__, opaque, 0-8 B, RFC7252 */ 108 #define COAP_OPTION_URI_HOST 3 /* CU-___U, String, 1-255 B, RFC7252 */ 109 #define COAP_OPTION_ETAG 4 /* ___RE__, opaque, 1-8 B, RFC7252 */ 110 #define COAP_OPTION_IF_NONE_MATCH 5 /* C___E__, empty, 0 B, RFC7252 */ 111 #define COAP_OPTION_OBSERVE 6 /* _U-_E_U, empty/uint,0/0-3 B, RFC7641 */ 112 #define COAP_OPTION_URI_PORT 7 /* CU-___U, uint, 0-2 B, RFC7252 */ 113 #define COAP_OPTION_LOCATION_PATH 8 /* ___RE__, String, 0-255 B, RFC7252 */ 114 #define COAP_OPTION_OSCORE 9 /* C_____U, *, 0-255 B, RFC8613 */ 115 #define COAP_OPTION_URI_PATH 11 /* CU-RE__, String, 0-255 B, RFC7252 */ 116 #define COAP_OPTION_CONTENT_FORMAT 12 /* ____E__, uint, 0-2 B, RFC7252 */ 117 #define COAP_OPTION_CONTENT_TYPE COAP_OPTION_CONTENT_FORMAT 118 /* COAP_OPTION_MAXAGE default 60 seconds if not set */ 119 #define COAP_OPTION_MAXAGE 14 /* _U-_E_U, uint, 0-4 B, RFC7252 */ 120 #define COAP_OPTION_URI_QUERY 15 /* CU-RE__, String, 1-255 B, RFC7252 */ 121 #define COAP_OPTION_HOP_LIMIT 16 /* ______U, uint, 1 B, RFC8768 */ 122 #define COAP_OPTION_ACCEPT 17 /* C___E__, uint, 0-2 B, RFC7252 */ 123 #define COAP_OPTION_LOCATION_QUERY 20 /* ___RE__, String, 0-255 B, RFC7252 */ 124 #define COAP_OPTION_BLOCK2 23 /* CU-_E_U, uint, 0-3 B, RFC7959 */ 125 #define COAP_OPTION_BLOCK1 27 /* CU-_E_U, uint, 0-3 B, RFC7959 */ 126 #define COAP_OPTION_SIZE2 28 /* __N_E_U, uint, 0-4 B, RFC7959 */ 127 #define COAP_OPTION_PROXY_URI 35 /* CU-___U, String, 1-1034 B, RFC7252 */ 128 #define COAP_OPTION_PROXY_SCHEME 39 /* CU-___U, String, 1-255 B, RFC7252 */ 129 #define COAP_OPTION_SIZE1 60 /* __N_E_U, uint, 0-4 B, RFC7252 */ 130 #define COAP_OPTION_NORESPONSE 258 /* _U-_E_U, uint, 0-1 B, RFC7967 */ 131 132 #define COAP_MAX_OPT 65535 /**< the highest option number we know */ 133 134 /* CoAP result codes (HTTP-Code / 100 * 40 + HTTP-Code % 100) */ 135 136 /* As of draft-ietf-core-coap-04, response codes are encoded to base 137 * 32, i.e. the three upper bits determine the response class while 138 * the remaining five fine-grained information specific to that class. 139 */ 140 #define COAP_RESPONSE_CODE(N) (((N)/100 << 5) | (N)%100) 141 142 /* Determines the class of response code C */ 143 #define COAP_RESPONSE_CLASS(C) (((C) >> 5) & 0xFF) 144 145 #ifndef SHORT_ERROR_RESPONSE 146 /** 147 * Returns a human-readable response phrase for the specified CoAP response @p 148 * code. This function returns @c NULL if not found. 149 * 150 * @param code The response code for which the literal phrase should be 151 * retrieved. 152 * 153 * @return A zero-terminated string describing the error, or @c NULL if not 154 * found. 155 */ 156 const char *coap_response_phrase(unsigned char code); 157 158 #define COAP_ERROR_PHRASE_LENGTH 32 /**< maximum length of error phrase */ 159 160 #else 161 #define coap_response_phrase(x) ((char *)NULL) 162 163 #define COAP_ERROR_PHRASE_LENGTH 0 /**< maximum length of error phrase */ 164 #endif /* SHORT_ERROR_RESPONSE */ 165 166 #define COAP_SIGNALING_CODE(N) (((N)/100 << 5) | (N)%100) 167 168 typedef enum coap_pdu_signaling_proto_t { 169 COAP_SIGNALING_CSM = COAP_SIGNALING_CODE(701), 170 COAP_SIGNALING_PING = COAP_SIGNALING_CODE(702), 171 COAP_SIGNALING_PONG = COAP_SIGNALING_CODE(703), 172 COAP_SIGNALING_RELEASE = COAP_SIGNALING_CODE(704), 173 COAP_SIGNALING_ABORT = COAP_SIGNALING_CODE(705), 174 } coap_pdu_signaling_proto_t; 175 176 /* Applies to COAP_SIGNALING_CSM */ 177 #define COAP_SIGNALING_OPTION_MAX_MESSAGE_SIZE 2 178 #define COAP_SIGNALING_OPTION_BLOCK_WISE_TRANSFER 4 179 /* Applies to COAP_SIGNALING_PING / COAP_SIGNALING_PONG */ 180 #define COAP_SIGNALING_OPTION_CUSTODY 2 181 /* Applies to COAP_SIGNALING_RELEASE */ 182 #define COAP_SIGNALING_OPTION_ALTERNATIVE_ADDRESS 2 183 #define COAP_SIGNALING_OPTION_HOLD_OFF 4 184 /* Applies to COAP_SIGNALING_ABORT */ 185 #define COAP_SIGNALING_OPTION_BAD_CSM_OPTION 2 186 187 /* CoAP media type encoding */ 188 189 #define COAP_MEDIATYPE_TEXT_PLAIN 0 /* text/plain (UTF-8) */ 190 #define COAP_MEDIATYPE_APPLICATION_LINK_FORMAT 40 /* application/link-format */ 191 #define COAP_MEDIATYPE_APPLICATION_XML 41 /* application/xml */ 192 #define COAP_MEDIATYPE_APPLICATION_OCTET_STREAM 42 /* application/octet-stream */ 193 #define COAP_MEDIATYPE_APPLICATION_RDF_XML 43 /* application/rdf+xml */ 194 #define COAP_MEDIATYPE_APPLICATION_EXI 47 /* application/exi */ 195 #define COAP_MEDIATYPE_APPLICATION_JSON 50 /* application/json */ 196 #define COAP_MEDIATYPE_APPLICATION_CBOR 60 /* application/cbor */ 197 #define COAP_MEDIATYPE_APPLICATION_CWT 61 /* application/cwt, RFC 8392 */ 198 199 /* Content formats from RFC 8152 */ 200 #define COAP_MEDIATYPE_APPLICATION_COSE_SIGN 98 /* application/cose; cose-type="cose-sign" */ 201 #define COAP_MEDIATYPE_APPLICATION_COSE_SIGN1 18 /* application/cose; cose-type="cose-sign1" */ 202 #define COAP_MEDIATYPE_APPLICATION_COSE_ENCRYPT 96 /* application/cose; cose-type="cose-encrypt" */ 203 #define COAP_MEDIATYPE_APPLICATION_COSE_ENCRYPT0 16 /* application/cose; cose-type="cose-encrypt0" */ 204 #define COAP_MEDIATYPE_APPLICATION_COSE_MAC 97 /* application/cose; cose-type="cose-mac" */ 205 #define COAP_MEDIATYPE_APPLICATION_COSE_MAC0 17 /* application/cose; cose-type="cose-mac0" */ 206 207 #define COAP_MEDIATYPE_APPLICATION_COSE_KEY 101 /* application/cose-key */ 208 #define COAP_MEDIATYPE_APPLICATION_COSE_KEY_SET 102 /* application/cose-key-set */ 209 210 /* Content formats from RFC 8428 */ 211 #define COAP_MEDIATYPE_APPLICATION_SENML_JSON 110 /* application/senml+json */ 212 #define COAP_MEDIATYPE_APPLICATION_SENSML_JSON 111 /* application/sensml+json */ 213 #define COAP_MEDIATYPE_APPLICATION_SENML_CBOR 112 /* application/senml+cbor */ 214 #define COAP_MEDIATYPE_APPLICATION_SENSML_CBOR 113 /* application/sensml+cbor */ 215 #define COAP_MEDIATYPE_APPLICATION_SENML_EXI 114 /* application/senml-exi */ 216 #define COAP_MEDIATYPE_APPLICATION_SENSML_EXI 115 /* application/sensml-exi */ 217 #define COAP_MEDIATYPE_APPLICATION_SENML_XML 310 /* application/senml+xml */ 218 #define COAP_MEDIATYPE_APPLICATION_SENSML_XML 311 /* application/sensml+xml */ 219 220 /* Content formats from RFC 8782 */ 221 #define COAP_MEDIATYPE_APPLICATION_DOTS_CBOR 271 /* application/dots+cbor */ 222 223 /* Note that identifiers for registered media types are in the range 0-65535. We 224 * use an unallocated type here and hope for the best. */ 225 #define COAP_MEDIATYPE_ANY 0xff /* any media type */ 226 227 /** 228 * coap_mid_t is used to store the CoAP Message ID of a CoAP PDU. 229 * Valid message ids are 0 to 2^16. Negative values are error codes. 230 */ 231 typedef int coap_mid_t; 232 233 /** Indicates an invalid message id. */ 234 #define COAP_INVALID_MID -1 235 236 /** 237 * Indicates an invalid message id. 238 * @deprecated Use COAP_INVALID_MID instead. 239 */ 240 #define COAP_INVALID_TID COAP_INVALID_MID 241 242 /** 243 * @deprecated Use coap_optlist_t instead. 244 * 245 * Structures for more convenient handling of options. (To be used with ordered 246 * coap_list_t.) The option's data will be added to the end of the coap_option 247 * structure (see macro COAP_OPTION_DATA). 248 */ 249 COAP_DEPRECATED typedef struct { 250 uint16_t key; /* the option key (no delta coding) */ 251 unsigned int length; 252 } coap_option; 253 254 #define COAP_OPTION_KEY(option) (option).key 255 #define COAP_OPTION_LENGTH(option) (option).length 256 #define COAP_OPTION_DATA(option) ((unsigned char *)&(option) + sizeof(coap_option)) 257 258 #ifdef WITH_LWIP 259 /** 260 * Creates a CoAP PDU from an lwIP @p pbuf, whose reference is passed on to this 261 * function. 262 * 263 * The pbuf is checked for being contiguous, and for having only one reference. 264 * The reference is stored in the PDU and will be freed when the PDU is freed. 265 * 266 * (For now, these are fatal errors; in future, a new pbuf might be allocated, 267 * the data copied and the passed pbuf freed). 268 * 269 * This behaves like coap_pdu_init(0, 0, 0, pbuf->tot_len), and afterwards 270 * copying the contents of the pbuf to the pdu. 271 * 272 * @return A pointer to the new PDU object or @c NULL on error. 273 */ 274 coap_pdu_t * coap_pdu_from_pbuf(struct pbuf *pbuf); 275 #endif 276 277 /** 278 * CoAP protocol types 279 */ 280 typedef enum coap_proto_t { 281 COAP_PROTO_NONE = 0, 282 COAP_PROTO_UDP, 283 COAP_PROTO_DTLS, 284 COAP_PROTO_TCP, 285 COAP_PROTO_TLS, 286 } coap_proto_t; 287 288 /** 289 * Set of codes available for a PDU. 290 */ 291 typedef enum coap_pdu_code_t { 292 COAP_EMPTY_CODE = 0, 293 294 COAP_REQUEST_CODE_GET = COAP_REQUEST_GET, 295 COAP_REQUEST_CODE_POST = COAP_REQUEST_POST, 296 COAP_REQUEST_CODE_PUT = COAP_REQUEST_PUT, 297 COAP_REQUEST_CODE_DELETE = COAP_REQUEST_DELETE, 298 COAP_REQUEST_CODE_FETCH = COAP_REQUEST_FETCH, 299 COAP_REQUEST_CODE_PATCH = COAP_REQUEST_PATCH, 300 COAP_REQUEST_CODE_IPATCH = COAP_REQUEST_IPATCH, 301 302 COAP_RESPONSE_CODE_OK = COAP_RESPONSE_CODE(200), 303 COAP_RESPONSE_CODE_CREATED = COAP_RESPONSE_CODE(201), 304 COAP_RESPONSE_CODE_DELETED = COAP_RESPONSE_CODE(202), 305 COAP_RESPONSE_CODE_VALID = COAP_RESPONSE_CODE(203), 306 COAP_RESPONSE_CODE_CHANGED = COAP_RESPONSE_CODE(204), 307 COAP_RESPONSE_CODE_CONTENT = COAP_RESPONSE_CODE(205), 308 COAP_RESPONSE_CODE_CONTINUE = COAP_RESPONSE_CODE(231), 309 COAP_RESPONSE_CODE_BAD_REQUEST = COAP_RESPONSE_CODE(400), 310 COAP_RESPONSE_CODE_UNAUTHORIZED = COAP_RESPONSE_CODE(401), 311 COAP_RESPONSE_CODE_BAD_OPTION = COAP_RESPONSE_CODE(402), 312 COAP_RESPONSE_CODE_FORBIDDEN = COAP_RESPONSE_CODE(403), 313 COAP_RESPONSE_CODE_NOT_FOUND = COAP_RESPONSE_CODE(404), 314 COAP_RESPONSE_CODE_NOT_ALLOWED = COAP_RESPONSE_CODE(405), 315 COAP_RESPONSE_CODE_NOT_ACCEPTABLE = COAP_RESPONSE_CODE(406), 316 COAP_RESPONSE_CODE_INCOMPLETE = COAP_RESPONSE_CODE(408), 317 COAP_RESPONSE_CODE_CONFLICT = COAP_RESPONSE_CODE(409), 318 COAP_RESPONSE_CODE_PRECONDITION_FAILED = COAP_RESPONSE_CODE(412), 319 COAP_RESPONSE_CODE_REQUEST_TOO_LARGE = COAP_RESPONSE_CODE(413), 320 COAP_RESPONSE_CODE_UNSUPPORTED_CONTENT_FORMAT = COAP_RESPONSE_CODE(415), 321 COAP_RESPONSE_CODE_UNPROCESSABLE = COAP_RESPONSE_CODE(422), 322 COAP_RESPONSE_CODE_TOO_MANY_REQUESTS = COAP_RESPONSE_CODE(429), 323 COAP_RESPONSE_CODE_INTERNAL_ERROR = COAP_RESPONSE_CODE(500), 324 COAP_RESPONSE_CODE_NOT_IMPLEMENTED = COAP_RESPONSE_CODE(501), 325 COAP_RESPONSE_CODE_BAD_GATEWAY = COAP_RESPONSE_CODE(502), 326 COAP_RESPONSE_CODE_SERVICE_UNAVAILABLE = COAP_RESPONSE_CODE(503), 327 COAP_RESPONSE_CODE_GATEWAY_TIMEOUT = COAP_RESPONSE_CODE(504), 328 COAP_RESPONSE_CODE_PROXYING_NOT_SUPPORTED = COAP_RESPONSE_CODE(505), 329 COAP_RESPONSE_CODE_HOP_LIMIT_REACHED = COAP_RESPONSE_CODE(508), 330 331 COAP_SIGNALING_CODE_CSM = COAP_SIGNALING_CSM, 332 COAP_SIGNALING_CODE_PING = COAP_SIGNALING_PING, 333 COAP_SIGNALING_CODE_PONG = COAP_SIGNALING_PONG, 334 COAP_SIGNALING_CODE_RELEASE = COAP_SIGNALING_RELEASE, 335 COAP_SIGNALING_CODE_ABORT = COAP_SIGNALING_ABORT 336 } coap_pdu_code_t; 337 338 /** 339 * Creates a new CoAP PDU with at least enough storage space for the given 340 * @p size maximum message size. The function returns a pointer to the 341 * node coap_pdu_t object on success, or @c NULL on error. The storage allocated 342 * for the result must be released with coap_delete_pdu() if coap_send() 343 * is not called. 344 * 345 * @param type The type of the PDU (one of COAP_MESSAGE_CON, COAP_MESSAGE_NON, 346 * COAP_MESSAGE_ACK, COAP_MESSAGE_RST). 347 * @param code The message code of the PDU. 348 * @param mid The message id to set or 0 if unknown / not applicable. 349 * @param size The maximum allowed number of byte for the message. 350 * @return A pointer to the new PDU object or @c NULL on error. 351 */ 352 coap_pdu_t *coap_pdu_init(coap_pdu_type_t type, coap_pdu_code_t code, 353 coap_mid_t mid, size_t size); 354 355 /** 356 * Creates a new CoAP PDU. 357 * 358 * @param type The type of the PDU (one of COAP_MESSAGE_CON, COAP_MESSAGE_NON, 359 * COAP_MESSAGE_ACK, COAP_MESSAGE_RST). 360 * @param code The message code of the PDU. 361 * @param session The session that will be using this PDU 362 * 363 * @return The skeletal PDU or @c NULL if failure. 364 */ 365 coap_pdu_t *coap_new_pdu(coap_pdu_type_t type, coap_pdu_code_t code, 366 coap_session_t *session); 367 368 /** 369 * Dispose of an CoAP PDU and frees associated storage. 370 * Not that in general you should not call this function directly. 371 * When a PDU is sent with coap_send(), coap_delete_pdu() will be called 372 * automatically for you. 373 * 374 * @param pdu The PDU for free off. 375 */ 376 void coap_delete_pdu(coap_pdu_t *pdu); 377 378 /** 379 * Duplicate an existing PDU. Specific options can be ignored and not copied 380 * across. The PDU data payload is not copied across. 381 * 382 * @param old_pdu The PDU to duplicate 383 * @param session The session that will be using this PDU. 384 * @param token_length The length of the token to use in this duplicated PDU. 385 * @param token The token to use in this duplicated PDU. 386 * @param drop_options A list of options not to copy into the duplicated PDU. 387 * If @c NULL, then all options are copied across. 388 * 389 * @return The duplicated PDU or @c NULL if failure. 390 */ 391 coap_pdu_t * 392 coap_pdu_duplicate(const coap_pdu_t *old_pdu, 393 coap_session_t *session, 394 size_t token_length, 395 const uint8_t *token, 396 coap_opt_filter_t *drop_options); 397 398 /** 399 * Adds token of length @p len to @p pdu. 400 * Adding the token destroys any following contents of the pdu. Hence options 401 * and data must be added after coap_add_token() has been called. In @p pdu, 402 * length is set to @p len + @c 4, and max_delta is set to @c 0. This function 403 * returns @c 0 on error or a value greater than zero on success. 404 * 405 * @param pdu The PDU where the token is to be added. 406 * @param len The length of the new token. 407 * @param data The token to add. 408 * 409 * @return A value greater than zero on success, or @c 0 on error. 410 */ 411 int coap_add_token(coap_pdu_t *pdu, 412 size_t len, 413 const uint8_t *data); 414 415 /** 416 * Adds option of given number to pdu that is passed as first 417 * parameter. 418 * coap_add_option() destroys the PDU's data, so coap_add_data() must be called 419 * after all options have been added. As coap_add_token() destroys the options 420 * following the token, the token must be added before coap_add_option() is 421 * called. This function returns the number of bytes written or @c 0 on error. 422 * 423 * Note: Where possible, the option data needs to be stripped of leading zeros 424 * (big endian) to reduce the amount of data needed in the PDU, as well as in 425 * some cases the maximum data size of an opton can be exceeded if not stripped 426 * and hence be illegal. This is done by using coap_encode_var_safe() or 427 * coap_encode_var_safe8(). 428 * 429 * @param pdu The PDU where the option is to be added. 430 * @param number The number of the new option. 431 * @param len The length of the new option. 432 * @param data The data of the new option. 433 * 434 * @return The overall length of the option or @c 0 on failure. 435 */ 436 size_t coap_add_option(coap_pdu_t *pdu, 437 coap_option_num_t number, 438 size_t len, 439 const uint8_t *data); 440 441 /** 442 * Adds given data to the pdu that is passed as first parameter. Note that the 443 * PDU's data is destroyed by coap_add_option(). coap_add_data() must be called 444 * only once per PDU, otherwise the result is undefined. 445 * 446 * @param pdu The PDU where the data is to be added. 447 * @param len The length of the data. 448 * @param data The data to add. 449 * 450 * @return @c 1 if success, else @c 0 if failure. 451 */ 452 int coap_add_data(coap_pdu_t *pdu, 453 size_t len, 454 const uint8_t *data); 455 456 /** 457 * Adds given data to the pdu that is passed as first parameter but does not 458 * copy it. Note that the PDU's data is destroyed by coap_add_option(). 459 * coap_add_data() must be have been called once for this PDU, otherwise the 460 * result is undefined. 461 * The actual data must be copied at the returned location. 462 * 463 * @param pdu The PDU where the data is to be added. 464 * @param len The length of the data. 465 * 466 * @return Where to copy the data of len to, or @c NULL is error. 467 */ 468 uint8_t *coap_add_data_after(coap_pdu_t *pdu, size_t len); 469 470 /** 471 * Retrieves the length and data pointer of specified PDU. Returns 0 on error or 472 * 1 if *len and *data have correct values. Note that these values are destroyed 473 * with the pdu. 474 * 475 * @param pdu The specified PDU. 476 * @param len Returns the length of the current data 477 * @param data Returns the ptr to the current data 478 * 479 * @return @c 1 if len and data are correctly filled in, else 480 * @c 0 if there is no data. 481 */ 482 int coap_get_data(const coap_pdu_t *pdu, 483 size_t *len, 484 const uint8_t **data); 485 486 /** 487 * Retrieves the data from a PDU, with support for large bodies of data that 488 * spans multiple PDUs. 489 * 490 * Note: The data pointed to on return is destroyed when the PDU is destroyed. 491 * 492 * @param pdu The specified PDU. 493 * @param len Returns the length of the current data 494 * @param data Returns the ptr to the current data 495 * @param offset Returns the offset of the current data from the start of the 496 * body comprising of many blocks (RFC7959) 497 * @param total Returns the total size of the body. 498 * If offset + length < total, then there is more data to follow. 499 * 500 * @return @c 1 if len, data, offset and total are correctly filled in, else 501 * @c 0 if there is no data. 502 */ 503 int coap_get_data_large(const coap_pdu_t *pdu, 504 size_t *len, 505 const uint8_t **data, 506 size_t *offset, 507 size_t *total); 508 509 /** 510 * Gets the PDU code associated with @p pdu. 511 * 512 * @param pdu The PDU object. 513 * 514 * @return The PDU code. 515 */ 516 coap_pdu_code_t coap_pdu_get_code(const coap_pdu_t *pdu); 517 518 /** 519 * Sets the PDU code in the @p pdu. 520 * 521 * @param pdu The PDU object. 522 * @param code The code to set in the PDU. 523 */ 524 void coap_pdu_set_code(coap_pdu_t *pdu, coap_pdu_code_t code); 525 526 /** 527 * Gets the PDU type associated with @p pdu. 528 * 529 * @param pdu The PDU object. 530 * 531 * @return The PDU type. 532 */ 533 coap_pdu_type_t coap_pdu_get_type(const coap_pdu_t *pdu); 534 535 /** 536 * Sets the PDU type in the @p pdu. 537 * 538 * @param pdu The PDU object. 539 * @param type The type to set for the PDU. 540 */ 541 void coap_pdu_set_type(coap_pdu_t *pdu, coap_pdu_type_t type); 542 543 /** 544 * Gets the token associated with @p pdu. 545 * 546 * @param pdu The PDU object. 547 * 548 * @return The token information. 549 */ 550 coap_bin_const_t coap_pdu_get_token(const coap_pdu_t *pdu); 551 552 /** 553 * Gets the message id associated with @p pdu. 554 * 555 * @param pdu The PDU object. 556 * 557 * @return The message id. 558 */ 559 coap_mid_t coap_pdu_get_mid(const coap_pdu_t *pdu); 560 561 /** 562 * Sets the message id in the @p pdu. 563 * 564 * @param pdu The PDU object. 565 * @param mid The message id value to set in the PDU. 566 * 567 */ 568 void coap_pdu_set_mid(coap_pdu_t *pdu, coap_mid_t mid); 569 570 /** @} */ 571 572 #endif /* COAP_PDU_H_ */ 573