static int discoverAllDevices(void)
{
// delete un/owned device lists before updating them
if(g_own_list)
{
OCDeleteDiscoveredDevices(g_own_list);
g_own_list = NULL;
}
if(g_unown_list)
{
OCDeleteDiscoveredDevices(g_unown_list);
g_unown_list = NULL;
}
// call |OCGetDevInfoFromNetwork| API actually
printf(" Discovering All Un/Owned Devices on Network..\n");
if(OC_STACK_OK != OCGetDevInfoFromNetwork(DISCOVERY_TIMEOUT, &g_own_list, &g_unown_list))
{
OIC_LOG(ERROR, TAG, "OCGetDevInfoFromNetwork API error");
return -1;
}
// display the discovered un/owned lists
printf(" > Discovered Owned Devices\n");
g_own_cnt = printDevList(g_own_list);
printf(" > Discovered Unowned Devices\n");
g_unown_cnt = printDevList(g_unown_list);
return 0;
}
OCSecureResource::~OCSecureResource()
{
if(devPtr)
{
OCDeleteDiscoveredDevices(devPtr);
}
}
static int discoverOwnedDevices(void)
{
// delete owned device list before updating it
if(g_own_list)
{
OCDeleteDiscoveredDevices(g_own_list);
g_own_list = NULL;
}
// call |OCDiscoverOwnedDevices| API actually
printf(" Discovering Only Owned Devices on Network..\n");
if(OC_STACK_OK != OCDiscoverOwnedDevices(DISCOVERY_TIMEOUT, &g_own_list))
{
OIC_LOG(ERROR, TAG, "OCDiscoverOwnedDevices API error");
return -1;
}
// display the discovered owned list
printf(" > Discovered Owned Devices\n");
g_own_cnt = printDevList(g_own_list);
return 0;
}
/**
* Provisioning client sample using ProvisioningAPI
*/
int main()
{
OCStackResult res = OC_STACK_OK;
int unused;
(void)unused;
// Initialize Persistent Storage for SVR database
OCPersistentStorage ps = { .open = NULL,
.read = NULL,
.write = NULL,
.close = NULL,
.unlink = NULL };
ps.open = client_fopen;
ps.read = fread;
ps.write = fwrite;
ps.close = fclose;
ps.unlink = unlink;
OCRegisterPersistentStorageHandler(&ps);
if (OC_STACK_OK != OCInit(NULL, 0, OC_CLIENT_SERVER))
{
OC_LOG(ERROR, TAG, "OCStack init error");
goto error;
}
OCProvisionDev_t* pDeviceList = NULL;
res = OCDiscoverUnownedDevices(PREDEFINED_TIMEOUT, &pDeviceList);
if(OC_STACK_OK != res)
{
OC_LOG_V(ERROR, TAG, "Failed to PMDeviceDiscovery : %d", res);
goto error;
}
OCProvisionDev_t* pCurDev = pDeviceList;
int i;
while(pCurDev !=NULL)
{
for(i = 0; i < UUID_LENGTH; i++)
printf("%c", pCurDev->doxm->deviceID.id[i]);
printf("\n");
pCurDev = pCurDev->next;
}
//Register callback function to each OxM
OTMCallbackData_t justWorksCBData = {.loadSecretCB=NULL,
.createSecureSessionCB=NULL,
.createSelectOxmPayloadCB=NULL,
.createOwnerTransferPayloadCB=NULL};
justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
OTMSetOwnershipTransferCallbackData(OIC_JUST_WORKS, &justWorksCBData);
OTMCallbackData_t pinBasedCBData = {.loadSecretCB=NULL,
.createSecureSessionCB=NULL,
.createSelectOxmPayloadCB=NULL,
.createOwnerTransferPayloadCB=NULL};
pinBasedCBData.loadSecretCB = InputPinCodeCallback;
pinBasedCBData.createSecureSessionCB = CreateSecureSessionRandomPinCallbak;
pinBasedCBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
pinBasedCBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
OTMSetOwnershipTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &pinBasedCBData);
SetInputPinCB(&InputPinCB);
char* myContext = "OTM Context";
//Perform ownership transfer
res = OCDoOwnershipTransfer((void*)myContext, pDeviceList, OwnershipTransferCB);
if(OC_STACK_OK == res)
{
OC_LOG(INFO, TAG, "Request for ownership transfer is sent successfully.");
}
else
{
OC_LOG_V(ERROR, TAG, "Failed to OCDoOwnershipTransfer : %d", res);
}
gOwnershipState = 0;
while ( gOwnershipState == 0 )
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
goto error;
}
sleep(1);
}
// Credential & ACL provisioning between two devices.
OCProvisionDev_t *pOwnedList = NULL;
OCProvisionDev_t *pOwnedDevices [MAX_OWNED_DEVICE] = {0,};
int nOwnedDevice = 0;
res = OCDiscoverOwnedDevices(PREDEFINED_TIMEOUT, &pOwnedList);
if (OC_STACK_OK == res)
{
printf("################## Owned Device List #######################\n");
while (pOwnedList != NULL)
{
nOwnedDevice ++;
printf(" %d : ", nOwnedDevice);
for (int i = 0; i < UUID_LENGTH; i++)
{
printf("%c", pOwnedList->doxm->deviceID.id[i]);
}
printf("\n");
pOwnedDevices[nOwnedDevice] = pOwnedList;
pOwnedList = pOwnedList->next;
}
}
else
{
OC_LOG(ERROR, TAG, "Error while Owned Device Discovery");
}
int Device1 = 0;
int Device2 = 0;
printf("Select 2 devices for Credential & ACL provisioning\n");
printf("Device 1: ");
unused = scanf("%d", &Device1);
printf("Device 2: ");
unused = scanf("%d", &Device2);
gAcl1 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
if (NULL == gAcl1)
{
OC_LOG(ERROR, TAG, "Error while memory allocation");
goto error;
}
gAcl2 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
if (NULL == gAcl2)
{
OC_LOG(ERROR, TAG, "Error while memory allocation");
goto error;
}
printf("Input ACL for Device1\n");
if ( 0 == InputACL(gAcl1))
{
printf("Success Input ACL\n");
}
else
{
OC_LOG(ERROR, TAG, "InputACL error");
goto error;
}
printf("Input ACL for Device2\n");
if (0 == InputACL(gAcl2))
{
printf("Success Input ACL\n");
}
else
{
OC_LOG(ERROR, TAG, "InputACL error");
goto error;
}
char *ctx = "DUMMY";
OCProvisionPairwiseDevices(ctx,SYMMETRIC_PAIR_WISE_KEY, OWNER_PSK_LENGTH_128, pOwnedDevices[Device1],
gAcl1, pOwnedDevices[Device2], gAcl2, ProvisionPairwiseCB);
gOwnershipState = 0;
while ( gOwnershipState == 0 )
{
if (OCProcess() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
goto error;
}
sleep(1);
}
if (OCStop() != OC_STACK_OK)
{
OC_LOG(ERROR, TAG, "OCStack process error");
goto error;
}
error:
deleteACL(gAcl1);
deleteACL(gAcl2);
OCDeleteDiscoveredDevices(&pDeviceList);
OCDeleteDiscoveredDevices(&pOwnedList);
return 0;
}
// main function for provisioning client using C-level provisioning API
int main()
{
// initialize provisioning client
if(initProvisionClient())
{
OIC_LOG(ERROR, TAG, "ProvisionClient init error");
goto PMCLT_ERROR;
}
// main loop for provisioning manager
int mn_num = 0;
for( ; ; )
{
printf("\n");
printMenu();
printf(">> Enter Menu Number: ");
for(int ret=0; 1!=ret; )
{
ret = scanf("%d", &mn_num);
for( ; 0x20<=getchar(); ); // for removing overflow garbages
// '0x20<=code' is character region
}
printf("\n");
switch(mn_num)
{
case _10_DISCOV_ALL_DEVS_:
if(discoverAllDevices())
{
OIC_LOG(ERROR, TAG, "_10_DISCOV_ALL_DEVS_: error");
}
break;
case _11_DISCOV_UNOWN_DEVS_:
if(discoverUnownedDevices())
{
OIC_LOG(ERROR, TAG, "_11_DISCOV_UNOWN_DEVS_: error");
}
break;
case _12_DISCOV_OWN_DEVS_:
if(discoverOwnedDevices())
{
OIC_LOG(ERROR, TAG, "_12_DISCOV_OWN_DEVS_: error");
}
break;
case _20_REGIST_DEVS_:
if(registerDevices())
{
OIC_LOG(ERROR, TAG, "_20_REGIST_DEVS_: error");
}
break;
case _30_PROVIS_PAIR_DEVS_:
if(provisionPairwise())
{
OIC_LOG(ERROR, TAG, "_30_PROVIS_PAIR_DEVS_: error");
}
break;
case _31_PROVIS_CRED_:
if(provisionCred())
{
OIC_LOG(ERROR, TAG, "_31_PROVIS_CRED_: error");
}
break;
case _32_PROVIS_ACL_:
if(provisionAcl())
{
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 _34_CHECK_LINK_STATUS_:
if(checkLinkedStatus())
{
OIC_LOG(ERROR, TAG, "_34_CHECK_LINK_STATUS_: error");
}
break;
case _40_UNLINK_PAIR_DEVS_:
if(unlinkPairwise())
{
OIC_LOG(ERROR, TAG, "_40_UNLINK_PAIR_DEVS_: error");
}
break;
case _50_REMOVE_SELEC_DEV_:
if(removeDevice())
{
OIC_LOG(ERROR, TAG, "_50_REMOVE_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_:
goto PMCLT_ERROR;
default:
printf(">> Entered Wrong Number. Please Enter Again\n\n");
break;
}
}
PMCLT_ERROR:
if(OC_STACK_OK != OCStop())
{
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
if(g_svr_fname)
{
OICFree(g_svr_fname); // after here |g_svr_fname| points nothing
}
if(g_prvn_fname)
{
OICFree(g_prvn_fname); // after here |g_prvn_fname| points nothing
}
return 0; // always return normal case
}
