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 "occloudprovisioning.h"
23 #include "OCCloudProvisioning.hpp"
24 #include "oic_malloc.h"
25 #include "oic_string.h"
28 #define TAG "CLOUD-WRAPPER"
30 #define MAX_ID_LENGTH (64)
31 #define MAX_STRING_LENGTH (256)
33 #define UUID_EXAMPLE_1 "9cfbeb8e-5a1e-4d1c-9d01-2ae6fdb"
34 #define UUID_EXAMPLE_2 "123e4567-e89b-12d3-a456-4266554"
35 #define UUID_EXAMPLE_3 "987e6543-e21b-12d3-a456-4266554"
36 #define SUBJECT_ID_EXAMPLE "72616E64-5069-6E44-6576-557569643030"
38 #define ACL_ID_EXAMPLE "0f3d9f7fe5491d54077d"
39 #define ACE_ID_EXAMPLE "a0001"
41 #define ID_EXAMPLE_1 "78f98b4f25f21e2487e8"
42 #define ID_EXAMPLE_2 "6caa7009386290fd3681"
44 #define RESOURCE_URI_EXAMPLE "/a/light/0"
45 #define RESOURCE_TYPE_EXAMPLE "core.light"
46 #define INTERFACE_EXAMPLE "oic.if.baseline"
48 //in case of optional parameters absence should be sent NULL
49 #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();
84 case 'y': return true;
85 case 'n': return false;
86 default: printf("Wrong value entered. Please press 'y' or 'n'\n");
93 * Read user input (expect string value)
95 * @param[out] item string item to fill
96 * @param[in] length max allowed string length
97 * @param[in] description item description
98 * @param[in] example item example
100 void readString(char* item, int length, const char* description, const char* example)
102 char *input = (char*)OICCalloc(length, sizeof(char));
105 OIC_LOG(INFO, TAG, "input is NULL");
109 printf("Enter %s (f.e. %s):\n", description, example);
110 char temp[8] = { 0 };
111 snprintf(temp, sizeof(temp), "%%%ds", length - 1);
113 for (int ret = 0; 1 != ret; )
115 ret = scanf(temp, input);
116 skipSpecialCharacters();
119 strncpy(item, input, length);
124 * Read user input (expect string value, but it is optional and can be skipped by user)
126 * @param[out] item string item to fill
127 * @param[in] length max allowed string length
128 * @param[in] description item description
129 * @param[in] example item example
131 static void readOptionalString(char* item, int length, const char* description, const char* example)
133 if (readOptional(description))
135 readString(item, length, description, example);
140 * Read user input (expect integer value)
142 * @param[out] item integer item to fill
143 * @param[in] description item description
144 * @param[in] example item example
146 void readInteger(int* item, const char* description, const char* example)
150 printf("Enter %s (f.e. %s):\n", description, example);
152 for (int ret = 0; 1 != ret; )
154 ret = scanf("%d", &temp);
155 skipSpecialCharacters();
162 * Read user input (expect array of strings)
164 * @param[out] list array of strings structure
165 * @param[in] length max allowed array item length
166 * @param[in] description whole array description
167 * @param[in] example array item example
169 static void readStringArray(stringArray_t *list, int length, const char* description, const char* example)
173 char hint[MAX_STRING_LENGTH] = { 0 };
175 snprintf(hint, sizeof(hint), "%s items count", description);
176 readInteger(&count, hint, "2");
185 item = (char**)OICCalloc(count, sizeof(char*));
192 for (i = 0; i < count; i++)
194 item[i] = (char*)OICCalloc(length, sizeof(char));
201 snprintf(hint, sizeof(hint), "%s %d item", description, i + 1);
202 readString(item[i], length, hint, example);
205 list->length = (size_t)count;
209 //free already allocated memory here
210 for (int k = 0; k < i; k++)
218 * Read user input (expect array of strings)
219 * It is optional and can be skipped by user.
221 * @param[out] list array of strings structure
222 * @param[in] length max allowed array item length
223 * @param[in] description whole array description
224 * @param[in] example array item example
226 static void readOptionalStringArray(stringArray_t *list, int length, const char* description, const char* example)
228 if (readOptional(description))
230 readStringArray(list, length, description, example);
235 * Copies whole binary file to crl variable
237 * @param[in] list array of strings structure
238 * @param[out] crl byte array to fill
239 * @return negative error code
241 static int ReadFile(const char *name, OCByteString *crl)
245 uint8_t *buffer = NULL;
250 file = fopen(name, "rb");
253 OIC_LOG_V(ERROR, TAG, "Unable to open file %s", name);
258 result = fseek(file, 0, SEEK_END);
261 OIC_LOG(ERROR, TAG, "Failed to SEEK_END");
265 length = ftell(file);
268 OIC_LOG(ERROR, TAG, "Failed to ftell");
272 result = fseek(file, 0, SEEK_SET);
275 OIC_LOG(ERROR, TAG, "Failed to SEEK_SET");
280 buffer = (uint8_t *)malloc(length);
283 OIC_LOG(ERROR, TAG, "Failed to allocate buffer");
287 //Read file contents into buffer
288 realLen = fread(buffer, length, 1, file);
289 if (realLen != (size_t)length)
291 OIC_LOG_V(ERROR, TAG, "Length mismatch: read %zu instead of %d bytes", realLen, length);
296 crl->len = (size_t)length;
304 OCStackResult OCWrapperCertificateIssueRequest(OCCloudProvisioning& ptr, ResponseCallBack callback)
306 return ptr.requestCertificate(callback);
309 OCStackResult OCWrapperGetCRL(OCCloudProvisioning& ptr, ResponseCallBack callback)
311 return ptr.getCRL(callback);
314 OCStackResult OCWrapperPostCRL(OCCloudProvisioning& ptr, ResponseCallBack callback)
316 OCStackResult result = OC_STACK_ERROR;
317 OCByteString crlData = {0, 0};
318 char filename[64] = {0};
319 char thisUpdate[16] = { 0 };
320 char nextUpdate[16] = { 0 };
321 stringArray_t serialNumbers = {0, 0};
322 stringArray_t *rcsn = 0;
323 OCByteString *crl = 0;
325 readString(thisUpdate, sizeof(thisUpdate), "Crl's thisUpdate value", "20160727000000");
326 readString(nextUpdate, sizeof(nextUpdate), "Crl's nextUpdate value", "20161027000000");
327 readOptionalStringArray(&serialNumbers, 16, "Revoked serial numbers", "1234");
329 if (NULL == serialNumbers.array)
331 readString(filename, sizeof(filename),
332 "filename from which binary Crl in DER format will be read", "crl");
334 if (ReadFile(filename, &crlData))
336 printf("Can't read crl from file %s\n", filename);
340 rcsn = serialNumbers.array? &serialNumbers : NULL;
341 crl = crlData.bytes? &crlData : NULL;
343 result = ptr.postCRL(thisUpdate, nextUpdate, crl, rcsn,
346 clearStringArray(&serialNumbers);
347 OICFree(crlData.bytes);
352 OCStackResult OCWrapperAclIdGetByDevice(OCCloudProvisioning& ptr, AclIdResponseCallBack callback)
354 char di[MAX_ID_LENGTH] = { 0 };
356 readString(di, sizeof(di), "device id", UUID_EXAMPLE_1);
358 return ptr.getAclIdByDevice(di, callback);
361 OCStackResult OCWrapperAclIdCreate(const OCDevAddr *endPoint, OCCloudResponseCB callback)
363 char oid[MAX_ID_LENGTH] = { 0 };
364 char di[MAX_ID_LENGTH] = { 0 };
366 readString(oid, sizeof(oid), "owner id", UUID_EXAMPLE_2);
367 readString(di, sizeof(di), "device id", UUID_EXAMPLE_1);
369 return OCCloudAclIdCreate(NULL, oid, di, endPoint, callback);
372 OCStackResult OCWrapperAclIdDelete(const OCDevAddr *endPoint, OCCloudResponseCB callback)
374 char aclid[MAX_ID_LENGTH] = { 0 };
376 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
378 return OCCloudAclIdDelete(NULL, aclid, endPoint, callback);
381 OCStackResult OCWrapperAclIndividualGetInfo(OCCloudProvisioning& ptr, ResponseCallBack callback)
383 char aclid[MAX_ID_LENGTH] = { 0 };
385 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
387 return ptr.getIndividualAclInfo(aclid, callback);
390 OCStackResult OCWrapperAclIndividualUpdateAce(const OCDevAddr *endPoint, OCCloudResponseCB callback)
392 OCStackResult result = OC_STACK_NO_MEMORY;
394 cloudAce_t *aces = NULL;
396 char aclid[MAX_ID_LENGTH] = { 0 };
397 readString(aclid, sizeof(aclid), "ace id", ACL_ID_EXAMPLE);
399 int acllist_count = 0;
400 readInteger(&acllist_count, "acl list count", "1");
401 if (0 >= acllist_count)
403 OIC_LOG(ERROR, TAG, "Wrong number of aclList");
407 aces = (cloudAce_t*)OICCalloc(acllist_count, sizeof(cloudAce_t));
410 OIC_LOG(ERROR, TAG, "Can't allocate memory for aces");
414 for (i = 0; i < acllist_count; i++)
416 cloudAce_t *ace = &aces[i];
417 if (i != acllist_count - 1) ace->next = &aces[i + 1];
419 char aceid[MAX_ID_LENGTH] = { 0 };
420 char subjectuuid[MAX_ID_LENGTH] = { 0 };
424 readString(aceid, sizeof(aceid), "ace id", ACE_ID_EXAMPLE);
425 readString(subjectuuid, sizeof(subjectuuid), "subjectuuid", SUBJECT_ID_EXAMPLE);
426 readInteger(&stype, "subject type", "0 – Device, 1 – User, 2 - Group");
427 readInteger(&permission, "permission", "6");
429 ace->aceId = OICStrdup(aceid);
431 ace->permission = permission;
432 memcpy(&ace->subjectuuid, subjectuuid, sizeof(OicUuid_t));
434 int reslist_count = 0;
435 readInteger(&reslist_count, "resources list count", "1");
437 ace->resources = (OicSecRsrc_t*)OICCalloc(reslist_count, sizeof(OicSecRsrc_t));
440 OIC_LOG(ERROR, TAG, "Can't allocate memory for resources");
444 for (j = 0; j < reslist_count; j++)
446 OicSecRsrc_t *res = &ace->resources[j];
447 if (j != reslist_count - 1) res->next = &ace->resources[j + 1];
449 char href[32] = { 0 };
450 readString(href, sizeof(href), "href", RESOURCE_URI_EXAMPLE);
452 stringArray_t rt = {0, 0};
453 readStringArray(&rt, MAX_ID_LENGTH, "resource type", RESOURCE_TYPE_EXAMPLE);
455 stringArray_t _if = {0, 0};
456 readStringArray(&_if, MAX_ID_LENGTH, "interface", INTERFACE_EXAMPLE);
458 res->href = OICStrdup(href);
459 res->types = rt.array;
460 res->typeLen = rt.length;
461 res->interfaces = _if.array;
462 res->interfaceLen = _if.length;
466 result = OCCloudAclIndividualUpdateAce(NULL, aclid, aces, endPoint, callback);
470 for (int k = 0; k < i; k++)
472 cloudAce_t *ace = &aces[k];
477 for (int l = 0; l < j; l++)
479 OicSecRsrc_t *res = &ace->resources[l];
482 stringArray_t rt { res->types, res->typeLen};
483 clearStringArray(&rt);
485 stringArray_t _if {res->interfaces, res->interfaceLen};
486 clearStringArray(&_if);
495 OCStackResult OCWrapperAclIndividualDelete(const OCDevAddr *endPoint, OCCloudResponseCB callback)
497 char aclid[MAX_ID_LENGTH] = { 0 };
499 readString(aclid, sizeof(aclid), "acl id", ACL_ID_EXAMPLE);
501 return OCCloudAclIndividualDelete(NULL, aclid, endPoint, callback);
504 OCStackResult OCWrapperAclCreateGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
506 char gtype[16] = { 0 };
507 char gmid[MAX_ID_LENGTH] = { 0 };
509 readString(gtype, sizeof(gtype), "Group type value", "Public");
510 readOptionalString(gmid, sizeof(gmid), "group member id value", UUID_EXAMPLE_2);
512 return OCCloudAclCreateGroup(NULL, gtype, OPTIONAL(gmid), endPoint, callback);
515 OCStackResult OCWrapperAclFindMyGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
517 char mid[MAX_ID_LENGTH] = { 0 };
519 readOptionalString(mid, sizeof(mid), "member id value", UUID_EXAMPLE_2);
521 return OCCloudAclFindMyGroup(NULL, OPTIONAL(mid), endPoint, callback);
524 OCStackResult OCWrapperAclDeleteGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
526 char gid[MAX_ID_LENGTH] = { 0 };
527 char gmid[MAX_ID_LENGTH] = { 0 };
529 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
531 readOptionalString(gmid, sizeof(gmid), "group member id value", UUID_EXAMPLE_2);
533 return OCCloudAclDeleteGroup(NULL, gid, OPTIONAL(gmid), endPoint, callback);
536 OCStackResult OCWrapperAclJoinToInvitedGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
538 char gid[MAX_ID_LENGTH] = { 0 };
540 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
542 return OCCloudAclJoinToInvitedGroup(NULL, gid, endPoint, callback);
545 OCStackResult OCWrapperAclObserveGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
547 char gid[MAX_ID_LENGTH] = { 0 };
549 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
551 return OCCloudAclObserveGroup(NULL, gid, endPoint, callback);
554 OCStackResult OCWrapperAclShareDeviceIntoGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
556 OCStackResult result = OC_STACK_NO_MEMORY;
557 char gid[MAX_ID_LENGTH] = { 0 };
558 stringArray_t midlist = {0,0};
559 stringArray_t dilist = {0,0};
561 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
563 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
565 readStringArray(&dilist, MAX_ID_LENGTH, "device list", UUID_EXAMPLE_1);
567 result = OCCloudAclShareDeviceIntoGroup(NULL, gid, &midlist, &dilist, endPoint, callback);
569 clearStringArray(&midlist);
570 clearStringArray(&dilist);
575 OCStackResult OCWrapperAclDeleteDeviceFromGroup(const OCDevAddr *endPoint, OCCloudResponseCB callback)
577 OCStackResult result = OC_STACK_NO_MEMORY;
578 char gid[MAX_ID_LENGTH] = { 0 };
579 stringArray_t midlist = {0,0};
580 stringArray_t dilist = {0,0};
582 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
584 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
586 readStringArray(&dilist, MAX_ID_LENGTH, "device list", UUID_EXAMPLE_1);
588 result = OCCloudAclDeleteDeviceFromGroup(NULL, gid, &midlist, &dilist, endPoint, callback);
590 clearStringArray(&midlist);
591 clearStringArray(&dilist);
596 OCStackResult OCWrapperAclGroupGetInfo(const OCDevAddr *endPoint, OCCloudResponseCB callback)
598 char gid[MAX_ID_LENGTH] = { 0 };
599 char mid[MAX_ID_LENGTH] = { 0 };
601 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
603 readOptionalString(mid, sizeof(mid), "member id value", UUID_EXAMPLE_2);
605 return OCCloudAclGroupGetInfo(NULL, gid, OPTIONAL(mid), endPoint, callback);
608 OCStackResult OCWrapperAclInviteUser(const OCDevAddr *endPoint, OCCloudResponseCB callback)
610 OCStackResult result = OC_STACK_NO_MEMORY;
611 char uid[MAX_ID_LENGTH] = { 0 };
612 stringArray_t midlist = {0,0};
613 stringArray_t gidlist = {0,0};
615 readOptionalString(uid, sizeof(uid), "user id value", UUID_EXAMPLE_2);
617 readStringArray(&gidlist, MAX_ID_LENGTH, "group id list", UUID_EXAMPLE_1);
619 readStringArray(&midlist, MAX_ID_LENGTH, "member id list", UUID_EXAMPLE_2);
621 result = OCCloudAclInviteUser(NULL, OPTIONAL(uid), &gidlist, &midlist, endPoint, callback);
623 clearStringArray(&midlist);
624 clearStringArray(&gidlist);
629 OCStackResult OCWrapperAclGetInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
631 char uid[MAX_ID_LENGTH] = { 0 };
633 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
635 return OCCloudAclGetInvitation(NULL, OPTIONAL(uid), endPoint, callback);
638 OCStackResult OCWrapperAclDeleteInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
640 char uid[MAX_ID_LENGTH] = { 0 };
641 char gid[MAX_ID_LENGTH] = { 0 };
643 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
644 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
646 return OCCloudAclDeleteInvitation(NULL, OPTIONAL(uid), gid, endPoint, callback);
649 OCStackResult OCWrapperAclCancelInvitation(const OCDevAddr *endPoint, OCCloudResponseCB callback)
651 char uid[MAX_ID_LENGTH] = { 0 };
652 char gid[MAX_ID_LENGTH] = { 0 };
653 char mid[MAX_ID_LENGTH] = { 0 };
655 readOptionalString(uid, sizeof(uid), "user uuid value", UUID_EXAMPLE_2);
657 readString(gid, sizeof(gid), "Group id value", ID_EXAMPLE_1);
658 readString(mid, sizeof(mid), "member id value", ID_EXAMPLE_1);
660 return OCCloudAclCancelInvitation(NULL, OPTIONAL(uid), gid, mid, endPoint, callback);
663 OCStackResult OCWrapperAclPolicyCheck(const OCDevAddr *endPoint, OCCloudResponseCB callback)
665 char sid[MAX_ID_LENGTH] = { 0 };
666 char di[MAX_ID_LENGTH] = { 0 };
668 char user_uri[32] = { 0 };
670 readString(sid, sizeof(sid), "subject id", UUID_EXAMPLE_1);
671 readString(di, sizeof(di), "device id", UUID_EXAMPLE_2);
672 readString(rm, sizeof(rm), "request method", "GET or POST or DELETE");
673 readString(user_uri, sizeof(user_uri), "request uri", RESOURCE_URI_EXAMPLE);
675 return OCCloudAclPolicyCheck(NULL, sid, di, rm, user_uri, endPoint, callback);