1 /* *****************************************************************
3 * Copyright 2016 Samsung Electronics All Rights Reserved.
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 * *****************************************************************/
22 #include "oic_malloc.h"
25 #include "ocpayload.h"
26 #include "pmutility.h"
27 #include "srmutility.h"
28 #include "cacommonutil.h"
29 #include "aclresource.h"
30 #include "ocpayloadcbor.h"
31 #include "payload_logging.h"
34 #define TAG "CLOUD-ACL-ID"
37 * ACL Id parse from received response
39 * @param[in] ctx context
40 * @param[out] data data required to external application
41 * @param[in] response peer response
42 * @return OCStackResult application result
44 static OCStackResult getAclIdFromResponse(void *ctx, void **data, OCClientResponse *response)
47 if (NULL == response->payload)
49 OIC_LOG(ERROR, TAG, "Receive NULL payload");
50 return OC_STACK_INVALID_PARAM;
55 if (!OCRepPayloadGetPropString((const OCRepPayload *)response->payload, OC_RSRVD_ACL_ID, &aclid))
57 OIC_LOG_V(ERROR, TAG, "Can't get: %s", OC_RSRVD_ACL_ID);
58 return OC_STACK_MALFORMED_RESPONSE;
61 OIC_LOG_V(INFO, TAG, "Received Acl id = %s", aclid);
68 * ACL Id by device request received data handler
70 * @param[in] ctx context
71 * @param[out] data data required to external application
72 * @param[in] response peer response
73 * @return OCStackResult application result
75 static OCStackResult handleGetAclIdByDeviceResponse(void *ctx, void **data,
76 OCClientResponse *response)
78 return getAclIdFromResponse(ctx, data, response);
82 * ACL Id create request received data handler
84 * @param[in] ctx context
85 * @param[out] data data required to external application
86 * @param[in] response peer response
87 * @return OCStackResult application result
89 static OCStackResult handleAclIdCreateResponse(void *ctx, void **data, OCClientResponse *response)
91 return getAclIdFromResponse(ctx, data, response);
94 OCStackResult OCCloudGetAclIdByDevice(void* ctx,
96 const OCDevAddr *endPoint,
97 OCCloudResponseCB callback)
99 char uri[MAX_URI_LENGTH] = { 0 };
101 VERIFY_NON_NULL_RET(endPoint, TAG, "NULL endpoint", OC_STACK_INVALID_PARAM);
102 VERIFY_NON_NULL_RET(deviceId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
104 snprintf(uri, MAX_URI_LENGTH, "%s%s:%d%s?%s=%s", DEFAULT_PREFIX,
105 endPoint->addr, endPoint->port, OC_RSRVD_ACL_ID_URL, OC_RSRVD_DEVICE_ID, deviceId);
107 OCCallbackData cbData;
108 fillCallbackData(&cbData, ctx, callback, handleGetAclIdByDeviceResponse, NULL);
110 return OCDoResource(NULL, OC_REST_GET, uri, NULL, NULL,
111 CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
114 OCStackResult OCCloudAclIdCreate(void* ctx,
116 const char *deviceId,
117 const OCDevAddr *endPoint,
118 OCCloudResponseCB callback)
120 char uri[MAX_URI_LENGTH] = { 0 };
122 VERIFY_NON_NULL_RET(endPoint, TAG, "NULL endpoint", OC_STACK_INVALID_PARAM);
123 VERIFY_NON_NULL_RET(ownerId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
124 VERIFY_NON_NULL_RET(deviceId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
126 snprintf(uri, MAX_URI_LENGTH, "%s%s:%d%s?%s=%s&%s=%s", DEFAULT_PREFIX,
127 endPoint->addr, endPoint->port, OC_RSRVD_ACL_ID_URL,
128 OC_RSRVD_OWNER_ID, ownerId, OC_RSRVD_DEVICE_ID, deviceId);
130 OCCallbackData cbData;
131 fillCallbackData(&cbData, ctx, callback, handleAclIdCreateResponse, NULL);
133 return OCDoResource(NULL, OC_REST_PUT, uri, NULL, NULL,
134 CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
137 OCStackResult OCCloudAclIdDelete(void* ctx,
139 const OCDevAddr *endPoint,
140 OCCloudResponseCB callback)
142 char uri[MAX_URI_LENGTH] = { 0 };
144 VERIFY_NON_NULL_RET(endPoint, TAG, "NULL endpoint", OC_STACK_INVALID_PARAM);
145 VERIFY_NON_NULL_RET(aclId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
147 snprintf(uri, MAX_URI_LENGTH, "%s%s:%d%s?%s=%s", DEFAULT_PREFIX,
148 endPoint->addr, endPoint->port, OC_RSRVD_ACL_ID_URL, OC_RSRVD_ACL_ID, aclId);
150 OCCallbackData cbData;
151 fillCallbackData(&cbData, ctx, callback, NULL, NULL);
153 return OCDoResource(NULL, OC_REST_DELETE, uri, NULL, NULL,
154 CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
158 * ACL Get Info received data handler
160 * @param[in] ctx context
161 * @param[out] data data required to external application
162 * @param[in] response peer response
163 * @return OCStackResult application result
165 static OCStackResult handleAclGetInfoResponse(void *ctx, void **data, OCClientResponse *response)
167 OCStackResult result = OC_STACK_OK;
168 uint8_t *cbor = NULL;
174 if (NULL == response->payload)
176 OIC_LOG(ERROR, TAG, "Receive NULL payload\n");
177 return OC_STACK_INVALID_PARAM;
180 result = OCConvertPayload(response->payload, &cbor, &size);
181 if (result != OC_STACK_OK)
183 OIC_LOG(ERROR, TAG, "Can't convert OCPayload to cbor");
187 OicSecAcl_t* acl = CBORPayloadToAcl2(cbor, size);
190 OIC_LOG(ERROR, TAG, "Can't parse CBOR payload");
196 result = InstallNewACL2(acl);
197 if (result != OC_STACK_OK)
199 OIC_LOG(ERROR, TAG, "Can't update ACL resource");
208 OCStackResult OCCloudAclIndividualGetInfo(void* ctx,
210 const OCDevAddr *endPoint,
211 OCCloudResponseCB callback)
213 char uri[MAX_URI_LENGTH] = { 0 };
215 VERIFY_NON_NULL_RET(endPoint, TAG, "NULL endpoint", OC_STACK_INVALID_PARAM);
216 VERIFY_NON_NULL_RET(aclId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
218 snprintf(uri, MAX_URI_LENGTH, "%s%s:%d%s/%s", DEFAULT_PREFIX,
219 endPoint->addr, endPoint->port, OC_RSRVD_ACL_ID_URL, aclId);
221 OCCallbackData cbData;
222 fillCallbackData(&cbData, ctx, callback, handleAclGetInfoResponse, NULL);
224 return OCDoResource(NULL, OC_REST_GET, uri, NULL, NULL,
225 CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
228 OCStackResult OCCloudAclIndividualUpdateAce(void* ctx,
230 const cloudAce_t *aces,
231 const OCDevAddr *endPoint,
232 OCCloudResponseCB callback)
234 size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
235 char uri[MAX_URI_LENGTH] = { 0 };
239 OCRepPayload **helperPayload = NULL;
240 OCRepPayload **helperPayload2 = NULL;
242 VERIFY_NON_NULL_RET(endPoint, TAG, "NULL endpoint", OC_STACK_INVALID_PARAM);
243 VERIFY_NON_NULL_RET(aclId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
244 VERIFY_NON_NULL_RET(aces, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
246 snprintf(uri, MAX_URI_LENGTH, "%s%s:%d%s/%s", DEFAULT_PREFIX,
247 endPoint->addr, endPoint->port, OC_RSRVD_ACL_ID_URL, aclId);
249 OCRepPayload *payload = OCRepPayloadCreate();
252 OIC_LOG_V(DEBUG, TAG, "Can't allocate memory for payload");
256 int acllist_count = 0;
257 //code below duplicates LL_COUNT, implemented in newer version of utlist.h
259 cloudAce_t *ace = (cloudAce_t*)aces;
267 helperPayload = OICCalloc(acllist_count, sizeof(OCRepPayload *));
270 OIC_LOG_V(DEBUG, TAG, "Can't allocate memory for helperPayload");
275 cloudAce_t *ace = NULL;
277 LL_FOREACH((cloudAce_t*)aces, ace)
279 OCRepPayload *payload = OCRepPayloadCreate();
282 OIC_LOG_V(DEBUG, TAG, "Can't allocate memory for helperPayload[i]");
285 helperPayload[i++] = payload;
288 if (OC_STACK_OK != ConvertUuidToStr(&ace->subjectuuid, &uuid))
290 OIC_LOG(ERROR, TAG, "Can't convert subjectuuid to string");
293 OCRepPayloadSetPropString(payload, OC_RSRVD_SUBJECT_UUID, (const char *)uuid);
294 OCRepPayloadSetPropInt(payload, OC_RSRVD_SUBJECT_TYPE, ace->stype);
295 OCRepPayloadSetPropInt(payload, OC_RSRVD_PERMISSION_MASK, ace->permission);
299 int reslist_count = 0;
300 //code below duplicates LL_COUNT, implemented in newer version of utlist.h
302 OicSecRsrc_t *res = ace->resources;
310 helperPayload2 = OICCalloc(reslist_count, sizeof(OCRepPayload *));
317 OicSecRsrc_t *res = NULL;
319 LL_FOREACH(ace->resources, res)
321 OCRepPayload *payload = OCRepPayloadCreate();
324 OIC_LOG_V(DEBUG, TAG, "Can't allocate memory for helperPayload2[j]");
327 helperPayload2[j++] = payload;
329 OCRepPayloadSetPropString(payload, OC_RSRVD_HREF, res->href);
331 dimensions[0] = res->typeLen;
332 OCRepPayloadSetStringArray(payload, OC_RSRVD_RESOURCE_TYPE,
333 (const char **)res->types, dimensions);
335 dimensions[0] = res->interfaceLen;
336 OCRepPayloadSetStringArray(payload, OC_RSRVD_INTERFACE,
337 (const char **)res->interfaces, dimensions);
339 dimensions[0] = reslist_count;
340 OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_RESOURCES,
341 (const OCRepPayload **)helperPayload2, dimensions);
343 dimensions[0] = acllist_count;
344 OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ACCESS_CONTROL_LIST,
345 (const OCRepPayload **)helperPayload, dimensions);
347 OCCallbackData cbData;
348 fillCallbackData(&cbData, ctx, callback, NULL, NULL);
350 OIC_LOG(DEBUG, TAG, "Next payload created:");
351 OIC_LOG_PAYLOAD(DEBUG, (OCPayload *)payload);
353 return OCDoResource(NULL, OC_REST_POST, uri, NULL, (OCPayload *)payload,
354 CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
358 for (int k = 0; k < j; k++) OCRepPayloadDestroy(helperPayload2[k]);
359 OICFree(helperPayload2);
363 for (int k = 0; k < i; k++) OCRepPayloadDestroy(helperPayload[k]);
364 OICFree(helperPayload);
366 OCRepPayloadDestroy(payload);
367 return OC_STACK_NO_MEMORY;
370 OCStackResult OCCloudAclIndividualUpdate(void* ctx,
373 const cloudAce_t *aces,
374 const OCDevAddr *endPoint,
375 OCCloudResponseCB callback)
377 size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
378 char uri[MAX_URI_LENGTH] = { 0 };
382 OCRepPayload **helperPayload = NULL;
383 OCRepPayload **helperPayload2 = NULL;
385 VERIFY_NON_NULL_RET(endPoint, TAG, "NULL endpoint", OC_STACK_INVALID_PARAM);
386 VERIFY_NON_NULL_RET(aclId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
387 VERIFY_NON_NULL_RET(aces, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
389 snprintf(uri, MAX_URI_LENGTH, "%s%s:%d%s/%s?%s=%s", DEFAULT_PREFIX,
390 endPoint->addr, endPoint->port, OC_RSRVD_ACL_ID_URL, aclId,
391 OC_RSRVD_ACE_ID, aceId);
393 OCRepPayload *payload = OCRepPayloadCreate();
396 OIC_LOG_V(DEBUG, TAG, "Can't allocate memory for payload");
400 int acllist_count = 1;
402 helperPayload = OICCalloc(acllist_count, sizeof(OCRepPayload *));
405 OIC_LOG_V(DEBUG, TAG, "Can't allocate memory for helperPayload");
410 cloudAce_t *ace = NULL;
412 LL_FOREACH((cloudAce_t*)aces, ace)
414 OCRepPayload *payload = OCRepPayloadCreate();
417 OIC_LOG_V(DEBUG, TAG, "Can't allocate memory for helperPayload[i]");
420 helperPayload[i++] = payload;
423 if (OC_STACK_OK != ConvertUuidToStr(&ace->subjectuuid, &uuid))
425 OIC_LOG(ERROR, TAG, "Can't convert subjectuuid to string");
428 OCRepPayloadSetPropString(payload, OC_RSRVD_SUBJECT_UUID, (const char *)uuid);
429 OCRepPayloadSetPropInt(payload, OC_RSRVD_SUBJECT_TYPE, ace->stype);
430 OCRepPayloadSetPropInt(payload, OC_RSRVD_PERMISSION_MASK, ace->permission);
434 int reslist_count = 0;
435 //code below duplicates LL_COUNT, implemented in newer version of utlist.h
437 OicSecRsrc_t *res = ace->resources;
445 helperPayload2 = OICCalloc(reslist_count, sizeof(OCRepPayload *));
452 OicSecRsrc_t *res = NULL;
454 LL_FOREACH(ace->resources, res)
456 OCRepPayload *payload = OCRepPayloadCreate();
459 OIC_LOG_V(DEBUG, TAG, "Can't allocate memory for helperPayload2[j]");
462 helperPayload2[j++] = payload;
464 OCRepPayloadSetPropString(payload, OC_RSRVD_HREF, res->href);
466 dimensions[0] = res->typeLen;
467 OCRepPayloadSetStringArray(payload, OC_RSRVD_RESOURCE_TYPE,
468 (const char **)res->types, dimensions);
470 dimensions[0] = res->interfaceLen;
471 OCRepPayloadSetStringArray(payload, OC_RSRVD_INTERFACE,
472 (const char **)res->interfaces, dimensions);
474 dimensions[0] = reslist_count;
475 OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_RESOURCES,
476 (const OCRepPayload **)helperPayload2, dimensions);
478 dimensions[0] = acllist_count;
479 OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ACCESS_CONTROL_LIST,
480 (const OCRepPayload **)helperPayload, dimensions);
482 OCCallbackData cbData;
483 fillCallbackData(&cbData, ctx, callback, NULL, NULL);
485 OIC_LOG(DEBUG, TAG, "Next payload created:");
486 OIC_LOG_PAYLOAD(DEBUG, (OCPayload *)payload);
488 return OCDoResource(NULL, OC_REST_POST, uri, NULL, (OCPayload *)payload,
489 CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
493 for (int k = 0; k < j; k++) OCRepPayloadDestroy(helperPayload2[k]);
494 OICFree(helperPayload2);
498 for (int k = 0; k < i; k++) OCRepPayloadDestroy(helperPayload[k]);
499 OICFree(helperPayload);
501 OCRepPayloadDestroy(payload);
502 return OC_STACK_NO_MEMORY;
507 OCStackResult OCCloudAclIndividualDelete(void* ctx,
509 const OCDevAddr *endPoint,
510 OCCloudResponseCB callback)
512 char uri[MAX_URI_LENGTH] = { 0 };
514 VERIFY_NON_NULL_RET(endPoint, TAG, "NULL endpoint", OC_STACK_INVALID_PARAM);
515 VERIFY_NON_NULL_RET(aclId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
517 snprintf(uri, MAX_URI_LENGTH, "%s%s:%d%s/%s", DEFAULT_PREFIX,
518 endPoint->addr, endPoint->port, OC_RSRVD_ACL_ID_URL, aclId);
520 OCCallbackData cbData;
521 fillCallbackData(&cbData, ctx, callback, NULL, NULL);
523 return OCDoResource(NULL, OC_REST_DELETE, uri, NULL, NULL,
524 CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
527 OCStackResult OCCloudAclIndividualDeleteAce(void* ctx,
530 const OCDevAddr *endPoint,
531 OCCloudResponseCB callback)
533 char uri[MAX_URI_LENGTH] = { 0 };
535 VERIFY_NON_NULL_RET(endPoint, TAG, "NULL endpoint", OC_STACK_INVALID_PARAM);
536 VERIFY_NON_NULL_RET(aclId, TAG, "NULL input param", OC_STACK_INVALID_PARAM);
538 snprintf(uri, MAX_URI_LENGTH, "%s%s:%d%s/%s?%s=%s", DEFAULT_PREFIX,
539 endPoint->addr, endPoint->port, OC_RSRVD_ACL_ID_URL, aclId,
540 OC_RSRVD_ACE_ID, aceId);
542 OCCallbackData cbData;
543 fillCallbackData(&cbData, ctx, callback, NULL, NULL);
545 return OCDoResource(NULL, OC_REST_DELETE, uri, NULL, NULL,
546 CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);