#include <string.h>
#include <unistd.h>
+#include "utlist.h"
#include "logger.h"
#include "oic_malloc.h"
#include "oic_string.h"
// declaration(s) for provisioning client using C-level provisioning API
// user input definition for main loop on provisioning client
-#define _10_DISCOV_ALL_DEVS_ 10
-#define _11_DISCOV_UNOWN_DEVS_ 11
-#define _12_DISCOV_OWN_DEVS_ 12
-#define _20_REGIST_DEVS_ 20
-#define _30_PROVIS_PAIR_DEVS_ 30
-#define _31_PROVIS_CRED_ 31
-#define _32_PROVIS_ACL_ 32
-#define _33_CHECK_LINK_STATUS_ 33
-#define _40_UNLINK_PAIR_DEVS_ 40
-#define _50_REMOVE_SELEC_DEV_ 50
-#define _99_EXIT_PRVN_CLT_ 99
+#define _10_DISCOV_ALL_DEVS_ 10
+#define _11_DISCOV_UNOWN_DEVS_ 11
+#define _12_DISCOV_OWN_DEVS_ 12
+#define _20_REGIST_DEVS_ 20
+#define _30_PROVIS_PAIR_DEVS_ 30
+#define _31_PROVIS_CRED_ 31
+#define _32_PROVIS_ACL_ 32
+#define _33_PROVIS_DP_ 33
+#define _34_CHECK_LINK_STATUS_ 34
+#define _40_UNLINK_PAIR_DEVS_ 40
+#define _50_REMOVE_SELEC_DEV_ 50
+#define _51_REMOVE_DEV_WITH_UUID_ 51
+#define _52_RESET_SELEC_DEV_ 52
+#define _60_GET_CRED_ 60
+#define _61_GET_ACL_ 61
+#define _99_EXIT_PRVN_CLT_ 99
#define ACL_RESRC_MAX_NUM 16
+#define ACL_RESRC_ARRAY_SIZE 3 //This value is used only for sample (not OCF spec)
#define ACL_RESRC_MAX_LEN 128
#define ACL_PEMISN_CNT 5
#define DISCOVERY_TIMEOUT 10 // 10 sec
#define TAG "provisioningclient"
static const char* ACL_PEMISN[5] = {"CREATE", "READ", "WRITE", "DELETE", "NOTIFY"};
-static const char* SVR_DB_FILE_NAME = "oic_svr_db_client.json";
+static const char* SVR_DB_FILE_NAME = "oic_svr_db_client.dat";
// '_' for separaing from the same constant variable in |srmresourcestrings.c|
static const char* PRVN_DB_FILE_NAME = "oic_prvn_mng.db";
+static const OicSecPrm_t SUPPORTED_PRMS[1] =
+{
+ PRM_PRE_CONFIGURED,
+};
+
// |g_ctx| means provision manager application context and
// the following, includes |un/own_list|, could be variables, which |g_ctx| has,
// for accessing all function(s) for these, they are declared on global domain
// function declaration(s) for calling them before implementing
static OicSecAcl_t* createAcl(const int);
+static OicSecPdAcl_t* createPdAcl(const int);
static OCProvisionDev_t* getDevInst(const OCProvisionDev_t*, const int);
static int printDevList(const OCProvisionDev_t*);
static size_t printUuidList(const OCUuidList_t*);
{
if(!hasError)
{
- OC_LOG_V(INFO, TAG, "Ownership Transfer SUCCEEDED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(INFO, TAG, "Ownership Transfer SUCCEEDED - ctx: %s", (char*) ctx);
}
else
{
- OC_LOG_V(ERROR, TAG, "Ownership Transfer FAILED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(ERROR, TAG, "Ownership Transfer FAILED - ctx: %s", (char*) ctx);
printResultList((const OCProvisionResult_t*) arr, nOfRes);
}
g_doneCB = true;
{
if(!hasError)
{
- OC_LOG_V(INFO, TAG, "Provision Pairwise SUCCEEDED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(INFO, TAG, "Provision Pairwise SUCCEEDED - ctx: %s", (char*) ctx);
}
else
{
- OC_LOG_V(ERROR, TAG, "Provision Pairwise FAILED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(ERROR, TAG, "Provision Pairwise FAILED - ctx: %s", (char*) ctx);
printResultList((const OCProvisionResult_t*) arr, nOfRes);
}
g_doneCB = true;
{
if(!hasError)
{
- OC_LOG_V(INFO, TAG, "Provision Credential SUCCEEDED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(INFO, TAG, "Provision Credential SUCCEEDED - ctx: %s", (char*) ctx);
}
else
{
- OC_LOG_V(ERROR, TAG, "Provision Credential FAILED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(ERROR, TAG, "Provision Credential FAILED - ctx: %s", (char*) ctx);
printResultList((const OCProvisionResult_t*) arr, nOfRes);
}
g_doneCB = true;
{
if(!hasError)
{
- OC_LOG_V(INFO, TAG, "Provision ACL SUCCEEDED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(INFO, TAG, "Provision ACL SUCCEEDED - ctx: %s", (char*) ctx);
+ }
+ else
+ {
+ OIC_LOG_V(ERROR, TAG, "Provision ACL FAILED - ctx: %s", (char*) ctx);
+ printResultList((const OCProvisionResult_t*) arr, nOfRes);
+ }
+ g_doneCB = true;
+}
+
+static void getCredCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
+{
+ if(!hasError)
+ {
+ OIC_LOG_V(INFO, TAG, "getCredCB SUCCEEDED - ctx: %s", (char*) ctx);
+ }
+ else
+ {
+ OIC_LOG_V(ERROR, TAG, "getCredCB FAILED - ctx: %s", (char*) ctx);
+ printResultList((const OCProvisionResult_t*) arr, nOfRes);
+ }
+ g_doneCB = true;
+}
+
+static void getAclCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
+{
+ if(!hasError)
+ {
+ OIC_LOG_V(INFO, TAG, "getAclCB SUCCEEDED - ctx: %s", (char*) ctx);
+ }
+ else
+ {
+ OIC_LOG_V(ERROR, TAG, "getAclCB FAILED - ctx: %s", (char*) ctx);
+ printResultList((const OCProvisionResult_t*) arr, nOfRes);
+ }
+ g_doneCB = true;
+}
+
+static void provisionDPCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
+{
+ if(!hasError)
+ {
+ OIC_LOG_V(INFO, TAG, "Provision Direct-Pairing SUCCEEDED - ctx: %s", (char*) ctx);
}
else
{
- OC_LOG_V(ERROR, TAG, "Provision ACL FAILED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(ERROR, TAG, "Provision Direct-Pairing FAILED - ctx: %s", (char*) ctx);
printResultList((const OCProvisionResult_t*) arr, nOfRes);
}
g_doneCB = true;
{
if(!hasError)
{
- OC_LOG_V(INFO, TAG, "Unlink Devices SUCCEEDED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(INFO, TAG, "Unlink Devices SUCCEEDED - ctx: %s", (char*) ctx);
}
else
{
- OC_LOG_V(ERROR, TAG, "Unlink Devices FAILED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(ERROR, TAG, "Unlink Devices FAILED - ctx: %s", (char*) ctx);
printResultList((const OCProvisionResult_t*) arr, nOfRes);
}
g_doneCB = true;
{
if(!hasError)
{
- OC_LOG_V(INFO, TAG, "Remove Device SUCCEEDED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(INFO, TAG, "Remove Device SUCCEEDED - ctx: %s", (char*) ctx);
}
else
{
- OC_LOG_V(ERROR, TAG, "Remove Device FAILED - ctx: %s", (char*) ctx);
+ OIC_LOG_V(ERROR, TAG, "Remove Device FAILED - ctx: %s", (char*) ctx);
+ printResultList((const OCProvisionResult_t*) arr, nOfRes);
+ }
+ g_doneCB = true;
+}
+
+static void syncDeviceCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
+{
+ if(!hasError)
+ {
+ OIC_LOG_V(INFO, TAG, "Sync Device SUCCEEDED - ctx: %s", (char*) ctx);
+ }
+ else
+ {
+ OIC_LOG_V(ERROR, TAG, "Sync Device FAILED - ctx: %s", (char*) ctx);
printResultList((const OCProvisionResult_t*) arr, nOfRes);
}
g_doneCB = true;
{
if(!pin || OXM_RANDOM_PIN_SIZE>=len)
{
- OC_LOG(ERROR, TAG, "inputPinCB invalid parameters");
+ OIC_LOG(ERROR, TAG, "inputPinCB invalid parameters");
return;
}
};
if(OC_STACK_OK != OCRegisterPersistentStorageHandler(&pstStr))
{
- OC_LOG(ERROR, TAG, "OCRegisterPersistentStorageHandler error");
+ OIC_LOG(ERROR, TAG, "OCRegisterPersistentStorageHandler error");
return -1;
}
// initialize OC stack and provisioning manager
if(OC_STACK_OK != OCInit(NULL, 0, OC_CLIENT_SERVER))
{
- OC_LOG(ERROR, TAG, "OCStack init error");
+ OIC_LOG(ERROR, TAG, "OCStack init error");
return -1;
}
if(OC_STACK_OK != OCInitPM(PRVN_DB_FILE_NAME))
{
- OC_LOG(ERROR, TAG, "OC_PM init error");
+ OIC_LOG(ERROR, TAG, "OC_PM init error");
return -1;
}
};
if(OC_STACK_OK != OCSetOwnerTransferCallbackData(OIC_JUST_WORKS, &otmcb))
{
- OC_LOG(ERROR, TAG, "OCSetOwnerTransferCallbackData error: OIC_JUST_WORKS");
+ OIC_LOG(ERROR, TAG, "OCSetOwnerTransferCallbackData error: OIC_JUST_WORKS");
return -1;
}
otmcb.loadSecretCB = InputPinCodeCallback;
- otmcb.createSecureSessionCB = CreateSecureSessionRandomPinCallbak;
+ otmcb.createSecureSessionCB = CreateSecureSessionRandomPinCallback;
otmcb.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
otmcb.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
if(OC_STACK_OK != OCSetOwnerTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &otmcb))
{
- OC_LOG(ERROR, TAG, "OCSetOwnerTransferCallbackData error: OIC_RANDOM_DEVICE_PIN");
+ OIC_LOG(ERROR, TAG, "OCSetOwnerTransferCallbackData error: OIC_RANDOM_DEVICE_PIN");
return -1;
}
SetInputPinCB(inputPinCB);
printf(" Discovering All Un/Owned Devices on Network..\n");
if(OC_STACK_OK != OCGetDevInfoFromNetwork(DISCOVERY_TIMEOUT, &g_own_list, &g_unown_list))
{
- OC_LOG(ERROR, TAG, "OCGetDevInfoFromNetwork API error");
+ OIC_LOG(ERROR, TAG, "OCGetDevInfoFromNetwork API error");
return -1;
}
printf(" Discovering Only Unowned Devices on Network..\n");
if(OC_STACK_OK != OCDiscoverUnownedDevices(DISCOVERY_TIMEOUT, &g_unown_list))
{
- OC_LOG(ERROR, TAG, "OCDiscoverUnownedDevices API error");
+ OIC_LOG(ERROR, TAG, "OCDiscoverUnownedDevices API error");
return -1;
}
printf(" Discovering Only Owned Devices on Network..\n");
if(OC_STACK_OK != OCDiscoverOwnedDevices(DISCOVERY_TIMEOUT, &g_own_list))
{
- OC_LOG(ERROR, TAG, "OCDiscoverOwnedDevices API error");
+ OIC_LOG(ERROR, TAG, "OCDiscoverOwnedDevices API error");
return -1;
}
OCStackResult rst = OCDoOwnershipTransfer((void*) g_ctx, g_unown_list, ownershipTransferCB);
if(OC_STACK_OK != rst)
{
- OC_LOG_V(ERROR, TAG, "OCDoOwnershipTransfer API error: %d", rst);
+ OIC_LOG_V(ERROR, TAG, "OCDoOwnershipTransfer API error: %d", rst);
return -1;
}
if(waitCallbackRet()) // input |g_doneCB| flag implicitly
{
- OC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
+ OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
return -1;
}
int dev_num[2] = {0};
if(selectTwoDiffNum(&(dev_num[0]), &(dev_num[1]), g_own_cnt, "for Linking Devices"))
{
- OC_LOG(ERROR, TAG, "selectTwoDiffNum error return");
+ OIC_LOG(ERROR, TAG, "selectTwoDiffNum error return");
return -1; // not need to 'goto' |ERROR| before allocating |acl|
}
acl[i] = createAcl(dev_num[i]);
if(!acl[i])
{
- OC_LOG(ERROR, TAG, "createAcl error return");
+ OIC_LOG(ERROR, TAG, "createAcl error return");
goto PVPWS_ERROR;
}
}
provisionPairwiseCB);
if(OC_STACK_OK != rst)
{
- OC_LOG_V(ERROR, TAG, "OCProvisionPairwiseDevices API error: %d", rst);
+ OIC_LOG_V(ERROR, TAG, "OCProvisionPairwiseDevices API error: %d", rst);
goto PVPWS_ERROR;
}
if(waitCallbackRet()) // input |g_doneCB| flag implicitly
{
- OC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
+ OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
goto PVPWS_ERROR;
}
OCDeleteACLList(acl[0]);
int dev_num[2] = {0};
if(selectTwoDiffNum(&(dev_num[0]), &(dev_num[1]), g_own_cnt, "for Linking CRED(s)"))
{
- OC_LOG(ERROR, TAG, "selectTwoDiffNum error return");
+ OIC_LOG(ERROR, TAG, "selectTwoDiffNum error return");
return -1;
}
provisionCredCB);
if(OC_STACK_OK != rst)
{
- OC_LOG_V(ERROR, TAG, "OCProvisionCredentials API error: %d", rst);
+ OIC_LOG_V(ERROR, TAG, "OCProvisionCredentials API error: %d", rst);
return -1;
}
if(waitCallbackRet()) // input |g_doneCB| flag implicitly
{
- OC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
+ OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
return -1;
}
acl = createAcl(dev_num);
if(!acl)
{
- OC_LOG(ERROR, TAG, "createAcl error return");
+ OIC_LOG(ERROR, TAG, "createAcl error return");
goto PVACL_ERROR;
}
// for error checking, the return value saved and printed
g_doneCB = false;
printf(" Provisioning Selected ACL..\n");
- OCStackResult rst =
- OCProvisionACL((void*) g_ctx,
- getDevInst((const OCProvisionDev_t*) g_own_list, dev_num),
- acl, provisionAclCB);
+ OCProvisionDev_t* dev = getDevInst((const OCProvisionDev_t*) g_own_list, dev_num);
+ if(!dev)
+ {
+ OIC_LOG(ERROR, TAG, "provisionAcl: device instance empty");
+ goto PVACL_ERROR;
+ }
+ OCStackResult rst = OCProvisionACL((void*) g_ctx, dev, acl, provisionAclCB);
if(OC_STACK_OK != rst)
{
- OC_LOG_V(ERROR, TAG, "OCProvisionACL API error: %d", rst);
+ OIC_LOG_V(ERROR, TAG, "OCProvisionACL API error: %d", rst);
goto PVACL_ERROR;
}
if(waitCallbackRet()) // input |g_doneCB| flag implicitly
{
- OC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
+ OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
goto PVACL_ERROR;
}
OCDeleteACLList(acl); // after here |acl| points nothing
return -1;
}
+static int provisionDirectPairing(void)
+{
+ // check |own_list| for provisioning direct-pairing
+ if(!g_own_list || 1>g_own_cnt)
+ {
+ printf(" > Owned Device List, to Provision ACL, is Empty\n");
+ printf(" > Please Register Unowned Devices first, with [20] Menu\n");
+ return 0; // normal case
+ }
+
+ // select device for provisioning direct-pairing
+ int dev_num = 0;
+ for( ; ; )
+ {
+ printf(" > Enter Device Number, for Provisioning Direct-Pairing: ");
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%d", &dev_num);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ if(0<dev_num && g_own_cnt>=dev_num)
+ {
+ break;
+ }
+ printf(" Entered Wrong Number. Please Enter Again\n");
+ }
+
+ // create Direct-Pairing Configuration(PIN, PDACL) for selected device
+ // TODO: default acl -> input from user !
+ OicSecPconf_t pconf;
+ memset(&pconf, 0, sizeof(OicSecPconf_t));
+
+ // set enable dp
+ pconf.edp = true;
+
+ // set default supported PRM types
+ pconf.prmLen = sizeof(SUPPORTED_PRMS)/sizeof(OicSecPrm_t);
+ pconf.prm = (OicSecPrm_t *)OICCalloc(pconf.prmLen, sizeof(OicSecPrm_t));
+ if(pconf.prm)
+ {
+ for (size_t i=0; i<pconf.prmLen; i++)
+ {
+ pconf.prm[i] = SUPPORTED_PRMS[i];
+ }
+ }
+ else
+ {
+ OIC_LOG(ERROR, TAG, "create prm error return");
+ goto PVDP_ERROR;
+ }
+
+ // set default pin
+ const char DP_DEFAULT_PIN[] = "00000000";
+ memcpy(pconf.pin.val, DP_DEFAULT_PIN, DP_PIN_LENGTH);
+
+ // set default pdacl
+ pconf.pdacls = createPdAcl(dev_num);
+ if(!pconf.pdacls)
+ {
+ OIC_LOG(ERROR, TAG, "createPdAcl error return");
+ goto PVDP_ERROR;
+ }
+
+ // call |OCProvisionDirectPairing| API actually
+ // calling this API with callback actually acts like blocking
+ // for error checking, the return value saved and printed
+ g_doneCB = false;
+ printf(" Atempt Direct-Pairing Provisioning (PIN : [%s])..\n", (char*)pconf.pin.val);
+ OCStackResult rst = OCProvisionDirectPairing((void*) g_ctx,
+ getDevInst((const OCProvisionDev_t*) g_own_list, dev_num),
+ &pconf, provisionDPCB);
+ if(OC_STACK_OK != rst)
+ {
+ OIC_LOG_V(ERROR, TAG, "OCProvisionDirectPairing API error: %d", rst);
+ if (OC_STACK_UNAUTHORIZED_REQ == rst)
+ {
+ OIC_LOG(ERROR, TAG, "Target Server NOT Support Direct-Pairing !!! (DPC == false)");
+ }
+ goto PVDP_ERROR;
+ }
+ if(waitCallbackRet()) // input |g_doneCB| flag implicitly
+ {
+ OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
+ goto PVDP_ERROR;
+ }
+ OCDeletePdAclList(pconf.pdacls);
+
+ // display the PCONF-provisioned result
+ printf(" > SUCCESS to provision Direct-Pairing !!\n");
+
+ return 0;
+
+PVDP_ERROR:
+ OCDeletePdAclList(pconf.pdacls); // after here |acl| points nothing
+ return -1;
+}
+
static int checkLinkedStatus(void)
{
// check |own_list| for checking selected link status on PRVN DB
printf(" Checking Selected Link Status on PRVN DB..\n");
OCUuidList_t* dvid_lst = NULL;
size_t dvid_cnt = 0;
+ OCProvisionDev_t* dev = getDevInst((const OCProvisionDev_t*)g_own_list, dev_num);
+ if(!dev || !dev->doxm)
+ {
+ OIC_LOG(ERROR, TAG, "checkLinkedStatus: device instance empty");
+ goto CKLST_ERROR;
+ }
+
if(OC_STACK_OK !=
OCGetLinkedStatus(
- &getDevInst((const OCProvisionDev_t*) g_own_list, dev_num)->doxm->deviceID,
+ &dev->doxm->deviceID,
&dvid_lst, &dvid_cnt)) // allow empty list
{
- OC_LOG(ERROR, TAG, "OCGetLinkedStatus API error");
+ OIC_LOG(ERROR, TAG, "OCGetLinkedStatus API error");
goto CKLST_ERROR;
}
}
if(dvid_cnt != printUuidList((const OCUuidList_t*) dvid_lst))
{
- OC_LOG(ERROR, TAG, "printUuidList error return");
+ OIC_LOG(ERROR, TAG, "printUuidList error return");
goto CKLST_ERROR;
}
OCDeleteUuidList(dvid_lst);
return -1;
}
+static int getCred(void)
+{
+ // check |own_list| for checking selected link status on PRVN DB
+ if(!g_own_list || 1>g_own_cnt)
+ {
+ printf(" > Owned Device List, to Check Linked Status on PRVN DB, is Empty\n");
+ printf(" > Please Register Unowned Devices first, with [20] Menu\n");
+ return 0; // normal case
+ }
+
+ // select device for checking selected link status on PRVN DB
+ int dev_num = 0;
+ for( ; ; )
+ {
+ printf(" > Enter Device Number, for Checking Linked Status on PRVN DB: ");
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%d", &dev_num);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ if(0<dev_num && g_own_cnt>=dev_num)
+ {
+ break;
+ }
+ printf(" Entered Wrong Number. Please Enter Again\n");
+ }
+
+ // call |getDevInst| API actually
+ // calling this API with callback actually acts like blocking
+ // for error checking, the return value saved and printed
+ g_doneCB = false;
+ OCProvisionDev_t* dev = getDevInst((const OCProvisionDev_t*) g_own_list, dev_num);
+ if(!dev)
+ {
+ OIC_LOG(ERROR, TAG, "getDevInst: device instance empty");
+ goto PVACL_ERROR;
+ }
+ OCStackResult rst = OCGetCredResource((void*) g_ctx, dev, getCredCB);
+ if(OC_STACK_OK != rst)
+ {
+ OIC_LOG_V(ERROR, TAG, "OCGetCred API error: %d", rst);
+ goto PVACL_ERROR;
+ }
+ if(waitCallbackRet()) // input |g_doneCB| flag implicitly
+ {
+ OIC_LOG(ERROR, TAG, "OCGetCredResource callback error");
+ goto PVACL_ERROR;
+ }
+
+ // display the result of get credential
+ printf(" > Get Cred SUCCEEDED\n");
+
+ return 0;
+
+PVACL_ERROR:
+ return -1;
+}
+
+static int getAcl(void)
+{
+ // check |own_list| for checking selected link status on PRVN DB
+ if(!g_own_list || 1>g_own_cnt)
+ {
+ printf(" > Owned Device List, to Check Linked Status on PRVN DB, is Empty\n");
+ printf(" > Please Register Unowned Devices first, with [20] Menu\n");
+ return 0; // normal case
+ }
+
+ // select device for checking selected link status on PRVN DB
+ int dev_num = 0;
+ for( ; ; )
+ {
+ printf(" > Enter Device Number, for Checking Linked Status on PRVN DB: ");
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%d", &dev_num);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ if(0<dev_num && g_own_cnt>=dev_num)
+ {
+ break;
+ }
+ printf(" Entered Wrong Number. Please Enter Again\n");
+ }
+
+ // call |getDevInst| API actually
+ // calling this API with callback actually acts like blocking
+ // for error checking, the return value saved and printed
+ g_doneCB = false;
+ OCProvisionDev_t* dev = getDevInst((const OCProvisionDev_t*) g_own_list, dev_num);
+ if(!dev)
+ {
+ OIC_LOG(ERROR, TAG, "getDevInst: device instance empty");
+ goto PVACL_ERROR;
+ }
+ OCStackResult rst = OCGetACLResource((void*) g_ctx, dev, getAclCB);
+ if(OC_STACK_OK != rst)
+ {
+ OIC_LOG_V(ERROR, TAG, "OCGetACLResource API error: %d", rst);
+
+ goto PVACL_ERROR;
+ }
+ if(waitCallbackRet()) // input |g_doneCB| flag implicitly
+ {
+ OIC_LOG(ERROR, TAG, "OCGetACLResource callback error");
+ goto PVACL_ERROR;
+ }
+
+ // display the result of get credential
+ printf(" > Get ACL SUCCEEDED\n");
+
+ return 0;
+
+PVACL_ERROR:
+ return -1;
+}
+
static int unlinkPairwise(void)
{
// check |own_list| for unlinking pairwise devices
int dev_num[2] = {0};
if(selectTwoDiffNum(&(dev_num[0]), &(dev_num[1]), g_own_cnt, "for Unlinking Devices"))
{
- OC_LOG(ERROR, TAG, "selectTwoDiffNum error return");
+ OIC_LOG(ERROR, TAG, "selectTwoDiffNum error return");
return -1;
}
unlinkDevicesCB);
if(OC_STACK_OK != rst)
{
- OC_LOG_V(ERROR, TAG, "OCUnlinkDevices API error: %d", rst);
+ OIC_LOG_V(ERROR, TAG, "OCUnlinkDevices API error: %d", rst);
return -1;
}
if(waitCallbackRet()) // input |g_doneCB| flag implicitly
{
- OC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
+ OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
return -1;
}
getDevInst((const OCProvisionDev_t*) g_own_list, dev_num), removeDeviceCB);
if(OC_STACK_OK != rst)
{
- OC_LOG_V(ERROR, TAG, "OCRemoveDevice API error: %d", rst);
+ OIC_LOG_V(ERROR, TAG, "OCRemoveDevice API error: %d", rst);
return -1;
}
if(waitCallbackRet()) // input |g_doneCB| flag implicitly
{
- OC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
+ OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
return -1;
}
return 0;
}
+static int removeDeviceWithUuid(void)
+{
+ char strUuid[64] = {0};
+ OicUuid_t revUuid;
+ printf("Input the UUID : ");
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%64s", strUuid);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ OCStackResult rst = ConvertStrToUuid(strUuid, &revUuid);
+ if(OC_STACK_OK != rst)
+ {
+ OIC_LOG_V(ERROR, TAG, "ConvertStrToUuid API error: %d", rst);
+ return -1;
+ }
+
+ rst = OCRemoveDeviceWithUuid("RemoveDeviceWithUUID", DISCOVERY_TIMEOUT, &revUuid, removeDeviceCB);
+ if(OC_STACK_OK != rst)
+ {
+ OIC_LOG_V(ERROR, TAG, "OCRemoveDeviceWithUuid API error: %d", rst);
+ return -1;
+ }
+
+ g_doneCB = false;
+ if(waitCallbackRet()) // input |g_doneCB| flag implicitly
+ {
+ OIC_LOG(ERROR, TAG, "OCRemoveDeviceWithUuid callback error");
+ return -1;
+ }
+
+ // display the removed result
+ printf(" > Removed %s Device\n", strUuid);
+ printf(" > Please Discover Owned Devices for the Registered Result, with [10|12] Menu\n");
+
+ return 0;
+}
+
+static int resetDevice(void)
+{
+ // check |own_list| for removing device
+ if (!g_own_list || 1 > g_own_cnt)
+ {
+ printf(" > Owned Device List, to Reset Device, is Empty\n");
+ printf(" > Please Register Unowned Devices first, with [20] Menu\n");
+ return 0;
+ }
+
+ // select device for removing it
+ int dev_num = 0;
+ for ( ; ; )
+ {
+ printf(" > Enter Device Number, for Resetting Device: ");
+ for (int ret = 0; 1 != ret; )
+ {
+ ret = scanf("%d", &dev_num);
+ for ( ; 0x20 <= getchar() ; ); // for removing overflow garbages
+ // '0x20 <= code' is character region
+ }
+ if (0 < dev_num && g_own_cnt >= dev_num)
+ {
+ break;
+ }
+ printf(" Entered Wrong Number. Please Enter Again\n");
+ }
+
+ g_doneCB = false;
+ printf(" Resetting Selected Owned Device..\n");
+
+ OCStackResult rst = OCResetDevice((void *) g_ctx, DISCOVERY_TIMEOUT,
+ getDevInst((const OCProvisionDev_t *) g_own_list, dev_num), syncDeviceCB);
+ if (OC_STACK_OK != rst)
+ {
+ OIC_LOG_V(ERROR, TAG, "OCResetDevice API error: %d", rst);
+ return -1;
+ }
+
+ if (waitCallbackRet()) // input |g_doneCB| flag implicitly
+ {
+ OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
+ return -1;
+ }
+
+ // display the removed result
+ printf(" > Reset Selected Owned Device SUCCEEDED\n");
+ printf(" > Please Discover Owned Devices for the Registered Result, with [10|12] Menu\n");
+
+ return 0;
+}
+
static OicSecAcl_t* createAcl(const int dev_num)
{
if(0>=dev_num || g_own_cnt<dev_num)
{
- OC_LOG(ERROR, TAG, "createAcl invalid parameters");
+ OIC_LOG(ERROR, TAG, "createAcl invalid parameters");
return NULL; // not need to 'goto' |ERROR| before allocating |acl|
}
OicSecAcl_t* acl = (OicSecAcl_t*) OICCalloc(1, sizeof(OicSecAcl_t));
if(!acl)
{
- OC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
+ OIC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
+ return NULL; // not need to 'goto' |ERROR| before allocating |acl|
+ }
+ OicSecAce_t* ace = (OicSecAce_t*) OICCalloc(1, sizeof(OicSecAce_t));
+ if(!ace)
+ {
+ OIC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
return NULL; // not need to 'goto' |ERROR| before allocating |acl|
}
+ LL_APPEND(acl->aces, ace);
// enter |subject| device number
int num = 0;
for( ; 0x20<=getchar(); ); // for removing overflow garbages
// '0x20<=code' is character region
}
- if(num && g_own_cnt>=num && dev_num!=num)
+ if(0<num && g_own_cnt>=num && dev_num!=num)
{
break;
}
printf(" Entered Wrong Number. Please Enter Again\n");
}
- memcpy(&acl->subject,
- &getDevInst((const OCProvisionDev_t*) g_own_list, num)->doxm->deviceID,
- UUID_LENGTH); // not need |*sizeof(uint8_t)|
+
+ OCProvisionDev_t* dev = getDevInst((const OCProvisionDev_t*)g_own_list, num);
+ if(!dev || !dev->doxm)
+ {
+ OIC_LOG(ERROR, TAG, "createAcl: device instance empty");
+ goto CRACL_ERROR;
+ }
+ memcpy(&ace->subjectuuid, &dev->doxm->deviceID, UUID_LENGTH);
// enter number of |resources| in 'accessed' device
for( ; ; )
// '16' is |ACL_RESRC_MAX_NUM|
for(int ret=0; 1!=ret; )
{
- ret = scanf("%zu", &acl->resourcesLen);
+ ret = scanf("%d", &num);
for( ; 0x20<=getchar(); ); // for removing overflow garbages
// '0x20<=code' is character region
}
- if(acl->resourcesLen && ACL_RESRC_MAX_NUM>=acl->resourcesLen)
- // |acl->resourcesLen| is unsigned
+ if(0<num && ACL_RESRC_MAX_NUM>=num)
{
break;
}
// enter actually each 'accessed' |resources| name
printf(" Enter Each Accessed Resource Name (each under 128 char)\n");
// '128' is ACL_RESRC_MAX_LEN
- num = acl->resourcesLen;
- acl->resources = (char**) OICCalloc(num, sizeof(char*));
- if(!acl->resources)
- {
- OC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
- goto CRACL_ERROR;
- }
+
char rsrc_in[ACL_RESRC_MAX_LEN+1] = {0}; // '1' for null termination
- for(int i=0; num>i; ++i)
+ for(int i = 0; num > i; ++i)
{
- printf(" Enter Accessed Resource[%d] Name: ", i+1);
+ OicSecRsrc_t* rsrc = (OicSecRsrc_t*)OICCalloc(1, sizeof(OicSecRsrc_t));
+ if(!rsrc)
+ {
+ OIC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
+ goto CRACL_ERROR;
+ }
+
+ printf(" Enter Accessed Resource[%d] Name: (e.g. /a/led)", i+1);
for(int ret=0; 1!=ret; )
{
ret = scanf("%128s", rsrc_in); // '128' is ACL_RESRC_MAX_LEN
// '0x20<=code' is character region
}
size_t len = strlen(rsrc_in)+1; // '1' for null termination
- char* rsrc = (char*) OICCalloc(len, sizeof(char));
+ rsrc->href = (char*) OICCalloc(len, sizeof(char));
if(!rsrc)
{
- OC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
+ OIC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
goto CRACL_ERROR;
}
- OICStrcpy(rsrc, len, rsrc_in);
- acl->resources[i] = rsrc; // after here, |rsrc| points nothing
+ OICStrcpy(rsrc->href, len, rsrc_in);
+
+ int arrLen = 0;
+ while(1)
+ {
+ printf(" Enter Number of resource type for [%s] : ", rsrc->href);
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%d", &arrLen);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ if(0 < arrLen && ACL_RESRC_ARRAY_SIZE >= arrLen)
+ {
+ break;
+ }
+ printf(" Entered Wrong Number. Please Enter under %d Again\n", ACL_RESRC_ARRAY_SIZE);
+ }
+
+ rsrc->typeLen = arrLen;
+ rsrc->types = (char**)OICCalloc(arrLen, sizeof(char*));
+ if(!rsrc->types)
+ {
+ OIC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
+ goto CRACL_ERROR;
+ }
+
+ for(int i = 0; i < arrLen; i++)
+ {
+ printf(" Enter ResourceType[%d] Name (e.g. core.led): ", i+1);
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%128s", rsrc_in); // '128' is ACL_RESRC_MAX_LEN
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ rsrc->types[i] = OICStrdup(rsrc_in);
+ if(!rsrc->types[i])
+ {
+ OIC_LOG(ERROR, TAG, "createAcl: OICStrdup error return");
+ goto CRACL_ERROR;
+ }
+ }
+
+ while(1)
+ {
+ printf(" Enter Number of interface for [%s]: ", rsrc->href);
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%d", &arrLen);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ if(0 < arrLen && ACL_RESRC_ARRAY_SIZE >= arrLen)
+ {
+ break;
+ }
+ printf(" Entered Wrong Number. Please Enter under %d Again\n", ACL_RESRC_ARRAY_SIZE);
+ }
+
+ rsrc->interfaceLen = arrLen;
+ rsrc->interfaces = (char**)OICCalloc(arrLen, sizeof(char*));
+ if(!rsrc->interfaces)
+ {
+ OIC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
+ goto CRACL_ERROR;
+ }
+
+ for(int i = 0; i < arrLen; i++)
+ {
+ printf(" Enter Interface[%d] Name (e.g. oic.if.baseline): ", i+1);
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%128s", rsrc_in); // '128' is ACL_RESRC_MAX_LEN
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ rsrc->interfaces[i] = OICStrdup(rsrc_in);
+ if(!rsrc->interfaces[i])
+ {
+ OIC_LOG(ERROR, TAG, "createAcl: OICStrdup error return");
+ goto CRACL_ERROR;
+ }
+ }
+
+ LL_APPEND(ace->resources, rsrc);
}
// enter |permission| for this access
}
pmsn_msk <<= 1;
}
- acl->permission = pmsn;
+ ace->permission = pmsn;
- // enter |owner| device number
- for( ; ; )
+ return acl;
+
+CRACL_ERROR:
+ OCDeleteACLList(acl); // after here |acl| points nothing
+ return NULL;
+}
+
+static OicSecPdAcl_t* createPdAcl(const int dev_num)
+{
+ if(0>=dev_num || g_own_cnt<dev_num)
{
- printf(" > [D] Enter Owner Device Number: ");
- for(int ret=0; 1!=ret; )
- {
- ret = scanf("%d", &num);
- for( ; 0x20<=getchar(); ); // for removing overflow garbages
- // '0x20<=code' is character region
- }
- if(num && g_own_cnt>=num)
- {
- break;
- }
- printf(" Entered Wrong Number. Please Enter Again\n");
+ OIC_LOG(ERROR, TAG, "createAcl invalid parameters");
+ return NULL; // not need to 'goto' |ERROR| before allocating |acl|
}
- acl->ownersLen = 1;
- acl->owners = (OicUuid_t*) OICCalloc(1, sizeof(OicUuid_t));
- if(!acl->owners)
+
+ // allocate memory for |pdacl| struct
+ printf(" **** Create PDACL for the Selected Device[%d]\n", dev_num);
+ OicSecPdAcl_t* pdAcl = (OicSecPdAcl_t*) OICCalloc(1, sizeof(OicSecPdAcl_t));
+ if(!pdAcl)
{
- OC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
- goto CRACL_ERROR;
+ OIC_LOG(ERROR, TAG, "createAcl: OICCalloc error return");
+ return NULL; // not need to 'goto' |ERROR| before allocating |acl|
}
- memcpy(acl->owners,
- &getDevInst((const OCProvisionDev_t*) g_own_list, num)->doxm->deviceID,
- UUID_LENGTH); // not need |*sizeof(uint8_t)|
- printf("\n");
- return acl;
-CRACL_ERROR:
- OCDeleteACLList(acl); // after here |acl| points nothing
+ // number of resources
+ char rsrc_in[][ACL_RESRC_MAX_LEN+1] = {"*", "/rsrc/*"};
+ pdAcl->resourcesLen = 1;
+
+ // resource
+ int num = pdAcl->resourcesLen;
+ pdAcl->resources = (char**) OICCalloc(num, sizeof(char*));
+ if(!pdAcl->resources)
+ {
+ OIC_LOG(ERROR, TAG, "createPdAcl: OICCalloc error return");
+ goto CRPDACL_ERROR;
+ }
+ for(int i=0; num>i; ++i)
+ {
+ size_t len = strlen(rsrc_in[i])+1; // '1' for null termination
+ char* rsrc = (char*) OICCalloc(len, sizeof(char));
+ if(!rsrc)
+ {
+ OIC_LOG(ERROR, TAG, "createPdAcl: OICCalloc error return");
+ goto CRPDACL_ERROR;
+ }
+ OICStrcpy(rsrc, len, rsrc_in[i]);
+ pdAcl->resources[i] = rsrc; // after here, |rsrc| points nothing
+ }
+
+ // permission
+ pdAcl->permission = PERMISSION_FULL_CONTROL;
+
+ return pdAcl;
+
+CRPDACL_ERROR:
+ OCDeletePdAclList(pdAcl);
return NULL;
}
sleep(1);
if(OC_STACK_OK != OCProcess())
{
- OC_LOG(ERROR, TAG, "OCStack process error");
+ OIC_LOG(ERROR, TAG, "OCStack process error");
return -1;
}
}
static int selectTwoDiffNum(int* a, int* b, const int max, const char* str)
{
- if(!a || !b || 2>=max || !str)
+ if(!a || !b || 2>max || !str)
{
return -1;
}
printf("** 30. Provision/Link Pairwise Things\n");
printf("** 31. Provision Credentials for Pairwise Things\n");
printf("** 32. Provision the Selected Access Control List(ACL)\n");
- printf("** 33. Check Linked Status of the Selected Device on PRVN DB\n\n");
+ printf("** 33. Provision Direct-Pairing Configuration\n");
+ printf("** 34. Check Linked Status of the Selected Device on PRVN DB\n\n");
printf("** [D] UNLINK PAIRWISE THINGS\n");
printf("** 40. Unlink Pairwise Things\n\n");
printf("** [E] REMOVE THE SELECTED DEVICE\n");
- printf("** 50. Remove the Selected Device\n\n");
+ printf("** 50. Remove the Selected Device\n");
+ printf("** 51. Remove Device with UUID (UUID input is required)\n");
+ printf("** 52. Reset the Selected Device\n\n");
+
+ printf("** [F] GET SECURITY RESOURCE FOR DEBUGGING ONLY\n");
+ printf("** 60. Get the Credential resources of the Selected Device\n");
+ printf("** 61. Get the ACL resources of the Selected Device\n\n");
- printf("** [F] EXIT PROVISIONING CLIENT\n");
+ printf("** [G] EXIT PROVISIONING CLIENT\n");
printf("** 99. Exit Provisionong Client\n\n");
printf("************************************************************\n\n");
// initialize provisioning client
if(initProvisionClient())
{
- OC_LOG(ERROR, TAG, "ProvisionClient init error");
+ OIC_LOG(ERROR, TAG, "ProvisionClient init error");
goto PMCLT_ERROR;
}
case _10_DISCOV_ALL_DEVS_:
if(discoverAllDevices())
{
- OC_LOG(ERROR, TAG, "_10_DISCOV_ALL_DEVS_: error");
+ OIC_LOG(ERROR, TAG, "_10_DISCOV_ALL_DEVS_: error");
}
break;
case _11_DISCOV_UNOWN_DEVS_:
if(discoverUnownedDevices())
{
- OC_LOG(ERROR, TAG, "_11_DISCOV_UNOWN_DEVS_: error");
+ OIC_LOG(ERROR, TAG, "_11_DISCOV_UNOWN_DEVS_: error");
}
break;
case _12_DISCOV_OWN_DEVS_:
if(discoverOwnedDevices())
{
- OC_LOG(ERROR, TAG, "_12_DISCOV_OWN_DEVS_: error");
+ OIC_LOG(ERROR, TAG, "_12_DISCOV_OWN_DEVS_: error");
}
break;
case _20_REGIST_DEVS_:
if(registerDevices())
{
- OC_LOG(ERROR, TAG, "_20_REGIST_DEVS_: error");
+ OIC_LOG(ERROR, TAG, "_20_REGIST_DEVS_: error");
}
break;
case _30_PROVIS_PAIR_DEVS_:
if(provisionPairwise())
{
- OC_LOG(ERROR, TAG, "_30_PROVIS_PAIR_DEVS_: error");
+ OIC_LOG(ERROR, TAG, "_30_PROVIS_PAIR_DEVS_: error");
}
break;
case _31_PROVIS_CRED_:
if(provisionCred())
{
- OC_LOG(ERROR, TAG, "_31_PROVIS_CRED_: error");
+ OIC_LOG(ERROR, TAG, "_31_PROVIS_CRED_: error");
}
break;
case _32_PROVIS_ACL_:
if(provisionAcl())
{
- OC_LOG(ERROR, TAG, "_32_PROVIS_ACL_: error");
+ OIC_LOG(ERROR, TAG, "_32_PROVIS_ACL_: error");
+ }
+ break;
+ case _33_PROVIS_DP_:
+ if(provisionDirectPairing())
+ {
+ OIC_LOG(ERROR, TAG, "_33_PROVIS_DP_: error");
}
break;
- case _33_CHECK_LINK_STATUS_:
+ case _34_CHECK_LINK_STATUS_:
if(checkLinkedStatus())
{
- OC_LOG(ERROR, TAG, "_33_CHECK_LINK_STATUS_: error");
+ OIC_LOG(ERROR, TAG, "_34_CHECK_LINK_STATUS_: error");
}
break;
case _40_UNLINK_PAIR_DEVS_:
if(unlinkPairwise())
{
- OC_LOG(ERROR, TAG, "_40_UNLINK_PAIR_DEVS_: error");
+ OIC_LOG(ERROR, TAG, "_40_UNLINK_PAIR_DEVS_: error");
}
break;
case _50_REMOVE_SELEC_DEV_:
if(removeDevice())
{
- OC_LOG(ERROR, TAG, "_50_REMOVE_SELEC_DEV_: error");
+ OIC_LOG(ERROR, TAG, "_50_REMOVE_SELEC_DEV_: error");
+ }
+ break;
+ case _51_REMOVE_DEV_WITH_UUID_:
+ if(removeDeviceWithUuid())
+ {
+ OIC_LOG(ERROR, TAG, "_51_REMOVE_DEV_WITH_UUID_: error");
+ }
+ break;
+ case _52_RESET_SELEC_DEV_:
+ if(resetDevice())
+ {
+ OIC_LOG(ERROR, TAG, "_52_RESET_SELEC_DEV_: error");
+ }
+ break;
+ case _60_GET_CRED_:
+ if(getCred())
+ {
+ OIC_LOG(ERROR, TAG, "_60_GET_CRED_: error");
+ }
+ break;
+ case _61_GET_ACL_:
+ if(getAcl())
+ {
+ OIC_LOG(ERROR, TAG, "_61_GET_ACL_: error");
}
break;
case _99_EXIT_PRVN_CLT_:
PMCLT_ERROR:
if(OC_STACK_OK != OCStop())
{
- OC_LOG(ERROR, TAG, "OCStack stop error");
+ OIC_LOG(ERROR, TAG, "OCStack stop error");
}
OCDeleteDiscoveredDevices(g_own_list); // after here |g_own_list| points nothing
OCDeleteDiscoveredDevices(g_unown_list); // after here |g_unown_list| points nothing
#ifdef __cplusplus
}
-#endif //__cplusplus
\ No newline at end of file
+#endif //__cplusplus