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 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
23 #include "oic_malloc.h"
24 #include "ocpayload.h"
25 #include "payload_logging.h"
26 #include "psinterface.h"
27 #include "resourcemanager.h"
29 #include "srmresourcestrings.h"
30 #include "srmutility.h"
31 #include "amaclresource.h"
33 #define TAG "SRM-AMACL"
35 /** Default cbor payload size. This value is increased in case of CborErrorOutOfMemory.
36 * The value of payload size is increased until reaching belox max cbor size. */
37 static const uint16_t CBOR_SIZE = 1024;
39 /* Max cbor size payload. */
40 static const uint16_t CBOR_MAX_SIZE = 4400;
42 /** AMACL Map size - Number of mandatory items. */
43 static const uint8_t AMACL_MAP_SIZE = 3;
44 static const uint8_t AMACL_RSRC_MAP_SIZE = 1;
45 static const uint8_t AMACL_RLIST_MAP_SIZE = 3;
47 static OicSecAmacl_t *gAmacl = NULL;
48 static OCResourceHandle gAmaclHandle = NULL;
50 void DeleteAmaclList(OicSecAmacl_t* amacl)
54 OicSecAmacl_t *amaclTmp1 = NULL, *amaclTmp2 = NULL;
55 LL_FOREACH_SAFE(amacl, amaclTmp1, amaclTmp2)
57 LL_DELETE(amacl, amaclTmp1);
60 for (size_t i = 0; i < amaclTmp1->resourcesLen; i++)
62 OICFree(amaclTmp1->resources[i]);
64 OICFree(amaclTmp1->resources);
67 OICFree(amaclTmp1->amss);
69 // Clean Amacl node itself
75 static size_t OicSecAmaclCount(const OicSecAmacl_t *secAmacl)
78 for (const OicSecAmacl_t *amacl = secAmacl; amacl; amacl = amacl->next)
85 OCStackResult AmaclToCBORPayload(const OicSecAmacl_t *amaclS, uint8_t **cborPayload,
88 if (NULL == amaclS || NULL == cborPayload || NULL != *cborPayload || NULL == cborSize)
90 return OC_STACK_INVALID_PARAM;
93 OCStackResult ret = OC_STACK_ERROR;
94 size_t cborLen = *cborSize;
103 CborEncoder encoder = { {.ptr = NULL }, .end = 0 };
104 CborEncoder amaclMap = { {.ptr = NULL }, .end = 0 };
105 int64_t cborEncoderResult = CborNoError;
106 CborEncoder rsrcMap = { {.ptr = NULL }, .end = 0 };
107 CborEncoder rlistArray = { {.ptr = NULL }, .end = 0 };
108 CborEncoder amss = { {.ptr = NULL }, .end = 0 };
109 char *stRowner = NULL;
111 const OicSecAmacl_t *amacl = amaclS;
112 uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen);
113 VERIFY_NON_NULL(TAG, outPayload, ERROR);
114 cbor_encoder_init(&encoder, outPayload, cborLen, 0);
117 cborEncoderResult = cbor_encoder_create_map(&encoder, &amaclMap, AMACL_MAP_SIZE);
118 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding AMACL Map.");
120 // resources -- Mandatory
121 cborEncoderResult = cbor_encode_text_string(&amaclMap, OIC_JSON_RESOURCES_NAME,
122 strlen(OIC_JSON_RESOURCES_NAME));
123 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding Resource Name Tag.");
125 cborEncoderResult = cbor_encoder_create_map(&amaclMap, &rsrcMap, AMACL_RSRC_MAP_SIZE);
126 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding Resource Map.");
129 cborEncoderResult = cbor_encode_text_string(&rsrcMap, OIC_JSON_RLIST_NAME,
130 strlen(OIC_JSON_RLIST_NAME));
131 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding RLIST Name Tag.");
133 // TODO : Need to input array length by OicSecAmacl_t->resources->rlistLen based on spec.
134 cborEncoderResult = cbor_encoder_create_array(&rsrcMap, &rlistArray, amacl->resourcesLen);
135 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding RLIST Array.");
137 // TODO : Need to add OicSecAmacl_t->rlist as array rMap based on RAML spec.
138 for (size_t i = 0; i < amacl->resourcesLen; i++)
140 // TODO : Need to create rMap structure based on RAML spec.
141 CborEncoder rMap = { {.ptr = NULL }, .end = 0 };
142 cborEncoderResult = cbor_encoder_create_map(&rlistArray, &rMap, AMACL_RLIST_MAP_SIZE);
143 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding RLIST Map.");
145 cborEncoderResult = cbor_encode_text_string(&rMap, OIC_JSON_HREF_NAME,
146 strlen(OIC_JSON_HREF_NAME));
147 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding HREF Name Tag.");
148 cborEncoderResult = cbor_encode_text_string(&rMap, amacl->resources[i],
149 strlen(amacl->resources[i]));
150 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding HREF Value in Map.");
152 cborEncoderResult = cbor_encode_text_string(&rMap, OIC_JSON_RT_NAME,
153 strlen(OIC_JSON_RT_NAME));
154 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding RT Name Tag.");
156 // TODO : Need to assign real value of RT
157 cborEncoderResult = cbor_encode_text_string(&rMap, OIC_JSON_EMPTY_STRING,
158 strlen(OIC_JSON_EMPTY_STRING));
159 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding RT Value.");
161 cborEncoderResult = cbor_encode_text_string(&rMap, OIC_JSON_IF_NAME,
162 strlen(OIC_JSON_IF_NAME));
163 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding IF Name Tag.");
165 // TODO : Need to assign real value of IF
166 cborEncoderResult = cbor_encode_text_string(&rMap, OIC_JSON_EMPTY_STRING,
167 strlen(OIC_JSON_EMPTY_STRING));
168 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding IF Value.");
170 cborEncoderResult = cbor_encoder_close_container(&rlistArray, &rMap);
171 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing RLIST Array.");
174 cborEncoderResult = cbor_encoder_close_container(&rsrcMap, &rlistArray);
175 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing RLIST Array.");
178 cborEncoderResult = cbor_encoder_close_container(&amaclMap, &rsrcMap);
179 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Resource Map.");
181 // TODO : Need to modify type of OicSecAmacl_t->amss based on RAML spec.
183 cborEncoderResult = cbor_encode_text_string(&amaclMap, OIC_JSON_AMS_NAME,
184 strlen(OIC_JSON_AMS_NAME));
185 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding AMSS Name Tag.");
187 cborEncoderResult = cbor_encoder_create_array(&amaclMap, &amss, amacl->amssLen);
188 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding AMS Name Array.");
189 for (size_t i = 0; i < amacl->amssLen; i++)
191 cborEncoderResult = cbor_encode_text_string(&amss, (const char *)amacl->amss[i].id,
192 sizeof(amacl->amss[i].id));
193 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding AMS Name Value.");
195 cborEncoderResult = cbor_encoder_close_container(&amaclMap, &amss);
196 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing AMSS Array.");
198 // TODO : Need to check owner property in the RAML spec.
199 // rowner -- Mandatory
200 cborEncoderResult = cbor_encode_text_string(&amaclMap, OIC_JSON_ROWNERID_NAME,
201 strlen(OIC_JSON_ROWNERID_NAME));
202 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding ROwnerID Name Tag.");
204 ret = ConvertUuidToStr(&amacl->rownerID, &stRowner);
205 VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
206 cborEncoderResult = cbor_encode_text_string(&amaclMap, stRowner, strlen(stRowner));
207 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding ROwner Value.");
210 cborEncoderResult = cbor_encoder_close_container(&encoder, &amaclMap);
211 VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Amacl Map.");
213 if (CborNoError == cborEncoderResult)
215 *cborPayload = outPayload;
216 *cborSize = encoder.ptr - outPayload;
221 if ((CborErrorOutOfMemory == cborEncoderResult) && (cborLen < CBOR_MAX_SIZE))
223 // reallocate and try again!
226 // Since the allocated initial memory failed, double the memory.
227 cborLen += encoder.ptr - encoder.end;
228 cborEncoderResult = CborNoError;
229 ret = AmaclToCBORPayload(amaclS, cborPayload, &cborLen);
230 if (OC_STACK_OK == ret)
237 if (CborNoError != cborEncoderResult || ret != OC_STACK_OK)
243 ret = OC_STACK_ERROR;
249 OCStackResult CBORPayloadToAmacl(const uint8_t *cborPayload, size_t size,
250 OicSecAmacl_t **secAmacl)
252 if (NULL == cborPayload || NULL == secAmacl || NULL != *secAmacl)
254 return OC_STACK_INVALID_PARAM;
259 OCStackResult ret = OC_STACK_ERROR;
261 CborValue amaclCbor = { .parser = NULL };
262 CborParser parser = { .end = NULL };
263 CborError cborFindResult = CborNoError;
269 cbor_parser_init(cborPayload, cborLen, 0, &parser, &amaclCbor);
271 OicSecAmacl_t *headAmacl = (OicSecAmacl_t *)OICCalloc(1, sizeof(OicSecAmacl_t));
273 CborValue amaclMap = { .parser = NULL };
274 cborFindResult = cbor_value_enter_container(&amaclCbor, &amaclMap);
275 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering Amacl Map.");
277 while(cbor_value_is_valid(&amaclMap))
281 cborFindResult = cbor_value_dup_text_string(&amaclMap, &name, &len, NULL);
282 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Amacl Data Name Tag.");
283 cborFindResult = cbor_value_advance(&amaclMap);
284 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Amacl Data Value.");
286 //CborType type = cbor_value_get_type(&amaclMap);
288 // Resources -- Mandatory
289 if (0 == strcmp(OIC_JSON_RESOURCES_NAME, name))
292 CborValue rsrcMap = { .parser = NULL };
293 cborFindResult = cbor_value_enter_container(&amaclMap, &rsrcMap);
294 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering Resource Map");
296 while(cbor_value_is_valid(&rsrcMap))
299 char *rsrcName = NULL;
300 size_t rsrcNameLen = 0;
301 cborFindResult = cbor_value_dup_text_string(&rsrcMap, &rsrcName, &rsrcNameLen, NULL);
302 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Resource Data Name Tag.");
303 cborFindResult = cbor_value_advance(&rsrcMap);
304 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Resource Data Value.");
307 if (0 == strcmp(OIC_JSON_RLIST_NAME, rsrcName))
310 // TODO : Need to assign array length to OicSecAmacl_t->resources->rlistLen based of RAML spec.
311 cborFindResult = cbor_value_get_array_length(&rsrcMap, &headAmacl->resourcesLen);
312 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Rlist Array Len.");
314 CborValue rsrcArray = { .parser = NULL };
317 cborFindResult = cbor_value_enter_container(&rsrcMap, &rsrcArray);
318 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering Rlist Array");
320 // TODO : Need to check data structure of OicSecAmacl_t based on RAML spec.
321 headAmacl->resources = (char **) OICCalloc(headAmacl->resourcesLen, sizeof(*headAmacl->resources));
322 VERIFY_NON_NULL(TAG, headAmacl->resources, ERROR);
324 while (cbor_value_is_valid(&rsrcArray))
327 CborValue rMap = { .parser = NULL };
328 cborFindResult = cbor_value_enter_container(&rsrcArray, &rMap);
329 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering Rlist Map");
331 while(cbor_value_is_valid(&rMap))
333 char *rMapName = NULL;
334 size_t rMapNameLen = 0;
335 cborFindResult = cbor_value_dup_text_string(&rMap, &rMapName, &rMapNameLen, NULL);
336 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding RMap Data Name Tag.");
337 cborFindResult = cbor_value_advance(&rMap);
338 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding RMap Data Value.");
341 if (0 == strcmp(OIC_JSON_HREF_NAME, rMapName))
343 // TODO : Need to check data structure of OicSecAmacl_t based on RAML spec.
344 cborFindResult = cbor_value_dup_text_string(&rMap, &headAmacl->resources[i++], &len, NULL);
345 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Href Value.");
349 if (0 == strcmp(OIC_JSON_RT_NAME, rMapName))
351 // TODO : Need to check data structure of OicSecAmacl_t and assign based on RAML spec.
353 cborFindResult = cbor_value_dup_text_string(&rMap, &rtData, &len, NULL);
354 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding RT Value.");
359 if (0 == strcmp(OIC_JSON_IF_NAME, rMapName))
361 // TODO : Need to check data structure of OicSecAmacl_t and assign based on RAML spec.
363 cborFindResult = cbor_value_dup_text_string(&rMap, &ifData, &len, NULL);
364 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding IF Value.");
368 if (cbor_value_is_valid(&rMap))
370 cborFindResult = cbor_value_advance(&rMap);
371 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Rlist Map.");
376 if (cbor_value_is_valid(&rsrcArray))
378 cborFindResult = cbor_value_advance(&rsrcArray);
379 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Resource Array.");
384 if (cbor_value_is_valid(&rsrcMap))
386 cborFindResult = cbor_value_advance(&rsrcMap);
387 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Resource Map.");
394 // TODO : Need to modify type of OicSecAmacl_t->amss based on RAML spec.
396 if (0 == strcmp(OIC_JSON_AMS_NAME, name))
399 CborValue amsArray = { .parser = NULL };
400 cborFindResult = cbor_value_get_array_length(&amaclMap, &headAmacl->amssLen);
401 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding AMS Array Len.");
402 cborFindResult = cbor_value_enter_container(&amaclMap, &amsArray);
403 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering AMS Array Container.");
404 headAmacl->amss = (OicUuid_t *)OICCalloc(headAmacl->amssLen, sizeof(*headAmacl->amss));
405 VERIFY_NON_NULL(TAG, headAmacl->amss, ERROR);
406 while (cbor_value_is_valid(&amsArray))
409 cborFindResult = cbor_value_dup_text_string(&amsArray, &amssId, &len, NULL);
410 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding AMS Id.");
411 cborFindResult = cbor_value_advance(&amsArray);
412 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing AMS.");
413 memcpy(headAmacl->amss[i++].id, (OicUuid_t *)amssId, len);
418 // Rowner -- Mandatory
419 if (0 == strcmp(OIC_JSON_ROWNERID_NAME, name))
421 char *stRowner = NULL;
422 cborFindResult = cbor_value_dup_text_string(&amaclMap, &stRowner, &len, NULL);
423 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding ROwner Value.");
425 ret = ConvertStrToUuid(stRowner, &headAmacl->rownerID);
426 VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
430 //if (CborMapType != type && cbor_value_is_valid(&amaclMap))
431 if (cbor_value_is_valid(&amaclMap))
433 cborFindResult = cbor_value_advance(&amaclMap);
434 VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Amacl Map.");
439 *secAmacl = headAmacl;
443 if (CborNoError != cborFindResult)
445 DeleteAmaclList(headAmacl);
448 ret = OC_STACK_ERROR;
453 static OCEntityHandlerResult HandleAmaclGetRequest (const OCEntityHandlerRequest * ehRequest)
455 // Convert Amacl data into JSON for transmission
457 uint8_t *cborPayload = NULL;
458 OCStackResult res = AmaclToCBORPayload(gAmacl, &cborPayload, &size);
460 OCEntityHandlerResult ehRet = (res == OC_STACK_OK) ? OC_EH_OK : OC_EH_ERROR;
462 // Send response payload to request originator
463 SendSRMCBORResponse(ehRequest, ehRet, cborPayload, size);
465 OICFree(cborPayload);
467 OIC_LOG_V (DEBUG, TAG, "%s RetVal %d", __func__ , ehRet);
471 static OCEntityHandlerResult HandleAmaclPostRequest (const OCEntityHandlerRequest * ehRequest)
473 OCEntityHandlerResult ehRet = OC_EH_ERROR;
475 // Convert CBOR Amacl data into binary. This will also validate the Amacl data received.
476 uint8_t *payload = ((OCSecurityPayload *) ehRequest->payload)->securityData1;
477 size_t size = ((OCSecurityPayload *) ehRequest->payload)->payloadSize;
480 OicSecAmacl_t *newAmacl = NULL;
481 OCStackResult res = CBORPayloadToAmacl(payload, size, &newAmacl);
482 if (newAmacl && OC_STACK_OK == res)
484 // Append the new Amacl to existing Amacl
485 LL_APPEND(gAmacl, newAmacl);
487 // Convert Amacl data into JSON for update to persistent storage.
488 uint8_t *cborPayload = NULL;
489 res = AmaclToCBORPayload(gAmacl, &cborPayload, &size);
490 if (cborPayload && (OC_STACK_OK == res) &&
491 (OC_STACK_OK == UpdateSecureResourceInPS(OIC_JSON_AMACL_NAME, cborPayload, size)))
493 ehRet = OC_EH_RESOURCE_CREATED;
495 OICFree(cborPayload);
500 // Send payload to request originator
501 SendSRMCBORResponse(ehRequest, ehRet, NULL, 0);
503 OIC_LOG_V(DEBUG, TAG, "%s RetVal %d", __func__ , ehRet);
508 * This internal method is the entity handler for Amacl resources and
509 * will handle REST request (GET/PUT/POST/DEL) for them.
511 static OCEntityHandlerResult AmaclEntityHandler (OCEntityHandlerFlag flag,
512 OCEntityHandlerRequest * ehRequest,
513 void* callbackParameter)
515 (void) callbackParameter;
516 OCEntityHandlerResult ehRet = OC_EH_ERROR;
523 if (flag & OC_REQUEST_FLAG)
525 OIC_LOG (DEBUG, TAG, "Flag includes OC_REQUEST_FLAG");
526 switch (ehRequest->method)
529 ehRet = HandleAmaclGetRequest(ehRequest);
533 ehRet = HandleAmaclPostRequest(ehRequest);
538 SendSRMCBORResponse(ehRequest, ehRet, NULL, 0);
546 * This internal method is used to create '/oic/sec/amacl' resource.
548 static OCStackResult CreateAmaclResource()
550 OCStackResult ret = OCCreateResource(&gAmaclHandle,
551 OIC_RSRC_TYPE_SEC_AMACL,
558 if (OC_STACK_OK != ret)
560 OIC_LOG (FATAL, TAG, "Unable to instantiate Amacl resource");
561 DeInitAmaclResource();
566 OCStackResult InitAmaclResource()
568 OCStackResult ret = OC_STACK_ERROR;
570 uint8_t *data = NULL;
572 ret = GetSecureVirtualDatabaseFromPS(OIC_JSON_AMACL_NAME, &data, &size);
574 // If database read failed
575 if (OC_STACK_OK != ret)
577 OIC_LOG(DEBUG, TAG, "ReadSVDataFromPS failed");
581 // Read AMACL resource from PS
582 ret = CBORPayloadToAmacl(data, size, &gAmacl);
583 if (OC_STACK_OK != ret)
585 OIC_LOG(DEBUG, TAG, "ReadAMACLresourcefromPS failed");
590 // Instantiate 'oic/sec/amacl' resource
591 ret = CreateAmaclResource();
593 if (OC_STACK_OK != ret)
595 DeInitAmaclResource();
600 void DeInitAmaclResource()
602 OCDeleteResource(gAmaclHandle);
605 DeleteAmaclList(gAmacl);
609 OCStackResult AmaclGetAmsDeviceId(const char *resource, OicUuid_t *amsDeviceId)
611 OicSecAmacl_t *amacl = NULL;
613 VERIFY_NON_NULL(TAG, resource, ERROR);
614 VERIFY_NON_NULL(TAG, amsDeviceId, ERROR);
616 LL_FOREACH(gAmacl, amacl)
618 for(size_t i = 0; i < amacl->resourcesLen; i++)
620 if (0 == strncmp((amacl->resources[i]), resource, strlen(amacl->resources[i])))
622 //Returning the ID of the first AMS service for the resource
623 memcpy(amsDeviceId, &amacl->amss[0], sizeof(*amsDeviceId));
630 return OC_STACK_ERROR;
634 OCStackResult SetAmaclRownerId(const OicUuid_t* newROwner)
636 OCStackResult ret = OC_STACK_ERROR;
637 uint8_t *cborPayload = NULL;
639 OicUuid_t prevId = {.id={0}};
641 if(NULL == newROwner)
643 ret = OC_STACK_INVALID_PARAM;
647 ret = OC_STACK_NO_RESOURCE;
650 if(newROwner && gAmacl)
652 memcpy(prevId.id, gAmacl->rownerID.id, sizeof(prevId.id));
653 memcpy(gAmacl->rownerID.id, newROwner->id, sizeof(newROwner->id));
655 ret = AmaclToCBORPayload(gAmacl, &cborPayload, &size);
656 VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
658 ret = UpdateSecureResourceInPS(OIC_JSON_AMACL_NAME, cborPayload, size);
659 VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
661 OICFree(cborPayload);
667 OICFree(cborPayload);
668 memcpy(gAmacl->rownerID.id, prevId.id, sizeof(prevId.id));