From 68d8bc92e43f40e51f8c4aee9568f09a22c2d751 Mon Sep 17 00:00:00 2001 From: "saerome.kim" Date: Thu, 21 Dec 2017 19:27:54 +0900 Subject: [PATCH] Implement d2d-subowner - ACL provisioning (Tested) - CRED provisioning (NOT Tested) Signed-off-by: saerome.kim --- src/d2d-manager/d2dm.c | 2 +- src/d2d-subowner/d2ds-service-interface.c | 50 +- src/d2d-subowner/d2ds-service.c | 2 +- src/d2d-subowner/d2ds-subowner.c | 1216 ++++++++++----------- src/d2d-subowner/d2ds-subowner.h | 22 + src/d2d-subowner/introspection/d2ds.xml | 50 +- 6 files changed, 638 insertions(+), 704 deletions(-) diff --git a/src/d2d-manager/d2dm.c b/src/d2d-manager/d2dm.c index 4e7976d..c72c506 100644 --- a/src/d2d-manager/d2dm.c +++ b/src/d2d-manager/d2dm.c @@ -26,7 +26,7 @@ #include "d2dm-log.h" #include "d2dm-util.h" #include "d2dm-service.h" -#invlude "d2dm-service-interface.h" +#include "d2dm-service-interface.h" /**< d2d-manager service */ d2dm_service *d2dsvc; diff --git a/src/d2d-subowner/d2ds-service-interface.c b/src/d2d-subowner/d2ds-service-interface.c index f32aa4a..9b49a42 100644 --- a/src/d2d-subowner/d2ds-service-interface.c +++ b/src/d2d-subowner/d2ds-service-interface.c @@ -169,10 +169,7 @@ static gboolean _d2ds_dbus_handle_disc_moted_devs(NetD2ds *object, } static gboolean _d2ds_dbus_handle_mot(NetD2ds *object, - GDBusMethodInvocation *invocation, - gchar *target, - gchar *pin, - gpointer user_data) + GDBusMethodInvocation *invocation, gchar *arg_target, gchar *arg_pin, gpointer user_data) { int ret = D2DS_ERROR_NONE; d2ds_service *service = (d2ds_service *)user_data; @@ -180,7 +177,7 @@ static gboolean _d2ds_dbus_handle_mot(NetD2ds *object, d2ds_check_null_ret_error("service", service, FALSE); - ret = d2ds_request_mot(service, target, pin); + ret = d2ds_request_mot(service, arg_target, arg_pin); if (D2DS_ERROR_NONE != ret) D2DS_LOGE("Failed to d2ds_request_disc_moted_devs !"); @@ -189,29 +186,42 @@ static gboolean _d2ds_dbus_handle_mot(NetD2ds *object, return TRUE; } -static gboolean _d2ds_dbus_handle_mot_pairwise(NetD2ds *object, - GDBusMethodInvocation *invocation, - gchar *arg_subject, - gchar *arg_uri, - gint arg_permission, - gchar *arg_target, - gpointer user_data) +static gboolean _d2ds_dbus_handle_prov_acl(NetD2ds *object, + GDBusMethodInvocation *invocation, gchar *arg_target, gchar *arg_subject, gchar *arg_uri, + gchar *arg_rt, gchar *arg_interface, gint arg_permission, gpointer user_data) { int ret = D2DS_ERROR_NONE; d2ds_service *service = (d2ds_service *)user_data; d2ds_check_null_ret_error("service", service, FALSE); -#if 0 - ret = d2ds_request_mot_pairwise(service); + + ret = d2ds_request_prov_acl(service, arg_target, arg_subject, arg_uri, arg_rt, arg_interface, arg_permission); if (D2DS_ERROR_NONE != ret) - D2DS_LOGE("Failed to d2ds_request_mot_pairwise !"); -#endif - net_d2ds_complete_mot_pairwise(object, invocation, ret); + D2DS_LOGE("Failed to d2ds_request_prov_acl !"); + + net_d2ds_complete_prov_acl(object, invocation, ret); return TRUE; } +static gboolean _d2ds_dbus_handle_prov_cred(NetD2ds *object, + GDBusMethodInvocation *invocation, gchar *arg_dev1, gchar *arg_dev2, gpointer user_data) +{ + int ret = D2DS_ERROR_NONE; + d2ds_service *service = (d2ds_service *)user_data; + + d2ds_check_null_ret_error("service", service, FALSE); + + + ret = d2ds_request_prov_cred(service, arg_dev1, arg_dev2); + if (D2DS_ERROR_NONE != ret) + D2DS_LOGE("Failed to d2ds_request_prov_cred !"); + + net_d2ds_complete_prov_cred(object, invocation, ret); + + return TRUE; +} static void _d2ds_dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name, gpointer user_data) @@ -234,8 +244,10 @@ static void _d2ds_dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name, G_CALLBACK(_d2ds_dbus_handle_disc_moted_devs), service); g_signal_connect(d2ds_dbus_object, "handle-mot", G_CALLBACK(_d2ds_dbus_handle_mot), service); - g_signal_connect(d2ds_dbus_object, "handle-mot-pairwise", - G_CALLBACK(_d2ds_dbus_handle_mot_pairwise), service); + g_signal_connect(d2ds_dbus_object, "handle-prov-acl", + G_CALLBACK(_d2ds_dbus_handle_prov_acl), service); + g_signal_connect(d2ds_dbus_object, "handle-prov-cred", + G_CALLBACK(_d2ds_dbus_handle_prov_cred), service); ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(d2ds_dbus_object), conn, D2DS_DBUS_OBJPATH, &error); diff --git a/src/d2d-subowner/d2ds-service.c b/src/d2d-subowner/d2ds-service.c index 650eef8..8ee1775 100644 --- a/src/d2d-subowner/d2ds-service.c +++ b/src/d2d-subowner/d2ds-service.c @@ -26,7 +26,7 @@ d2ds_service *d2ds_service_new() { d2ds_service *service; - service = g_malloc0(sizeof(struct _d2ds_service)); + service = calloc(1, sizeof(struct _d2ds_service)); /* Create g-main loop */ service->main_loop = g_main_loop_new(NULL, FALSE); diff --git a/src/d2d-subowner/d2ds-subowner.c b/src/d2d-subowner/d2ds-subowner.c index 06710b8..0ef87e0 100644 --- a/src/d2d-subowner/d2ds-subowner.c +++ b/src/d2d-subowner/d2ds-subowner.c @@ -38,64 +38,76 @@ #include "oxmrandompin.h" #include "securevirtualresourcetypes.h" #include "security/srmutility.h" -//#include "srmutility.h" #include "pmtypes.h" #include "pmutility.h" #include -#define MAX_FILE_PATH_LEN 1024 - #include "d2ds.h" #include "d2ds-log.h" #include "d2ds-util.h" +#include "d2ds-subowner.h" -// declaration(s) for provisioning client using C-level provisioning API -// user input definition for main loop on provisioning client -#define _10_DISCOV_MOT_ENABLED_DEV_ 10 -#define _11_DISCOV_MULTIPLE_OWNED_DEV_ 11 -#define _20_PERFORM_MOT_ 20 -#define _30_GET_LED_RESOURCE_ 30 -#define _31_PUT_LED_RESOURCE_ 31 -#define _40_PROVISION_ACL_ 40 -#define _41_PROVISION_CRED_ 41 -#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 MAX_FILE_PATH_LEN 1024 #define ACL_RESRC_MAX_LEN 128 -#define ACL_PEMISN_CNT 5 -#define DISCOVERY_TIMEOUT 1 // 1 sec -#define CALLBACK_TIMEOUT /* 100ms */ 10 * 10 -#define TAG "subownerclient" +/*This value is used only for sample (not OCF spec) */ +#define ACL_RESRC_ARRAY_SIZE 3 + +#define DISCOVERY_TIMEOUT 5 /* 5 sec */ +#define CALLBACK_TIMEOUT_S 5 /* 5 sec */ +#define CALLBACK_TIMEOUT_MS 10 * 50 /* 5sec = 100ms * 50 */ + +/* '_' for separaing from the same constant variable in srmresourcestrings.c */ static const char* SVR_DB_FILE_NAME = "oic_svr_db_subowner_client.dat"; - // '_' for separaing from the same constant variable in |srmresourcestrings.c| static const char* PRVN_DB_FILE_NAME = "oic_pdm_subowner.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 -static const char* g_ctx = "SubOwner Client Context"; -static char* g_svr_fname; -static char* g_prvn_fname; -static OCProvisionDev_t* g_own_list; -static OCProvisionDev_t* g_unown_list; -static OCProvisionDev_t* g_motdev_list; -static OCProvisionDev_t* g_mowned_list; -static int g_own_cnt; -static int g_unown_cnt; -static int g_motdev_cnt; -static int g_mowned_cnt; -static bool g_doneCB; - -// function declaration(s) for calling them before implementing - -static void _d2d_print_uuid(const OicUuid_t* uuid) + +static const OicSecPrm_t SUPPORTED_PRMS[2] = { PRM_PRE_CONFIGURED, PRM_RANDOM_PIN }; + +typedef struct { + d2ds_cmd_id_e cid; /**< Command ID */ + int tid; /**< Timer ID */ + GThread *thread; /**< Thread handle */ + unsigned int sid; /**< Subcribed signal ID */ + bool found; /**< Whether we discoverd devices */ + void *cb; /**< Callback function pointer */ + void *userdata; /**< User data */ + + /* To-Do : Change belows to union type */ + + /* For MOT */ + OCProvisionDev_t *target; /**< Target device for MOT */ + gchar *pin; /**< PIN */ + + /* For ACL provisioning */ + OCProvisionDev_t *subject; /**< Target device for ACL */ + gchar *rsrc_uri; /**< Resource URI */ + gchar *rsrc_type; /**< Resouce Type */ + gchar *rsrc_interface; /**< Resource Interface Array To-Do : Make this as array */ + int permission;/**< Permision */ + + /* For CRED provisioning */ + OCProvisionDev_t *dev1; /**< 1st device for CRED provisiong */ + OCProvisionDev_t *dev2; /**< 2nd device for CRED provisiong */ +} d2ds_req_cb_s; + +typedef struct _d2ds_subowner { + OCProvisionDev_t* g_motdev_list; /**< Discoverd MOT enabled devices list */ + OCProvisionDev_t* g_mowned_list; /**< My owned MOT enabled devices list */ + + int g_motdev_cnt; /**< Number of MOT enabled devices */ + int g_mowndev_cnt; /**< Number of my owned MOT enabled devices */ + + bool g_doneCB; /**< This means callback completed or not */ + + char *rnd_pin; /**< Random PIN */ + int rnd_pin_len; /**< Random PIN length */ + +} d2ds_subowner_s; + +d2ds_subowner_s *g_client; + +static void _print_uuid(const OicUuid_t* uuid) { char uuid_string[256] = {0}; snprintf(uuid_string, sizeof(uuid_string), @@ -121,7 +133,7 @@ static OCProvisionDev_t* _get_dev_by_id(const OCProvisionDev_t* dev_lst, const i lst = lst->next; } - return NULL; // in here |lst| is always |NULL| + return NULL; } static OCProvisionDev_t* _get_dev_by_uuid(const OCProvisionDev_t* dev_lst, @@ -138,16 +150,18 @@ static OCProvisionDev_t* _get_dev_by_uuid(const OCProvisionDev_t* dev_lst, } OCProvisionDev_t* lst = (OCProvisionDev_t*)dev_lst; + _print_uuid(&lst->doxm->deviceID); while (lst) { if (!memcmp((const void *)&lst->doxm->deviceID, (const void *)uuid, sizeof(OicUuid_t))) return lst; + _print_uuid(uuid); lst = lst->next; } return NULL; } -static int printDevList(const OCProvisionDev_t* dev_lst) +static int _print_dev_list(const OCProvisionDev_t* dev_lst) { if(!dev_lst) { D2DS_LOGI(" Device List is Empty..\n\n"); @@ -158,33 +172,14 @@ static int printDevList(const OCProvisionDev_t* dev_lst) int lst_cnt = 0; for( ; lst; ) { D2DS_LOGI(" [%d] ", ++lst_cnt); - _d2d_print_uuid((const OicUuid_t*) &lst->doxm->deviceID); + _print_uuid((const OicUuid_t*) &lst->doxm->deviceID); lst = lst->next; } return lst_cnt; } -static size_t printUuidList(const OCUuidList_t* uid_lst) -{ - if(!uid_lst) { - D2DS_LOGI(" Device List is Empty..\n\n"); - return 0; - } - - OCUuidList_t* lst = (OCUuidList_t*) uid_lst; - size_t lst_cnt = 0; - for( ; lst; ) { - D2DS_LOGI(" [%zu] ", ++lst_cnt); - _d2d_print_uuid((const OicUuid_t*) &lst->dev); - lst = lst->next; - } - D2DS_LOGI("\n"); - - return lst_cnt; -} - -static int printResultList(const OCProvisionResult_t* rslt_lst, const int rslt_cnt) +static int _print_result_list(const OCProvisionResult_t* rslt_lst, const int rslt_cnt) { if(!rslt_lst || 0>=rslt_cnt) { D2DS_LOGI(" Device List is Empty..\n\n"); @@ -193,16 +188,14 @@ static int printResultList(const OCProvisionResult_t* rslt_lst, const int rslt_c int lst_cnt = 0; for( ; rslt_cnt>lst_cnt; ++lst_cnt) { - D2DS_LOGI(" [%d] ", lst_cnt+1); - _d2d_print_uuid((const OicUuid_t*) &rslt_lst[lst_cnt].deviceId); - D2DS_LOGI(" - result: %d\n", rslt_lst[lst_cnt].res); + _print_uuid((const OicUuid_t*) &rslt_lst[lst_cnt].deviceId); + D2DS_LOGI(" -> result: %d\n", rslt_lst[lst_cnt].res); } - D2DS_LOGI("\n"); return lst_cnt; } -static FILE*_d2ds_fopen_prvn_mng(const char* path, const char* mode) +static FILE* _fopen_prvn_mng(const char* path, const char* mode) { char data_dir[MAX_FILE_PATH_LEN] = {0,}; @@ -217,10 +210,10 @@ static FILE*_d2ds_fopen_prvn_mng(const char* path, const char* mode) return fopen(data_dir, mode); } -static int ___d2d_wait_cb_ret(void) +static int _wait_cb_ret(int milli_seconds) { OCStackResult ret = OC_STACK_OK; - for(int i=0; !g_doneCB && CALLBACK_TIMEOUT>i; ++i) { + for(int i=0; !g_client->g_doneCB && milli_seconds > i; ++i) { usleep(1000); ret = OCProcess(); if(OC_STACK_OK != ret) { @@ -229,179 +222,52 @@ static int ___d2d_wait_cb_ret(void) } } - if(!g_doneCB) + if(!g_client->g_doneCB) OCPDMCleanupForTimeout(); return ret; } -#if 0 /* TEST */ -static int selectTwoDiffNum(int* a, int* b, const int max, const char* str) -{ - if(!a || !b || 2>max || !str) { - return -1; - } - - for( ; ; ) { - for(int i=0; 2>i; ++i) { - int* num = 0==i?a:b; - for( ; ; ) { - printf(" > Enter Device[%d] Number, %s: ", i+1, str); - for(int ret=0; 1!=ret; ) { - ret = scanf("%d", num); - for( ; 0x20<=getchar(); ); // for removing overflow garbages - // '0x20<=code' is character region - } - if(0<*num && max>=*num) { - break; - } - printf(" Entered Wrong Number. Please Enter Again\n"); - } - } - if(*a != *b) { - printf("\n"); - return 0; - } - } - - return -1; -} - -// callback function(s) for provisioning client using C-level provisioning API -static void ownershipTransferCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError) -{ - if(!hasError) - { - D2DS_LOGD( "Ownership Transfer SUCCEEDED - ctx: %s", (char*) ctx); - } - else - { - D2DS_LOGD( "Ownership Transfer FAILED - ctx: %s", (char*) ctx); - printResultList((const OCProvisionResult_t*) arr, nOfRes); - } - g_doneCB = true; -} - -static void updateDoxmForMOTCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError) -{ - if(!hasError) - { - D2DS_LOGD( "POST 'doxm' SUCCEEDED - ctx: %s", (char*) ctx); - } - else - { - D2DS_LOGD( "POST 'doxm' FAILED - ctx: %s", (char*) ctx); - printResultList((const OCProvisionResult_t*) arr, nOfRes); - } - g_doneCB = true; -} - -static void provisionCredCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError) -{ - if(!hasError) - { - D2DS_LOGD( "Provision Credential SUCCEEDED - ctx: %s", (char*) ctx); - } - else - { - D2DS_LOGD( "Provision Credential FAILED - ctx: %s", (char*) ctx); - printResultList((const OCProvisionResult_t*) arr, nOfRes); - } - g_doneCB = true; -} - -static void provisionAclCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError) -{ - if(!hasError) - { - D2DS_LOGD( "Provision ACL SUCCEEDED - ctx: %s", (char*) ctx); - } - else - { - D2DS_LOGD( "Provision ACL FAILED - ctx: %s", (char*) ctx); - printResultList((const OCProvisionResult_t*) arr, nOfRes); - } - g_doneCB = true; -} - -// response handler for LED requests. -static void LedCB(void *ctx, OCDoHandle UNUSED, - OCClientResponse *clientResponse) -{ - if(clientResponse) - { - if(OC_STACK_OK == clientResponse->result) - { - printf("Received OC_STACK_OK from server\n"); - if(clientResponse->payload) - { - printf("Response ===================> %s\n", clientResponse->payload); - } - } - else if(OC_STACK_RESOURCE_CHANGED == clientResponse->result) - { - printf("Received OC_STACK_RESOURCE_CHANGED from server\n"); - } - else - { - printf("Error in response : %d\n", clientResponse->result); - } - } - else - { - printf("Hit the response callback but can not find response data\n"); - } - - g_doneCB = true; -} -#endif /* TEST */ - -static void inputPinCB(char* pin, size_t len) +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; } - printf(" > INPUT PIN: "); - for(int ret=0; 1!=ret; ) - { - ret = scanf("%32s", pin); - for( ; 0x20<=getchar(); ); // for removing overflow garbages - // '0x20<=code' is character region - } + memcpy(pin, g_client->rnd_pin, g_client->rnd_pin_len); + D2DS_LOGI("Random PIN : %s", g_client->rnd_pin); } -static void _d2ds_remove_mot_client() +static void _remove_mot_client() { GMutex motdev_mutex; g_mutex_init(&motdev_mutex); g_mutex_lock(&motdev_mutex); - if(g_motdev_list) { - OCDeleteDiscoveredDevices(g_motdev_list); - g_motdev_list = NULL; + if(g_client->g_motdev_list) { + OCDeleteDiscoveredDevices(g_client->g_motdev_list); + g_client->g_motdev_list = NULL; } g_mutex_unlock(&motdev_mutex); } -static void _d2ds_remove_owned_client() +static void _remove_owned_client() { GMutex owned_dev_mutex; /* delete un/owned device lists before updating them */ g_mutex_init(&owned_dev_mutex); g_mutex_lock(&owned_dev_mutex); - if(g_mowned_list) { - OCDeleteDiscoveredDevices(g_mowned_list); - g_mowned_list = NULL; + if(g_client->g_mowned_list) { + OCDeleteDiscoveredDevices(g_client->g_mowned_list); + g_client->g_mowned_list = NULL; } g_mutex_unlock(&owned_dev_mutex); } // function(s) for provisioning client using C-level provisioning API -static int d2ds_init_provision_client(void) +static int _init_provision_client(void) { OCStackResult ret = OC_STACK_OK; char data_dir[MAX_FILE_PATH_LEN] = {0,}; @@ -409,26 +275,20 @@ static int d2ds_init_provision_client(void) snprintf(data_dir, MAX_FILE_PATH_LEN, "%s/network/%s", tzplatform_getenv(TZ_SYS_GLOBALUSER_DATA), PRVN_DB_FILE_NAME); - // initialize persistent storage for SVR DB - static OCPersistentStorage ps = { - _d2ds_fopen_prvn_mng, - fread, - fwrite, - fclose, - unlink - }; + /* initialize persistent storage for SVR DB */ + static OCPersistentStorage ps = { _fopen_prvn_mng, fread, fwrite, fclose, unlink }; ret = OCRegisterPersistentStorageHandler(&ps); if(OC_STACK_OK != ret ) { D2DS_LOGE( "OCRegisterPersistentStorageHandler error = %d", ret); - return -1; + return ret; } - // initialize OC stack and provisioning manager + /* initialize OC stack and provisioning manager */ ret = OCInit(NULL, 0, OC_CLIENT_SERVER); if(OC_STACK_OK != ret ) { D2DS_LOGE( "OCInit() error = %d", ret); - return -1; + return ret; } if (access(data_dir, F_OK) != -1) @@ -439,63 +299,82 @@ static int d2ds_init_provision_client(void) ret = OCInitPM(data_dir); if(OC_STACK_OK != ret ) { D2DS_LOGE( "OCInitPM() error = %d", ret); - return -1; + return ret; } - SetInputPinCB(inputPinCB); + SetInputPinCB(_input_pin_cb); + + g_client = calloc(1, sizeof(d2ds_subowner_s)); + if(!g_client) { + D2DS_LOGE( "memory allocation error = %d", errno); + return D2DS_ERROR_OUT_OF_MEMORY; + } + g_client->g_motdev_list = NULL; + g_client->g_mowned_list = NULL; + g_client->rnd_pin = NULL; return ret; } - -/* command id */ -typedef enum { - D2DS_DISC_MOT_ENB_DEVS = 0, - D2DS_DISC_MOTED_DEVS, - D2DS_MOT, - D2DS_MOT_PAIRWISE, -} d2ds_cmd_id_e; - -typedef struct { - d2ds_cmd_id_e cid; /**< Command ID */ - int tid; /**< Timer ID */ - GThread *thread; /**< Thread handle */ - unsigned int sid; /**< Subcribed signal ID */ - bool found; /**< Whether we discoverd devices */ - void *cb; /**< Callback function pointer */ - void *userdata; /**< User data */ - - OCProvisionDev_t *target; /**< Target device */ - guchar *pin /**< PIN */ - -} d2ds_req_cb_s; - -static void _d2sd_request_cleanup(gpointer data) +static void _request_cleanup(gpointer data) { d2ds_req_cb_s *con = (d2ds_req_cb_s *)data; d2ds_service *service = (d2ds_service *)con->userdata; + if (!con) { + D2DS_LOGI("container is null"); + return; + } + if (con->tid) { g_source_remove(con->tid); con->tid = 0; } con->sid = 0; con->found = FALSE; - if (con->target) +#if 0 + if (con->target) { PMDeleteDeviceList(con->target); - if (con->pin) + con->target = NULL; + } +#endif + if (con->pin) { free(con->pin); + con->pin = NULL; + } +#if 0 + D2DS_LOGE("KSR : %p", con->subject); + if (con->subject) { + PMDeleteDeviceList(con->subject); + con->subject = NULL; + } +#endif + if (con->rsrc_uri) { + free(con->rsrc_uri); + con->rsrc_uri = NULL; + } + if (con->rsrc_type) { + free(con->rsrc_type); + con->rsrc_type = NULL; + } + if (con->rsrc_interface) { + free(con->rsrc_interface); + con->rsrc_interface = NULL; + } /* Set d2ds status 'pending' */ g_atomic_int_set(&service->pending, 0); - free(con); + if (con) { + free(con); + con = NULL; + } } -static gboolean _d2ds_timeout_cb(gpointer p) +static gboolean _d2ds_timeout_cb(gpointer data) { - d2ds_req_cb_s *con = (d2ds_req_cb_s *)p; + d2ds_req_cb_s *con = (d2ds_req_cb_s *)data; - if (NULL == con, G_SOURCE_REMOVE) { + if (NULL == con) { D2DS_LOGE("container is NULL"); return G_SOURCE_REMOVE; } @@ -512,78 +391,51 @@ static gboolean _d2ds_timeout_cb(gpointer p) OCPDMCleanupForTimeout(); switch (con->cid) { - case D2DS_DISC_MOT_ENB_DEVS: - // display the discovered device lists - D2DS_LOGE(" > Discovered Multiple Ownership Transfer Enabled Devices\n"); - g_motdev_cnt = printDevList(g_motdev_list); - break; - case D2DS_DISC_MOTED_DEVS: - break; - case D2DS_MOT: - break; - case D2DS_MOT_PAIRWISE: - break; - } - - _d2sd_request_cleanup((gpointer)con); + case D2DS_DISC_MOT_ENB_DEVS: + 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"); + g_client->g_mowndev_cnt = _print_dev_list(g_client->g_mowned_list); + break; + case D2DS_MOT: + case D2DS_PROV_ACL: + case D2DS_PROV_CRED: + break; + } + + _request_cleanup((gpointer)con); return G_SOURCE_REMOVE; } -#ifdef TIMER_TEST -static int _d2ds_disc_mot_enb_devs_timer(d2ds_service *service) +static gpointer _disc_mot_env_devs_func(gpointer data) { - d2ds_req_cb_s *con = NULL; - - _d2ds_remove_mot_client(); - - // call |OCDiscoverMultipleOwnerEnabledDevices| API actually - D2DS_LOGI(" Discovering Multiple Ownership Transfer enabled Devices on Network..\n"); - if(OC_STACK_OK != OCDiscoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT, - &g_motdev_list)) { - D2DS_LOGE( "OCDiscoverMultipleOwnerEnalbedDevices API error"); - return D2DS_ERROR_OPERATION_FAILED; - } - - con = calloc(1, sizeof(d2ds_req_cb_s)); - if (NULL == con) { - D2DS_LOGE( "calloc() Fail=%d", errno); - return D2DS_ERROR_OUT_OF_MEMORY; - } - - //con->cb = cb; - //con->sid = sub_id; - con->userdata = service; - con->cid = D2DS_DISC_MOT_ENB_DEVS; - con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con); - - return D2DS_ERROR_NONE; -} -#endif - -static gpointer __d2ds_disc_mot_env_devs_func(gpointer data) -{ - NOTUSED(data); + d2ds_req_cb_s *con = (d2ds_req_cb_s *)data; /* delete un/owned device lists before updating them */ - _d2ds_remove_mot_client(); + _remove_mot_client(); - // call |OCDiscoverMultipleOwnerEnabledDevices| API actually - D2DS_LOGI(" Discovering Multiple Ownership Transfer enabled Devices on Network..\n"); + D2DS_LOGI("Discovering Multiple Ownership Transfer enabled Devices on Network.."); if(OC_STACK_OK != OCDiscoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT, - &g_motdev_list)) { + &g_client->g_motdev_list)) { D2DS_LOGE( "OCDiscoverMultipleOwnerEnalbedDevices API error"); - return NULL; + goto DISC_MOT_ENB_DEVS_END; } - g_thread_exit(GINT_TO_POINTER (1)); + /* display the discovered device lists */ + D2DS_LOGD(" > Discovered Multiple Owner Transfer Enabled Devices\n"); + g_client->g_motdev_cnt = _print_dev_list(g_client->g_motdev_list); - _d2sd_request_cleanup((gpointer)data); +DISC_MOT_ENB_DEVS_END: + _request_cleanup(con); + g_thread_exit(GINT_TO_POINTER (1)); return NULL; } -static int _d2ds_disc_mot_enb_devs_thd(d2ds_service *service) +static int _disc_mot_enb_devs(d2ds_service *service) { d2ds_req_cb_s *con = NULL; con = calloc(1, sizeof(d2ds_req_cb_s)); @@ -592,45 +444,48 @@ static int _d2ds_disc_mot_enb_devs_thd(d2ds_service *service) return D2DS_ERROR_OUT_OF_MEMORY; } - con->thread = g_thread_try_new("disc_mot_env_devs", __d2ds_disc_mot_env_devs_func, con, NULL); + con->thread = g_thread_try_new("disc_mot_env_devs", _disc_mot_env_devs_func, con, NULL); if (!con->thread) { D2DS_LOGE("Failed to create thread"); + _request_cleanup(con); return D2DS_ERROR_OUT_OF_MEMORY; } g_thread_unref(con->thread); con->userdata = service; con->cid = D2DS_DISC_MOT_ENB_DEVS; - con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con); + //con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con); return D2DS_ERROR_NONE; } -static gpointer __d2ds_disc_owned_env_devs_func(gpointer data) +static gpointer _disc_owned_devs_func(gpointer data) { - NOTUSED(data); + OCStackResult ret = OC_STACK_OK; + d2ds_req_cb_s *con = (d2ds_req_cb_s *)data; - // delete un/owned device lists before updating them - _d2ds_remove_owned_client(); + /* delete un/owned device lists before updating them */ + _remove_owned_client(); - // call |OCDiscoverMultipleOwnedDevices| API actually - printf(" Discovering Multiple Owned Devices on Network..\n"); - if(OC_STACK_OK != OCDiscoverMultipleOwnedDevices(DISCOVERY_TIMEOUT, &g_mowned_list)) - { + D2DS_LOGD(" Discovering Multiple Owned Devices on Network."); + ret = OCDiscoverMultipleOwnedDevices(DISCOVERY_TIMEOUT, &g_client->g_mowned_list); + if(OC_STACK_OK != ret) { D2DS_LOGE( "OCDiscoverMultipleOwnerEnabledDevices API error"); - return NULL; + goto DISC_OWNED_DEVS_END; } - // display the discovered device lists - printf(" > Discovered Multiple Owned Devices\n"); - g_mowned_cnt = printDevList(g_mowned_list); + /* display the discovered device lists */ + D2DS_LOGD(" > Discovered My Owned Devices\n"); + g_client->g_mowndev_cnt = _print_dev_list(g_client->g_mowned_list); - _d2sd_request_cleanup(data); +DISC_OWNED_DEVS_END: + _request_cleanup(data); + g_thread_exit(GINT_TO_POINTER (1)); return NULL; } -static int _d2ds_disc_owned_devs(d2ds_service *service) +static int _disc_owned_devs(d2ds_service *service) { d2ds_req_cb_s *con = NULL; con = calloc(1, sizeof(d2ds_req_cb_s)); @@ -639,33 +494,34 @@ static int _d2ds_disc_owned_devs(d2ds_service *service) return D2DS_ERROR_OUT_OF_MEMORY; } - con->thread = g_thread_try_new("disc_owned_devs", __d2ds_disc_owned_env_devs_func, con, NULL); + con->userdata = service; + con->cid = D2DS_DISC_MOWNED_DEVS; + + con->thread = g_thread_try_new("disc_owned_devs", _disc_owned_devs_func, con, NULL); if (!con->thread) { D2DS_LOGE("Failed to create thread"); + _request_cleanup(con); return D2DS_ERROR_OUT_OF_MEMORY; } g_thread_unref(con->thread); - con->userdata = service; - con->cid = D2DS_DISC_MOTED_DEVS; - con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con); + //con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con); return D2DS_ERROR_NONE; } -// callback function(s) for provisioning client using C-level provisioning API -static void ___d2ds_mot_cb(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError) +static void _mot_cb(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError) { if(!hasError) { D2DS_LOGD("Multiple Ownership Transfer SUCCEEDED - ctx: %s", (char*) ctx); } else { D2DS_LOGD( "Multiple Ownership Transfer FAILED - ctx: %s", (char*) ctx); - printResultList((const OCProvisionResult_t*) arr, nOfRes); + _print_result_list((const OCProvisionResult_t*) arr, nOfRes); } - g_doneCB = true; + g_client->g_doneCB = true; } -static gpointer __d2ds_mot_func(gpointer data) +static gpointer _mot_func(gpointer data) { OCStackResult ret = OC_STACK_OK; d2ds_req_cb_s *con = (d2ds_req_cb_s *)data; @@ -674,17 +530,15 @@ static gpointer __d2ds_mot_func(gpointer data) D2DS_LOGE("Target device is NULL"); return NULL; } - // 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; + + g_client->g_doneCB = false; #ifdef MULTIPLE_OWNER OCProvisionDev_t* dev = NULL; LL_FOREACH(con->target, dev) { if(OIC_PRECONFIG_PIN == dev->doxm->oxmSel) { //Pre-Configured PIN initialization - const char* testPreconfigPin = con->pin;//"12341234"; + const char* testPreconfigPin = con->pin;/* Ex) "12341234" */ if(OC_STACK_OK != OCAddPreconfigPin(dev, testPreconfigPin, strlen(testPreconfigPin))) { D2DS_LOGE("Failed to save the pre-configured PIN"); D2DS_LOGE("You can't use the pre-configured PIN OxM for MOT"); @@ -693,27 +547,27 @@ static gpointer __d2ds_mot_func(gpointer data) } } #endif //MULTIPLE_OWNER - ret = OCDoMultipleOwnershipTransfer(g_ctx, con->target, ___d2ds_mot_cb); + ret = OCDoMultipleOwnershipTransfer(g_client, con->target, _mot_cb); if(OC_STACK_OK != ret ) { D2DS_LOGE( "OCDoMultipleOwnershipTransfer: ret=%d", ret); return NULL; } - ret = ___d2d_wait_cb_ret(); + ret = _wait_cb_ret(CALLBACK_TIMEOUT_MS); if(ret) { D2DS_LOGE( "OCProvisionCredentials callback error = %d", ret); return NULL; } - // display the registered result + /* display the registered result */ D2DS_LOGE(" > Registered Discovered Devices\n"); - _d2sd_request_cleanup(data); + _request_cleanup(data); return NULL; } -OicUuid_t* __d2ds_convert_uuid(const gchar *device_id) +OicUuid_t* _convert_uuid(const gchar *device_id) { OicUuid_t *uuid; @@ -749,7 +603,7 @@ OicUuid_t* __d2ds_convert_uuid(const gchar *device_id) #if 0 D2DS_LOGE("device_id : %s", device_id); - _d2d_print_uuid(uuid); + _print_uuid(uuid); #endif return uuid; } @@ -769,14 +623,15 @@ static int _d2ds_mot(d2ds_service *service, gchar *uuid_str, gchar *pin) return D2DS_ERROR_OUT_OF_MEMORY; } - uuid = __d2ds_convert_uuid(uuid_str); - src_dev = _get_dev_by_uuid(g_motdev_list, uuid); + uuid = _convert_uuid(uuid_str); + src_dev = _get_dev_by_uuid(g_client->g_motdev_list, uuid); if (!src_dev) { D2DS_LOGE("We can't find in MOT dev list"); - /* Unset d2ds status 'pending' */ - g_atomic_int_set(&service->pending, 0); + g_free(uuid); + _request_cleanup(con); return D2DS_ERROR_NO_DATA; } + g_free(uuid); /* Copy target device & PIN */ con->target = PMCloneOCProvisionDev(src_dev); @@ -787,8 +642,7 @@ static int _d2ds_mot(d2ds_service *service, gchar *uuid_str, gchar *pin) con->pin = calloc(1, OXM_RANDOM_PIN_MAX_SIZE+1); if (!pin) { D2DS_LOGE("Failed to allocate PIN number"); - /* Unset d2ds status 'pending' */ - g_atomic_int_set(&service->pending, 0); + _request_cleanup(con); return D2DS_ERROR_OUT_OF_MEMORY; } memcpy(con->pin, pin, OXM_RANDOM_PIN_MAX_SIZE); @@ -797,16 +651,15 @@ static int _d2ds_mot(d2ds_service *service, gchar *uuid_str, gchar *pin) con->userdata = service; con->cid = D2DS_MOT; - con->thread = g_thread_try_new("mot", __d2ds_mot_func, con, NULL); + con->thread = g_thread_try_new("mot", _mot_func, con, NULL); if (!con->thread) { D2DS_LOGE("Failed to create thread"); - /* Unset d2ds status 'pending' */ - g_atomic_int_set(&service->pending, 0); + _request_cleanup(con); return D2DS_ERROR_OUT_OF_MEMORY; } g_thread_unref(con->thread); - con->tid = g_timeout_add_seconds(DISCOVERY_TIMEOUT + 1, _d2ds_timeout_cb, con); + //con->tid = g_timeout_add_seconds(CALLBACK_TIMEOUT_S + 1, _d2ds_timeout_cb, con); return D2DS_ERROR_NONE; } @@ -932,269 +785,352 @@ static int sendPutLed() return 0; } - -static OicSecAcl_t* createAclForLEDAccess(const OicUuid_t* subject) +#endif /* TEST */ +static OicSecAcl_t* _create_target_acl(const OicUuid_t* target, const OicUuid_t* subject, + const char *rsrc_uri, const char *rsrc_type, const char *rsrc_interface, int permission) { - if(NULL == subject) - { - D2DS_LOGE( "createAcl: Invalid paramters"); + /* For example + * subejct = "12341234-1234-1234-12341234" + * rsrc_uri = "/a/led" + * rsrc_type = "oic.r.core" + * rsrc_interface = "oic.if.baseline" + * rsrc_permission = D2DS_PERMISSION_FULL + */ + size_t len; + OicSecAcl_t* acl = NULL; + OicSecAce_t* ace = NULL; + OicSecRsrc_t* rsrc = NULL; + + if(NULL == target) { + D2DS_LOGE( "target is NULL"); return NULL; } - // allocate memory for |acl| struct - OicSecAcl_t* acl = (OicSecAcl_t*) OICCalloc(1, sizeof(OicSecAcl_t)); - if(!acl) - { - D2DS_LOGE( "createAcl: OICCalloc error return"); - return NULL; // not need to 'goto' |ERROR| before allocating |acl| + + if(NULL == subject) { + D2DS_LOGE( "subejct is NULL"); + return NULL; } - OicSecAce_t* ace = (OicSecAce_t*) OICCalloc(1, sizeof(OicSecAce_t)); - if(!ace) - { - D2DS_LOGE( "createAcl: OICCalloc error return"); - return NULL; // not need to 'goto' |ERROR| before allocating |acl| + + acl = (OicSecAcl_t*) OICCalloc(1, sizeof(OicSecAcl_t)); + if(!acl) { + D2DS_LOGE( "acl : OICCalloc failed =%d", errno); + return NULL; + } + ace = (OicSecAce_t*) OICCalloc(1, sizeof(OicSecAce_t)); + if(!ace) { + D2DS_LOGE( "ace : OICCalloc failed =%d", errno); + return NULL; } LL_APPEND(acl->aces, ace); memcpy(ace->subjectuuid.id, subject->id, sizeof(subject->id)); - // fill the href - char* rsrc_in = "/a/led"; // '1' for null termination - OicSecRsrc_t* rsrc = (OicSecRsrc_t*)OICCalloc(1, sizeof(OicSecRsrc_t)); - if(!rsrc) - { - D2DS_LOGE( "createAcl: OICCalloc error return"); - goto CRACL_ERROR; + /* fill the href */ + rsrc = (OicSecRsrc_t*)OICCalloc(1, sizeof(OicSecRsrc_t)); + if(!rsrc) { + D2DS_LOGE( "rsrc: OICCalloc failed =%d", errno); + goto CREATE_ACL_ERROR; } - size_t len = strlen(rsrc_in)+1; // '1' for null termination + len = strlen(rsrc_uri)+1; // '1' for null termination rsrc->href = (char*) OICCalloc(len, sizeof(char)); - if(!rsrc->href) - { - D2DS_LOGE( "createAcl: OICCalloc error return"); - goto CRACL_ERROR; + if(!rsrc->href) { + D2DS_LOGE( "rsrc->href: OICStrdup failed =%d", errno); + goto CREATE_ACL_ERROR; } - OICStrcpy(rsrc->href, len, rsrc_in); + OICStrcpy(rsrc->href, len, rsrc_uri); - //fill the resource type (rt) + /* Fill the resource type (rt) */ rsrc->typeLen = 1; rsrc->types = (char**)OICCalloc(1, sizeof(char*)); - if(!rsrc->types) - { - D2DS_LOGE( "createAcl: OICCalloc error return"); - goto CRACL_ERROR; + if(!rsrc->types) { + D2DS_LOGE( "rsrc->types: OICCalloc failed =%d", errno); + goto CREATE_ACL_ERROR; } - rsrc->types[0] = OICStrdup("oic.r.core"); - if(!rsrc->types[0]) - { - D2DS_LOGE( "createAcl: OICStrdup error return"); - goto CRACL_ERROR; + rsrc->types[0] = OICStrdup(rsrc_type); + if(!rsrc->types[0]) { + D2DS_LOGE( "rsrc->types[0]: OICStrdup failed =%d", errno); + goto CREATE_ACL_ERROR; } - //fill the interface (if) + /* Fill the interface (if) */ rsrc->interfaceLen = 1; rsrc->interfaces = (char**)OICCalloc(1, sizeof(char*)); - if(!rsrc->interfaces) - { - D2DS_LOGE( "createAcl: OICCalloc error return"); - goto CRACL_ERROR; + if(!rsrc->interfaces) { + D2DS_LOGE( "rsrc->interfaces: OICCalloc failed =%d", errno); + goto CREATE_ACL_ERROR; } - rsrc->interfaces[0] = OICStrdup("oic.if.baseline"); - if(!rsrc->interfaces[0]) - { - D2DS_LOGE( "createAcl: OICStrdup error return"); - goto CRACL_ERROR; + rsrc->interfaces[0] = OICStrdup(rsrc_interface); + if(!rsrc->interfaces[0]) { + D2DS_LOGE( "rsrc->interfaces[0] : OICStrdup failed =%d", errno); + goto CREATE_ACL_ERROR; } LL_APPEND(ace->resources, rsrc); - // full permission for /a/led - ace->permission = PERMISSION_FULL_CONTROL; + /* Fill permission for the reource */ + ace->permission = permission; ace->eownerID = (OicUuid_t*)OICCalloc(1, sizeof(OicUuid_t)); - if(NULL == ace->eownerID) - { - D2DS_LOGE( "createAcl: OICCalloc error return"); - goto CRACL_ERROR; + if(NULL == ace->eownerID) { + D2DS_LOGE( "ace->eownerID : OICCalloc failed =%d", errno); + goto CREATE_ACL_ERROR; } - memcpy(ace->eownerID->id, subject->id, sizeof(subject->id)); return acl; -CRACL_ERROR: - OCDeleteACLList(acl); // after here |acl| points nothing +CREATE_ACL_ERROR: + OCDeleteACLList(acl); return NULL; } -static int provisionAclForLed() +static void _provisioning_acl_cb(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError) { - OicSecAcl_t* acl = NULL; - - // check |own_list| for provisioning access control list - if(!g_mowned_list || 1> g_mowned_cnt) - { - printf(" > MOT Device List is Empty\n"); - printf(" > Please Perform MOT first, with [12|21] Menu\n"); - return 0; // normal case + if(!hasError) { + D2DS_LOGD( "Provision ACL SUCCEEDED - ctx: %s", (char*) ctx); + } else { + D2DS_LOGD( "Provision ACL FAILED - ctx: %s", (char*) ctx); + _print_result_list((const OCProvisionResult_t*) arr, nOfRes); } + g_client->g_doneCB = true; +} - // display the MOT dev list - printf(" > MOT Devices\n"); - g_mowned_cnt = printDevList(g_mowned_list); +static gpointer _provisioning_acl_func(gpointer data) +{ + OCStackResult ret = OC_STACK_OK; + d2ds_req_cb_s *con = (d2ds_req_cb_s *)data; + OicSecAcl_t* acl = NULL; - // select device for provisioning access control list - int dev_num = 0; - for( ; ; ) - { - printf(" > Enter Device Number, for Provisioning LED's ACL: "); - 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) - { - break; - } - printf(" Entered Wrong Number. Please Enter Again\n"); + 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 ); + D2DS_LOGE("%s", con->rsrc_type ); + D2DS_LOGE("%s", con->rsrc_interface ); + return NULL; } - g_doneCB = false; - printf(" Provisioning Selected ACL..\n"); - OCProvisionDev_t* dev = _get_dev_by_id((const OCProvisionDev_t*) g_mowned_list, dev_num); - if(!dev) - { - D2DS_LOGE( "provisionAcl: device instance empty"); - goto PVACL_ERROR; - } + g_client->g_doneCB = false; + D2DS_LOGI(" Provisioning Selected ACL.."); - acl = createAclForLEDAccess(&dev->doxm->subOwners->uuid); - if(NULL == acl) - { - D2DS_LOGE( "provisionAcl: Failed to create ACL for LED"); - return -1; + 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) { + D2DS_LOGE( "Failed to create ACL for %s", con->rsrc_uri); + goto PVACL_ERROR; } - OCStackResult rst = OCProvisionACL((void*) g_ctx, dev, acl, provisionAclCB); - if(OC_STACK_OK != rst) - { - D2DS_LOGD( "OCProvisionACL API error: %d", rst); + ret= OCProvisionACL((void*) g_client, con->subject, acl, _provisioning_acl_cb); + if(OC_STACK_OK != ret) { + D2DS_LOGD( "OCProvisionACL API error: %d", ret); goto PVACL_ERROR; } - if(waitCallbackRet()) // input |g_doneCB| flag implicitly - { - D2DS_LOGE( "OCProvisionCredentials callback error"); + + ret = _wait_cb_ret(CALLBACK_TIMEOUT_MS * 2); + if(ret) { + D2DS_LOGE( "OCProvisionCredentials Faild = %d", errno); goto PVACL_ERROR; } - // display the ACL-provisioned result - printf(" > Provisioned Selected ACL\n"); - - OCDeleteACLList(acl); // after here |acl| points nothing - return 0; + /* display the ACL-provisioned result */ + D2DS_LOGI(" -> Provisioned Selected ACL Successfully"); PVACL_ERROR: - OCDeleteACLList(acl); - return -1; + if (acl) { + OCDeleteACLList(acl); + acl = NULL; + } + _request_cleanup(con); + g_thread_exit(GINT_TO_POINTER (1)); + return NULL; } -static int provisionCred() +static int _provisioning_acl(d2ds_service *service, gchar *target, gchar *subject, + gchar *rsrc_uri, gchar *rsrc_type, gchar *rsrc_interface, int permission) { - // check |unown_list| for registering devices - if(!g_mowned_list|| 0 >=g_mowned_cnt) - { - printf(" > Multiple Owned Device List is Empty\n"); - printf(" > Please Discover Devices first, with [13] Menu\n"); - return 0; // normal case + + OicUuid_t *uuid = NULL; + OCProvisionDev_t *target_dev = NULL; + OCProvisionDev_t *subject_dev = NULL; + + d2ds_req_cb_s *con = NULL; + con = calloc(1, sizeof(d2ds_req_cb_s)); + if (NULL == con) { + D2DS_LOGE( "calloc() Fail=%d", errno); + /* Unset d2ds status 'pending' */ + g_atomic_int_set(&service->pending, 0); + return D2DS_ERROR_OUT_OF_MEMORY; } - // display the MOT dev list - printf(" > Multiple Owned Devices\n"); - g_mowned_cnt = printDevList(g_mowned_list); + uuid = _convert_uuid(target); + target_dev = _get_dev_by_uuid(g_client->g_mowned_list, uuid); + if (!target_dev) { + D2DS_LOGE("We can't find target in MOWNED dev list"); + _request_cleanup(con); + return D2DS_ERROR_NO_DATA; + } + g_free(uuid); - int dev_num = 0; - for( ; ; ) - { - printf(" > Enter Multiple Owned Device Number to link : "); - 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) - { - break; - } - printf(" Entered Wrong Number. Please Enter Again\n"); + /* Copy subject device and related information */ + con->target = PMCloneOCProvisionDev(target_dev); + /* To do ACL provisioning only one */ + con->target->next = NULL; + + uuid = _convert_uuid(subject); + subject_dev = _get_dev_by_uuid(g_client->g_mowned_list, uuid); + if (!subject_dev) { + D2DS_LOGE("We can't find subject in MOWNED dev list"); + _request_cleanup(con); + return D2DS_ERROR_NO_DATA; } + g_free(uuid); - OCProvisionDev_t* motDev = _get_dev_by_id(g_mowned_list, dev_num); - if(NULL == motDev) - { - D2DS_LOGE( "Failed to _get_dev_by_id()"); - return -1; + /* Copy subject device and related information */ + con->subject = PMCloneOCProvisionDev(subject_dev); + /* To do ACL provisioning only one */ + con->subject->next = NULL; + + con->rsrc_uri = OICStrdup(rsrc_uri); + con->rsrc_type = OICStrdup(rsrc_type); + con->rsrc_interface = OICStrdup(rsrc_interface); + con->userdata = service; + con->cid = D2DS_PROV_ACL; + + con->thread = g_thread_try_new("prov_acl", _provisioning_acl_func, con, NULL); + if (!con->thread) { + D2DS_LOGE("Failed to create thread"); + _request_cleanup(con); + return D2DS_ERROR_OUT_OF_MEMORY; } + g_thread_unref(con->thread); - // display the MOT dev list - printf(" > Owned Devices\n"); - g_own_cnt = printDevList(g_own_list); + //con->tid = g_timeout_add_seconds(CALLBACK_TIMEOUT_S + 1, _d2ds_timeout_cb, con); - for( ; ; ) - { - printf(" > Enter Owned Device Number to link : "); - 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) - { - break; - } - printf(" Entered Wrong Number. Please Enter Again\n"); + return D2DS_ERROR_NONE; +} + +static void _provision_cred_cb(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError) +{ + if(!hasError) { + D2DS_LOGD("Provision Credential SUCCEEDED - ctx: %s", (char*) ctx); + } else { + D2DS_LOGD("Provision Credential FAILED - ctx: %s", (char*) ctx); + _print_result_list((const OCProvisionResult_t*) arr, nOfRes); } + g_client->g_doneCB = true; +} - OCProvisionDev_t* ownDev = _get_dev_by_id(g_own_list, dev_num); - if(NULL == ownDev) - { - D2DS_LOGE( "Failed to _get_dev_by_id()"); - return -1; +static gpointer _cred_provisioning_func(gpointer data) +{ + OCStackResult ret = OC_STACK_OK; + d2ds_req_cb_s *con = (d2ds_req_cb_s *)data; + + if(!con->target ) { + D2DS_LOGE("Target device is NULL"); + return NULL; } - // call |OCProvisionCredentials| API actually - // calling this API with callback actually acts like blocking - // for error checking, the return value saved and printed - g_doneCB = false; - printf(" Provisioning Selected Pairwise Devices..\n"); - OCStackResult rst = OCProvisionCredentials((void*) g_ctx, + g_client->g_doneCB = false; + + D2DS_LOGI(" Provisioning Selected Pairwise Devices.."); + OCStackResult rst = OCProvisionCredentials((void*) g_client, SYMMETRIC_PAIR_WISE_KEY, OWNER_PSK_LENGTH_128, - ownDev, motDev, provisionCredCB); - if(OC_STACK_OK != rst) - { + con->dev1, con->dev2, _provision_cred_cb); + if (OC_STACK_OK != rst) { D2DS_LOGD( "OCProvisionPairwiseDevices API error: %d", rst); goto PVPWS_ERROR; } - if(waitCallbackRet()) // input |g_doneCB| flag implicitly - { - D2DS_LOGE( "OCProvisionCredentials callback error"); + + ret = _wait_cb_ret(CALLBACK_TIMEOUT_MS); + if (ret) { + D2DS_LOGE( "OCProvisionCredentials Faild = %d", errno); goto PVPWS_ERROR; } - // display the pairwise-provisioned result - printf(" > Provisioned Selected Pairwise Devices\n"); + /* display the pairwise-provisioned result */ + D2DS_LOGI(" > Provisioned Selected Pairwise Devices"); return 0; PVPWS_ERROR: - return -1; + _request_cleanup(con); + g_thread_exit(GINT_TO_POINTER (1)); + + return NULL; } -#endif /* TEST */ + +static int _d2ds_provisioning_cred(d2ds_service *service, + gchar *uuid_dev1, gchar *uuid_dev2) +{ + + OicUuid_t *uuid = NULL; + OCProvisionDev_t *dev1 = NULL; + OCProvisionDev_t *dev2 = NULL; + + d2ds_req_cb_s *con = NULL; + con = calloc(1, sizeof(d2ds_req_cb_s)); + if (!con) { + D2DS_LOGE( "calloc() Fail=%d", errno); + /* Unset d2ds status 'pending' */ + g_atomic_int_set(&service->pending, 0); + return D2DS_ERROR_OUT_OF_MEMORY; + } + + if (!uuid_dev1 ||!uuid_dev2) { + D2DS_LOGE( "Invaild Prameters"); + _request_cleanup(con); + return D2DS_ERROR_INVALID_PARAMETER; + } + + uuid = _convert_uuid(uuid_dev1); + dev1 = _get_dev_by_uuid(g_client->g_mowned_list, uuid); + if (!dev1) { + D2DS_LOGE("We can't find in MOWNED dev list"); + g_free(uuid); + _request_cleanup(con); + return D2DS_ERROR_NO_DATA; + } + g_free(uuid); + + uuid = _convert_uuid(uuid_dev2); + dev2 = _get_dev_by_uuid(g_client->g_mowned_list, uuid); + if (!dev2) { + D2DS_LOGE("We can't find in MOWNED dev list"); + g_free(uuid); + _request_cleanup(con); + return D2DS_ERROR_NO_DATA; + } + g_free(uuid); + + /* Copy subject device and related information */ + con->dev1 = PMCloneOCProvisionDev(dev1); + /* To do ACL provisioning only one */ + con->dev1->next = NULL; + + con->dev2 = PMCloneOCProvisionDev(dev2); + /* To do ACL provisioning only one */ + con->dev2->next = NULL; + + con->userdata = service; + con->cid = D2DS_PROV_CRED; + + con->thread = g_thread_try_new("prov_cred", _cred_provisioning_func, con, NULL); + if (!con->thread) { + D2DS_LOGE("Failed to create thread"); + _request_cleanup(con); + 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); + + return D2DS_ERROR_NONE; +} + int d2ds_request_enable(d2ds_service *service) { int ret = D2DS_ERROR_NONE; d2ds_check_null_ret_error("service", service, FALSE); - ret = d2ds_init_provision_client(); + ret = _init_provision_client(); return ret; } @@ -1213,11 +1149,8 @@ int d2ds_request_disc_mot_enb_devs(d2ds_service *service) /* Set d2ds status 'pending' */ g_atomic_int_set(&service->pending, 1); -#ifdef TIMER_TEST - ret = _d2ds_disc_mot_enb_devs_timer(service); -#else - ret = _d2ds_disc_mot_enb_devs_thd(service); -#endif + ret = _disc_mot_enb_devs(service); + return ret; } @@ -1236,12 +1169,12 @@ int d2ds_request_disc_owned_devs(d2ds_service *service) /* Set d2ds status 'pending' */ g_atomic_int_set(&service->pending, 1); - ret = _d2ds_disc_owned_devs(service); + ret = _disc_owned_devs(service); return ret; } -int d2ds_request_mot(d2ds_service *service, gchar* uuid, gchar *pin) +int d2ds_request_mot(d2ds_service *service, gchar* uuid_str, gchar *pin) { int ret =D2DS_ERROR_NONE; @@ -1253,137 +1186,94 @@ int d2ds_request_mot(d2ds_service *service, gchar* uuid, gchar *pin) if (g_atomic_int_get(&service->pending)) return D2DS_ERROR_IN_PROGRESS; - if (!uuid || !pin) + if (!uuid_str || !pin) { + D2DS_LOGE("uuid_str = %s", uuid_str); + D2DS_LOGE("pin = %s", pin); return D2DS_ERROR_INVALID_PARAMETER; + } /* Set d2ds status 'pending' */ g_atomic_int_set(&service->pending, 1); - ret = _d2ds_mot(service, uuid, pin); + ret = _d2ds_mot(service, uuid_str, pin); return ret; } -int d2ds_request_disable(d2ds_service *service) +int d2ds_request_prov_acl(d2ds_service *service, gchar *target, gchar *subject, + gchar *rsrc_uri, gchar *rsrc_type, gchar *rsrc_interface, int permission) { + int ret =D2DS_ERROR_NONE; + d2ds_check_null_ret_error("service", service, FALSE); - if(OC_STACK_OK != OCStop()) { - D2DS_LOGE( "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 - OCDeleteDiscoveredDevices(g_motdev_list); // after here |g_motdev_list| points nothing - if(g_svr_fname) { - OICFree(g_svr_fname); // after here |g_svr_fname| points nothing + D2DS_LOGD("[IPC] Provisioning ACL"); + + /* If we are working now? */ + if (g_atomic_int_get(&service->pending)) + return D2DS_ERROR_IN_PROGRESS; + + if (!target || !subject || !rsrc_uri || !rsrc_type || !rsrc_interface) { + D2DS_LOGE("target = %s", target); + D2DS_LOGE("subject = %s", subject); + D2DS_LOGE("rsrc_uri = %s", rsrc_uri); + D2DS_LOGE("rsrc_type = %s", rsrc_type); + D2DS_LOGE("rsrc_interface = %s", rsrc_interface); + return D2DS_ERROR_INVALID_PARAMETER; } - if(g_prvn_fname) { - OICFree(g_prvn_fname); // after here |g_prvn_fname| points nothing + + /* Set d2ds status 'pending' */ + g_atomic_int_set(&service->pending, 1); + + ret = _provisioning_acl(service, target, subject, rsrc_uri, rsrc_type, rsrc_interface, permission); + + return ret; +} + +int d2ds_request_prov_cred(d2ds_service *service, gchar *uuid_dev1, gchar *uuid_dev2) +{ + int ret =D2DS_ERROR_NONE; + + d2ds_check_null_ret_error("service", service, FALSE); + + D2DS_LOGD("[IPC] Provisioning Credential"); + + /* If we are working now? */ + if (g_atomic_int_get(&service->pending)) + return D2DS_ERROR_IN_PROGRESS; + + if (!uuid_dev1 || !uuid_dev2) { + D2DS_LOGE("uuid_dev1 = %s", uuid_dev1); + D2DS_LOGE("uuid_dev2 = %s", uuid_dev2); + return D2DS_ERROR_INVALID_PARAMETER; } - return D2DS_ERROR_NONE; + /* Set d2ds status 'pending' */ + g_atomic_int_set(&service->pending, 1); + + ret = _d2ds_provisioning_cred(service, uuid_dev1, uuid_dev2); + + return ret; } -#if 0 -// main function for provisioning client using C-level provisioning API -int main() +int d2ds_request_disable(d2ds_service *service) { - // initialize provisioning client - if(initProvisionClient()) - { - D2DS_LOGE( "ProvisionClient init error"); - goto PMCLT_ERROR; - } - - // main loop for provisioning manager - int mnNum = 0; - int selDevNum = 0; - for( ; ; ) - { - printf("\n"); - printMenu(); - printf(">> Enter Menu Number: "); - for(int ret=0; 1!=ret; ) - { - ret = scanf("%d", &mnNum); - for( ; 0x20<=getchar(); ); // for removing overflow garbages - // '0x20<=code' is character region - } - printf("\n"); - switch(mnNum) - { - case _10_DISCOV_MOT_ENABLED_DEV_: - if(discoverMotSupportedDevices()) - { - D2DS_LOGE( "_12_MOT_DISCOV_DEV_: error"); - } - break; - case _11_DISCOV_MULTIPLE_OWNED_DEV_: - if(discoverSubOwnerDevices()) - { - D2DS_LOGE( "_13_DISCOV_MULTIPLE_OWNED_DEV_: error"); - } - break; - case _20_PERFORM_MOT_: - if(multipleOwnershipTransfer()) - { - D2DS_LOGE( "_21_PERFORM_MOT_: error"); - } - break; - case _30_GET_LED_RESOURCE_: - if(sendGetLed()) - { - D2DS_LOGE( "_30_GET_LED_RESOURCE_: error"); - } - break; - case _31_PUT_LED_RESOURCE_: - if(sendPutLed()) - { - D2DS_LOGE( "_31_PUT_LED_RESOURCE_: error"); - } - break; - case _40_PROVISION_ACL_: - if(provisionAclForLed()) - { - D2DS_LOGE( "_40_PROVISION_ACL_: error"); - } - break; - case _41_PROVISION_CRED_: - D2DS_LOGE( "NOT SUPPORTED YET."); - break; - /* - if(provisionCred()) - { - D2D_LOGE( "_41_PROVISION_CRED_: 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()) - { - //D2D_LOGE( "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 - OCDeleteDiscoveredDevices(g_motdev_list); // after here |g_motdev_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 + NOTUSED(service); + + if(OC_STACK_OK != OCStop()) { + D2DS_LOGE( "OCStack stop error"); + } + + OCDeleteDiscoveredDevices(g_client->g_mowned_list); + OCDeleteDiscoveredDevices(g_client->g_motdev_list); + + if (g_client->rnd_pin) { + g_free(g_client->rnd_pin); + g_client->rnd_pin = NULL; + } + g_free(g_client); + g_client = NULL; + + return D2DS_ERROR_NONE; } -#endif diff --git a/src/d2d-subowner/d2ds-subowner.h b/src/d2d-subowner/d2ds-subowner.h index abef769..fd4d081 100644 --- a/src/d2d-subowner/d2ds-subowner.h +++ b/src/d2d-subowner/d2ds-subowner.h @@ -25,10 +25,32 @@ extern "C" { #endif +/* command id */ +typedef enum { + D2DS_DISC_MOT_ENB_DEVS = 0, /**< Discover MOT enabled devices */ + D2DS_DISC_MOWNED_DEVS, /**< Discover my owned MOT enabled devices */ + D2DS_MOT, /**< Do Multiplw Onwership Transfer */ + D2DS_PROV_ACL, /**< ACL Provisioning */ + D2DS_PROV_CRED, /**< CRED Provisioning */ +} d2ds_cmd_id_e; + +/* ACL Permission type */ +typedef enum { + D2DS_PERMISSION_CREATE = (1 << 0), /**< C */ + D2DS_PERMISSION_READ = (1 << 1), /**< R */ + D2DS_PERMISSION_WRITE = (1 << 2), /**< U */ + D2DS_PERMISSION_DELETE = (1 << 3), /**< D */ + D2DS_PERMISSION_NOTIFY = (1 << 4), /**< N */ + D2DS_PERMISSION_FULL = 0x11111 /**< CRUDN */ +} d2ds_permission_e; + int d2ds_request_enable(d2ds_service *servic); int d2ds_request_disc_mot_enb_devs(d2ds_service *service); int d2ds_request_disc_owned_devs(d2ds_service *service); int d2ds_request_mot(d2ds_service *service, gchar* uuid, gchar *pin); +int d2ds_request_prov_acl(d2ds_service *service, gchar *target, gchar *subject, + gchar *rsrc_uri, gchar *rsrc_type, gchar *rsrc_interface, int permission); +int d2ds_request_prov_cred(d2ds_service *service, gchar *uuid_dev1, gchar *uuid_dev2); int d2ds_request_disable(d2ds_service *service); #ifdef __cplusplus diff --git a/src/d2d-subowner/introspection/d2ds.xml b/src/d2d-subowner/introspection/d2ds.xml index 2265420..37f7665 100644 --- a/src/d2d-subowner/introspection/d2ds.xml +++ b/src/d2d-subowner/introspection/d2ds.xml @@ -1,35 +1,42 @@ + "-//freedesktop//DTD D-Bus Object Introspection 1.0//EN" + "http://standards.freedesktop.org/dbus/1.0/introspect.dtd"> - - - - + + + + - - + + - - - + + + + + + - - + + + + + + - - - - + + + + @@ -39,8 +46,11 @@ - + - - + + + + + -- 2.34.1