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 * *****************************************************************/
21 #include "occloudprovisioning.h"
22 #include "oic_malloc.h"
23 #include "oic_string.h"
24 #include "srmutility.h"
25 #include "aclresource.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)
54 * Skip special characters from stdin
56 static void skipSpecialCharacters()
58 for( ; 0x20<=getchar(); ); // for removing overflow garbages
59 // '0x20<=code' is character region
62 static bool readOptional(const char* description)
64 if (NULL == description)
69 printf("Do you want to Enter %s (y/n):\n", description);
70 char temp, choice = 0;
74 for(int ret = 0; 1 != ret; )
76 ret = scanf("%c", &temp);
77 skipSpecialCharacters();
83 case 'y': return true;
84 case 'n': return false;
85 default: printf("Wrong value entered. Please press 'y' or 'n'\n");
91 void readString(char* item, int length, const char* description, const char* example)
93 char *temp = (char*)OICCalloc(length, sizeof(char));
96 OIC_LOG(INFO, TAG, "temp is NULL");
100 printf("Enter %s (f.e. %s):\n", description, example);
101 char template[8] = { 0 };
102 snprintf(template, sizeof(template), "%%%ds", length - 1);
104 for(int ret = 0; 1 != ret; )
106 ret = scanf(template, temp);
107 skipSpecialCharacters();
109 strncpy(item, temp, length);
114 * Read user input (expect string value, but it is optional and can be skipped by user)
116 * @param[out] item string item to fill
117 * @param[in] length max allowed string length
118 * @param[in] description item description
119 * @param[in] example item example
121 static void readOptionalString(char* item, int length, const char* description, const char* example)
123 if (readOptional(description))
125 readString(item, length, description, example);
129 void readInteger(int* item, const char* description, const char* example)
133 printf("Enter %s (f.e. %s):\n", description, example);
135 for(int ret = 0; 1 != ret; )
137 ret = scanf("%d", &temp);
138 skipSpecialCharacters();
144 * Read user input (expect array of strings)
146 * @param[out] list array of strings structure
147 * @param[in] length max allowed array item length
148 * @param[in] description whole array description
149 * @param[in] example array item example
151 static void readStringArray(stringArray_t *list, int length, const char* description, const char* example)
155 char hint[MAX_STRING_LENGTH] = { 0 };
157 snprintf(hint, sizeof(hint), "%s items count", description);
158 readInteger(&count, hint, "2");
167 item = OICCalloc(count, sizeof(char*));
174 for (i = 0; i < count; i++)
176 item[i] = OICCalloc(length, sizeof(char));
183 snprintf(hint, sizeof(hint), "%s %d item", description, i + 1);
184 readString(item[i], length, hint, example);
187 list->length = count;
191 //free already allocated memory here
192 for (int k = 0; k < i; k++)
200 * Read user input (expect array of strings)
201 * It is optional and can be skipped by user.
203 * @param[out] list array of strings structure
204 * @param[in] length max allowed array item length
205 * @param[in] description whole array description
206 * @param[in] example array item example
208 static void readOptionalStringArray(stringArray_t *list, int length, const char* description, const char* example)
210 if (readOptional(description))
212 readStringArray(list, length, description, example);
216 void printStringArray(stringArray_t *list)
220 OIC_LOG(INFO, TAG, "Received NULL list");
224 OIC_LOG_V(INFO, TAG, "List contains %zu items", list->length);
226 for (size_t i = 0; i < list->length; i++)
228 OIC_LOG_V(INFO, TAG, "item[%zu] = %s", i, list->array[i]);
232 void printInviteResponse(inviteResponse_t *in)
236 OIC_LOG(INFO, TAG, "Received NULL invitation response");
240 OIC_LOG(INFO, TAG, "Received next invite gid list:");
241 printStringArray(&in->invite.gidlist);
243 OIC_LOG(INFO, TAG, "Received next invite mid list:");
244 printStringArray(&in->invite.midlist);
246 OIC_LOG(INFO, TAG, "Received next invited gid list:");
247 printStringArray(&in->invited.gidlist);
249 OIC_LOG(INFO, TAG, "Received next invited mid list:");
250 printStringArray(&in->invited.midlist);
253 void clearInviteResponse(inviteResponse_t *in)
260 clearStringArray(&in->invite.gidlist);
261 clearStringArray(&in->invite.midlist);
263 clearStringArray(&in->invited.gidlist);
264 clearStringArray(&in->invited.midlist);
267 bool readFile(const char *name, OCByteString *out)
271 uint8_t *buffer = NULL;
275 file = fopen(name, "rb");
278 OIC_LOG_V(ERROR, TAG, "Unable to open file %s", name);
283 if (fseek(file, 0, SEEK_END))
285 OIC_LOG(ERROR, TAG, "Failed to SEEK_END");
289 length = ftell(file);
292 OIC_LOG(ERROR, TAG, "Failed to ftell");
296 if (fseek(file, 0, SEEK_SET))
298 OIC_LOG(ERROR, TAG, "Failed to SEEK_SET");
303 buffer = (uint8_t *)malloc(length);
306 OIC_LOG(ERROR, TAG, "Failed to allocate buffer");
310 //Read file contents into buffer
312 size_t realCount = fread(buffer, length, count, file);
313 if (realCount != count)
315 OIC_LOG_V(ERROR, TAG, "Read %d bytes %zu times instead of %zu", length, realCount, count);
329 * Frees particular cloudAce object
331 * @param[in] ace ace object to free
333 static void freeCloudAce(cloudAce_t *ace)
338 OicSecRsrc_t* rsrc = NULL;
339 OicSecRsrc_t* tmpRsrc = NULL;
340 LL_FOREACH_SAFE(ace->resources, rsrc, tmpRsrc)
342 LL_DELETE(ace->resources, rsrc);
350 * Deletes cloudAce list
352 * @param[in] ace aces list to delete
354 static void deleteCloudAceList(cloudAce_t *aces)
356 cloudAce_t *ace = NULL;
357 cloudAce_t *tmpAce = NULL;
358 LL_FOREACH_SAFE(aces, ace, tmpAce)
360 LL_DELETE(aces, ace);
365 OCStackResult OCWrapperCertificateIssueRequest(const OCDevAddr *endPoint, OCCloudResponseCB callback)
367 return OCCloudCertificateIssueRequest(NULL, endPoint, callback);
370 OCStackResult OCWrapperGetCRL(const OCDevAddr *endPoint, OCCloudResponseCB callback)
372 return OCCloudGetCRL(NULL, endPoint, callback);
375 OCStackResult OCWrapperPostCRL(const OCDevAddr *endPoint, OCCloudResponseCB callback)
377 OCStackResult result = OC_STACK_ERROR;
378 OCByteString crlData = {0, 0};
379 char filename[64] = {0};
380 char thisUpdate[16] = { 0 };
381 char nextUpdate[16] = { 0 };
382 stringArray_t serialNumbers = {0, 0};
384 readString(thisUpdate, sizeof(thisUpdate), "Crl's thisUpdate value", "20160727000000");
385 readString(nextUpdate, sizeof(nextUpdate), "Crl's nextUpdate value", "20161027000000");
386 readOptionalStringArray(&serialNumbers, 16, "Revoked serial numbers", "1234");
388 if (NULL == serialNumbers.array)
390 readString(filename, sizeof(filename),
391 "filename from which binary Crl in DER format will be read", "crl");
393 if (!readFile(filename, &crlData))
395 printf("Can't read crl from file %s\n", filename);
399 stringArray_t *rcsn = serialNumbers.array? &serialNumbers : NULL;
400 OCByteString *crl = crlData.bytes? &crlData : NULL;
402 result = OCCloudPostCRL(NULL, thisUpdate, nextUpdate, crl, rcsn,
405 clearStringArray(&serialNumbers);
406 OICFree(crlData.bytes);
411 OCStackResult OCWrapperAclIdGetByDevice(const OCDevAddr *endPoint, OCCloudResponseCB callback)
413 char di[MAX_ID_LENGTH] = { 0 };
415 readString(di, sizeof(di), "device id", UUID_EXAMPLE_1);
417 return OCCloudGetAclIdByDevice(NULL, di, endPoint, callback);
420 OCStackResult OCWrapperAclIdCreate(const OCDevAddr *endPoint, OCCloudResponseCB callback)
422 char oid[MAX_ID_LENGTH] = { 0 };
423 char di[MAX_ID_LENGTH] = { 0 };
425 readString(oid, sizeof(oid), "owner id", UUID_EXAMPLE_2);
426 readString(di, sizeof(di), "device id", UUID_EXAMPLE_1);
428 return OCCloudAclIdCreate(NULL, oid, di, endPoint, callback);
431 OCStackResult OCWrapperAclIdDelete(const OCDevAddr *endPoint, OCCloudResponseCB callback)
433 char aclid[MAX_ID_LENGTH] = { 0 };
435 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
437 return OCCloudAclIdDelete(NULL, aclid, endPoint, callback);
440 OCStackResult OCWrapperAclIndividualGetInfo(const OCDevAddr *endPoint, OCCloudResponseCB callback)
442 char aclid[MAX_ID_LENGTH] = { 0 };
444 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
446 return OCCloudAclIndividualGetInfo(NULL, aclid, endPoint, callback);
449 OCStackResult OCWrapperAclIndividualUpdateAce(const OCDevAddr *endPoint, OCCloudResponseCB callback)
451 OCStackResult result = OC_STACK_NO_MEMORY;
453 char aclid[MAX_ID_LENGTH] = { 0 };
454 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
456 int acllist_count = 0;
457 readInteger(&acllist_count, "acl list count", "1");
459 cloudAce_t *aces = NULL;
461 for (int i = 0; i < acllist_count; i++)
463 cloudAce_t *ace = OICCalloc(1, sizeof(cloudAce_t));
466 OIC_LOG(ERROR, TAG, "Can't allocate memory for ace");
469 LL_APPEND(aces, ace);
471 char aceid[MAX_ID_LENGTH] = { 0 };
472 char subjectuuid[MAX_ID_LENGTH] = { 0 };
478 readString(subjectuuid, sizeof(subjectuuid), "subjectuuid", SUBJECT_ID_EXAMPLE);
479 } while (OC_STACK_OK != ConvertStrToUuid(subjectuuid, &ace->subjectuuid));
481 readInteger(&stype, "subject type", "0 – Device, 1 – User, 2 - Group");
482 readInteger(&permission, "permission", "6");
484 ace->aceId = OICStrdup(aceid);
486 ace->permission = permission;
488 int reslist_count = 0;
489 readInteger(&reslist_count, "resources list count", "1");
491 for (int i = 0; i < reslist_count; i++)
493 OicSecRsrc_t *res = OICCalloc(1, sizeof(OicSecRsrc_t));
496 OIC_LOG(ERROR, TAG, "Can't allocate memory for res");
499 LL_APPEND(ace->resources, res);
501 char href[32] = { 0 };
502 readString(href, sizeof(href), "href", RESOURCE_URI_EXAMPLE);
504 stringArray_t rt = {0, 0};
505 readStringArray(&rt, MAX_ID_LENGTH, "resource type", RESOURCE_TYPE_EXAMPLE);
507 stringArray_t _if = {0, 0};
508 readStringArray(&_if, MAX_ID_LENGTH, "interface", INTERFACE_EXAMPLE);
510 res->href = OICStrdup(href);
511 res->types = rt.array;
512 res->typeLen = rt.length;
513 res->interfaces = _if.array;
514 res->interfaceLen = _if.length;
518 result = OCCloudAclIndividualUpdateAce(NULL, aclid, aces, endPoint, callback);
520 deleteCloudAceList(aces);
524 OCStackResult OCWrapperAclIndividualUpdate(const OCDevAddr *endPoint, OCCloudResponseCB callback)
526 OCStackResult result = OC_STACK_NO_MEMORY;
528 char aclid[MAX_ID_LENGTH] = { 0 };
529 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
531 cloudAce_t *ace = OICCalloc(1, sizeof(cloudAce_t));
534 OIC_LOG(ERROR, TAG, "Can't allocate memory for ace");
538 char aceid[MAX_ID_LENGTH] = { 0 };
539 char subjectuuid[MAX_ID_LENGTH] = { 0 };
543 readString(aceid, sizeof(aceid), "ace id", ACE_ID_EXAMPLE);
546 readString(subjectuuid, sizeof(subjectuuid), "subjectuuid", SUBJECT_ID_EXAMPLE);
547 } while (OC_STACK_OK != ConvertStrToUuid(subjectuuid, &ace->subjectuuid));
549 readInteger(&stype, "subject type", "0 – Device, 1 – User, 2 - Group");
550 readInteger(&permission, "permission", "6");
553 ace->permission = permission;
555 int reslist_count = 0;
556 readInteger(&reslist_count, "resources list count", "1");
558 for (int i = 0; i < reslist_count; i++)
560 OicSecRsrc_t *res = OICCalloc(1, sizeof(OicSecRsrc_t));
563 OIC_LOG(ERROR, TAG, "Can't allocate memory for res");
566 LL_APPEND(ace->resources, res);
568 char href[32] = { 0 };
569 readString(href, sizeof(href), "href", RESOURCE_URI_EXAMPLE);
571 stringArray_t rt = {0, 0};
572 readStringArray(&rt, MAX_ID_LENGTH, "resource type", RESOURCE_TYPE_EXAMPLE);
574 stringArray_t _if = {0, 0};
575 readStringArray(&_if, MAX_ID_LENGTH, "interface", INTERFACE_EXAMPLE);
577 res->href = OICStrdup(href);
578 res->types = rt.array;
579 res->typeLen = rt.length;
580 res->interfaces = _if.array;
581 res->interfaceLen = _if.length;
585 result = OCCloudAclIndividualUpdate(NULL, aclid,aceid, ace, endPoint, callback);
590 OCStackResult OCWrapperAclIndividualDelete(const OCDevAddr *endPoint, OCCloudResponseCB callback)
592 char aclid[MAX_ID_LENGTH] = { 0 };
594 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
596 return OCCloudAclIndividualDelete(NULL, aclid, endPoint, callback);
599 OCStackResult OCWrapperAclIndividualDeleteAce(const OCDevAddr *endPoint, OCCloudResponseCB callback)
601 char aclid[MAX_ID_LENGTH] = { 0 };
602 char aceid[MAX_ID_LENGTH] = { 0 };
604 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
605 readString(aceid, sizeof(aceid), "ace id", ACE_ID_EXAMPLE);
607 return OCCloudAclIndividualDeleteAce(NULL, aclid, aceid, endPoint, callback);
610 OCStackResult OCWrapperAclCreateGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
612 char gtype[16] = { 0 };
613 char gmid[MAX_ID_LENGTH] = { 0 };
615 readString(gtype, sizeof(gtype), "Group type value", "Public");
616 readOptionalString(gmid, sizeof(gmid), "group member id value", UUID_EXAMPLE_2);
618 return OCCloudAclCreateGroup(NULL, gtype, OPTIONAL(gmid), endPoint, callback);
621 OCStackResult OCWrapperAclFindMyGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
623 char mid[MAX_ID_LENGTH] = { 0 };
625 readOptionalString(mid, sizeof(mid), "member id value", UUID_EXAMPLE_2);
627 return OCCloudAclFindMyGroup(NULL, OPTIONAL(mid), endPoint, callback);
630 OCStackResult OCWrapperAclDeleteGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
632 char gid[MAX_ID_LENGTH] = { 0 };
633 char gmid[MAX_ID_LENGTH] = { 0 };
635 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
637 readOptionalString(gmid, sizeof(gmid), "group member id value", UUID_EXAMPLE_2);
639 return OCCloudAclDeleteGroup(NULL, gid, OPTIONAL(gmid), endPoint, callback);
642 OCStackResult OCWrapperAclJoinToInvitedGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
644 char gid[MAX_ID_LENGTH] = { 0 };
646 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
648 return OCCloudAclJoinToInvitedGroup(NULL, gid, endPoint, callback);
651 OCStackResult OCWrapperAclObserveGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
653 char gid[MAX_ID_LENGTH] = { 0 };
655 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
657 return OCCloudAclObserveGroup(NULL, gid, endPoint, callback);
660 OCStackResult OCWrapperAclShareDeviceIntoGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
662 OCStackResult result = OC_STACK_NO_MEMORY;
663 char gid[MAX_ID_LENGTH] = { 0 };
664 stringArray_t midlist = {0,0};
665 stringArray_t dilist = {0,0};
667 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
669 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
671 readStringArray(&dilist, MAX_ID_LENGTH, "device list", UUID_EXAMPLE_1);
673 result = OCCloudAclShareDeviceIntoGroup(NULL, gid, &midlist, &dilist, endPoint, callback);
675 clearStringArray(&midlist);
676 clearStringArray(&dilist);
681 OCStackResult OCWrapperAclDeleteDeviceFromGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
683 OCStackResult result = OC_STACK_NO_MEMORY;
684 char gid[MAX_ID_LENGTH] = { 0 };
685 stringArray_t midlist = {0,0};
686 stringArray_t dilist = {0,0};
688 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
690 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
692 readStringArray(&dilist, MAX_ID_LENGTH, "device list", UUID_EXAMPLE_1);
694 result = OCCloudAclDeleteDeviceFromGroup(NULL, gid, &midlist, &dilist, endPoint, callback);
696 clearStringArray(&midlist);
697 clearStringArray(&dilist);
702 OCStackResult OCWrapperAclGroupGetInfo(const OCDevAddr *endPoint, OCCloudResponseCB callback)
704 char gid[MAX_ID_LENGTH] = { 0 };
705 char mid[MAX_ID_LENGTH] = { 0 };
707 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
709 readOptionalString(mid, sizeof(mid), "member id value", UUID_EXAMPLE_2);
711 return OCCloudAclGroupGetInfo(NULL, gid, OPTIONAL(mid), endPoint, callback);
714 OCStackResult OCWrapperAclInviteUser(const OCDevAddr *endPoint, OCCloudResponseCB callback)
716 OCStackResult result = OC_STACK_NO_MEMORY;
717 char uid[MAX_ID_LENGTH] = { 0 };
718 stringArray_t midlist = {0,0};
719 stringArray_t gidlist = {0,0};
721 readOptionalString(uid, sizeof(uid), "user id value", UUID_EXAMPLE_2);
723 readStringArray(&gidlist, MAX_ID_LENGTH, "group id list", UUID_EXAMPLE_1);
725 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
727 result = OCCloudAclInviteUser(NULL, OPTIONAL(uid), &gidlist, &midlist, endPoint, callback);
729 clearStringArray(&midlist);
730 clearStringArray(&gidlist);
735 OCStackResult OCWrapperAclGetInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
737 char uid[MAX_ID_LENGTH] = { 0 };
739 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
741 return OCCloudAclGetInvitation(NULL, OPTIONAL(uid), endPoint, callback);
744 OCStackResult OCWrapperAclDeleteInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
746 char uid[MAX_ID_LENGTH] = { 0 };
747 char gid[MAX_ID_LENGTH] = { 0 };
749 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
750 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
752 return OCCloudAclDeleteInvitation(NULL, OPTIONAL(uid), gid, endPoint, callback);
755 OCStackResult OCWrapperAclCancelInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
757 char uid[MAX_ID_LENGTH] = { 0 };
758 char gid[MAX_ID_LENGTH] = { 0 };
759 char mid[MAX_ID_LENGTH] = { 0 };
761 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
763 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
764 readString(mid, sizeof(mid), "member id value", ID_EXAMPLE_1);
766 return OCCloudAclCancelInvitation(NULL, OPTIONAL(uid), gid, mid, endPoint, callback);
769 OCStackResult OCWrapperAclPolicyCheck(const OCDevAddr *endPoint, OCCloudResponseCB callback)
771 char sid[MAX_ID_LENGTH] = { 0 };
772 char di[MAX_ID_LENGTH] = { 0 };
774 char user_uri[32] = { 0 };
776 readString(sid, sizeof(sid), "subject id", UUID_EXAMPLE_1);
777 readString(di, sizeof(di), "device id", UUID_EXAMPLE_2);
778 readString(rm, sizeof(rm), "request method", "GET or POST or DELETE");
779 readString(user_uri, sizeof(user_uri), "request uri", RESOURCE_URI_EXAMPLE);
781 return OCCloudAclPolicyCheck(NULL, sid, di, rm, user_uri, endPoint, callback);