2 * //******************************************************************
4 * // Copyright 2016 Samsung Electronics All Rights Reserved.
6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
8 * // Licensed under the Apache License, Version 2.0 (the "License");
9 * // you may not use this file except in compliance with the License.
10 * // You may obtain a copy of the License at
12 * // http://www.apache.org/licenses/LICENSE-2.0
14 * // Unless required by applicable law or agreed to in writing, software
15 * // distributed under the License is distributed on an "AS IS" BASIS,
16 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * // See the License for the specific language governing permissions and
18 * // limitations under the License.
20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
24 #include "occloudprovisioning.h"
25 #include "OCCloudProvisioning.h"
26 #include "oic_malloc.h"
27 #include "oic_string.h"
30 #define TAG "CLOUD-WRAPPER"
32 #define MAX_ID_LENGTH (64)
33 #define MAX_STRING_LENGTH (256)
35 #define UUID_EXAMPLE_1 "9cfbeb8e-5a1e-4d1c-9d01-2ae6fdb"
36 #define UUID_EXAMPLE_2 "123e4567-e89b-12d3-a456-4266554"
37 #define UUID_EXAMPLE_3 "987e6543-e21b-12d3-a456-4266554"
38 #define SUBJECT_ID_EXAMPLE "72616E64-5069-6E44-6576-557569643030"
40 #define ACL_ID_EXAMPLE "0f3d9f7fe5491d54077d"
41 #define ACE_ID_EXAMPLE "a0001"
43 #define ID_EXAMPLE_1 "78f98b4f25f21e2487e8"
44 #define ID_EXAMPLE_2 "6caa7009386290fd3681"
46 #define RESOURCE_URI_EXAMPLE "/a/light/0"
47 #define RESOURCE_TYPE_EXAMPLE "core.light"
48 #define INTERFACE_EXAMPLE "oic.if.baseline"
50 //in case of optional parameters absence should be sent NULL
51 #define OPTIONAL(str) (str[0] ? str : NULL)
55 static bool readOptional(const char* description)
57 if (NULL == description)
62 printf("Do you want to Enter %s (y/n):\n", description);
72 case 'y': return true;
73 case 'n': return false;
74 default: printf("Wrong value entered. Please press 'y' or 'n'\n");
81 * Read user input (expect string value)
83 * @param[out] item string item to fill
84 * @param[in] length max allowed string length
85 * @param[in] description item description
86 * @param[in] example item example
88 void readString(char* item, int length, const char* description, const char* example)
90 printf("Enter %s (f.e. %s):\n", description, example);
92 snprintf(temp, sizeof(temp), "%%%ds", length - 1);
98 * Read user input (expect string value, but it is optional and can be skipped by user)
100 * @param[out] item string item to fill
101 * @param[in] length max allowed string length
102 * @param[in] description item description
103 * @param[in] example item example
105 static void readOptionalString(char* item, int length, const char* description, const char* example)
107 if (readOptional(description))
109 readString(item, length, description, example);
114 * Read user input (expect integer value)
116 * @param[out] item integer item to fill
117 * @param[in] description item description
118 * @param[in] example item example
120 void readInteger(int* item, const char* description, const char* example)
122 printf("Enter %s (f.e. %s):\n", description, example);
128 * Read user input (expect array of strings)
130 * @param[out] list array of strings structure
131 * @param[in] length max allowed array item length
132 * @param[in] description whole array description
133 * @param[in] example array item example
135 static void readStringArray(stringArray_t *list, int length, const char* description, const char* example)
139 char hint[MAX_STRING_LENGTH] = { 0 };
141 snprintf(hint, sizeof(hint), "%s items count", description);
142 readInteger(&count, hint, "2");
151 item = (char**)OICCalloc(count, sizeof(char*));
158 for (i = 0; i < count; i++)
160 item[i] = (char*)OICCalloc(length, sizeof(char));
167 snprintf(hint, sizeof(hint), "%s %d item", description, i + 1);
168 readString(item[i], length, hint, example);
171 list->length = (size_t)count;
175 //free already allocated memory here
176 for (int k = 0; k < i; k++)
184 * Read user input (expect array of strings)
185 * It is optional and can be skipped by user.
187 * @param[out] list array of strings structure
188 * @param[in] length max allowed array item length
189 * @param[in] description whole array description
190 * @param[in] example array item example
192 static void readOptionalStringArray(stringArray_t *list, int length, const char* description, const char* example)
194 if (readOptional(description))
196 readStringArray(list, length, description, example);
201 * Copies whole binary file to crl variable
203 * @param[in] list array of strings structure
204 * @param[out] crl byte array to fill
205 * @return negative error code
207 static int ReadFile(const char *name, OCByteString *crl)
211 uint8_t *buffer = NULL;
216 file = fopen(name, "rb");
219 OIC_LOG_V(ERROR, TAG, "Unable to open file %s", name);
224 result = fseek(file, 0, SEEK_END);
227 OIC_LOG(ERROR, TAG, "Failed to SEEK_END");
231 length = ftell(file);
234 OIC_LOG(ERROR, TAG, "Failed to ftell");
238 result = fseek(file, 0, SEEK_SET);
241 OIC_LOG(ERROR, TAG, "Failed to SEEK_SET");
246 buffer = (uint8_t *)malloc(length);
249 OIC_LOG(ERROR, TAG, "Failed to allocate buffer");
253 //Read file contents into buffer
254 realLen = fread(buffer, length, 1, file);
255 if (realLen != (size_t)length)
257 OIC_LOG_V(ERROR, TAG, "Length mismatch: read %zu instead of %d bytes", realLen, length);
262 crl->len = (size_t)length;
270 OCStackResult OCWrapperCertificateIssueRequest(OCCloudProvisioning& ptr, ResponseCallBack callback)
272 return ptr.requestCertificate(callback);
275 OCStackResult OCWrapperGetCRL(OCCloudProvisioning& ptr, ResponseCallBack callback)
277 return ptr.getCRL(callback);
280 OCStackResult OCWrapperPostCRL(OCCloudProvisioning& ptr, ResponseCallBack callback)
282 OCStackResult result = OC_STACK_ERROR;
283 OCByteString crlData = {0, 0};
284 char filename[64] = {0};
285 char thisUpdate[16] = { 0 };
286 char nextUpdate[16] = { 0 };
287 stringArray_t serialNumbers = {0, 0};
288 stringArray_t *rcsn = 0;
289 OCByteString *crl = 0;
291 readString(thisUpdate, sizeof(thisUpdate), "Crl's thisUpdate value", "20160727000000");
292 readString(nextUpdate, sizeof(nextUpdate), "Crl's nextUpdate value", "20161027000000");
293 readOptionalStringArray(&serialNumbers, 16, "Revoked serial numbers", "1234");
295 if (NULL == serialNumbers.array)
297 readString(filename, sizeof(filename),
298 "filename from which binary Crl in DER format will be read", "crl");
300 if (ReadFile(filename, &crlData))
302 printf("Can't read crl from file %s\n", filename);
306 rcsn = serialNumbers.array? &serialNumbers : NULL;
307 crl = crlData.bytes? &crlData : NULL;
309 result = ptr.postCRL(thisUpdate, nextUpdate, crl, rcsn,
312 clearStringArray(&serialNumbers);
313 OICFree(crlData.bytes);
318 OCStackResult OCWrapperAclIdGetByDevice(OCCloudProvisioning& ptr, AclIdResponseCallBack callback)
320 char di[MAX_ID_LENGTH] = { 0 };
322 readString(di, sizeof(di), "device id", UUID_EXAMPLE_1);
324 return ptr.getAclIdByDevice(di, callback);
327 OCStackResult OCWrapperAclIdCreate(const OCDevAddr *endPoint, OCCloudResponseCB callback)
329 char oid[MAX_ID_LENGTH] = { 0 };
330 char di[MAX_ID_LENGTH] = { 0 };
332 readString(oid, sizeof(oid), "owner id", UUID_EXAMPLE_2);
333 readString(di, sizeof(di), "device id", UUID_EXAMPLE_1);
335 return OCCloudAclIdCreate(NULL, oid, di, endPoint, callback);
338 OCStackResult OCWrapperAclIdDelete(const OCDevAddr *endPoint, OCCloudResponseCB callback)
340 char aclid[MAX_ID_LENGTH] = { 0 };
342 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
344 return OCCloudAclIdDelete(NULL, aclid, endPoint, callback);
347 OCStackResult OCWrapperAclIndividualGetInfo(OCCloudProvisioning& ptr, ResponseCallBack callback)
349 char aclid[MAX_ID_LENGTH] = { 0 };
351 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
353 return ptr.getIndividualAclInfo(aclid, callback);
356 OCStackResult OCWrapperAclIndividualUpdateAce(const OCDevAddr *endPoint, OCCloudResponseCB callback)
358 OCStackResult result = OC_STACK_NO_MEMORY;
360 cloudAce_t *aces = NULL;
362 char aclid[MAX_ID_LENGTH] = { 0 };
363 readString(aclid, sizeof(aclid), "ace id", ACL_ID_EXAMPLE);
365 int acllist_count = 0;
366 readInteger(&acllist_count, "acl list count", "1");
367 if (0 >= acllist_count)
369 OIC_LOG(ERROR, TAG, "Wrong number of aclList");
373 aces = (cloudAce_t*)OICCalloc(acllist_count, sizeof(cloudAce_t));
376 OIC_LOG(ERROR, TAG, "Can't allocate memory for aces");
380 for (i = 0; i < acllist_count; i++)
382 cloudAce_t *ace = &aces[i];
383 if (i != acllist_count - 1) ace->next = &aces[i + 1];
385 char aceid[MAX_ID_LENGTH] = { 0 };
386 char subjectuuid[MAX_ID_LENGTH] = { 0 };
390 readString(aceid, sizeof(aceid), "ace id", ACE_ID_EXAMPLE);
391 readString(subjectuuid, sizeof(subjectuuid), "subjectuuid", SUBJECT_ID_EXAMPLE);
392 readInteger(&stype, "subject type", "0 – Device, 1 – User, 2 - Group");
393 readInteger(&permission, "permission", "6");
395 ace->aceId = OICStrdup(aceid);
397 ace->permission = permission;
398 memcpy(&ace->subjectuuid, subjectuuid, sizeof(OicUuid_t));
400 int reslist_count = 0;
401 readInteger(&reslist_count, "resources list count", "1");
403 ace->resources = (OicSecRsrc_t*)OICCalloc(reslist_count, sizeof(OicSecRsrc_t));
406 OIC_LOG(ERROR, TAG, "Can't allocate memory for resources");
410 for (j = 0; j < reslist_count; j++)
412 OicSecRsrc_t *res = &ace->resources[j];
413 if (j != reslist_count - 1) res->next = &ace->resources[j + 1];
415 char href[32] = { 0 };
416 readString(href, sizeof(href), "href", RESOURCE_URI_EXAMPLE);
418 stringArray_t rt = {0, 0};
419 readStringArray(&rt, MAX_ID_LENGTH, "resource type", RESOURCE_TYPE_EXAMPLE);
421 stringArray_t _if = {0, 0};
422 readStringArray(&_if, MAX_ID_LENGTH, "interface", INTERFACE_EXAMPLE);
424 res->href = OICStrdup(href);
425 res->types = rt.array;
426 res->typeLen = rt.length;
427 res->interfaces = _if.array;
428 res->interfaceLen = _if.length;
432 result = OCCloudAclIndividualUpdateAce(NULL, aclid, aces, endPoint, callback);
436 for (int k = 0; k < i; k++)
438 cloudAce_t *ace = &aces[k];
443 for (int l = 0; l < j; l++)
445 OicSecRsrc_t *res = &ace->resources[l];
448 stringArray_t rt { res->types, res->typeLen};
449 clearStringArray(&rt);
451 stringArray_t _if {res->interfaces, res->interfaceLen};
452 clearStringArray(&_if);
461 OCStackResult OCWrapperAclIndividualDelete(const OCDevAddr *endPoint, OCCloudResponseCB callback)
463 char aclid[MAX_ID_LENGTH] = { 0 };
465 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
467 return OCCloudAclIndividualDelete(NULL, aclid, endPoint, callback);
470 OCStackResult OCWrapperAclCreateGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
472 char gtype[16] = { 0 };
473 char gmid[MAX_ID_LENGTH] = { 0 };
475 readString(gtype, sizeof(gtype), "Group type value", "Public");
476 readOptionalString(gmid, sizeof(gmid), "group member id value", UUID_EXAMPLE_2);
478 return OCCloudAclCreateGroup(NULL, gtype, OPTIONAL(gmid), endPoint, callback);
481 OCStackResult OCWrapperAclFindMyGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
483 char mid[MAX_ID_LENGTH] = { 0 };
485 readOptionalString(mid, sizeof(mid), "member id value", UUID_EXAMPLE_2);
487 return OCCloudAclFindMyGroup(NULL, OPTIONAL(mid), endPoint, callback);
490 OCStackResult OCWrapperAclDeleteGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
492 char gid[MAX_ID_LENGTH] = { 0 };
493 char gmid[MAX_ID_LENGTH] = { 0 };
495 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
497 readOptionalString(gmid, sizeof(gmid), "group member id value", UUID_EXAMPLE_2);
499 return OCCloudAclDeleteGroup(NULL, gid, OPTIONAL(gmid), endPoint, callback);
502 OCStackResult OCWrapperAclJoinToInvitedGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
504 char gid[MAX_ID_LENGTH] = { 0 };
506 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
508 return OCCloudAclJoinToInvitedGroup(NULL, gid, endPoint, callback);
511 OCStackResult OCWrapperAclObserveGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
513 char gid[MAX_ID_LENGTH] = { 0 };
515 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
517 return OCCloudAclObserveGroup(NULL, gid, endPoint, callback);
520 OCStackResult OCWrapperAclShareDeviceIntoGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
522 OCStackResult result = OC_STACK_NO_MEMORY;
523 char gid[MAX_ID_LENGTH] = { 0 };
524 stringArray_t midlist = {0,0};
525 stringArray_t dilist = {0,0};
527 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
529 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
531 readStringArray(&dilist, MAX_ID_LENGTH, "device list", UUID_EXAMPLE_1);
533 result = OCCloudAclShareDeviceIntoGroup(NULL, gid, &midlist, &dilist, endPoint, callback);
535 clearStringArray(&midlist);
536 clearStringArray(&dilist);
541 OCStackResult OCWrapperAclDeleteDeviceFromGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
543 OCStackResult result = OC_STACK_NO_MEMORY;
544 char gid[MAX_ID_LENGTH] = { 0 };
545 stringArray_t midlist = {0,0};
546 stringArray_t dilist = {0,0};
548 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
550 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
552 readStringArray(&dilist, MAX_ID_LENGTH, "device list", UUID_EXAMPLE_1);
554 result = OCCloudAclDeleteDeviceFromGroup(NULL, gid, &midlist, &dilist, endPoint, callback);
556 clearStringArray(&midlist);
557 clearStringArray(&dilist);
562 OCStackResult OCWrapperAclGroupGetInfo(const OCDevAddr *endPoint, OCCloudResponseCB callback)
564 char gid[MAX_ID_LENGTH] = { 0 };
565 char mid[MAX_ID_LENGTH] = { 0 };
567 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
569 readOptionalString(mid, sizeof(mid), "member id value", UUID_EXAMPLE_2);
571 return OCCloudAclGroupGetInfo(NULL, gid, OPTIONAL(mid), endPoint, callback);
574 OCStackResult OCWrapperAclInviteUser(const OCDevAddr *endPoint, OCCloudResponseCB callback)
576 OCStackResult result = OC_STACK_NO_MEMORY;
577 char uid[MAX_ID_LENGTH] = { 0 };
578 stringArray_t midlist = {0,0};
579 stringArray_t gidlist = {0,0};
581 readOptionalString(uid, sizeof(uid), "user id value", UUID_EXAMPLE_2);
583 readStringArray(&gidlist, MAX_ID_LENGTH, "group id list", UUID_EXAMPLE_1);
585 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
587 result = OCCloudAclInviteUser(NULL, OPTIONAL(uid), &gidlist, &midlist, endPoint, callback);
589 clearStringArray(&midlist);
590 clearStringArray(&gidlist);
595 OCStackResult OCWrapperAclGetInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
597 char uid[MAX_ID_LENGTH] = { 0 };
599 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
601 return OCCloudAclGetInvitation(NULL, OPTIONAL(uid), endPoint, callback);
604 OCStackResult OCWrapperAclDeleteInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
606 char uid[MAX_ID_LENGTH] = { 0 };
607 char gid[MAX_ID_LENGTH] = { 0 };
609 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
610 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
612 return OCCloudAclDeleteInvitation(NULL, OPTIONAL(uid), gid, endPoint, callback);
615 OCStackResult OCWrapperAclCancelInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
617 char uid[MAX_ID_LENGTH] = { 0 };
618 char gid[MAX_ID_LENGTH] = { 0 };
619 char mid[MAX_ID_LENGTH] = { 0 };
621 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
623 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
624 readString(mid, sizeof(mid), "member id value", ID_EXAMPLE_1);
626 return OCCloudAclCancelInvitation(NULL, OPTIONAL(uid), gid, mid, endPoint, callback);
629 OCStackResult OCWrapperAclPolicyCheck(const OCDevAddr *endPoint, OCCloudResponseCB callback)
631 char sid[MAX_ID_LENGTH] = { 0 };
632 char di[MAX_ID_LENGTH] = { 0 };
634 char user_uri[32] = { 0 };
636 readString(sid, sizeof(sid), "subject id", UUID_EXAMPLE_1);
637 readString(di, sizeof(di), "device id", UUID_EXAMPLE_2);
638 readString(rm, sizeof(rm), "request method", "GET or POST or DELETE");
639 readString(user_uri, sizeof(user_uri), "request uri", RESOURCE_URI_EXAMPLE);
641 return OCCloudAclPolicyCheck(NULL, sid, di, rm, user_uri, endPoint, callback);