// External includes
#include "logger.h"
#include "oic_malloc.h"
+#include "oic_string.h"
+
+#define ES_PROV_TAG "EASY_SETUP_PROVISIONING"
bool g_provisioningCondFlag = false;
OCStackResult ret = OC_STACK_ERROR;
/* Initialize OCStack*/
if (OCInit(NULL, 0, OC_CLIENT) != OC_STACK_OK) {
- OIC_LOG(ERROR, TAG, "OCStack init error");
+ OIC_LOG(ERROR, ES_PROV_TAG, "OCStack init error");
return ret;
}
- char *string = "listeningFunc invoked in a thread";
-
pthread_t thread_handle;
- if (pthread_create(&thread_handle, NULL, listeningFunc, (void *) string)) {
- OIC_LOG(DEBUG, TAG, "Thread creation failed");
+ if (pthread_create(&thread_handle, NULL, listeningFunc, NULL)) {
+ OIC_LOG(DEBUG, ES_PROV_TAG, "Thread creation failed");
return OC_STACK_ERROR;
}
OCStackResult TerminateProvisioningHandler() {
OCStackResult ret = OC_STACK_ERROR;
if (OCStop() != OC_STACK_OK) {
- OIC_LOG(ERROR, TAG, "OCStack stop error");
+ OIC_LOG(ERROR, ES_PROV_TAG, "OCStack stop error");
}
g_provisioningCondFlag = true;
return ret;
}
-void *listeningFunc(void *data) {
+void *listeningFunc(void* /*data*/) {
while (!g_provisioningCondFlag) {
OCStackResult result;
result = OCProcess();
if (result != OC_STACK_OK) {
- OIC_LOG(ERROR, TAG, "OCStack stop error");
+ OIC_LOG(ERROR, ES_PROV_TAG, "OCStack stop error");
}
// To minimize CPU utilization we may wish to do this with sleep
}
-OCStackApplicationResult ProvisionEnrolleeResponse(void *ctx, OCDoHandle handle,
+OCStackApplicationResult ProvisionEnrolleeResponse(void* /*ctx*/, OCDoHandle /*handle*/,
OCClientResponse *clientResponse) {
- OIC_LOG_V(DEBUG, TAG, "INSIDE ProvisionEnrolleeResponse");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "INSIDE ProvisionEnrolleeResponse");
// If user stopped the process then return from this function;
if (IsSetupStopped()) {
return OC_STACK_DELETE_TRANSACTION;
}
- ProvisioningInfo *provInfo;
-
if (!ValidateEnrolleResponse(clientResponse)) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
return OC_STACK_DELETE_TRANSACTION;
continue;
}
else {
- OIC_LOG_V(DEBUG, TAG, "PS is NOT proper");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "PS is NOT proper");
goto Error;
}
if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_TNN, &tnn)) {
if (!strcmp(tnn, netProvInfo->netAddressInfo.WIFI.ssid)) {
- OIC_LOG_V(DEBUG, TAG, "SSID is proper");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "SSID is proper");
input = input->next;
continue;
}
else {
- OIC_LOG_V(DEBUG, TAG, "SSID is NOT proper");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "SSID is NOT proper");
goto Error;
}
}
if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CD, &cd)) {
if (!strcmp(cd, netProvInfo->netAddressInfo.WIFI.pwd)) {
- OIC_LOG_V(DEBUG, TAG, "Password is proper");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "Password is proper");
input = input->next;
continue;
}
else {
- OIC_LOG_V(DEBUG, TAG, "Password is NOT proper");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "Password is NOT proper");
goto Error;
}
}
input = input->next;
+ OICFree(tnn);
+ OICFree(cd);
}
SuccessCallback(clientResponse);
Error:
{
+ OICFree(tnn);
+ OICFree(cd);
ErrorCallback(DEVICE_NOT_PROVISIONED);
OCProvisioningStatusCB provisioningStatusCallback,
char *findResQuery) {
- OCStackResult result = OC_STACK_ERROR;
-
- snprintf(szFindResourceQueryUri, sizeof(szFindResourceQueryUri) - 1, findResQuery);
- char *string = "Starting provisioning process ";
+ if(findResQuery != NULL)
+ {
+ OICStrcpy(szFindResourceQueryUri, sizeof(szFindResourceQueryUri) - 1, findResQuery);
+ }
+ else
+ {
+ OIC_LOG(ERROR, ES_PROV_TAG, PCF("Find resource query is NULL"));
+ goto Error;
+ }
pthread_t thread_handle;
if (!SetProgress(provisioningStatusCallback)) {
// Device provisioning session is running already.
- OIC_LOG(INFO, TAG, PCF("Device provisioning session is running already"));
+ OIC_LOG(INFO, ES_PROV_TAG, PCF("Device provisioning session is running already"));
goto Error;
}
goto Error;
}
- if (pthread_create(&thread_handle, NULL, FindProvisioningResource, (void *) string)) {
+ if (pthread_create(&thread_handle, NULL, FindProvisioningResource, NULL)) {
goto Error;
}
bool ClearMemory() {
- OIC_LOG(DEBUG, TAG, "thread_pool_add_task of FindProvisioningResource failed");
+ OIC_LOG(DEBUG, ES_PROV_TAG, "thread_pool_add_task of FindProvisioningResource failed");
+ OICFree(netProvInfo);
return true;
}
netProvInfo = (EnrolleeNWProvInfo_t *) OICCalloc(1, sizeof(EnrolleeNWProvInfo_t));
if (netProvInfo == NULL) {
- OIC_LOG(ERROR, TAG, "Invalid input..");
+ OIC_LOG(ERROR, ES_PROV_TAG, "Invalid input..");
return false;
}
memcpy(netProvInfo, netInfo, sizeof(EnrolleeNWProvInfo_t));
- OIC_LOG_V(DEBUG, TAG, "Network Provisioning Info. SSID = %s",
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "Network Provisioning Info. SSID = %s",
netProvInfo->netAddressInfo.WIFI.ssid);
- OIC_LOG_V(DEBUG, TAG, "Network Provisioning Info. PWD = %s",
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "Network Provisioning Info. PWD = %s",
netProvInfo->netAddressInfo.WIFI.pwd);
return true;
switch (val->type) {
case OCREP_PROP_NULL:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s: NULL", val->name);
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s: NULL", val->name);
break;
case OCREP_PROP_INT:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(int):%lld", val->name, val->i);
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(int):%lld", val->name, val->i);
break;
case OCREP_PROP_DOUBLE:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(double):%f", val->name, val->d);
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(double):%f", val->name, val->d);
break;
case OCREP_PROP_BOOL:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(bool):%s", val->name, val->b ? "true" : "false");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(bool):%s", val->name, val->b ? "true" : "false");
break;
case OCREP_PROP_STRING:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(string):%s", val->name, val->str);
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(string):%s", val->name, val->str);
break;
case OCREP_PROP_OBJECT:
// Note: Only prints the URI (if available), to print further, you'll
// need to dig into the object better!
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(OCRep):%s", val->name, val->obj->uri);
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(OCRep):%s", val->name, val->obj->uri);
break;
case OCREP_PROP_ARRAY:
switch (val->arr.type) {
case OCREP_PROP_INT:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(int array):%lld x %lld x %lld", val->name,
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(int array):%d x %d x %d",
+ val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
case OCREP_PROP_DOUBLE:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(double array):%lld x %lld x %lld", val->name,
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(double array):%d x %d x %d",
+ val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
case OCREP_PROP_BOOL:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(bool array):%lld x %lld x %lld", val->name,
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(bool array):%d x %d x %d",
+ val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
case OCREP_PROP_STRING:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(string array):%lld x %lld x %lld", val->name,
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(string array):%d x %d x %d",
+ val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
case OCREP_PROP_OBJECT:
- OIC_LOG_V(DEBUG, TAG, "\t\t%s(OCRep array):%lld x %lld x %lld", val->name,
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "\t\t%s(OCRep array):%d x %d x %d",
+ val->name,
val->arr.dimensions[0], val->arr.dimensions[1],
val->arr.dimensions[2]);
break;
OCStackResult FindNetworkResource() {
OCStackResult ret = OC_STACK_ERROR;
if (OCStop() != OC_STACK_OK) {
- OIC_LOG(ERROR, TAG, "OCStack stop error");
+ OIC_LOG(ERROR, ES_PROV_TAG, "OCStack stop error");
}
return ret;
ProvisioningInfo *provInfo = (ProvisioningInfo *) OICCalloc(1, sizeof(ProvisioningInfo));
if (provInfo == NULL) {
- OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
+ OIC_LOG_V(ERROR, ES_PROV_TAG, "Failed to allocate memory");
return NULL;
}
OCDevAddr *devAddr = (OCDevAddr *) OICCalloc(1, sizeof(OCDevAddr));
if (devAddr == NULL) {
- OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
+ OIC_LOG_V(ERROR, ES_PROV_TAG, "Failed to allocate memory");
+ OICFree(provInfo);
return NULL;
}
- strncpy(devAddr->addr, clientResponse->addr->addr, sizeof(devAddr->addr));
+ OICStrcpy(devAddr->addr, sizeof(devAddr->addr), clientResponse->addr->addr);
+
devAddr->port = clientResponse->addr->port;
provInfo->provDeviceInfo.addr = devAddr;
// It means already Easy Setup provisioning session is going on.
if (NULL != cbData) {
- OIC_LOG(ERROR, TAG, "Easy setup session is already in progress");
+ OIC_LOG(ERROR, ES_PROV_TAG, "Easy setup session is already in progress");
return true;
}
ProvisioningInfo *provInfo = (ProvisioningInfo *) OICCalloc(1, sizeof(ProvisioningInfo));
if (provInfo == NULL) {
- OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
+ OIC_LOG_V(ERROR, ES_PROV_TAG, "Failed to allocate memory");
return NULL;
}
OCDevAddr *devAddr = (OCDevAddr *) OICCalloc(1, sizeof(OCDevAddr));
if (devAddr == NULL) {
- OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
+ OIC_LOG_V(ERROR, ES_PROV_TAG, "Failed to allocate memory");
+ OICFree(provInfo);
return NULL;
}
ProvisioningInfo *GetCallbackObjectOnError(ProvStatus status) {
ProvisioningInfo *provInfo = CreateCallBackObject();
- strncpy(provInfo->provDeviceInfo.addr->addr, netProvInfo->netAddressInfo.WIFI.ipAddress,
- sizeof(provInfo->provDeviceInfo.addr->addr));
+ OICStrcpy(provInfo->provDeviceInfo.addr->addr, sizeof(provInfo->provDeviceInfo.addr->addr),
+ netProvInfo->netAddressInfo.WIFI.ipAddress);
+
provInfo->provDeviceInfo.addr->port = IP_PORT;
provInfo->provStatus = status;
return provInfo;
ProvisioningInfo *GetCallbackObjectOnSuccess(OCClientResponse *clientResponse,
ProvStatus provStatus) {
ProvisioningInfo *provInfo = CreateCallBackObject();
- strncpy(provInfo->provDeviceInfo.addr->addr, clientResponse->addr->addr,
- sizeof(provInfo->provDeviceInfo.addr->addr));
+ OICStrcpy(provInfo->provDeviceInfo.addr->addr, sizeof(provInfo->provDeviceInfo.addr->addr),
+ clientResponse->addr->addr);
+
provInfo->provDeviceInfo.addr->port = clientResponse->addr->port;
provInfo->provStatus = provStatus;
return provInfo;
if (!(clientResponse) || !(clientResponse->payload)) {
- OIC_LOG_V(INFO, TAG, "ProvisionEnrolleeResponse received Null clientResponse");
+ OIC_LOG_V(INFO, ES_PROV_TAG, "ProvisionEnrolleeResponse received Null clientResponse");
return false;
if (!(clientResponse) || !(clientResponse->payload)) {
- OIC_LOG_V(INFO, TAG, "ProvisionEnrolleeResponse received Null clientResponse");
+ OIC_LOG_V(INFO, ES_PROV_TAG, "ProvisionEnrolleeResponse received Null clientResponse");
return false;
if (clientResponse->payload->type != PAYLOAD_TYPE_REPRESENTATION) {
- OIC_LOG_V(DEBUG, TAG, "Incoming payload not a representation");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "Incoming payload not a representation");
return false;
}
ResetProgress();
}
-void *FindProvisioningResource(void *data) {
+void* FindProvisioningResource(void* /*data*/) {
// If user stopped the process before thread get scheduled then check and return from this function;
if (IsSetupStopped()) {
OCStackResult ret = OC_STACK_ERROR;
- OIC_LOG_V(DEBUG, TAG, "szFindResourceQueryUri = %s", szFindResourceQueryUri);
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "szFindResourceQueryUri = %s", szFindResourceQueryUri);
OCCallbackData ocCBData;
&cbData, options, numOptions);
if (ret != OC_STACK_OK) {
- OIC_LOG_V(ERROR, TAG, "OCDoResource returns error %d with method %d", ret, method);
+ OIC_LOG_V(ERROR, ES_PROV_TAG, "OCDoResource returns error %d with method %d", ret, method);
}
return ret;
// This sleep is required in case of BLE provisioning due to packet drop issue.
- OIC_LOG_V(INFO, TAG, "Sleeping for %d seconds", pauseBeforeStart);
+ OIC_LOG_V(INFO, ES_PROV_TAG, "Sleeping for %d seconds", pauseBeforeStart);
sleep(pauseBeforeStart);
- OIC_LOG_V(INFO, TAG, "\n\nExecuting ProvisionEnrollee%s", __func__);
+ OIC_LOG_V(INFO, ES_PROV_TAG, "\n\nExecuting ProvisionEnrollee%s", __func__);
OCRepPayload *payload = OCRepPayloadCreate();
OCRepPayloadSetPropString(payload, OC_RSRVD_ES_TNN, netProvInfo->netAddressInfo.WIFI.ssid);
OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CD, netProvInfo->netAddressInfo.WIFI.pwd);
- OIC_LOG_V(DEBUG, TAG, "OCPayload ready for ProvisionEnrollee");
+ OIC_LOG_V(DEBUG, ES_PROV_TAG, "OCPayload ready for ProvisionEnrollee");
- OCStackResult ret = InvokeOCDoResource(query, OC_REST_PUT, destination, OC_HIGH_QOS,
+ OCStackResult ret = InvokeOCDoResource(query, OC_REST_PUT, destination, qos,
ProvisionEnrolleeResponse, payload, NULL, 0);
return ret;
// External includes
#include "logger.h"
-#include "oic_malloc.h"
+#define ES_WIFI_PROV_TAG "ES_WIFI_PROVISIONING"
-static EnrolleeNWProvInfo_t *netProvInfo;
+static const char * UNICAST_PROV_STATUS_QUERY = "coap://%s:%d%s";
-/**
- * @var cbData
- * @brief Callback for providing provisioning status callback to application
- */
-static OCProvisioningStatusCB cbData = NULL;
-
-
-OCStackApplicationResult GetProvisioningStatusResponse(void *ctx, OCDoHandle handle,
- OCClientResponse *clientResponse) {
+OCStackApplicationResult GetProvisioningStatusResponse(void* /*ctx*/,
+ OCDoHandle /*handle*/,
+ OCClientResponse *clientResponse) {
// If user stopped the process then return from this function;
return OC_STACK_DELETE_TRANSACTION;
}
-
- ProvisioningInfo *provInfo;
-
if (!ValidateEnrolleResponse(clientResponse)) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
char resURI[MAX_URI_LENGTH] =
{'\0'};
- OIC_LOG_V(DEBUG, TAG, "resUri = %s", input->uri);
+ OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "resUri = %s", input->uri);
strncpy(resURI, input->uri, sizeof(resURI) - 1);
snprintf(query, sizeof(query), UNICAST_PROV_STATUS_QUERY, clientResponse->addr->addr, IP_PORT,
resURI);
- //OCPayloadLogRep(DEBUG,TAG,input);
-
if (ProvisionEnrollee(OC_HIGH_QOS, query, OC_RSRVD_ES_URI_PROV, clientResponse->addr, 0)
!= OC_STACK_OK) {
- OIC_LOG(INFO, TAG,
- "GetProvisioningStatusResponse received NULL clientResponse.Invoking Provisioing Status Callback");
+ OIC_LOG(INFO, ES_WIFI_PROV_TAG, "GetProvisioningStatusResponse received NULL clientResponse");
ErrorCallback(DEVICE_NOT_PROVISIONED);
ClearMemory();
OCStackResult ret = OC_STACK_ERROR;
OCHeaderOption options[MAX_HEADER_OPTIONS];
- OIC_LOG_V(INFO, TAG, "\n\nExecuting %s", __func__);
+ OIC_LOG_V(INFO, ES_WIFI_PROV_TAG, "\n\nExecuting %s", __func__);
uint8_t option0[] =
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
memcpy(options[1].optionData, option1, sizeof(option1));
options[1].optionLength = 10;
- ret = InvokeOCDoResource(query, OC_REST_GET, destination, OC_HIGH_QOS,
+ ret = InvokeOCDoResource(query, OC_REST_GET, destination, qos,
GetProvisioningStatusResponse, NULL, options, 2);
return ret;
}
// This is a function called back when a device is discovered
-OCStackApplicationResult FindProvisioningResourceResponse(void *ctx, OCDoHandle handle,
- OCClientResponse *clientResponse) {
+OCStackApplicationResult FindProvisioningResourceResponse(void* /*ctx*/,
+ OCDoHandle /*handle*/,
+ OCClientResponse *clientResponse) {
- OIC_LOG(INFO, TAG, PCF("Entering FindProvisioningResourceResponse"));
+ OIC_LOG(INFO, ES_WIFI_PROV_TAG, PCF("Entering FindProvisioningResourceResponse"));
// If user stopped the process then return from this function;
if (IsSetupStopped()) {
return OC_STACK_DELETE_TRANSACTION;
}
- OCStackApplicationResult response = OC_STACK_DELETE_TRANSACTION;
-
- ProvisioningInfo *provInfo;
- char szQueryUri[64] =
- {0};
+ char szQueryUri[64] = {0};
OCDiscoveryPayload *discoveryPayload = (OCDiscoveryPayload * )(clientResponse->payload);
- // Need to conform if below check is required or not. As Null check of clientResponse->payload is already performed above
- if (!discoveryPayload) {
- OIC_LOG_V(DEBUG, TAG, "Failed To parse");
- ErrorCallback(DEVICE_NOT_PROVISIONED);
- return OC_STACK_DELETE_TRANSACTION;
- }
-
- OIC_LOG_V(DEBUG, TAG, "resUri = %s", discoveryPayload->resources->uri);
+ OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "resUri = %s", discoveryPayload->resources->uri);
snprintf(szQueryUri, sizeof(szQueryUri), UNICAST_PROV_STATUS_QUERY,
clientResponse->devAddr.addr, IP_PORT, discoveryPayload->resources->uri);
- OIC_LOG_V(DEBUG, TAG, "query before GetProvisioningStatus call = %s", szQueryUri);
+ OIC_LOG_V(DEBUG, ES_WIFI_PROV_TAG, "query before GetProvisioningStatus call = %s", szQueryUri);
if (GetProvisioningStatus(OC_HIGH_QOS, szQueryUri, &clientResponse->devAddr) != OC_STACK_OK) {
ErrorCallback(DEVICE_NOT_PROVISIONED);
OCProvisioningStatusCB provisioningStatusCallback) {
if (netInfo == NULL || strlen(netInfo->netAddressInfo.WIFI.ipAddress) == 0) {
- OIC_LOG(ERROR, TAG, "Request URI is NULL");
+ OIC_LOG(ERROR, ES_WIFI_PROV_TAG, "Request URI is NULL");
return false;
}
if (provisioningStatusCallback == NULL) {
- OIC_LOG(ERROR, TAG, "ProvisioningStatusCallback is NULL");
+ OIC_LOG(ERROR, ES_WIFI_PROV_TAG, "ProvisioningStatusCallback is NULL");
return false;
}