d2ds_subowner_s *g_client;
+#define CASE_TO_STR(x) case x: return #x;
+const char* _error_to_string(OCStackResult err)
+{
+ switch (err) {
+ /* CHECK: List all enum values here */
+ CASE_TO_STR(OC_STACK_OK)
+ CASE_TO_STR(OC_STACK_RESOURCE_CREATED)
+ CASE_TO_STR(OC_STACK_RESOURCE_DELETED)
+ CASE_TO_STR(OC_STACK_CONTINUE)
+ CASE_TO_STR(OC_STACK_RESOURCE_CHANGED)
+ CASE_TO_STR(OC_STACK_INVALID_URI)
+ CASE_TO_STR(OC_STACK_INVALID_QUERY)
+ CASE_TO_STR(OC_STACK_INVALID_IP)
+ CASE_TO_STR(OC_STACK_INVALID_PORT)
+ CASE_TO_STR(OC_STACK_INVALID_CALLBACK)
+ CASE_TO_STR(OC_STACK_INVALID_METHOD)
+ CASE_TO_STR(OC_STACK_INVALID_PARAM)
+ CASE_TO_STR(OC_STACK_INVALID_OBSERVE_PARAM)
+
+
+ CASE_TO_STR(OC_STACK_NO_MEMORY)
+ CASE_TO_STR(OC_STACK_COMM_ERROR)
+ CASE_TO_STR(OC_STACK_TIMEOUT)
+ CASE_TO_STR(OC_STACK_ADAPTER_NOT_ENABLED)
+ CASE_TO_STR(OC_STACK_NOTIMPL)
+ CASE_TO_STR(OC_STACK_RESOURCE_ERROR)
+ CASE_TO_STR(OC_STACK_SLOW_RESOURCE)
+ CASE_TO_STR(OC_STACK_DUPLICATE_REQUEST)
+ CASE_TO_STR(OC_STACK_OBSERVER_NOT_FOUND)
+ CASE_TO_STR(OC_STACK_VIRTUAL_DO_NOT_HANDLE)
+ CASE_TO_STR(OC_STACK_INVALID_OPTION)
+ CASE_TO_STR(OC_STACK_MALFORMED_RESPONSE)
+ CASE_TO_STR(OC_STACK_PERSISTENT_BUFFER_REQUIRED)
+
+ CASE_TO_STR(OC_STACK_INVALID_REQUEST_HANDLE)
+ CASE_TO_STR(OC_STACK_INVALID_DEVICE_INFO)
+ CASE_TO_STR(OC_STACK_INVALID_JSON)
+ CASE_TO_STR(OC_STACK_UNAUTHORIZED_REQ)
+ CASE_TO_STR(OC_STACK_TOO_LARGE_REQ)
+ CASE_TO_STR(OC_STACK_PDM_IS_NOT_INITIALIZED)
+ CASE_TO_STR(OC_STACK_DUPLICATE_UUID)
+ CASE_TO_STR(OC_STACK_INCONSISTENT_DB)
+ CASE_TO_STR(OC_STACK_SVR_DB_NOT_EXIST)
+ CASE_TO_STR(OC_STACK_AUTHENTICATION_FAILURE)
+ CASE_TO_STR(OC_STACK_NOT_ALLOWED_OXM)
+#ifdef WITH_PRESENCE
+ CASE_TO_STR(OC_STACK_PRESENCE_STOPPED)
+ CASE_TO_STR(OC_STACK_PRESENCE_TIMEOUT)
+ CASE_TO_STR(OC_STACK_PRESENCE_DO_NOT_HANDLE)
+#endif
+ CASE_TO_STR(OC_STACK_USER_DENIED_REQ)
+ CASE_TO_STR(OC_STACK_NOT_ACCEPTABLE)
+ CASE_TO_STR(OC_STACK_METHOD_NOT_ALLOWED)
+ CASE_TO_STR(OC_STACK_FORBIDDEN_REQ)
+ CASE_TO_STR(OC_STACK_INTERNAL_SERVER_ERROR)
+ CASE_TO_STR(OC_STACK_NOT_IMPLEMENTED)
+ CASE_TO_STR(OC_STACK_BAD_GATEWAY)
+ CASE_TO_STR(OC_STACK_SERVICE_UNAVAILABLE)
+ CASE_TO_STR(OC_STACK_GATEWAY_TIMEOUT)
+ CASE_TO_STR(OC_STACK_PROXY_NOT_SUPPORTED)
+ CASE_TO_STR(OC_STACK_ERROR)
+ default :
+ return "Unknown Error";
+ }
+}
+
static void _print_uuid(const OicUuid_t* uuid)
{
char uuid_string[256] = {0};
#ifdef TEST
static OCProvisionDev_t* _get_dev_by_id(const OCProvisionDev_t* dev_lst, const int dev_num)
{
- if(!dev_lst || 0>=dev_num) {
- D2DS_LOGI(" Device List is Empty..\n");
+ if (!dev_lst || 0>=dev_num) {
+ D2DS_LOGI("Device List is Empty..\n");
return NULL;
}
OCProvisionDev_t* lst = (OCProvisionDev_t*) dev_lst;
- for(int i=0; lst; ) {
- if(dev_num == ++i) {
+ for (int i=0; lst; ) {
+ if (dev_num == ++i) {
return lst;
}
lst = lst->next;
static OCProvisionDev_t* _get_dev_by_uuid(const OCProvisionDev_t* dev_lst,
const OicUuid_t* uuid)
{
- if(!dev_lst ) {
+ if (!dev_lst ) {
D2DS_LOGI("dev_lst is empty");
return NULL;
}
- if(!uuid ) {
+ if (!uuid ) {
D2DS_LOGI("uuid is NULL");
return NULL;
}
static int _print_dev_list(const OCProvisionDev_t* dev_lst)
{
- if(!dev_lst) {
- D2DS_LOGI(" Device List is Empty..\n\n");
+ if (!dev_lst) {
+ D2DS_LOGI("Device List is Empty..\n\n");
return 0;
}
OCProvisionDev_t* lst = (OCProvisionDev_t*) dev_lst;
int lst_cnt = 0;
- for( ; lst; ) {
- D2DS_LOGI(" [%d] ", ++lst_cnt);
+ for ( ; lst; ) {
+ D2DS_LOGI("[%d] ", ++lst_cnt);
_print_uuid((const OicUuid_t*) &lst->doxm->deviceID);
lst = lst->next;
}
static int _print_result_list(const OCProvisionResult_t* rslt_lst, const int rslt_cnt)
{
- if(!rslt_lst || 0>=rslt_cnt) {
+ if (!rslt_lst || 0>=rslt_cnt) {
D2DS_LOGI(" Device List is Empty..\n\n");
return 0;
}
int lst_cnt = 0;
- for( ; rslt_cnt>lst_cnt; ++lst_cnt) {
+ for ( ; rslt_cnt>lst_cnt; ++lst_cnt) {
_print_uuid((const OicUuid_t*) &rslt_lst[lst_cnt].deviceId);
- D2DS_LOGI(" -> result: %d\n", rslt_lst[lst_cnt].res);
+ D2DS_LOGI(": result: %s", _error_to_string(rslt_lst[lst_cnt].res));
}
return lst_cnt;
static int _wait_cb_ret(int milli_seconds)
{
OCStackResult ret = OC_STACK_OK;
- for(int i=0; !g_client->g_doneCB && milli_seconds > i; ++i) {
+ for (int i=0; !g_client->g_doneCB && milli_seconds > i; ++i) {
usleep(1000);
ret = OCProcess();
- if(OC_STACK_OK != ret) {
+ if (OC_STACK_OK != ret) {
D2DS_LOGE( "OCStack process error = %d", ret);
return ret;
}
}
- if(!g_client->g_doneCB)
+ if (!g_client->g_doneCB)
OCPDMCleanupForTimeout();
return ret;
static void _input_pin_cb(char* pin, size_t len)
{
- if(!pin || OXM_RANDOM_PIN_MAX_SIZE>=len) {
+ if (!pin || OXM_RANDOM_PIN_MAX_SIZE>=len) {
D2DS_LOGE( "inputPinCB invalid parameters");
return;
}
g_mutex_init(&motdev_mutex);
g_mutex_lock(&motdev_mutex);
- if(g_client->g_motdev_list) {
+ if (g_client->g_motdev_list) {
OCDeleteDiscoveredDevices(g_client->g_motdev_list);
g_client->g_motdev_list = NULL;
}
/* delete un/owned device lists before updating them */
g_mutex_init(&owned_dev_mutex);
g_mutex_lock(&owned_dev_mutex);
- if(g_client->g_mowned_list) {
+ if (g_client->g_mowned_list) {
OCDeleteDiscoveredDevices(g_client->g_mowned_list);
g_client->g_mowned_list = NULL;
}
static OCPersistentStorage ps = { _fopen_prvn_mng, fread, fwrite, fclose, unlink };
ret = OCRegisterPersistentStorageHandler(&ps);
- if(OC_STACK_OK != ret ) {
+ if (OC_STACK_OK != ret ) {
D2DS_LOGE( "OCRegisterPersistentStorageHandler error = %d", ret);
return ret;
}
/* initialize OC stack and provisioning manager */
ret = OCInit(NULL, 0, OC_CLIENT_SERVER);
- if(OC_STACK_OK != ret ) {
+ if (OC_STACK_OK != ret ) {
D2DS_LOGE( "OCInit() error = %d", ret);
return ret;
}
D2DS_LOGI("No provisioning DB file, creating new");
ret = OCInitPM(data_dir);
- if(OC_STACK_OK != ret ) {
+ if (OC_STACK_OK != ret ) {
D2DS_LOGE( "OCInitPM() error = %d", ret);
return ret;
}
SetInputPinCB(_input_pin_cb);
g_client = g_malloc0(sizeof(d2ds_subowner_s));
- if(!g_client) {
+ if (!g_client) {
D2DS_LOGE( "memory allocation error = %d", errno);
return D2DS_ERROR_OUT_OF_MEMORY;
}
switch (con->cid) {
case D2DS_DISC_MOT_ENB_DEVS:
- D2DS_LOGE(" > Discovered Multiple Ownership Transfer Enabled Devices\n");
+ D2DS_LOGE("Discovered Multiple Ownership Transfer Enabled Devices\n");
g_client->g_motdev_cnt = _print_dev_list(g_client->g_motdev_list);
break;
case D2DS_DISC_MOWNED_DEVS:
- D2DS_LOGE(" > Discovered Multiple Ownership Transfer Enabled Devices\n");
+ D2DS_LOGE("Discovered Multiple Ownership Transfer Enabled Devices\n");
g_client->g_mowndev_cnt = _print_dev_list(g_client->g_mowned_list);
break;
case D2DS_MOT:
_remove_mot_client();
D2DS_LOGI("Discovering Multiple Ownership Transfer enabled Devices on Network..");
- if(OC_STACK_OK != OCDiscoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
+ if (OC_STACK_OK != OCDiscoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
&g_client->g_motdev_list)) {
D2DS_LOGE( "OCDiscoverMultipleOwnerEnalbedDevices API error");
goto DISC_MOT_ENB_DEVS_END;
}
/* display the discovered device lists */
- D2DS_LOGD(" > Discovered Multiple Owner Transfer Enabled Devices\n");
+ D2DS_LOGD("Discovered Multiple Owner Transfer Enabled Devices");
g_client->g_motdev_cnt = _print_dev_list(g_client->g_motdev_list);
DISC_MOT_ENB_DEVS_END:
con->userdata = service;
con->cid = D2DS_DISC_MOT_ENB_DEVS;
- //con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con);
-
+#ifdef TIMEOUT_USED
+ con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con);
+#endif
return D2DS_ERROR_NONE;
}
/* delete un/owned device lists before updating them */
_remove_owned_client();
- D2DS_LOGD(" Discovering Multiple Owned Devices on Network.");
+ D2DS_LOGD("Discovering Multiple Owned Devices on Network.");
ret = OCDiscoverMultipleOwnedDevices(DISCOVERY_TIMEOUT, &g_client->g_mowned_list);
- if(OC_STACK_OK != ret) {
+ if (OC_STACK_OK != ret) {
D2DS_LOGE( "OCDiscoverMultipleOwnerEnabledDevices API error");
goto DISC_OWNED_DEVS_END;
}
/* display the discovered device lists */
- D2DS_LOGD(" > Discovered My Owned Devices\n");
+ D2DS_LOGD("Discovered My Owned Devices");
g_client->g_mowndev_cnt = _print_dev_list(g_client->g_mowned_list);
DISC_OWNED_DEVS_END:
return D2DS_ERROR_OUT_OF_MEMORY;
}
g_thread_unref(con->thread);
-
- //con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con);
-
+#ifdef TIMEOUT_USED
+ con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con);
+#endif
return D2DS_ERROR_NONE;
}
static void _mot_cb(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
{
- if(!hasError) {
+ if (!hasError) {
D2DS_LOGD("Multiple Ownership Transfer SUCCEEDED - ctx: %s", (char*) ctx);
} else {
D2DS_LOGD( "Multiple Ownership Transfer FAILED - ctx: %s", (char*) ctx);
OCStackResult ret = OC_STACK_OK;
d2ds_req_cb_s *con = (d2ds_req_cb_s *)data;
- if(!con->target) {
+ if (!con->target) {
D2DS_LOGE("Target device is NULL");
return NULL;
}
}
#endif //MULTIPLE_OWNER
ret = OCDoMultipleOwnershipTransfer(g_client, con->target, _mot_cb);
- if(OC_STACK_OK != ret ) {
+ if (OC_STACK_OK != ret ) {
D2DS_LOGE( "OCDoMultipleOwnershipTransfer: ret=%d", ret);
return NULL;
}
printDevList(g_mowned_list);
// select device for provisioning access control list
- for( ; ; )
- {
+ for( ; ; ) {
printf(" > Enter Device Number, for sending GET LED request: ");
- for(int ret=0; 1!=ret; )
- {
+ for(int ret=0; 1!=ret; ) {
ret = scanf("%d", &selDevNum);
for( ; 0x20<=getchar(); ); // for removing overflow garbages
// '0x20<=code' is character region
}
- if(0<selDevNum && g_mowned_cnt>=selDevNum)
- {
+ if(0<selDevNum && g_mowned_cnt>=selDevNum) {
break;
}
printf(" Entered Wrong Number. Please Enter Again\n");
}
OCProvisionDev_t* selDev = _get_dev_by_id(g_mowned_list, selDevNum);
- if(NULL == selDev)
- {
+ if(NULL == selDev) {
printf("Failed to _get_dev_by_id()\n");
return -1;
}
if(PMGenerateQuery(true, selDev->endpoint.addr, selDev->securePort, selDev->connType,
- query, sizeof(query), "/a/led"))
- {
+ query, sizeof(query), "/a/led")) {
g_doneCB = false;
printf("query=%s\n", query);
if(OC_STACK_OK != OCDoResource(NULL, OC_REST_GET, query, NULL, NULL, selDev->connType,
- OC_HIGH_QOS, &cbData, NULL, 0))
- {
+ OC_HIGH_QOS, &cbData, NULL, 0)) {
printf("********************************\n");
printf("Failed to send GET request to %s\n", query);
printf("********************************\n");
}
waitCallbackRet();
- }
- else
- {
+ } else {
printf("Failed to generate GET request for /a/led\n");
return -1;
}
printDevList(g_mowned_list);
// select device for provisioning access control list
- for( ; ; )
- {
+ for( ; ; ) {
printf(" > Enter Device Number, for sending PUT LED request: ");
- for(int ret=0; 1!=ret; )
- {
+ for(int ret=0; 1!=ret; ) {
ret = scanf("%d", &selDevNum);
for( ; 0x20<=getchar(); ); // for removing overflow garbages
// '0x20<=code' is character region
}
- if(0<selDevNum && g_mowned_cnt>=selDevNum)
- {
+ if(0<selDevNum && g_mowned_cnt>=selDevNum) {
break;
}
printf(" Entered Wrong Number. Please Enter Again\n");
}
OCProvisionDev_t* selDev = _get_dev_by_id(g_mowned_list, selDevNum);
- if(NULL == selDev)
- {
+ if (NULL == selDev) {
printf("Failed to _get_dev_by_id()\n");
return -1;
}
- if(PMGenerateQuery(true, selDev->endpoint.addr, selDev->securePort, selDev->connType, query,
- sizeof(query), "/a/led"))
- {
+ if (PMGenerateQuery(true, selDev->endpoint.addr, selDev->securePort, selDev->connType, query,
+ sizeof(query), "/a/led")) {
g_doneCB = false;
D2DS_LOGI("query=%s\n", query);
if(OC_STACK_OK != OCDoResource(NULL, OC_REST_PUT, query, NULL, NULL, selDev->connType,
- OC_LOW_QOS, &cbData, NULL, 0))
- {
+ OC_LOW_QOS, &cbData, NULL, 0)) {
D2DS_LOGI("********************************\n");
D2DS_LOGI("Failed to send PUT request to %s\n", query);
D2DS_LOGI("********************************\n");
}
waitCallbackRet();
- }
- else
- {
+ } else {
printf("Failed to generate PUT request for /a/led\n");
return -1;
}
OicSecAce_t* ace = NULL;
OicSecRsrc_t* rsrc = NULL;
- if(NULL == target) {
+ if (NULL == target) {
D2DS_LOGE( "target is NULL");
return NULL;
}
- if(NULL == subject) {
+ if (NULL == subject) {
D2DS_LOGE( "subejct is NULL");
return NULL;
}
acl = (OicSecAcl_t*) OICCalloc(1, sizeof(OicSecAcl_t));
- if(!acl) {
+ if (!acl) {
D2DS_LOGE( "acl : OICCalloc failed =%d", errno);
return NULL;
}
ace = (OicSecAce_t*) OICCalloc(1, sizeof(OicSecAce_t));
- if(!ace) {
+ if (!ace) {
D2DS_LOGE( "ace : OICCalloc failed =%d", errno);
return NULL;
}
/* fill the href */
rsrc = (OicSecRsrc_t*)OICCalloc(1, sizeof(OicSecRsrc_t));
- if(!rsrc) {
+ if (!rsrc) {
D2DS_LOGE( "rsrc: OICCalloc failed =%d", errno);
goto CREATE_ACL_ERROR;
}
len = strlen(rsrc_uri)+1; // '1' for null termination
rsrc->href = (char*) OICCalloc(len, sizeof(char));
- if(!rsrc->href) {
+ if (!rsrc->href) {
D2DS_LOGE( "rsrc->href: OICStrdup failed =%d", errno);
goto CREATE_ACL_ERROR;
}
/* Fill the resource type (rt) */
rsrc->typeLen = 1;
rsrc->types = (char**)OICCalloc(1, sizeof(char*));
- if(!rsrc->types) {
+ if (!rsrc->types) {
D2DS_LOGE( "rsrc->types: OICCalloc failed =%d", errno);
goto CREATE_ACL_ERROR;
}
rsrc->types[0] = OICStrdup(rsrc_type);
- if(!rsrc->types[0]) {
+ if (!rsrc->types[0]) {
D2DS_LOGE( "rsrc->types[0]: OICStrdup failed =%d", errno);
goto CREATE_ACL_ERROR;
}
/* Fill the interface (if) */
rsrc->interfaceLen = 1;
rsrc->interfaces = (char**)OICCalloc(1, sizeof(char*));
- if(!rsrc->interfaces) {
+ if (!rsrc->interfaces) {
D2DS_LOGE( "rsrc->interfaces: OICCalloc failed =%d", errno);
goto CREATE_ACL_ERROR;
}
rsrc->interfaces[0] = OICStrdup(rsrc_interface);
- if(!rsrc->interfaces[0]) {
+ if (!rsrc->interfaces[0]) {
D2DS_LOGE( "rsrc->interfaces[0] : OICStrdup failed =%d", errno);
goto CREATE_ACL_ERROR;
}
ace->permission = permission;
ace->eownerID = (OicUuid_t*)OICCalloc(1, sizeof(OicUuid_t));
- if(NULL == ace->eownerID) {
+ if (NULL == ace->eownerID) {
D2DS_LOGE( "ace->eownerID : OICCalloc failed =%d", errno);
goto CREATE_ACL_ERROR;
}
static void _provisioning_acl_cb(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
{
- if(!hasError) {
+ if (!hasError) {
D2DS_LOGD( "Provision ACL SUCCEEDED - ctx: %s", (char*) ctx);
} else {
D2DS_LOGD( "Provision ACL FAILED - ctx: %s", (char*) ctx);
d2ds_req_cb_s *con = (d2ds_req_cb_s *)data;
OicSecAcl_t* acl = NULL;
- if(!con->subject || !con->rsrc_uri || !con->rsrc_type || !con->rsrc_interface) {
+ if (!con->subject || !con->rsrc_uri || !con->rsrc_type || !con->rsrc_interface) {
D2DS_LOGE("Some parameters are wrong");
D2DS_LOGE("%p", con->subject );
D2DS_LOGE("%s", con->rsrc_uri );
acl = _create_target_acl(&con->target->doxm->deviceID, &con->subject->doxm->deviceID, con->rsrc_uri, con->rsrc_type,
con->rsrc_interface, con->permission);
- if(NULL == acl) {
+ if (NULL == acl) {
D2DS_LOGE( "Failed to create ACL for %s", con->rsrc_uri);
goto PVACL_ERROR;
}
ret= OCProvisionACL((void*) g_client, con->subject, acl, _provisioning_acl_cb);
- if(OC_STACK_OK != ret) {
+ if (OC_STACK_OK != ret) {
D2DS_LOGD( "OCProvisionACL API error: %d", ret);
goto PVACL_ERROR;
}
ret = _wait_cb_ret(CALLBACK_TIMEOUT_MS * 2);
- if(ret) {
+ if (ret) {
D2DS_LOGE( "OCProvisionCredentials Faild = %d", errno);
goto PVACL_ERROR;
}
/* display the ACL-provisioned result */
- D2DS_LOGI(" -> Provisioned Selected ACL Successfully");
+ D2DS_LOGI(" Provisioned Selected ACL Successfully");
PVACL_ERROR:
if (acl) {
return D2DS_ERROR_OUT_OF_MEMORY;
}
g_thread_unref(con->thread);
-
- //con->tid = g_timeout_add_seconds(CALLBACK_TIMEOUT_S + 1, _d2ds_timeout_cb, con);
-
+#ifdef TIMEOUT_USED
+ con->tid = g_timeout_add_seconds(CALLBACK_TIMEOUT_S + 1, _d2ds_timeout_cb, con);
+#endif
return D2DS_ERROR_NONE;
}
static void _provision_cred_cb(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
{
- if(!hasError) {
+ if (!hasError) {
D2DS_LOGD("Provision Credential SUCCEEDED - ctx: %s", (char*) ctx);
} else {
D2DS_LOGD("Provision Credential FAILED - ctx: %s", (char*) ctx);
OCStackResult ret = OC_STACK_OK;
d2ds_req_cb_s *con = (d2ds_req_cb_s *)data;
- if(!con->target ) {
- D2DS_LOGE("Target device is NULL");
+ if (!con->dev1 ) {
+ D2DS_LOGE("dev1 is NULL");
+ return NULL;
+ }
+ if (!con->dev2) {
+ D2DS_LOGE("dev1 is NULL");
return NULL;
}
g_client->g_doneCB = false;
- D2DS_LOGI(" Provisioning Selected Pairwise Devices..");
+ D2DS_LOGI("Provisioning Selected Pairwise Devices..");
OCStackResult rst = OCProvisionCredentials((void*) g_client,
SYMMETRIC_PAIR_WISE_KEY, OWNER_PSK_LENGTH_128,
con->dev1, con->dev2, _provision_cred_cb);
}
/* display the pairwise-provisioned result */
- D2DS_LOGI(" > Provisioned Selected Pairwise Devices");
+ D2DS_LOGI("Provisioned Selected Pairwise Devices");
return 0;
return D2DS_ERROR_OUT_OF_MEMORY;
}
g_thread_unref(con->thread);
-
- //con->tid = g_timeout_add_seconds(CALLBACK_TIMEOUT_S + 1, _d2ds_timeout_cb, con);
-
+#ifdef TIMEOUT_USED
+ con->tid = g_timeout_add_seconds(CALLBACK_TIMEOUT_S + 1, _d2ds_timeout_cb, con);
+#endif
return D2DS_ERROR_NONE;
}
{
NOTUSED(service);
- if(OC_STACK_OK != OCStop()) {
+ if (OC_STACK_OK != OCStop()) {
D2DS_LOGE( "OCStack stop error");
}
projects / platform / core / api / multi-device-group.git / commitdiff