1 //******************************************************************
3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "ocpayloadcbor.h"
23 #include "oic_malloc.h"
25 #include "ocpayload.h"
27 #include "ocresourcehandler.h"
30 #define TAG PCF("OCPayloadConvert")
32 static OCStackResult OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t** outPayload,
34 static OCStackResult OCConvertDevicePayload(OCDevicePayload* payload, uint8_t** outPayload,
36 static OCStackResult OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t** outPayload,
38 static OCStackResult OCConvertRepPayload(OCRepPayload* payload, uint8_t** outPayload, size_t* size);
39 static OCStackResult OCConvertPresencePayload(OCPresencePayload* payload, uint8_t** outPayload,
41 static OCStackResult OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t** outPayload,
44 bool AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
47 bool ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
51 OCStackResult OCConvertPayload(OCPayload* payload, uint8_t** outPayload, size_t* size)
53 OC_LOG_V(INFO, TAG, "Converting payload of type %d", payload->type);
56 case PAYLOAD_TYPE_DISCOVERY:
57 return OCConvertDiscoveryPayload((OCDiscoveryPayload*)payload, outPayload, size);
58 case PAYLOAD_TYPE_DEVICE:
59 return OCConvertDevicePayload((OCDevicePayload*)payload, outPayload, size);
60 case PAYLOAD_TYPE_PLATFORM:
61 return OCConvertPlatformPayload((OCPlatformPayload*)payload, outPayload, size);
62 case PAYLOAD_TYPE_REPRESENTATION:
63 return OCConvertRepPayload((OCRepPayload*)payload, outPayload, size);
64 case PAYLOAD_TYPE_PRESENCE:
65 return OCConvertPresencePayload((OCPresencePayload*)payload, outPayload, size);
66 case PAYLOAD_TYPE_SECURITY:
67 return OCConvertSecurityPayload((OCSecurityPayload*)payload, outPayload, size);
69 OC_LOG_V(INFO,TAG, "ConvertPayload default %d", payload->type);
70 return OC_STACK_NOTIMPL;
74 static OCStackResult OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t** outPayload,
77 *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
78 *size = MAX_REQUEST_LENGTH;
82 return OC_STACK_NO_MEMORY;
88 cbor_encoder_init(&encoder, *outPayload, *size, 0);
90 CborEncoder rootArray;
91 err = err || cbor_encoder_create_array(&encoder, &rootArray, 2);
92 err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_SECURITY);
96 err = err || cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
98 if(payload->securityData)
100 err = err || AddTextStringToMap(&map, OC_RSRVD_REPRESENTATION,
101 sizeof(OC_RSRVD_REPRESENTATION) - 1,
102 payload->securityData);
105 err = err || cbor_encoder_close_container(&rootArray, &map);
107 err = err || cbor_encoder_close_container(&encoder, &rootArray);
111 OC_LOG_V(ERROR, TAG, "Convert Security Payload failed", err);
112 OICFree(*outPayload);
113 return OC_STACK_ERROR;
116 *size = encoder.ptr - *outPayload;
117 uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
121 OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
122 OICFree(*outPayload);
123 return OC_STACK_ERROR;
126 *outPayload = tempPayload;
130 static OCStackResult OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t** outPayload,
133 *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
134 *size = MAX_REQUEST_LENGTH;
138 return OC_STACK_NO_MEMORY;
141 CborEncoder encoder = {0};
143 size_t resourceCount = OCDiscoveryPayloadGetResourceCount(payload);
145 cbor_encoder_init(&encoder, *outPayload, *size, 0);
147 CborEncoder rootArray;
148 err = err || cbor_encoder_create_array(&encoder, &rootArray, 1 + resourceCount);
149 err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_DISCOVERY);
151 for(size_t i = 0; i < resourceCount; ++i)
154 OCResourcePayload* resource = OCDiscoveryPayloadGetResource(payload, i);
158 OICFree(*outPayload);
159 return OC_STACK_INVALID_PARAM;
162 err = err || cbor_encoder_create_map(&rootArray, &map, 3);
164 err = err || AddTextStringToMap(&map, OC_RSRVD_HREF,
165 sizeof(OC_RSRVD_HREF) - 1,
169 err = err || cbor_encode_text_string(&map, OC_RSRVD_SERVER_INSTANCE_ID,
170 sizeof(OC_RSRVD_SERVER_INSTANCE_ID) - 1);
171 err = err || cbor_encode_byte_string(&map, resource->sid, UUID_SIZE);
175 err = err || cbor_encode_text_string(&map, OC_RSRVD_PROPERTY,
176 sizeof(OC_RSRVD_PROPERTY) -1 );
177 err = err || cbor_encoder_create_map(&map, &propMap, 3);
182 err = err || cbor_encode_text_string(&propMap, OC_RSRVD_RESOURCE_TYPE,
183 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
184 err = err || cbor_encoder_create_array(&propMap, &rtArray, CborIndefiniteLength);
186 OCStringLL* rtPtr = resource->types;
189 err = err || cbor_encode_text_string(&rtArray, rtPtr->value,
190 strlen(rtPtr->value));
194 err = err || cbor_encoder_close_container(&propMap, &rtArray);
200 err = err || cbor_encode_text_string(&propMap, OC_RSRVD_INTERFACE,
201 sizeof(OC_RSRVD_INTERFACE) - 1);
202 err = err || cbor_encoder_create_array(&propMap, &ifArray, CborIndefiniteLength);
203 OCStringLL* ifPtr = resource->interfaces;
207 err = err || cbor_encode_text_string(&ifArray, ifPtr->value,
208 strlen(ifPtr->value));
212 err = err || cbor_encoder_close_container(&propMap, &ifArray);
216 CborEncoder policyMap;
217 err = err || cbor_encode_text_string(&propMap, OC_RSRVD_POLICY,
218 sizeof(OC_RSRVD_POLICY) - 1);
219 err = err || cbor_encoder_create_map(&propMap, &policyMap, CborIndefiniteLength);
222 err = err || cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP,
223 sizeof(OC_RSRVD_BITMAP) - 1);
224 err = err || cbor_encode_uint(&policyMap, resource->bitmap);
228 err = err || cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
229 sizeof(OC_RSRVD_SECURE) - 1);
230 err = err || cbor_encode_boolean(&policyMap, OC_RESOURCE_SECURE);
232 if(resource->port != 0)
234 err = err || cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
235 sizeof(OC_RSRVD_HOSTING_PORT) - 1);
236 err = err || cbor_encode_uint(&policyMap, resource->port);
240 err = err || cbor_encoder_close_container(&propMap, &policyMap);
243 err = err || cbor_encoder_close_container(&map, &propMap);
246 err = err || cbor_encoder_close_container(&rootArray, &map);
249 err = err || cbor_encoder_close_container(&encoder, &rootArray);
253 OC_LOG_V(ERROR, TAG, "Convert Discovery Payload failed with : %d", err);
254 return OC_STACK_ERROR;
257 *size = encoder.ptr - *outPayload;
258 uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
262 OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
263 OICFree(*outPayload);
264 return OC_STACK_ERROR;
267 *outPayload = tempPayload;
271 static OCStackResult OCConvertDevicePayload(OCDevicePayload* payload, uint8_t** outPayload,
274 *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
275 *size = MAX_REQUEST_LENGTH;
279 return OC_STACK_NO_MEMORY;
282 CborEncoder encoder = {0};
285 cbor_encoder_init(&encoder, *outPayload, *size, 0);
286 CborEncoder rootArray;
287 err = err || cbor_encoder_create_array(&encoder, &rootArray, 2);
288 err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_DEVICE);
292 err = err || cbor_encoder_create_map(&rootArray, &map, 2);
295 err = err || AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
301 err = err || cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
302 sizeof(OC_RSRVD_REPRESENTATION) - 1);
303 err = err || cbor_encoder_create_map(&map, &repMap, 4);
306 err = err || cbor_encode_text_string(&repMap, OC_RSRVD_DEVICE_ID,
307 sizeof(OC_RSRVD_DEVICE_ID) - 1);
308 err = err || cbor_encode_byte_string(&repMap, payload->sid, UUID_SIZE);
311 err = err || AddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
312 sizeof(OC_RSRVD_DEVICE_NAME) - 1,
313 payload->deviceName);
315 // Device Spec Version
316 err = err || AddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
317 sizeof(OC_RSRVD_SPEC_VERSION) - 1,
318 payload->specVersion);
320 // Device data Model Version
321 err = err || AddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
322 sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1,
323 payload->dataModelVersion);
325 err = err || cbor_encoder_close_container(&map, &repMap);
329 err = err || cbor_encoder_close_container(&rootArray, &map);
333 err = err || cbor_encoder_close_container(&encoder, &rootArray);
337 OC_LOG_V(ERROR, TAG, "Convert Device Payload failed with : %d", err);
338 return OC_STACK_ERROR;
341 *size = encoder.ptr - *outPayload;
342 uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
346 OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
347 OICFree(*outPayload);
348 return OC_STACK_ERROR;
351 *outPayload = tempPayload;
355 static OCStackResult OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t** outPayload,
358 *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
359 *size = MAX_REQUEST_LENGTH;
363 return OC_STACK_NO_MEMORY;
366 CborEncoder encoder = {0};
369 cbor_encoder_init(&encoder, *outPayload, *size, 0);
370 CborEncoder rootArray;
371 err = err || cbor_encoder_create_array(&encoder, &rootArray, 2);
372 err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_PLATFORM);
375 err = err || cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
378 err = err || AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
384 err = err || cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
385 sizeof(OC_RSRVD_REPRESENTATION) - 1);
386 err = err || cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
389 err = err || AddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
390 sizeof(OC_RSRVD_PLATFORM_ID) - 1,
391 payload->info.platformID);
394 err = err || AddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
395 sizeof(OC_RSRVD_MFG_NAME) - 1,
396 payload->info.manufacturerName);
399 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
400 sizeof(OC_RSRVD_MFG_URL) - 1,
401 payload->info.manufacturerUrl);
404 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
405 sizeof(OC_RSRVD_MODEL_NUM) - 1,
406 payload->info.modelNumber);
409 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
410 sizeof(OC_RSRVD_MFG_DATE) - 1,
411 payload->info.dateOfManufacture);
414 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
415 sizeof(OC_RSRVD_PLATFORM_VERSION) - 1,
416 payload->info.platformVersion);
419 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
420 sizeof(OC_RSRVD_OS_VERSION) - 1,
421 payload->info.operatingSystemVersion);
424 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
425 sizeof(OC_RSRVD_HARDWARE_VERSION) - 1,
426 payload->info.hardwareVersion);
429 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
430 sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1,
431 payload->info.firmwareVersion);
434 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
435 sizeof(OC_RSRVD_SUPPORT_URL) - 1,
436 payload->info.supportUrl);
439 err = err || ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
440 sizeof(OC_RSRVD_SYSTEM_TIME) - 1,
441 payload->info.systemTime);
442 err = err || cbor_encoder_close_container(&map, &repMap);
446 err = err || cbor_encoder_close_container(&rootArray, &map);
450 err = err || cbor_encoder_close_container(&encoder, &rootArray);
454 OC_LOG_V(ERROR, TAG, "Convert Platform Payload failed with : %d", err);
455 return OC_STACK_ERROR;
458 *size = encoder.ptr - *outPayload;
459 uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
463 OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
464 OICFree(*outPayload);
465 return OC_STACK_ERROR;
468 *outPayload = tempPayload;
473 static bool OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload);
475 static bool OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray)
480 err = err || cbor_encoder_create_array(parent, &array, CborIndefiniteLength);
481 err = err || cbor_encode_uint(&array, valArray->type);
482 for(int i = 0; i < MAX_REP_ARRAY_DEPTH; ++i)
484 err = err || cbor_encode_uint(&array, valArray->dimensions[i]);
487 size_t dimTotal = calcDimTotal(valArray->dimensions);
489 for(size_t i = 0; i < dimTotal; ++i)
491 switch(valArray->type)
493 case OCREP_PROP_NULL:
494 OC_LOG(ERROR, TAG, PCF("ConvertArray Invalid NULL"));
495 err = CborUnknownError;
498 err = err || cbor_encode_int(&array, valArray->iArray[i]);
500 case OCREP_PROP_DOUBLE:
501 err = err || cbor_encode_double(&array, valArray->dArray[i]);
503 case OCREP_PROP_BOOL:
504 err = err || cbor_encode_boolean(&array, valArray->bArray[i]);
506 case OCREP_PROP_STRING:
507 err = err || cbor_encode_text_string(&array, valArray->strArray[i],
508 strlen(valArray->strArray[i]));
510 case OCREP_PROP_OBJECT:
511 err = OCConvertSingleRepPayload(&array, valArray->objArray[i]);
513 case OCREP_PROP_ARRAY:
514 OC_LOG(ERROR, TAG, PCF("ConvertArray Invalid child array"));
515 err = CborUnknownError;
520 err = err || cbor_encoder_close_container(parent, &array);
524 static bool OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload)
528 err = err || cbor_encoder_create_map(parent, &map, CborIndefiniteLength);
531 err = err || ConditionalAddTextStringToMap(&map, OC_RSRVD_HREF,
532 sizeof(OC_RSRVD_HREF) - 1,
536 // resource types, interfaces
537 if(payload->types || payload->interfaces)
539 OC_LOG_V(INFO, TAG, "Payload has types or interfaces");
540 err = err || cbor_encode_text_string(&map,
542 sizeof(OC_RSRVD_PROPERTY) - 1);
544 err = err || cbor_encoder_create_map(&map, &propMap, 2);
546 CborEncoder curArray;
549 err = err || cbor_encode_text_string(&propMap,
550 OC_RSRVD_RESOURCE_TYPE,
551 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
552 err = err || cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
553 OCStringLL* val = payload->types;
556 err = err || cbor_encode_text_string(&curArray, val->value, strlen(val->value));
559 err = err || cbor_encoder_close_container(&propMap, &curArray);
561 if(payload->interfaces)
563 err = err || cbor_encode_text_string(&propMap,
565 sizeof(OC_RSRVD_INTERFACE) - 1);
566 err = err || cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
567 OCStringLL* val = payload->interfaces;
570 err = err || cbor_encode_text_string(&curArray, val->value, strlen(val->value));
573 err = err || cbor_encoder_close_container(&propMap, &curArray);
575 err = err || cbor_encoder_close_container(&map, &propMap);
581 err = err || cbor_encode_text_string(&map,
582 OC_RSRVD_REPRESENTATION,
583 sizeof(OC_RSRVD_REPRESENTATION) - 1);
584 err = err || cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
585 OCRepPayloadValue* value = payload->values;
588 err = err || cbor_encode_text_string(&repMap,
590 strlen(value->name));
593 case OCREP_PROP_NULL:
594 err = err || cbor_encode_null(&repMap);
597 err = err || cbor_encode_int(&repMap,
600 case OCREP_PROP_DOUBLE:
601 err = err || cbor_encode_double(&repMap,
604 case OCREP_PROP_BOOL:
605 err = err || cbor_encode_boolean(&repMap,
608 case OCREP_PROP_STRING:
609 err = err || cbor_encode_text_string(&repMap,
610 value->str, strlen(value->str));
612 case OCREP_PROP_OBJECT:
613 err = err || OCConvertSingleRepPayload(&repMap, value->obj);
615 case OCREP_PROP_ARRAY:
616 err = err || OCConvertArray(&repMap, &value->arr);
619 OC_LOG_V(ERROR, TAG, "Invalid Prop type: %d",
626 err = err || cbor_encoder_close_container(&map, &repMap);
630 err = err || cbor_encoder_close_container(parent, &map);
635 static OCStackResult OCConvertRepPayload(OCRepPayload* payload, uint8_t** outPayload, size_t* size)
637 *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
638 *size = MAX_REQUEST_LENGTH;
642 return OC_STACK_NO_MEMORY;
645 CborEncoder encoder = {0};
648 cbor_encoder_init(&encoder, *outPayload, *size, 0);
649 CborEncoder rootArray;
650 err = err || cbor_encoder_create_array(&encoder, &rootArray, CborIndefiniteLength);
651 err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_REPRESENTATION);
653 while(payload != NULL && !err)
655 err = err || OCConvertSingleRepPayload(&rootArray, payload);
656 payload = payload->next;
660 err = err || cbor_encoder_close_container(&encoder, &rootArray);
664 OC_LOG_V(ERROR, TAG, "Convert Rep Payload failed with : %d", err);
665 return OC_STACK_ERROR;
668 *size = encoder.ptr - *outPayload;
669 uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
673 OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
674 OICFree(*outPayload);
675 return OC_STACK_ERROR;
678 *outPayload = tempPayload;
683 static OCStackResult OCConvertPresencePayload(OCPresencePayload* payload,
684 uint8_t** outPayload, size_t* size)
686 *outPayload = (uint8_t*)OICCalloc(1, MAX_REQUEST_LENGTH);
687 *size = MAX_REQUEST_LENGTH;
691 return OC_STACK_NO_MEMORY;
694 CborEncoder encoder = {0};
697 cbor_encoder_init(&encoder, *outPayload, *size, 0);
698 CborEncoder rootArray;
700 err = err || cbor_encoder_create_array(&encoder, &rootArray, 2);
701 err = err || cbor_encode_uint(&rootArray, PAYLOAD_TYPE_PRESENCE);
705 err = err || cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
708 err = err || cbor_encode_text_string(&map,
710 sizeof(OC_RSRVD_NONCE) - 1);
711 err = err || cbor_encode_uint(&map, payload->sequenceNumber);
714 err = err || cbor_encode_text_string(&map,
716 sizeof(OC_RSRVD_TTL) - 1);
717 err = err || cbor_encode_uint(&map, payload->maxAge);
720 const char* triggerStr = convertTriggerEnumToString(payload->trigger);
721 err = err || AddTextStringToMap(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1,
724 // Resource type name
725 if(payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
727 err = err || ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
728 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
732 err = err || cbor_encoder_close_container(&rootArray, &map);
733 err = err || cbor_encoder_close_container(&encoder, &rootArray);
737 OC_LOG_V(ERROR, TAG, "Convert Presence Payload failed with : %d", err);
738 return OC_STACK_ERROR;
741 *size = encoder.ptr - *outPayload;
742 uint8_t* tempPayload = (uint8_t*)OICRealloc(*outPayload, *size);
746 OC_LOG_V(ERROR, TAG, PCF("Payload realloc failed!"));
747 OICFree(*outPayload);
748 return OC_STACK_ERROR;
751 *outPayload = tempPayload;
756 bool AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
759 return cbor_encode_text_string(map, key, keylen) ||
760 cbor_encode_text_string(map, value, strlen(value));
763 bool ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
766 return value ? AddTextStringToMap(map, key, keylen, value) : false;