1 //******************************************************************
3 // Copyright 2015 Samsung Electronics 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 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
20 #include "rdpayload.h"
22 #include "oic_malloc.h"
23 #include "oic_string.h"
26 #include "ocpayload.h"
27 #include "payload_logging.h"
29 #define TAG "OCRDPayload"
31 #define CBOR_ROOT_ARRAY_LENGTH 1
33 static CborError FindStringInMap(CborValue *map, char *tags, char **value);
34 static CborError FindIntInMap(CborValue *map, char *tags, uint64_t *value);
35 static CborError FindStringLLInMap(const CborValue *linksMap, char *tag, OCStringLL **links);
36 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen, const char *value);
37 static int64_t ConditionalAddIntToMap(CborEncoder *map, const char *tags, const size_t size, const uint64_t *value);
38 static int64_t AddStringLLToMap(CborEncoder *map, char *tag, const size_t size, OCStringLL *value);
40 int64_t OCRDPayloadToCbor(const OCRDPayload *rdPayload, uint8_t *outPayload, size_t *size)
42 if (!outPayload || !size)
44 OC_LOG(ERROR, TAG, "Invalid parameters.");
45 return OC_STACK_INVALID_PARAM;
50 cbor_encoder_init(&encoder, outPayload, *size, flags);
52 CborEncoder rootArray;
53 CborError cborEncoderResult;
54 cborEncoderResult = cbor_encoder_create_array(&encoder, &rootArray, CBOR_ROOT_ARRAY_LENGTH);
55 if (CborNoError != cborEncoderResult)
57 OC_LOG(ERROR, TAG, "Failed creating cbor array.");
61 if (rdPayload->rdDiscovery)
64 cborEncoderResult = cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
65 if (CborNoError != cborEncoderResult)
67 OC_LOG(ERROR, TAG, "Failed creating discovery map.");
70 if (CborNoError != ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_NAME,
71 sizeof(OC_RSRVD_DEVICE_NAME) - 1, (char *)rdPayload->rdDiscovery->n.deviceName))
73 OC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_DEVICE_NAME.");
76 if (CborNoError != ConditionalAddTextStringToMap(&map, OC_RSRVD_DEVICE_ID,
77 sizeof(OC_RSRVD_DEVICE_ID) - 1, (char *)rdPayload->rdDiscovery->di.id))
79 OC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_DEVICE_ID.");
82 uint64_t sel = (uint8_t) rdPayload->rdDiscovery->sel;
83 if (CborNoError != ConditionalAddIntToMap(&map, OC_RSRVD_RD_DISCOVERY_SEL,
84 sizeof(OC_RSRVD_RD_DISCOVERY_SEL) - 1, &sel))
86 OC_LOG(ERROR, TAG, "Failed setting OC_RSRVD_RD_DISCOVERY_SEL.");
89 cborEncoderResult = cbor_encoder_close_container(&rootArray, &map);
90 if (CborNoError != cborEncoderResult)
92 OC_LOG(ERROR, TAG, "Failed closing discovery map.");
96 else if (rdPayload->rdPublish)
99 cborEncoderResult = cbor_encoder_create_array(&rootArray, &colArray, CborIndefiniteLength);
100 if (CborNoError != cborEncoderResult)
102 OC_LOG(ERROR, TAG, "Failed creating collection array.");
106 OCResourceCollectionPayload *rdPublish = rdPayload->rdPublish;
109 if (OC_STACK_OK != OCTagsPayloadToCbor(rdPublish->tags, &colArray))
111 OC_LOG(ERROR, TAG, "Failed creating tags payload.");
114 if (OC_STACK_OK != OCLinksPayloadToCbor(rdPublish->setLinks, &colArray))
116 OC_LOG(ERROR, TAG, "Failed creating links payload.");
119 rdPublish = rdPublish->next;
121 cborEncoderResult = cbor_encoder_close_container(&rootArray, &colArray);
122 if (CborNoError != cborEncoderResult)
124 OC_LOG(ERROR, TAG, "Failed closing collection array.");
128 cborEncoderResult = cbor_encoder_close_container(&encoder, &rootArray);
129 if (CborNoError != cborEncoderResult)
131 OC_LOG(ERROR, TAG, "Failed closing root array container. ");
135 *size = encoder.ptr - outPayload;
140 return OC_STACK_ERROR;
143 OCStackResult OCTagsPayloadToCbor(OCTagsPayload *tags, CborEncoder *setMap)
146 CborError cborEncoderResult = cbor_encoder_create_map(setMap, &tagsMap, CborIndefiniteLength);
147 if (CborNoError != cborEncoderResult)
149 OC_LOG(ERROR, TAG, "Failed creating TAGS map.");
150 return OC_STACK_ERROR;
153 if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_NAME,
154 sizeof(OC_RSRVD_DEVICE_NAME) - 1, (char *)tags->n.deviceName))
156 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DEVICE_NAME in TAGS map.");
157 return OC_STACK_ERROR;
159 if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DEVICE_ID,
160 sizeof(OC_RSRVD_DEVICE_ID) - 1, (char *)tags->di.id))
162 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DEVICE_ID in TAGS map.");
163 return OC_STACK_ERROR;
165 if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_RTS,
166 sizeof(OC_RSRVD_RTS) - 1, (char *)tags->rts))
168 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_RTS in TAGS map.");
169 return OC_STACK_ERROR;
171 if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_DREL,
172 sizeof(OC_RSRVD_DREL) - 1, (char *)tags->drel))
174 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_DREL in TAGS map.");
175 return OC_STACK_ERROR;
177 if (CborNoError != ConditionalAddTextStringToMap(&tagsMap, OC_RSRVD_BASE_URI,
178 sizeof(OC_RSRVD_BASE_URI) - 1, (char *)tags->baseURI))
180 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_BASE_URI in TAGS map.");
181 return OC_STACK_ERROR;
183 uint64_t temp = (uint64_t)tags->bitmap;
184 if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_BITMAP,
185 sizeof(OC_RSRVD_BITMAP) - 1, &temp))
187 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_BITMAP in TAGS map.");
188 return OC_STACK_ERROR;
190 temp = (uint64_t)tags->port;
191 if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_HOSTING_PORT,
192 sizeof(OC_RSRVD_HOSTING_PORT) - 1, &temp))
194 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_HOSTING_PORT in TAGS map.");
195 return OC_STACK_ERROR;
197 temp = (uint64_t)tags->ins;
198 if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_INS,
199 sizeof(OC_RSRVD_INS) - 1, &temp))
201 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INS in TAGS map.");
202 return OC_STACK_ERROR;
204 temp = (uint64_t)tags->ttl;
205 if (CborNoError != ConditionalAddIntToMap(&tagsMap, OC_RSRVD_TTL,
206 sizeof(OC_RSRVD_TTL) - 1, &temp))
208 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_TTL in TAGS map.");
209 return OC_STACK_ERROR;
211 cborEncoderResult = cbor_encoder_close_container(setMap, &tagsMap);
212 if (CborNoError != cborEncoderResult)
214 OC_LOG(ERROR, TAG, "Failed closing TAGS map.");
215 return OC_STACK_ERROR;
220 OCStackResult OCLinksPayloadToCbor(OCLinksPayload *rtPtr, CborEncoder *setMap)
222 CborEncoder linksArray;
223 CborError cborEncoderResult;
225 cborEncoderResult = cbor_encoder_create_array(setMap, &linksArray, CborIndefiniteLength);
226 if (CborNoError != cborEncoderResult)
228 OC_LOG(ERROR, TAG, "Failed creating LINKS array.");
229 return OC_STACK_ERROR;
233 CborEncoder linksMap;
234 cborEncoderResult = cbor_encoder_create_map(&linksArray, &linksMap,
235 CborIndefiniteLength);
236 if (CborNoError != cborEncoderResult)
238 OC_LOG(ERROR, TAG, "Failed creating LINKS map.");
239 return OC_STACK_ERROR;
241 if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_HREF,
242 sizeof(OC_RSRVD_HREF) - 1, rtPtr->href))
244 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_HREF in LINKS map.");
245 return OC_STACK_ERROR;
247 if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_REL,
248 sizeof(OC_RSRVD_REL) - 1, rtPtr->rel))
250 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_REL in LINKS map.");
251 return OC_STACK_ERROR;
253 if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_TITLE,
254 sizeof(OC_RSRVD_TITLE) - 1, rtPtr->title))
256 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_TITLE in LINKS map.");
257 return OC_STACK_ERROR;
259 if (CborNoError != ConditionalAddTextStringToMap(&linksMap, OC_RSRVD_URI,
260 sizeof(OC_RSRVD_URI) - 1, rtPtr->uri))
262 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_URI in LINKS map.");
263 return OC_STACK_ERROR;
265 if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_RESOURCE_TYPE,
266 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, rtPtr->rt))
268 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_RESOURCE_TYPE in LINKS map.");
269 return OC_STACK_ERROR;
271 if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_INTERFACE,
272 sizeof(OC_RSRVD_INTERFACE) - 1, rtPtr->itf))
274 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INTERFACE in LINKS map.");
275 return OC_STACK_ERROR;
277 if (CborNoError != AddStringLLToMap(&linksMap, OC_RSRVD_MEDIA_TYPE,
278 sizeof(OC_RSRVD_MEDIA_TYPE) - 1, rtPtr->mt))
280 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_MEDIA_TYPE in LINKS map.");
281 return OC_STACK_ERROR;
283 uint64_t temp = (uint64_t)rtPtr->ins;
284 if (CborNoError != ConditionalAddIntToMap(&linksMap, OC_RSRVD_INS,
285 sizeof(OC_RSRVD_INS) - 1, &temp))
287 OC_LOG(ERROR, TAG, "Failed adding OC_RSRVD_INS in LINKS map.");
288 return OC_STACK_ERROR;
290 cborEncoderResult = cbor_encoder_close_container(&linksArray, &linksMap);
291 if (CborNoError != cborEncoderResult)
293 OC_LOG(ERROR, TAG, "Failed closing LINKS map.");
294 return OC_STACK_ERROR;
298 cborEncoderResult = cbor_encoder_close_container(setMap, &linksArray);
299 if (CborNoError != cborEncoderResult)
301 OC_LOG(ERROR, TAG, "Failed closing LINKS array.");
302 return OC_STACK_ERROR;;
307 OCStackResult OCRDCborToPayload(const CborValue *cborPayload, OCPayload **outPayload)
309 CborValue *rdCBORPayload = (CborValue *)cborPayload;
310 CborError cborFindResult;
312 OCRDPayload *rdPayload = OCRDPayloadCreate();
318 if (cbor_value_is_array(rdCBORPayload))
320 OCLinksPayload *linksPayload = NULL;
321 OCTagsPayload *tagsPayload = NULL;
323 while (cbor_value_is_container(rdCBORPayload))
327 cborFindResult = cbor_value_enter_container(rdCBORPayload, &tags);
328 if (cborFindResult != CborNoError)
332 if (OC_STACK_OK != OCTagsCborToPayload(&tags, &tagsPayload))
334 OCFreeTagsResource(tagsPayload);
337 OCTagsLog(DEBUG, tagsPayload);
338 if (OC_STACK_OK != OCLinksCborToPayload(&tags, &linksPayload))
340 OCFreeLinksResource(linksPayload);
341 OCFreeTagsResource(tagsPayload);
344 OCLinksLog(DEBUG, linksPayload);
345 // Move from tags payload to links array.
346 if (CborNoError != cbor_value_advance(rdCBORPayload))
348 OC_LOG(DEBUG, TAG, "Failed advancing from tags payload to links.");
349 OCFreeLinksResource(linksPayload);
350 OCFreeTagsResource(tagsPayload);
354 rdPayload->rdPublish = OCCopyCollectionResource(tagsPayload, linksPayload);
355 if (!rdPayload->rdPublish)
360 else if (cbor_value_is_map(rdCBORPayload))
363 if (CborNoError != FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_NAME, &name))
368 if (CborNoError != FindStringInMap(rdCBORPayload, OC_RSRVD_DEVICE_ID, &id))
372 uint64_t biasFactor = 0;
373 if (CborNoError != FindIntInMap(rdCBORPayload, OC_RSRVD_RD_DISCOVERY_SEL, &biasFactor))
377 rdPayload->rdDiscovery = OCRDDiscoveryPayloadCreate(name, id, (uint8_t)biasFactor);
378 if (!rdPayload->rdDiscovery)
384 cborFindResult = cbor_value_advance(rdCBORPayload);
385 if (CborNoError != cborFindResult)
390 OC_LOG_PAYLOAD(DEBUG, (OCPayload *) rdPayload);
391 *outPayload = (OCPayload *)rdPayload;
394 OC_LOG(ERROR, TAG, "Failed allocating memory.");
395 OCRDPayloadDestroy(rdPayload);
396 return OC_STACK_NO_MEMORY;
399 OCRDPayloadDestroy(rdPayload);
400 return OC_STACK_ERROR;
403 static CborError FindStringInMap(CborValue *map, char *tags, char **value)
407 CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal);
408 if (CborNoError == cborFindResult && cbor_value_is_text_string(&curVal))
410 cborFindResult = cbor_value_dup_text_string(&curVal, value, &len, NULL);
411 if (CborNoError != cborFindResult)
413 OC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags);
414 return cborFindResult;
420 static CborError FindIntInMap(CborValue *map, char *tags, uint64_t *value)
423 CborError cborFindResult = cbor_value_map_find_value(map, tags, &curVal);
424 if (CborNoError == cborFindResult && cbor_value_is_unsigned_integer(&curVal))
426 cborFindResult = cbor_value_get_uint64(&curVal, value);
427 if (CborNoError != cborFindResult)
429 OC_LOG_V(ERROR, TAG, "Failed finding value for tag %s .", tags);
430 return cborFindResult;
436 static CborError FindStringLLInMap(const CborValue *linksMap, char *tag, OCStringLL **links)
439 CborError cborFindResult;
441 cborFindResult = cbor_value_map_find_value(linksMap, tag, &rtArray);
442 if (CborNoError != cborFindResult)
444 return CborUnknownError;
447 cborFindResult = cbor_value_enter_container(&rtArray, &rtVal);
448 if (CborNoError != cborFindResult)
450 return CborUnknownError;
452 OCStringLL* llPtr = *links;
453 while (cbor_value_is_text_string(&rtVal))
457 llPtr = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
460 return CborUnknownError;
470 llPtr->next = (OCStringLL *)OICCalloc(1, sizeof(OCStringLL));
473 return CborUnknownError;
476 cborFindResult = cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL);
477 if (CborNoError != cborFindResult)
479 return CborUnknownError;
481 cborFindResult = cbor_value_advance(&rtVal);
482 if (CborNoError != cborFindResult)
484 return CborUnknownError;
488 cborFindResult = cbor_value_leave_container(&rtArray, &rtVal);
489 return cborFindResult;
492 OCStackResult OCTagsCborToPayload(CborValue *tagsMap, OCTagsPayload **tagsPayload)
494 OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
497 return OC_STACK_NO_MEMORY;
499 if (cbor_value_is_map(tagsMap))
501 if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DEVICE_NAME, &tags->n.deviceName))
503 OCFreeTagsResource(tags);
504 return OC_STACK_ERROR;
506 if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DREL, &tags->drel))
508 OCFreeTagsResource(tags);
509 return OC_STACK_ERROR;
511 if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_RTS, &tags->rts))
513 OCFreeTagsResource(tags);
514 return OC_STACK_ERROR;
516 if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_BASE_URI, &tags->baseURI))
518 OCFreeTagsResource(tags);
519 return OC_STACK_ERROR;
522 if (CborNoError != FindStringInMap(tagsMap, OC_RSRVD_DEVICE_ID, &id))
524 OCFreeTagsResource(tags);
525 return OC_STACK_ERROR;
529 OICStrcpy((char*)tags->di.id, MAX_IDENTITY_SIZE, id);
530 tags->di.id_length = MAX_IDENTITY_SIZE;
534 if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_HOSTING_PORT, &temp))
536 OCFreeTagsResource(tags);
537 return OC_STACK_ERROR;
539 tags->port = (uint16_t) temp;
540 if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_BITMAP, &temp))
542 OCFreeTagsResource(tags);
543 return OC_STACK_ERROR;
545 tags->bitmap = (uint8_t) temp;
546 if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_INS, &temp))
548 OCFreeTagsResource(tags);
549 return OC_STACK_ERROR;
551 tags->ins = (uint8_t) temp;
552 if (CborNoError != FindIntInMap(tagsMap, OC_RSRVD_TTL, &temp))
554 OCFreeTagsResource(tags);
555 return OC_STACK_ERROR;
557 tags->ttl = (uint32_t) temp;
559 if (CborNoError != cbor_value_advance(tagsMap))
561 OCFreeTagsResource(tags);
562 return OC_STACK_ERROR;
569 OCStackResult OCLinksCborToPayload(CborValue *linksArray, OCLinksPayload **linksPayload)
572 CborError cborFindResult = cbor_value_enter_container(linksArray, &linksMap);
573 if (CborNoError != cborFindResult)
575 OC_LOG(ERROR, TAG, "Failed enter links map");
576 return OC_STACK_ERROR;
579 while (cbor_value_is_map(&linksMap))
581 OCLinksPayload *setLinks = (OCLinksPayload *)OICCalloc(1, sizeof(OCLinksPayload));
584 OC_LOG(ERROR, TAG, "Failed allocating memory.");
585 OCFreeLinksResource(*linksPayload);
586 return OC_STACK_NO_MEMORY;
588 cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_HREF, &setLinks->href);
589 if (CborNoError != cborFindResult)
591 OCFreeLinksResource(*linksPayload);
592 OCFreeLinksResource(setLinks);
593 return OC_STACK_ERROR;
595 cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_REL, &setLinks->rel);
596 if (CborNoError != cborFindResult)
598 OCFreeLinksResource(*linksPayload);
599 OCFreeLinksResource(setLinks);
600 return OC_STACK_ERROR;
603 cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_TITLE, &setLinks->title);
604 if (CborNoError != cborFindResult)
606 OCFreeLinksResource(*linksPayload);
607 OCFreeLinksResource(setLinks);
608 return OC_STACK_ERROR;
610 cborFindResult = FindStringInMap(&linksMap, OC_RSRVD_URI, &setLinks->uri);
611 if (CborNoError != cborFindResult)
613 OCFreeLinksResource(*linksPayload);
614 OCFreeLinksResource(setLinks);
615 return OC_STACK_ERROR;
617 cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_RESOURCE_TYPE, &setLinks->rt);
618 if (CborNoError != cborFindResult)
620 OCFreeLinksResource(*linksPayload);
621 OCFreeLinksResource(setLinks);
622 return OC_STACK_ERROR;
624 cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_INTERFACE, &setLinks->itf);
625 if (CborNoError != cborFindResult)
627 OCFreeLinksResource(*linksPayload);
628 OCFreeLinksResource(setLinks);
629 return OC_STACK_ERROR;
631 cborFindResult = FindStringLLInMap(&linksMap, OC_RSRVD_MEDIA_TYPE, &setLinks->mt);
632 if (CborNoError != cborFindResult)
634 OCFreeLinksResource(*linksPayload);
635 OCFreeLinksResource(setLinks);
636 return OC_STACK_ERROR;
639 cborFindResult = FindIntInMap(&linksMap, OC_RSRVD_INS, &temp);
640 if (CborNoError != cborFindResult)
642 OCFreeLinksResource(*linksPayload);
643 OCFreeLinksResource(setLinks);
644 return OC_STACK_ERROR;
646 setLinks->ins = (uint8_t) temp;
650 *linksPayload = setLinks;
654 OCLinksPayload *temp = *linksPayload;
659 temp->next = setLinks;
661 cborFindResult = cbor_value_advance(&linksMap);
662 if (CborNoError != cborFindResult)
664 OC_LOG(ERROR, TAG, "Failed advancing links map");
665 OCFreeLinksResource(*linksPayload);
666 OCFreeLinksResource(setLinks);
667 return OC_STACK_ERROR;
673 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
676 return cbor_encode_text_string(map, key, keylen) |
677 cbor_encode_text_string(map, value, strlen(value));
680 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
683 return value ? AddTextStringToMap(map, key, keylen, value) : 0;
686 static int64_t ConditionalAddIntToMap(CborEncoder *map, const char *tags, const size_t size,
687 const uint64_t *value)
689 return (*value) ? (cbor_encode_text_string(map, tags, size) |
690 cbor_encode_uint(map, *value)): 0;
693 static int64_t AddStringLLToMap(CborEncoder *map, char *tag, const size_t size, OCStringLL *value)
696 CborError cborEncoderResult;
697 cborEncoderResult = cbor_encode_text_string(map, tag, size);
698 if (CborNoError != cborEncoderResult)
700 return cborEncoderResult;
702 cborEncoderResult = cbor_encoder_create_array(map, &array, CborIndefiniteLength);
703 if (CborNoError != cborEncoderResult)
705 return cborEncoderResult;
707 OCStringLL *strType = value;
710 cborEncoderResult = cbor_encode_text_string(&array, strType->value, strlen(strType->value));
711 if (CborNoError != cborEncoderResult)
713 return cborEncoderResult;
715 strType = strType->next;
717 cborEncoderResult = cbor_encoder_close_container(map, &array);
718 if (CborNoError != cborEncoderResult)
720 return cborEncoderResult;
722 return cborEncoderResult;
725 OCRDPayload *OCRDPayloadCreate()
727 OCRDPayload *rdPayload = (OCRDPayload *)OICCalloc(1, sizeof(OCRDPayload));
734 rdPayload->base.type = PAYLOAD_TYPE_RD;
739 OCRDDiscoveryPayload *OCRDDiscoveryPayloadCreate(const char *deviceName, const char *id, int biasFactor)
741 OCRDDiscoveryPayload *discoveryPayload = (OCRDDiscoveryPayload *)OICCalloc(1, sizeof(OCRDDiscoveryPayload));
743 if (!discoveryPayload)
750 discoveryPayload->n.deviceName = OICStrdup(deviceName);
751 if (!discoveryPayload->n.deviceName)
753 OICFree(discoveryPayload);
759 OICStrcpy((char*)discoveryPayload->di.id, MAX_IDENTITY_SIZE, id);
762 discoveryPayload->sel = biasFactor;
764 return discoveryPayload;
767 void OCRDPayloadDestroy(OCRDPayload *payload)
774 if (payload->rdDiscovery)
776 if (payload->rdDiscovery->n.deviceName)
778 OICFree(payload->rdDiscovery->n.deviceName);
780 OICFree(payload->rdDiscovery);
783 if (payload->rdPublish)
785 for (OCResourceCollectionPayload *col = payload->rdPublish; col; )
789 OCFreeLinksResource(col->setLinks);
794 OCFreeTagsResource(col->tags);
796 OCResourceCollectionPayload *temp = col->next;
805 OCTagsPayload* OCCopyTagsResources(const char *deviceName, const unsigned char *id, const char *baseURI,
806 uint8_t bitmap, uint16_t port, uint8_t ins, const char *rts,const char *drel, uint32_t ttl)
808 OCTagsPayload *tags = (OCTagsPayload *)OICCalloc(1, sizeof(OCTagsPayload));
815 tags->n.deviceName = OICStrdup(deviceName);
816 if (!tags->n.deviceName)
818 goto memory_allocation_failed;
823 OICStrcpy((char*)tags->di.id, MAX_IDENTITY_SIZE, (char *)id);
826 goto memory_allocation_failed;
831 tags->baseURI = OICStrdup(baseURI);
834 goto memory_allocation_failed;
837 tags->bitmap = bitmap;
842 tags->rts = OICStrdup(rts);
845 goto memory_allocation_failed;
850 tags->drel = OICStrdup(drel);
853 goto memory_allocation_failed;
859 memory_allocation_failed:
860 OC_LOG(ERROR, TAG, "Memory allocation failed.");
861 OCFreeTagsResource(tags);
865 OCLinksPayload* OCCopyLinksResources(const char *href, OCStringLL *rt, OCStringLL *itf,
866 const char *rel, bool obs, const char *title, const char *uri, uint8_t ins, OCStringLL *mt)
868 OCLinksPayload *links = (OCLinksPayload *)OICCalloc(1, sizeof(OCLinksPayload));
871 OC_LOG(ERROR, TAG, "Failed allocating memory.");
876 links->href = OICStrdup(href);
879 goto memory_allocation_failed;
884 links->rt = CloneOCStringLL(rt);
887 goto memory_allocation_failed;
892 links->itf = CloneOCStringLL(itf);
895 goto memory_allocation_failed;
900 links->rel = OICStrdup(rel);
903 goto memory_allocation_failed;
909 links->title = OICStrdup(title);
912 goto memory_allocation_failed;
917 links->uri = OICStrdup(uri);
920 goto memory_allocation_failed;
926 links->mt = CloneOCStringLL(mt);
929 goto memory_allocation_failed;
935 memory_allocation_failed:
936 OC_LOG(ERROR, TAG, "Memory allocation failed.");
937 OCFreeLinksResource(links);
941 void OCLinksAddResource(OCDiscoveryPayload *payload, const char *href, OCStringLL *rt,
942 OCStringLL *itf, const char *rel, bool obs, const char *title, const char *uri,
943 uint8_t ins, OCStringLL *mt)
945 if(!payload->collectionResources->setLinks)
947 payload->collectionResources->setLinks =
948 OCCopyLinksResources(href, rt, itf, rel, obs, title, uri, ins, mt);
952 OCLinksPayload *p = payload->collectionResources->setLinks;
957 p->next = OCCopyLinksResources(href, rt, itf, rel, obs, title, uri, ins, mt);
961 OCResourceCollectionPayload* OCCopyCollectionResource(OCTagsPayload *tags, OCLinksPayload *links)
967 OCResourceCollectionPayload *pl = (OCResourceCollectionPayload *)OICCalloc(1, sizeof(OCResourceCollectionPayload));
970 OC_LOG(ERROR, TAG, "Failed allocating memory for the OCResourceCollectionPayload.");
974 pl->setLinks = links;
979 OCStackResult OCDiscoveryCollectionPayloadAddResource(OCDiscoveryPayload *payload, OCTagsPayload *tags, OCLinksPayload *links)
981 OCResourceCollectionPayload* res = OCCopyCollectionResource(tags, links);
984 return OC_STACK_NO_MEMORY;
986 if(!payload->collectionResources)
988 payload->collectionResources = res;
992 OCResourceCollectionPayload *p = payload->collectionResources;
1002 void OCFreeLinksResource(OCLinksPayload *payload)
1008 OICFree(payload->href);
1009 OCFreeOCStringLL(payload->rt);
1010 OCFreeOCStringLL(payload->itf);
1011 OICFree(payload->rel);
1012 OICFree(payload->title);
1013 OICFree(payload->uri);
1014 OCFreeOCStringLL(payload->mt);
1015 OCFreeLinksResource(payload->next);
1019 void OCFreeTagsResource(OCTagsPayload *payload)
1025 OICFree(payload->n.deviceName);
1026 OICFree(payload->baseURI);
1027 OICFree(payload->rts);
1028 OICFree(payload->drel);
1032 void OCFreeCollectionResource(OCResourceCollectionPayload *payload)
1040 OCFreeTagsResource(payload->tags);
1042 if (payload->setLinks)
1044 OCFreeLinksResource(payload->setLinks);
1046 OCFreeCollectionResource(payload->next);
1050 void OCDiscoveryCollectionPayloadDestroy(OCDiscoveryPayload* payload)
1057 OCFreeCollectionResource(payload->collectionResources);
1062 void OCTagsLog(const LogLevel level, const OCTagsPayload *tags)
1066 if (tags->n.deviceName)
1068 OC_LOG_V(level, TAG, " Device Name : %s ",tags->n.deviceName);
1072 OC_LOG_V(level, TAG, " Base URI : %s ",tags->baseURI);
1074 OC_LOG_V(level, TAG, " Device ID : %s ",tags->di.id);
1075 OC_LOG_V(level, TAG, " Bitmap : %d ",tags->bitmap);
1076 OC_LOG_V(level, TAG, " Port : %d ",tags->port);
1077 OC_LOG_V(level, TAG, " Ins : %d ",tags->ins);
1078 OC_LOG_V(level, TAG, " Ttl : %d ",tags->ttl);
1082 OC_LOG_V(level, TAG, " RTS : %s ",tags->rts);
1086 OC_LOG_V(level, TAG, " DREL : %s ",tags->drel);
1091 void OCLinksLog(const LogLevel level, const OCLinksPayload *links)
1097 OC_LOG_V(level, TAG, " href: %s ",links->href);
1099 OC_LOG(level, TAG, " RT: ");
1100 OCStringLL *rt = links->rt;
1105 OC_LOG_V(level, TAG, " %s", rt->value);
1109 OC_LOG(level, TAG, " IF: ");
1110 OCStringLL *itf = links->itf;
1115 OC_LOG_V(level, TAG, " %s", itf->value);
1119 OC_LOG(level, TAG, " MT: ");
1120 OCStringLL *mt = links->mt;
1125 OC_LOG_V(level, TAG, " %s", mt->value);
1129 OC_LOG_V(level, TAG, " INS: %d", links->ins);
1130 OC_LOG_V(level, TAG, " OBS: %d", links->obs);
1133 OC_LOG_V(level, TAG, " REL: %s", links->rel);
1137 OC_LOG_V(level, TAG, " TITLE: %s", links->title);
1141 OC_LOG_V(level, TAG, " URI: %s", links->uri);
1143 links = links->next;