From: youngman Date: Fri, 24 Jul 2015 05:01:12 +0000 (+0900) Subject: Modify gdbus structure(related to CRUD) and gvariant builder X-Git-Tag: submit/tizen/20151130.235229~100 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=0cc23a788c96184a973bb6b15755cf780b650c1f;p=platform%2Fcore%2Fiot%2Fiotcon.git Modify gdbus structure(related to CRUD) and gvariant builder Change-Id: Ibf1130756be41018551ad6687ea1d239e977c46f Signed-off-by: youngman --- diff --git a/.gitignore b/.gitignore index a5f168c..795775b 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,5 @@ cscope.out *.sw* .cproject .project +common/ic-dbus.c +common/ic-dbus.h diff --git a/common/gen.sh b/common/gen.sh new file mode 100755 index 0000000..5410007 --- /dev/null +++ b/common/gen.sh @@ -0,0 +1,9 @@ +#!/bin/sh + +DIR_PATH=`dirname $0` + +gdbus-codegen --generate-c-code "$DIR_PATH"/ic-dbus\ + --interface-prefix org.tizen.iotcon.\ + --c-namespace ic\ + "$DIR_PATH"/ic-dbus.xml + diff --git a/common/ic-common.h b/common/ic-common.h index d926e05..810cf6a 100644 --- a/common/ic-common.h +++ b/common/ic-common.h @@ -29,10 +29,6 @@ #define IC_DBUS_SIGNAL_REQUEST_HANDLER "REQ" #define IC_DBUS_SIGNAL_FOUND_RESOURCE "RES" -#define IC_DBUS_SIGNAL_GET "GET" -#define IC_DBUS_SIGNAL_PUT "PUT" -#define IC_DBUS_SIGNAL_POST "POST" -#define IC_DBUS_SIGNAL_DELETE "DELETE" #define IC_DBUS_SIGNAL_OBSERVE "OBSERVE" #define IC_DBUS_SIGNAL_DEVICE "DEVICE" #define IC_DBUS_SIGNAL_PLATFORM "PLATFORM" diff --git a/common/ic-dbus.xml b/common/ic-dbus.xml index b9a1ee0..6cff5e7 100644 --- a/common/ic-dbus.xml +++ b/common/ic-dbus.xml @@ -55,27 +55,23 @@ - - + - - + - - + - - + diff --git a/daemon/icd-dbus.c b/daemon/icd-dbus.c index 30d5b27..e1de746 100644 --- a/daemon/icd-dbus.c +++ b/daemon/icd-dbus.c @@ -24,13 +24,14 @@ #include "icd-ioty.h" #include "icd-dbus.h" -static GDBusConnection *icd_dbus_conn; +static icDbus *icd_dbus_object; -static GList *icd_dbus_client_list; /* global list to care resource handle for each sender bus */ +/* global list to care resource handle for each client */ +static GList *icd_dbus_client_list; static GMutex icd_dbus_client_list_mutex; typedef struct _icd_dbus_client_s { - gchar *sender; + gchar *bus_name; GList *hdlist; } icd_dbus_client_s; @@ -40,77 +41,71 @@ typedef struct _icd_resource_handle { } icd_resource_handle_s; -static void _icd_dbus_client_list_lock() +icDbus* icd_dbus_get_object() { - g_mutex_lock(&icd_dbus_client_list_mutex); -} - - -static void _icd_dbus_client_list_unlock() -{ - g_mutex_unlock(&icd_dbus_client_list_mutex); + return icd_dbus_object; } static void _icd_dbus_resource_handle_free(void *handle) { - icd_dbus_client_s *bus; - GList *cur_bus, *cur_hd; + icd_dbus_client_s *client; + GList *cur_client, *cur_hd; icd_resource_handle_s *rsrc_handle; - _icd_dbus_client_list_lock(); - cur_bus = icd_dbus_client_list; - while (cur_bus) { - bus = cur_bus->data; - if (NULL == bus) { - ERR("bus is NULL"); - _icd_dbus_client_list_unlock(); + g_mutex_lock(&icd_dbus_client_list_mutex); + cur_client = icd_dbus_client_list; + while (cur_client) { + client = cur_client->data; + if (NULL == client) { + ERR("client is NULL"); + g_mutex_unlock(&icd_dbus_client_list_mutex); return; } - cur_hd = bus->hdlist; + cur_hd = client->hdlist; while (cur_hd) { rsrc_handle = cur_hd->data; if (rsrc_handle->handle == handle) { DBG("resource handle(%u, %u) removed from handle list", handle, rsrc_handle->number); - bus->hdlist = g_list_delete_link(bus->hdlist, cur_hd); + client->hdlist = g_list_delete_link(client->hdlist, cur_hd); free(rsrc_handle); - _icd_dbus_client_list_unlock(); + g_mutex_unlock(&icd_dbus_client_list_mutex); return; } cur_hd = cur_hd->next; } - cur_bus = cur_bus->next; + cur_client = cur_client->next; } - _icd_dbus_client_list_unlock(); + g_mutex_unlock(&icd_dbus_client_list_mutex); return; } -int icd_dbus_bus_list_get_info(void *handle, unsigned int *sig_num, gchar **sender) +int icd_dbus_client_list_get_info(void *handle, unsigned int *sig_num, gchar **bus_name) { FN_CALL; - icd_dbus_client_s *bus; - GList *cur_bus, *cur_hd; + icd_dbus_client_s *client; + GList *cur_client, *cur_hd; icd_resource_handle_s *rsrc_handle; RETV_IF(NULL == sig_num, IOTCON_ERROR_INVALID_PARAMETER); - RETV_IF(NULL == sender, IOTCON_ERROR_INVALID_PARAMETER); - - _icd_dbus_client_list_lock(); - cur_bus = icd_dbus_client_list; - while (cur_bus) { - bus = cur_bus->data; - if (NULL == bus) { - ERR("bus is NULL"); - _icd_dbus_client_list_unlock(); + RETV_IF(NULL == bus_name, IOTCON_ERROR_INVALID_PARAMETER); + + g_mutex_lock(&icd_dbus_client_list_mutex); + cur_client = icd_dbus_client_list; + while (cur_client) { + client = cur_client->data; + if (NULL == client) { + ERR("client is NULL"); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_NO_DATA; } - cur_hd = bus->hdlist; + cur_hd = client->hdlist; while (cur_hd) { rsrc_handle = cur_hd->data; @@ -118,17 +113,17 @@ int icd_dbus_bus_list_get_info(void *handle, unsigned int *sig_num, gchar **send DBG("signal_number(%u) for resource handle(%u) found", rsrc_handle->number, handle); *sig_num = rsrc_handle->number; - *sender = ic_utils_strdup(bus->sender); - _icd_dbus_client_list_unlock(); + *bus_name = ic_utils_strdup(client->bus_name); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_NONE; } cur_hd = cur_hd->next; } - cur_bus = cur_bus->next; + cur_client = cur_client->next; } - _icd_dbus_client_list_unlock(); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_NO_DATA; } @@ -136,10 +131,15 @@ int icd_dbus_emit_signal(const char *dest, const char *signal_name, GVariant *va { gboolean ret; GError *error = NULL; + GDBusConnection *conn; + icDbusSkeleton *skeleton; DBG("SIG : %s, %s", signal_name, g_variant_print(value, FALSE)); - ret = g_dbus_connection_emit_signal(icd_dbus_conn, + skeleton = IC_DBUS_SKELETON(icd_dbus_get_object()); + conn = g_dbus_interface_skeleton_get_connection(G_DBUS_INTERFACE_SKELETON(skeleton)); + + ret = g_dbus_connection_emit_signal(conn, dest, IOTCON_DBUS_OBJPATH, IOTCON_DBUS_INTERFACE, @@ -152,7 +152,7 @@ int icd_dbus_emit_signal(const char *dest, const char *signal_name, GVariant *va return IOTCON_ERROR_DBUS; } - if (FALSE == g_dbus_connection_flush_sync(icd_dbus_conn, NULL, &error)) { + if (FALSE == g_dbus_connection_flush_sync(conn, NULL, &error)) { ERR("g_dbus_connection_flush_sync() Fail(%s)", error->message); g_error_free(error); return IOTCON_ERROR_DBUS; @@ -178,49 +178,49 @@ static void _icd_dbus_cleanup_handle(void *data) free(rsrc_handle); } -static int _icd_dbus_bus_list_cleanup_handle_list(GList *list) +static int _icd_dbus_client_list_cleanup_handle_list(GList *client_list) { - icd_dbus_client_s *bus; + icd_dbus_client_s *client; - RETV_IF(NULL == list, IOTCON_ERROR_INVALID_PARAMETER); + RETV_IF(NULL == client_list, IOTCON_ERROR_INVALID_PARAMETER); - bus = list->data; - g_list_free_full(bus->hdlist, _icd_dbus_cleanup_handle); - free(bus->sender); - bus->sender = NULL; - free(bus); + client = client_list->data; + g_list_free_full(client->hdlist, _icd_dbus_cleanup_handle); + free(client->bus_name); + client->bus_name = NULL; + free(client); return IOTCON_ERROR_NONE; } -static int _icd_dbus_bus_list_find_sender(const gchar *owner, GList **ret_list) +static int _icd_dbus_client_list_find_client(const gchar *owner, GList **ret_list) { - GList *cur; - icd_dbus_client_s *bus; + GList *client_list; + icd_dbus_client_s *client; RETV_IF(NULL == owner, IOTCON_ERROR_INVALID_PARAMETER); RETV_IF(NULL == ret_list, IOTCON_ERROR_INVALID_PARAMETER); - cur = icd_dbus_client_list; - while (cur) { - bus = cur->data; - if (NULL == bus) { - ERR("bus is NULL"); + client_list = icd_dbus_client_list; + while (client_list) { + client = client_list->data; + if (NULL == client) { + ERR("client is NULL"); return IOTCON_ERROR_NO_DATA; } - if (IC_STR_EQUAL == g_strcmp0(bus->sender, owner)) { - *ret_list = cur; + if (IC_STR_EQUAL == g_strcmp0(client->bus_name, owner)) { + *ret_list = client_list; return IOTCON_ERROR_NONE; } - cur = cur->next; + client_list = client_list->next; } - return IOTCON_ERROR_NONE; + return IOTCON_ERROR_NO_DATA; } -static void _icd_dbus_name_owner_changed_cb(GDBusConnection *connection, +static void _icd_dbus_name_owner_changed_cb(GDBusConnection *conn, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, @@ -229,41 +229,41 @@ static void _icd_dbus_name_owner_changed_cb(GDBusConnection *connection, gpointer user_data) { int ret; - GList *sender = NULL; + GList *client = NULL; gchar *name, *old_owner, *new_owner; g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner); if (0 == strlen(new_owner)) { - _icd_dbus_client_list_lock(); - ret = _icd_dbus_bus_list_find_sender(old_owner, &sender); + g_mutex_lock(&icd_dbus_client_list_mutex); + ret = _icd_dbus_client_list_find_client(old_owner, &client); if (IOTCON_ERROR_NONE != ret) { - ERR("_icd_dbus_bus_list_find_sender() Fail(%d)", ret); - _icd_dbus_client_list_unlock(); + ERR("_icd_dbus_client_list_find_client() Fail(%d)", ret); + g_mutex_unlock(&icd_dbus_client_list_mutex); return; } - if (sender) { /* found bus name in our bus list */ + if (client) { /* found bus name in our bus list */ DBG("bus(%s) stopped", old_owner); - ret = _icd_dbus_bus_list_cleanup_handle_list(sender); + ret = _icd_dbus_client_list_cleanup_handle_list(client); if (IOTCON_ERROR_NONE != ret) { - ERR("_icd_dbus_bus_list_cleanup_handle_list() Fail(%d)", ret); - _icd_dbus_client_list_unlock(); + ERR("_icd_dbus_client_list_cleanup_handle_list() Fail(%d)", ret); + g_mutex_unlock(&icd_dbus_client_list_mutex); return; } - icd_dbus_client_list = g_list_delete_link(icd_dbus_client_list, sender); + icd_dbus_client_list = g_list_delete_link(icd_dbus_client_list, client); } - _icd_dbus_client_list_unlock(); + g_mutex_unlock(&icd_dbus_client_list_mutex); } } -static int _icd_dbus_subscribe_name_owner_changed() +static int _icd_dbus_subscribe_name_owner_changed(GDBusConnection *conn) { FN_CALL; unsigned int id; - id = g_dbus_connection_signal_subscribe(icd_dbus_conn, + id = g_dbus_connection_signal_subscribe(conn, "org.freedesktop.DBus", /* bus name */ "org.freedesktop.DBus", /* interface */ "NameOwnerChanged", /* member */ @@ -281,98 +281,94 @@ static int _icd_dbus_subscribe_name_owner_changed() return IOTCON_ERROR_NONE; } -static int _icd_dbus_resource_list_append_handle(const gchar *sender, void *handle, +static int _icd_dbus_resource_list_append_handle(const gchar *bus_name, void *handle, unsigned int signal_number) { FN_CALL; - char *sender_dup; - GList *cur_bus, *cur_hd; - bool sender_exist = false; + GList *cur_client, *cur_hd; + bool client_exist = false; icd_resource_handle_s *rsrc_handle; - icd_dbus_client_s *new_bus = NULL; - icd_dbus_client_s *bus; + icd_dbus_client_s *client = NULL; - RETV_IF(NULL == sender, IOTCON_ERROR_INVALID_PARAMETER); + RETV_IF(NULL == bus_name, IOTCON_ERROR_INVALID_PARAMETER); RETV_IF(NULL == handle, IOTCON_ERROR_INVALID_PARAMETER); - _icd_dbus_client_list_lock(); - cur_bus = icd_dbus_client_list; + g_mutex_lock(&icd_dbus_client_list_mutex); + cur_client = icd_dbus_client_list; - while (cur_bus) { - bus = cur_bus->data; - if (NULL == bus) { - ERR("bus is NULL"); - _icd_dbus_client_list_unlock(); + while (cur_client) { + client = cur_client->data; + if (NULL == client) { + ERR("client is NULL"); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_NO_DATA; } - if (IC_STR_EQUAL == g_strcmp0(bus->sender, sender)) { - DBG("sender(%s) already exist", sender); - sender_exist = true; + if (IC_STR_EQUAL == g_strcmp0(client->bus_name, bus_name)) { + DBG("bus_name(%s) already exist", bus_name); + client_exist = true; break; } - cur_bus = cur_bus->next; + cur_client = cur_client->next; } - if (true == sender_exist) { - cur_hd = bus->hdlist; + if (true == client_exist) { + cur_hd = client->hdlist; while (cur_hd) { rsrc_handle = cur_hd->data; if (rsrc_handle->handle == handle) { ERR("resource handle(%u, %u) already exist", rsrc_handle->handle, rsrc_handle->number); - _icd_dbus_client_list_unlock(); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_ALREADY; } cur_hd = cur_hd->next; } } else { - DBG("sender(%s) not exist. make new one.", sender); + DBG("bus_name(%s) not exist. make new one.", bus_name); - new_bus = calloc(1, sizeof(icd_dbus_client_s)); - if (NULL == new_bus) { - ERR("calloc(bus) Fail(%d)", errno); - _icd_dbus_client_list_unlock(); + client = calloc(1, sizeof(icd_dbus_client_s)); + if (NULL == client) { + ERR("calloc(client) Fail(%d)", errno); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_OUT_OF_MEMORY; } - sender_dup = ic_utils_strdup(sender); - if (NULL == sender_dup) { + client->bus_name = ic_utils_strdup(bus_name); + if (NULL == client->bus_name) { ERR("ic_utils_strdup() Fail"); - free(new_bus); - _icd_dbus_client_list_unlock(); + free(client); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_OUT_OF_MEMORY; } - new_bus->sender = sender_dup; - DBG("new bus(%s, %d) added", sender, signal_number); - bus = new_bus; + DBG("new client(%s, %d) added", bus_name, signal_number); } rsrc_handle = calloc(1, sizeof(icd_resource_handle_s)); if (NULL == rsrc_handle) { ERR("calloc(handle) Fail(%d)", errno); - if (false == sender_exist) { - free(new_bus->sender); - free(new_bus); + if (false == client_exist) { + free(client->bus_name); + free(client); } - _icd_dbus_client_list_unlock(); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_OUT_OF_MEMORY; } rsrc_handle->handle = handle; rsrc_handle->number = signal_number; - DBG("handle(%u) added in the bus(%s, %u)", handle, sender, signal_number); + DBG("handle(%u) added in the client(%s, %u)", handle, bus_name, signal_number); - bus->hdlist = g_list_append(bus->hdlist, rsrc_handle); + client->hdlist = g_list_append(client->hdlist, rsrc_handle); - if (false == sender_exist) - icd_dbus_client_list = g_list_append(icd_dbus_client_list, bus); + if (false == client_exist) + icd_dbus_client_list = g_list_append(icd_dbus_client_list, client); - _icd_dbus_client_list_unlock(); + g_mutex_unlock(&icd_dbus_client_list_mutex); return IOTCON_ERROR_NONE; } @@ -508,84 +504,6 @@ static gboolean _dbus_handle_find_resource(icDbus *object, } -static gboolean _dbus_handle_get(icDbus *object, GDBusMethodInvocation *invocation, - GVariant *client, GVariant *query, guint signal_number) -{ - int ret; - const gchar *sender; - - sender = g_dbus_method_invocation_get_sender(invocation); - ret = icd_ioty_get(client, query, signal_number, sender); - if (IOTCON_ERROR_NONE != ret) - ERR("icd_ioty_get() Fail(%d)", ret); - - ic_dbus_complete_get(object, invocation, ret); - - return TRUE; -} - - -static gboolean _dbus_handle_put(icDbus *object, - GDBusMethodInvocation *invocation, - GVariant *client, - const gchar *repr, - GVariant *query, - guint signal_number) -{ - int ret; - const gchar *sender; - - sender = g_dbus_method_invocation_get_sender(invocation); - ret = icd_ioty_put(client, repr, query, signal_number, sender); - if (IOTCON_ERROR_NONE != ret) - ERR("icd_ioty_put() Fail(%d)", ret); - - ic_dbus_complete_put(object, invocation, ret); - - return TRUE; -} - - -static gboolean _dbus_handle_post(icDbus *object, - GDBusMethodInvocation *invocation, - GVariant *client, - const gchar *repr, - GVariant *query, - guint signal_number) -{ - int ret; - const gchar *sender; - - sender = g_dbus_method_invocation_get_sender(invocation); - ret = icd_ioty_post(client, repr, query, signal_number, sender); - if (IOTCON_ERROR_NONE != ret) - ERR("icd_ioty_post() Fail(%d)", ret); - - ic_dbus_complete_post(object, invocation, ret); - - return TRUE; -} - - -static gboolean _dbus_handle_delete(icDbus *object, - GDBusMethodInvocation *invocation, - GVariant *client, - guint signal_number) -{ - int ret; - const gchar *sender; - - sender = g_dbus_method_invocation_get_sender(invocation); - ret = icd_ioty_delete(client, signal_number, sender); - if (IOTCON_ERROR_NONE != ret) - ERR("icd_ioty_delete() Fail(%d)", ret); - - ic_dbus_complete_delete(object, invocation, ret); - - return TRUE; -} - - static gboolean _dbus_handle_observer_start(icDbus *object, GDBusMethodInvocation *invocation, GVariant *client, @@ -815,77 +733,73 @@ static void _dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name, gpointer user_data) { gboolean ret; - icDbus *dbus_object; GError *error = NULL; - - icd_dbus_conn = conn; - - dbus_object = ic_dbus_skeleton_new(); - if (NULL == dbus_object) { + icd_dbus_object = ic_dbus_skeleton_new(); + if (NULL == icd_dbus_object) { ERR("ic_iotcon_skeletion_new() Fail"); return; } - g_signal_connect(dbus_object, "handle-register-resource", + g_signal_connect(icd_dbus_object, "handle-register-resource", G_CALLBACK(_dbus_handle_register_resource), NULL); - g_signal_connect(dbus_object, "handle-unregister-resource", + g_signal_connect(icd_dbus_object, "handle-unregister-resource", G_CALLBACK(_dbus_handle_unregister_resource), NULL); - g_signal_connect(dbus_object, "handle-bind-interface", + g_signal_connect(icd_dbus_object, "handle-bind-interface", G_CALLBACK(_dbus_handle_bind_interface), NULL); - g_signal_connect(dbus_object, "handle-bind-type", + g_signal_connect(icd_dbus_object, "handle-bind-type", G_CALLBACK(_dbus_handle_bind_type), NULL); - g_signal_connect(dbus_object, "handle-bind-resource", + g_signal_connect(icd_dbus_object, "handle-bind-resource", G_CALLBACK(_dbus_handle_bind_resource), NULL); - g_signal_connect(dbus_object, "handle-unbind-resource", + g_signal_connect(icd_dbus_object, "handle-unbind-resource", G_CALLBACK(_dbus_handle_unbind_resource), NULL); - g_signal_connect(dbus_object, "handle-find-resource", + g_signal_connect(icd_dbus_object, "handle-find-resource", G_CALLBACK(_dbus_handle_find_resource), NULL); - g_signal_connect(dbus_object, "handle-get", - G_CALLBACK(_dbus_handle_get), NULL); - g_signal_connect(dbus_object, "handle-put", - G_CALLBACK(_dbus_handle_put), NULL); - g_signal_connect(dbus_object, "handle-post", - G_CALLBACK(_dbus_handle_post), NULL); - g_signal_connect(dbus_object, "handle-delete", - G_CALLBACK(_dbus_handle_delete), NULL); - g_signal_connect(dbus_object, "handle-observer-start", + g_signal_connect(icd_dbus_object, "handle-get", + G_CALLBACK(icd_ioty_get), NULL); + g_signal_connect(icd_dbus_object, "handle-put", + G_CALLBACK(icd_ioty_put), NULL); + g_signal_connect(icd_dbus_object, "handle-post", + G_CALLBACK(icd_ioty_post), NULL); + g_signal_connect(icd_dbus_object, "handle-delete", + G_CALLBACK(icd_ioty_delete), NULL); + g_signal_connect(icd_dbus_object, "handle-observer-start", G_CALLBACK(_dbus_handle_observer_start), NULL); - g_signal_connect(dbus_object, "handle-observer-stop", + g_signal_connect(icd_dbus_object, "handle-observer-stop", G_CALLBACK(_dbus_handle_observer_stop), NULL); - g_signal_connect(dbus_object, "handle-notify-list-of-observers", + g_signal_connect(icd_dbus_object, "handle-notify-list-of-observers", G_CALLBACK(_dbus_handle_notify_list_of_observers), NULL); - g_signal_connect(dbus_object, "handle-notify-all", + g_signal_connect(icd_dbus_object, "handle-notify-all", G_CALLBACK(_dbus_handle_notify_all), NULL); - g_signal_connect(dbus_object, "handle-send-response", + g_signal_connect(icd_dbus_object, "handle-send-response", G_CALLBACK(_dbus_handle_send_response), NULL); #ifdef DEVICE_INFO_IMPL /* not implemented in iotivity 0.9.1 */ - g_signal_connect(dbus_object, "handle-register-device-info", + g_signal_connect(icd_dbus_object, "handle-register-device-info", G_CALLBACK(_dbus_handle_register_device_info), NULL); - g_signal_connect(dbus_object, "handle-get-device-info", + g_signal_connect(icd_dbus_object, "handle-get-device-info", G_CALLBACK(_dbus_handle_get_device_info), NULL); #endif - g_signal_connect(dbus_object, "handle-register-platform-info", + g_signal_connect(icd_dbus_object, "handle-register-platform-info", G_CALLBACK(_dbus_handle_register_platform_info), NULL); - g_signal_connect(dbus_object, "handle-get-platform-info", + g_signal_connect(icd_dbus_object, "handle-get-platform-info", G_CALLBACK(_dbus_handle_get_platform_info), NULL); - g_signal_connect(dbus_object, "handle-start-presence", + g_signal_connect(icd_dbus_object, "handle-start-presence", G_CALLBACK(_dbus_handle_start_presence), NULL); - g_signal_connect(dbus_object, "handle-stop-presence", + g_signal_connect(icd_dbus_object, "handle-stop-presence", G_CALLBACK(_dbus_handle_stop_presence), NULL); - g_signal_connect(dbus_object, "handle-subscribe-presence", + g_signal_connect(icd_dbus_object, "handle-subscribe-presence", G_CALLBACK(_dbus_handle_subscribe_presence), NULL); - g_signal_connect(dbus_object, "handle-unsubscribe-presence", + g_signal_connect(icd_dbus_object, "handle-unsubscribe-presence", G_CALLBACK(_dbus_handle_unsubscribe_presence), NULL); - ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(dbus_object), conn, - IOTCON_DBUS_OBJPATH, &error); + ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(icd_dbus_object), + conn, IOTCON_DBUS_OBJPATH, &error); if (FALSE == ret) { ERR("g_dbus_interface_skeleton_export() Fail(%s)", error->message); g_error_free(error); } - ret = _icd_dbus_subscribe_name_owner_changed(); + ret = _icd_dbus_subscribe_name_owner_changed(conn); if (IOTCON_ERROR_NONE != ret) { ERR("_icd_dbus_subscribe_name_owner_changed() Fail(%d)", ret); return; @@ -894,14 +808,14 @@ static void _dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name, } -static void _dbus_on_name_lost(GDBusConnection *connection, const gchar *name, +static void _dbus_on_name_lost(GDBusConnection *conn, const gchar *name, gpointer user_data) { DBG("Lost the name %s", name); } -static void _dbus_on_name_acquired(GDBusConnection *connection, const gchar *name, +static void _dbus_on_name_acquired(GDBusConnection *conn, const gchar *name, gpointer user_data) { DBG("Acquired the name %s", name); diff --git a/daemon/icd-dbus.h b/daemon/icd-dbus.h index 15adac1..9f896bf 100644 --- a/daemon/icd-dbus.h +++ b/daemon/icd-dbus.h @@ -17,8 +17,10 @@ #define __IOT_CONNECTIVITY_MANAGER_DAEMON_DBUS_H__ #include +#include "ic-dbus.h" -int icd_dbus_bus_list_get_info(void *handle, unsigned int *sig_num, gchar **sender); +icDbus* icd_dbus_get_object(); +int icd_dbus_client_list_get_info(void *handle, unsigned int *sig_num, gchar **bus_name); int icd_dbus_emit_signal(const char *dest, const char *sig_name, GVariant *value); unsigned int icd_dbus_init(); void icd_dbus_deinit(unsigned int id); diff --git a/daemon/icd-ioty-ocprocess.c b/daemon/icd-ioty-ocprocess.c index 3412e88..5a30f39 100644 --- a/daemon/icd-ioty-ocprocess.c +++ b/daemon/icd-ioty-ocprocess.c @@ -48,7 +48,7 @@ enum _icd_secure_type struct icd_req_context { unsigned int signum; - char *sender; + char *bus_name; char *payload; int types; int observer_id; @@ -62,7 +62,7 @@ struct icd_req_context { struct icd_find_context { unsigned int signum; - char *sender; + char *bus_name; char *payload; OCDevAddr *dev_addr; int conn_type; @@ -70,11 +70,10 @@ struct icd_find_context { struct icd_get_context { - unsigned int signum; int res; - char *sender; char *payload; GVariantBuilder *options; + GDBusMethodInvocation *invocation; }; @@ -196,12 +195,12 @@ static int _worker_req_handler(void *context) GPOINTER_TO_INT(ctx->request_h), GPOINTER_TO_INT(ctx->resource_h)); - ret = _ocprocess_response_signal(ctx->sender, IC_DBUS_SIGNAL_REQUEST_HANDLER, + ret = _ocprocess_response_signal(ctx->bus_name, IC_DBUS_SIGNAL_REQUEST_HANDLER, ctx->signum, value); if (IOTCON_ERROR_NONE != ret) ERR("_ocprocess_response_signal() Fail(%d)", ret); - free(ctx->sender); + free(ctx->bus_name); free(ctx->payload); g_variant_builder_unref(ctx->options); g_variant_builder_unref(ctx->query); @@ -218,7 +217,7 @@ OCEntityHandlerResult icd_ioty_ocprocess_req_handler(OCEntityHandlerFlag flag, unsigned int signal_number; char *query_str, *query_key, *query_value; char *token, *save_ptr1, *save_ptr2; - char *sender = NULL; + char *bus_name = NULL; struct icd_req_context *req_ctx; RETV_IF(NULL == request, OC_EH_ERROR); @@ -233,16 +232,16 @@ OCEntityHandlerResult icd_ioty_ocprocess_req_handler(OCEntityHandlerFlag flag, req_ctx->request_h = request->requestHandle; req_ctx->resource_h = request->resource; - ret = icd_dbus_bus_list_get_info(req_ctx->resource_h, &signal_number, &sender); + ret = icd_dbus_client_list_get_info(req_ctx->resource_h, &signal_number, &bus_name); if (IOTCON_ERROR_NONE != ret) { - ERR("icd_dbus_bus_list_get_info() Fail(%d)", ret); + ERR("icd_dbus_client_list_get_info() Fail(%d)", ret); free(req_ctx); return OC_EH_ERROR; } - /* signal number & sender */ + /* signal number & bus_name */ req_ctx->signum = signal_number; - req_ctx->sender = sender; + req_ctx->bus_name = bus_name; /* request type */ if (OC_REQUEST_FLAG & flag) { @@ -271,7 +270,7 @@ OCEntityHandlerResult icd_ioty_ocprocess_req_handler(OCEntityHandlerFlag flag, req_ctx->payload = strdup(IC_STR_NULL); break; default: - free(req_ctx->sender); + free(req_ctx->bus_name); free(req_ctx); return OC_EH_ERROR; } @@ -300,7 +299,7 @@ OCEntityHandlerResult icd_ioty_ocprocess_req_handler(OCEntityHandlerFlag flag, ret = _ocprocess_worker_start(_worker_req_handler, req_ctx); if (IOTCON_ERROR_NONE != ret) { ERR("_ocprocess_worker_start() Fail(%d)", ret); - free(req_ctx->sender); + free(req_ctx->bus_name); free(req_ctx->payload); g_variant_builder_unref(req_ctx->options); g_variant_builder_unref(req_ctx->query); @@ -433,7 +432,7 @@ static inline int _find_cb_response(JsonObject *rsrc_obj, /* TODO : If one device has multi resources, it comes as bulk data. * To reduce the number of emit_signal, let's send signal only one time for one device. * for ex, client list. */ - ret = _ocprocess_response_signal(ctx->sender, IC_DBUS_SIGNAL_FOUND_RESOURCE, + ret = _ocprocess_response_signal(ctx->bus_name, IC_DBUS_SIGNAL_FOUND_RESOURCE, ctx->signum, value); if (IOTCON_ERROR_NONE != ret) { ERR("_ocprocess_response_signal() Fail(%d)", ret); @@ -509,7 +508,7 @@ static int _worker_find_cb(void *context) ERR("_find_cb_handle_context() Fail(%d)", ret); /* ctx was allocated from icd_ioty_ocprocess_find_cb() */ - free(ctx->sender); + free(ctx->bus_name); free(ctx->payload); free(ctx->dev_addr); free(ctx); @@ -545,7 +544,7 @@ OCStackApplicationResult icd_ioty_ocprocess_find_cb(void *ctx, OCDoHandle handle memcpy(dev_addr, resp->addr, sizeof(OCDevAddr)); find_ctx->signum = sig_context->signum; - find_ctx->sender = ic_utils_strdup(sig_context->sender); + find_ctx->bus_name = ic_utils_strdup(sig_context->bus_name); find_ctx->payload = ic_utils_strdup(resp->resJSONPayload); find_ctx->dev_addr = dev_addr; find_ctx->conn_type = resp->connType; @@ -553,7 +552,7 @@ OCStackApplicationResult icd_ioty_ocprocess_find_cb(void *ctx, OCDoHandle handle ret = _ocprocess_worker_start(_worker_find_cb, find_ctx); if (IOTCON_ERROR_NONE != ret) { ERR("_ocprocess_worker_start() Fail(%d)", ret); - free(find_ctx->sender); + free(find_ctx->bus_name); free(find_ctx->payload); free(find_ctx->dev_addr); free(find_ctx); @@ -576,13 +575,9 @@ static int _worker_get_cb(void *context) RETV_IF(NULL == ctx, IOTCON_ERROR_INVALID_PARAMETER); value = g_variant_new("(a(qs)si)", ctx->options, ctx->payload, ctx->res); - - ret = _ocprocess_response_signal(ctx->sender, IC_DBUS_SIGNAL_GET, ctx->signum, value); - if (IOTCON_ERROR_NONE != ret) - ERR("_ocprocess_response_signal() Fail(%d)", ret); + icd_ioty_get_complete(ctx->invocation, value); /* ctx was allocated from icd_ioty_ocprocess_get_cb() */ - free(ctx->sender); free(ctx->payload); g_variant_builder_unref(ctx->options); free(ctx); @@ -591,19 +586,6 @@ static int _worker_get_cb(void *context) } -static void _get_cb_response_error(const char *dest, unsigned int signum, int ret_val) -{ - int ret; - GVariant *value; - - value = g_variant_new("(a(qs)si)", NULL, IC_STR_NULL, ret_val); - - ret = _ocprocess_response_signal(dest, IC_DBUS_SIGNAL_GET, signum, value); - if (IOTCON_ERROR_NONE != ret) - ERR("_ocprocess_response_signal() Fail(%d)", ret); -} - - OCStackApplicationResult icd_ioty_ocprocess_get_cb(void *ctx, OCDoHandle handle, OCClientResponse *resp) { @@ -612,22 +594,19 @@ OCStackApplicationResult icd_ioty_ocprocess_get_cb(void *ctx, OCDoHandle handle, OCStackResult result; GVariantBuilder *options; struct icd_get_context *get_ctx; - icd_sig_ctx_s *sig_context = ctx; RETV_IF(NULL == ctx, OC_STACK_DELETE_TRANSACTION); if (NULL == resp->resJSONPayload || '\0' == resp->resJSONPayload[0]) { ERR("json payload is empty"); - _get_cb_response_error(sig_context->sender, sig_context->signum, - IOTCON_ERROR_IOTIVITY); + icd_ioty_get_complete_error(ctx, IOTCON_ERROR_IOTIVITY); return OC_STACK_DELETE_TRANSACTION; } get_ctx = calloc(1, sizeof(struct icd_get_context)); if (NULL == get_ctx) { ERR("calloc() Fail(%d)", errno); - _get_cb_response_error(sig_context->sender, sig_context->signum, - IOTCON_ERROR_OUT_OF_MEMORY); + icd_ioty_get_complete_error(ctx, IOTCON_ERROR_OUT_OF_MEMORY); return OC_STACK_DELETE_TRANSACTION; } @@ -643,23 +622,20 @@ OCStackApplicationResult icd_ioty_ocprocess_get_cb(void *ctx, OCDoHandle handle, } get_ctx->payload = strdup(resp->resJSONPayload); - get_ctx->signum = sig_context->signum; get_ctx->res = res; - get_ctx->sender = ic_utils_strdup(sig_context->sender); get_ctx->options = options; + get_ctx->invocation = ctx; ret = _ocprocess_worker_start(_worker_get_cb, get_ctx); if (IOTCON_ERROR_NONE != ret) { ERR("_ocprocess_worker_start() Fail(%d)", ret); - _get_cb_response_error(sig_context->sender, sig_context->signum, ret); - free(get_ctx->sender); + icd_ioty_get_complete_error(ctx, ret); free(get_ctx->payload); g_variant_builder_unref(get_ctx->options); free(get_ctx); return OC_STACK_DELETE_TRANSACTION; } - /* DO NOT FREE sig_context. It MUST be freed in the ocstack */ /* DO NOT FREE get_ctx. It MUST be freed in the _worker_get_cb func */ return OC_STACK_DELETE_TRANSACTION; diff --git a/daemon/icd-ioty.c b/daemon/icd-ioty.c index 35c464a..2723f9b 100644 --- a/daemon/icd-ioty.c +++ b/daemon/icd-ioty.c @@ -26,8 +26,10 @@ #include #include "iotcon.h" +#include "ic-dbus.h" #include "ic-utils.h" #include "icd.h" +#include "icd-dbus.h" #include "icd-ioty.h" #include "icd-ioty-ocprocess.h" @@ -369,12 +371,12 @@ int icd_ioty_send_response(GVariant *resp) static void _ioty_free_signal_context(void *data) { icd_sig_ctx_s *context = data; - free(context->sender); + free(context->bus_name); free(context); } int icd_ioty_find_resource(const char *host_address, const char *resource_type, - unsigned int signum, const char *sender) + unsigned int signum, const char *bus_name) { int len; OCStackResult result; @@ -404,7 +406,7 @@ int icd_ioty_find_resource(const char *host_address, const char *resource_type, return IOTCON_ERROR_OUT_OF_MEMORY; } - context->sender = ic_utils_strdup(sender); + context->bus_name = ic_utils_strdup(bus_name); context->signum = signum; cbdata.context = context; @@ -418,7 +420,7 @@ int icd_ioty_find_resource(const char *host_address, const char *resource_type, if (OC_STACK_OK != result) { ERR("OCDoResource() Fail(%d)", result); - free(context->sender); + free(context->bus_name); free(context); return IOTCON_ERROR_IOTIVITY; } @@ -435,7 +437,7 @@ static char* _icd_ioty_resource_generate_uri(char *host, char *uri_path, GVarian int len; bool loop_first = true; char *key, *value; - GVariantIter *queryIter; + GVariantIter query_iter; char uri_buf[PATH_MAX] = {0}; len = snprintf(uri_buf, sizeof(uri_buf), "%s%s", host, uri_path); @@ -446,9 +448,9 @@ static char* _icd_ioty_resource_generate_uri(char *host, char *uri_path, GVarian len--; } - g_variant_get(query, "a(ss)", &queryIter); + g_variant_iter_init(&query_iter, query); - while (g_variant_iter_loop(queryIter, "(&s&s)", &key, &value)) { + while (g_variant_iter_loop(&query_iter, "(&s&s)", &key, &value)) { int query_len; DBG("query exist. key(%s), value(%s)", key, value); @@ -462,22 +464,35 @@ static char* _icd_ioty_resource_generate_uri(char *host, char *uri_path, GVarian len += query_len; } - g_variant_iter_free(queryIter); return strdup(uri_buf); } -int icd_ioty_get(GVariant *resource, GVariant *query, unsigned int signal_number, - const char *sender) +void icd_ioty_get_complete(GDBusMethodInvocation *invocation, GVariant *value) +{ + ic_dbus_complete_get(icd_dbus_get_object(), invocation, value); +} + + +void icd_ioty_get_complete_error(GDBusMethodInvocation *invocation, int ret_val) +{ + GVariant *value; + + value = g_variant_new("(a(qs)si)", NULL, IC_STR_NULL, ret_val); + + ic_dbus_complete_get(icd_dbus_get_object(), invocation, value); +} + + +gboolean icd_ioty_get(icDbus *object, GDBusMethodInvocation *invocation, + GVariant *resource, GVariant *query) { - FN_CALL; - int conn_type, options_size; - char *uri_path, *host, *uri; OCStackResult result; GVariantIter *options; OCCallbackData cbdata = {0}; - icd_sig_ctx_s *context; + int conn_type, options_size; + char *uri_path, *host, *uri; int is_observable, ifaces, observe_handle; OCHeaderOption oic_options[MAX_HEADER_OPTIONS]; @@ -488,21 +503,12 @@ int icd_ioty_get(GVariant *resource, GVariant *query, unsigned int signal_number if (NULL == uri) { ERR("_icd_ioty_resource_generate_uri() Fail"); g_variant_iter_free(options); - return IOTCON_ERROR_INVALID_PARAMETER; + icd_ioty_get_complete_error(invocation, IOTCON_ERROR_INVALID_PARAMETER); + return TRUE; } - context = calloc(1, sizeof(icd_sig_ctx_s)); - if (NULL == context) { - ERR("calloc() Fail(%d)", errno); - g_variant_iter_free(options); - return IOTCON_ERROR_OUT_OF_MEMORY; - } - context->sender = ic_utils_strdup(sender); - context->signum = signal_number; - - cbdata.context = context; + cbdata.context = invocation; cbdata.cb = icd_ioty_ocprocess_get_cb; - cbdata.cd = _ioty_free_signal_context; options_size = g_variant_iter_n_children(options); if (0 != options_size) { @@ -510,11 +516,10 @@ int icd_ioty_get(GVariant *resource, GVariant *query, unsigned int signal_number sizeof(oic_options) / sizeof(oic_options[0])); if (IOTCON_ERROR_NONE != ret) { ERR("_ioty_get_header_options() Fail(%d)", ret); - free(context->sender); - free(context); free(uri); g_variant_iter_free(options); - return ret; + icd_ioty_get_complete_error(invocation, ret); + return TRUE; } } g_variant_iter_free(options); @@ -529,33 +534,80 @@ int icd_ioty_get(GVariant *resource, GVariant *query, unsigned int signal_number if (OC_STACK_OK != result) { ERR("OCDoResource() Fail(%d)", result); - free(context->sender); - free(context); - return IOTCON_ERROR_IOTIVITY; + icd_ioty_get_complete_error(invocation, IOTCON_ERROR_IOTIVITY); + return TRUE; } - return IOTCON_ERROR_NONE; + return TRUE; } -int icd_ioty_put(GVariant *resource, const char *repr, GVariant *query, - unsigned int signal_number, const char *sender) +void icd_ioty_put_complete(GDBusMethodInvocation *invocation, GVariant *value) +{ + ic_dbus_complete_put(icd_dbus_get_object(), invocation, value); +} + + +void icd_ioty_put_complete_error(GDBusMethodInvocation *invocation, int ret_val) +{ + GVariant *value; + + value = g_variant_new("(a(qs)si)", NULL, IC_STR_NULL, ret_val); + + ic_dbus_complete_put(icd_dbus_get_object(), invocation, value); +} + + +gboolean icd_ioty_put(icDbus *object, GDBusMethodInvocation *invocation, + GVariant *resource, const char *repr, GVariant *query) { // TODO : To be implemented return IOTCON_ERROR_NONE; } -int icd_ioty_post(GVariant *resource, const char *repr, GVariant *query, - unsigned int signal_number, const char *sender) +void icd_ioty_post_complete(GDBusMethodInvocation *invocation, GVariant *value) +{ + ic_dbus_complete_post(icd_dbus_get_object(), invocation, value); +} + + +void icd_ioty_post_complete_error(GDBusMethodInvocation *invocation, int ret_val) +{ + GVariant *value; + + value = g_variant_new("(a(qs)si)", NULL, IC_STR_NULL, ret_val); + + ic_dbus_complete_post(icd_dbus_get_object(), invocation, value); +} + + +gboolean icd_ioty_post(icDbus *object, GDBusMethodInvocation *invocation, + GVariant *resource, const char *repr, GVariant *query) { // TODO : To be implemented return IOTCON_ERROR_NONE; } -int icd_ioty_delete(GVariant *resource, unsigned int signal_number, - const char *sender) +void icd_ioty_delete_complete(GDBusMethodInvocation *invocation, GVariant *value) +{ + ic_dbus_complete_delete(icd_dbus_get_object(), invocation, value); +} + + +void icd_ioty_delete_complete_error(GDBusMethodInvocation *invocation, int ret_val) +{ + GVariant *value; + + value = g_variant_new("(a(qs)i)", NULL, IC_STR_NULL, ret_val); + + ic_dbus_complete_delete(icd_dbus_get_object(), invocation, value); +} + + +gboolean icd_ioty_delete(icDbus *object, GDBusMethodInvocation *invocation, + GVariant *resource) { // TODO : To be implemented return IOTCON_ERROR_NONE; @@ -563,7 +615,7 @@ int icd_ioty_delete(GVariant *resource, unsigned int signal_number, int icd_ioty_observer_start(GVariant *resource, int observe_type, - GVariant *query, unsigned int signal_number, const char *sender, int *observe_h) + GVariant *query, unsigned int signal_number, const char *bus_name, int *observe_h) { // TODO : To be implemented return IOTCON_ERROR_NONE; @@ -586,7 +638,7 @@ int icd_ioty_register_device_info(GVariant *value) int icd_ioty_get_device_info(const char *host_address, - unsigned int signal_number, const char *sender) + unsigned int signal_number, const char *bus_name) { // TODO : To be implemented return IOTCON_ERROR_NONE; @@ -602,7 +654,7 @@ int icd_ioty_register_platform_info(GVariant *value) int icd_ioty_get_platform_info(const char *host_address, unsigned int signal_number, - const char *sender) + const char *bus_name) { // TODO : To be implemented return IOTCON_ERROR_NONE; @@ -610,7 +662,7 @@ int icd_ioty_get_platform_info(const char *host_address, unsigned int signal_num OCDoHandle icd_ioty_subscribe_presence(const char *host_address, - const char *resource_type, unsigned int signal_number, const char *sender) + const char *resource_type, unsigned int signal_number, const char *bus_name) { // TODO : To be implemented return NULL; diff --git a/daemon/icd-ioty.h b/daemon/icd-ioty.h index a8e5caa..faa0128 100644 --- a/daemon/icd-ioty.h +++ b/daemon/icd-ioty.h @@ -27,7 +27,7 @@ typedef struct { unsigned int signum; - char *sender; + char *bus_name; } icd_sig_ctx_s; @@ -59,21 +59,30 @@ int icd_ioty_notify_all(void *handle); int icd_ioty_send_response(GVariant *resp); int icd_ioty_find_resource(const char *host_address, const char *resource_type, - unsigned int signal_number, const char *sender); + unsigned int signal_number, const char *bus_name); -int icd_ioty_get(GVariant *resource, GVariant *query, unsigned int signal_number, - const char *sender); +void icd_ioty_get_complete(GDBusMethodInvocation *invocation, GVariant *value); +void icd_ioty_get_complete_error(GDBusMethodInvocation *invocation, int ret_val); +gboolean icd_ioty_get(icDbus *object, GDBusMethodInvocation *invocation, + GVariant *resource, GVariant *query); -int icd_ioty_put(GVariant *resource, const char *repr, GVariant *query, - unsigned int signal_number, const char *sender); +void icd_ioty_put_complete(GDBusMethodInvocation *invocation, GVariant *value); +void icd_ioty_put_complete_error(GDBusMethodInvocation *invocation, int ret_val); +gboolean icd_ioty_put(icDbus *object, GDBusMethodInvocation *invocation, + GVariant *resource, const char *repr, GVariant *query); -int icd_ioty_post(GVariant *resource, const char *repr, GVariant *query, - unsigned int signal_number, const char *sender); +void icd_ioty_post_complete(GDBusMethodInvocation *invocation, GVariant *value); +void icd_ioty_post_complete_error(GDBusMethodInvocation *invocation, int ret_val); +gboolean icd_ioty_post(icDbus *object, GDBusMethodInvocation *invocation, + GVariant *resource, const char *repr, GVariant *query); -int icd_ioty_delete(GVariant *resource, unsigned int signal_number, const char *sender); +void icd_ioty_delete_complete(GDBusMethodInvocation *invocation, GVariant *value); +void icd_ioty_delete_complete_error(GDBusMethodInvocation *invocation, int ret_val); +gboolean icd_ioty_delete(icDbus *object, GDBusMethodInvocation *invocation, + GVariant *resource); int icd_ioty_observer_start(GVariant *resource, int observe_type, GVariant *query, - unsigned int signal_number, const char *sender, int *observe_h); + unsigned int signal_number, const char *bus_name, int *observe_h); int icd_ioty_observer_stop(void *observe_h); @@ -81,16 +90,16 @@ int icd_ioty_observer_stop(void *observe_h); int icd_ioty_register_device_info(GVariant *value); int icd_ioty_get_device_info(const char *host_address, unsigned int signal_number, - const char *sender); + const char *bus_name); #endif int icd_ioty_register_platform_info(GVariant *value); int icd_ioty_get_platform_info(const char *host_address, unsigned int signal_number, - const char *sender); + const char *bus_name); void* icd_ioty_subscribe_presence(const char *host_address, const char *resource_type, - unsigned int signal_number, const char *sender); + unsigned int signal_number, const char *bus_name); int icd_ioty_unsubscribe_presence(void *presence_handle); diff --git a/lib/icl-client-crud.c b/lib/icl-client-crud.c index f28baa4..f6d4525 100644 --- a/lib/icl-client-crud.c +++ b/lib/icl-client-crud.c @@ -20,6 +20,7 @@ #include "iotcon.h" #include "ic-utils.h" +#include "ic-dbus.h" #include "icl.h" #include "icl-options.h" #include "icl-dbus.h" @@ -31,14 +32,12 @@ typedef struct { iotcon_on_cru_cb cb; void *user_data; iotcon_client_h resource; - unsigned int id; } icl_on_cru_s; typedef struct { iotcon_on_delete_cb cb; void *user_data; iotcon_client_h resource; - unsigned int id; } icl_on_delete_s; typedef struct { @@ -48,28 +47,17 @@ typedef struct { } icl_on_observe_s; -static void _icl_on_cru_cb(GDBusConnection *connection, - const gchar *sender_name, - const gchar *object_path, - const gchar *interface_name, - const gchar *signal_name, - GVariant *parameters, - gpointer user_data) +static void _icl_on_cru_cb(GVariant *result, icl_on_cru_s *cb_container) { int res; + iotcon_repr_h repr; GVariantIter *options; unsigned short option_id; - char *option_data; + char *option_data, *repr_json; iotcon_options_h header_options = NULL; - iotcon_repr_h repr = NULL; - char *repr_json = NULL; - - icl_on_cru_s *cb_container = user_data; iotcon_on_cru_cb cb = cb_container->cb; - icl_dbus_unsubscribe_signal(cb_container->id); - - g_variant_get(parameters, "(a(qs)si)", &options, &repr_json, &res); + g_variant_get(result, "(a(qs)si)", &options, &repr_json, &res); if (IOTCON_ERROR_NONE == res && g_variant_iter_n_children(options)) { header_options = iotcon_options_new(); @@ -86,6 +74,9 @@ static void _icl_on_cru_cb(GDBusConnection *connection, ERR("icl_repr_create_repr() Fail"); if (header_options) iotcon_options_free(header_options); + + iotcon_client_free(cb_container->resource); + free(cb_container); return; } } @@ -100,54 +91,81 @@ static void _icl_on_cru_cb(GDBusConnection *connection, if (header_options) iotcon_options_free(header_options); + iotcon_client_free(cb_container->resource); + free(cb_container); } -static void _icl_cru_conn_cleanup(icl_on_cru_s *cb_container) +static void _icl_on_get_cb(GObject *object, GAsyncResult *g_async_res, + gpointer user_data) { - iotcon_client_free(cb_container->resource); - free(cb_container); + GVariant *result; + GError *error = NULL; + icl_on_cru_s *cb_container = user_data; + + ic_dbus_call_get_finish(IC_DBUS(object), &result, g_async_res, &error); + if (error) { + ERR("ic_dbus_call_get_finish() Fail(%s)", error->message); + g_error_free(error); + iotcon_client_free(cb_container->resource); + free(cb_container); + return; + } + + _icl_on_cru_cb(result, cb_container); } -API int iotcon_get(iotcon_client_h resource, iotcon_query_h query, - iotcon_on_cru_cb cb, void *user_data) +static void _icl_on_put_cb(GObject *object, GAsyncResult *g_async_res, + gpointer user_data) { - int ret; + GVariant *result; GError *error = NULL; - unsigned int sub_id; - int signal_number; - char signal_name[IC_DBUS_SIGNAL_LENGTH] = {0}; - icl_on_cru_s *cb_container; - GVariant *arg_client; - GVariant *arg_query; + icl_on_cru_s *cb_container = user_data; - RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS); - RETV_IF(NULL == resource, IOTCON_ERROR_INVALID_PARAMETER); - RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER); + ic_dbus_call_put_finish(IC_DBUS(object), &result, g_async_res, &error); + if (error) { + ERR("ic_dbus_call_put_finish() Fail(%s)", error->message); + g_error_free(error); + iotcon_client_free(cb_container->resource); + free(cb_container); + return; + } - signal_number = icl_dbus_generate_signal_number(); + _icl_on_cru_cb(result, cb_container); +} - arg_client = icl_dbus_client_to_gvariant(resource); - arg_query = icl_dbus_query_to_gvariant(query); - ic_dbus_call_get_sync(icl_dbus_get_object(), arg_client, arg_query, signal_number, - &ret, NULL, &error); +static void _icl_on_post_cb(GObject *object, GAsyncResult *g_async_res, + gpointer user_data) +{ + GVariant *result; + GError *error = NULL; + icl_on_cru_s *cb_container = user_data; + + ic_dbus_call_post_finish(IC_DBUS(object), &result, g_async_res, &error); if (error) { - ERR("ic_dbus_call_get_sync() Fail(%s)", error->message); + ERR("ic_dbus_call_post_finish() Fail(%s)", error->message); g_error_free(error); - g_variant_unref(arg_query); - g_variant_unref(arg_client); - return IOTCON_ERROR_DBUS; + iotcon_client_free(cb_container->resource); + free(cb_container); + return; } - if (IOTCON_ERROR_NONE != ret) { - ERR("iotcon-daemon Fail(%d)", ret); - return icl_dbus_convert_daemon_error(ret); - } + _icl_on_cru_cb(result, cb_container); +} - snprintf(signal_name, sizeof(signal_name), "%s_%u", IC_DBUS_SIGNAL_GET, - signal_number); + +API int iotcon_get(iotcon_client_h resource, iotcon_query_h query, + iotcon_on_cru_cb cb, void *user_data) +{ + GVariant *arg_client; + GVariant *arg_query; + icl_on_cru_s *cb_container; + + RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS); + RETV_IF(NULL == resource, IOTCON_ERROR_INVALID_PARAMETER); + RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER); cb_container = calloc(1, sizeof(icl_on_cru_s)); if (NULL == cb_container) { @@ -165,70 +183,29 @@ API int iotcon_get(iotcon_client_h resource, iotcon_query_h query, cb_container->cb = cb; cb_container->user_data = user_data; - sub_id = icl_dbus_subscribe_signal(signal_name, cb_container, _icl_cru_conn_cleanup, - _icl_on_cru_cb); - if (0 == sub_id) { - ERR("icl_dbus_subscribe_signal() Fail"); - _icl_cru_conn_cleanup(cb_container); - return IOTCON_ERROR_DBUS; - } + arg_client = icl_dbus_client_to_gvariant(resource); + arg_query = icl_dbus_query_to_gvariant(query); - cb_container->id = sub_id; + ic_dbus_call_get(icl_dbus_get_object(), arg_client, arg_query, NULL, _icl_on_get_cb, + cb_container); - return ret; + return IOTCON_ERROR_NONE; } API int iotcon_put(iotcon_client_h resource, iotcon_repr_h repr, iotcon_query_h query, iotcon_on_cru_cb cb, void *user_data) { - int ret; - GError *error = NULL; - unsigned int sub_id; - int signal_number; - char signal_name[IC_DBUS_SIGNAL_LENGTH] = {0}; char *arg_repr; - icl_on_cru_s *cb_container; GVariant *arg_client; GVariant *arg_query; + icl_on_cru_s *cb_container; RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS); RETV_IF(NULL == resource, IOTCON_ERROR_INVALID_PARAMETER); RETV_IF(NULL == repr, IOTCON_ERROR_INVALID_PARAMETER); RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER); - signal_number = icl_dbus_generate_signal_number(); - - arg_repr = icl_repr_generate_json(repr, FALSE); - if (NULL == arg_repr) { - ERR("icl_repr_generate_json() Fail"); - return IOTCON_ERROR_REPRESENTATION; - } - - arg_client = icl_dbus_client_to_gvariant(resource); - arg_query = icl_dbus_query_to_gvariant(query); - - ic_dbus_call_put_sync(icl_dbus_get_object(), arg_client, arg_repr, arg_query, - signal_number, &ret, NULL, &error); - if (error) { - ERR("ic_dbus_call_put_sync() Fail(%s)", error->message); - g_error_free(error); - g_variant_unref(arg_query); - g_variant_unref(arg_client); - free(arg_repr); - return IOTCON_ERROR_DBUS; - } - - if (IOTCON_ERROR_NONE != ret) { - ERR("iotcon-daemon Fail(%d)", ret); - free(arg_repr); - return icl_dbus_convert_daemon_error(ret); - } - free(arg_repr); - - snprintf(signal_name, sizeof(signal_name), "%s_%u", IC_DBUS_SIGNAL_PUT, - signal_number); - cb_container = calloc(1, sizeof(icl_on_cru_s)); if (NULL == cb_container) { ERR("calloc() Fail(%d)", errno); @@ -245,70 +222,39 @@ API int iotcon_put(iotcon_client_h resource, iotcon_repr_h repr, cb_container->cb = cb; cb_container->user_data = user_data; - sub_id = icl_dbus_subscribe_signal(signal_name, cb_container, _icl_cru_conn_cleanup, - _icl_on_cru_cb); - if (0 == sub_id) { - ERR("icl_dbus_subscribe_signal() Fail"); - _icl_cru_conn_cleanup(cb_container); - return IOTCON_ERROR_DBUS; + arg_repr = icl_repr_generate_json(repr, FALSE); + if (NULL == arg_repr) { + ERR("icl_repr_generate_json() Fail"); + iotcon_client_free(cb_container->resource); + free(cb_container); + return IOTCON_ERROR_REPRESENTATION; } - cb_container->id = sub_id; + arg_client = icl_dbus_client_to_gvariant(resource); + arg_query = icl_dbus_query_to_gvariant(query); - return ret; + ic_dbus_call_put(icl_dbus_get_object(), arg_client, arg_repr, arg_query, NULL, + _icl_on_put_cb, cb_container); + + free(arg_repr); + + return IOTCON_ERROR_NONE; } API int iotcon_post(iotcon_client_h resource, iotcon_repr_h repr, iotcon_query_h query, iotcon_on_cru_cb cb, void *user_data) { - int ret; - GError *error = NULL; - unsigned int sub_id; - int signal_number; - char signal_name[IC_DBUS_SIGNAL_LENGTH] = {0}; char *arg_repr; - icl_on_cru_s *cb_container; GVariant *arg_client; GVariant *arg_query; + icl_on_cru_s *cb_container; RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS); RETV_IF(NULL == resource, IOTCON_ERROR_INVALID_PARAMETER); RETV_IF(NULL == repr, IOTCON_ERROR_INVALID_PARAMETER); RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER); - signal_number = icl_dbus_generate_signal_number(); - - arg_repr = icl_repr_generate_json(repr, FALSE); - if (NULL == arg_repr) { - ERR("icl_repr_generate_json() Fail"); - return IOTCON_ERROR_REPRESENTATION; - } - - arg_client = icl_dbus_client_to_gvariant(resource); - arg_query = icl_dbus_query_to_gvariant(query); - - ic_dbus_call_post_sync(icl_dbus_get_object(), arg_client, arg_repr, arg_query, - signal_number, &ret, NULL, &error); - if (error) { - ERR("ic_dbus_call_post_sync() Fail(%s)", error->message); - g_error_free(error); - g_variant_unref(arg_client); - g_variant_unref(arg_query); - free(arg_repr); - return IOTCON_ERROR_DBUS; - } - - if (IOTCON_ERROR_NONE != ret) { - ERR("iotcon-daemon Fail(%d)", ret); - free(arg_repr); - return icl_dbus_convert_daemon_error(ret); - } - free(arg_repr); - - snprintf(signal_name, sizeof(signal_name), "%s_%u", IC_DBUS_SIGNAL_POST, - signal_number); - cb_container = calloc(1, sizeof(icl_on_cru_s)); if (NULL == cb_container) { ERR("calloc() Fail(%d)", errno); @@ -325,58 +271,65 @@ API int iotcon_post(iotcon_client_h resource, iotcon_repr_h repr, cb_container->cb = cb; cb_container->user_data = user_data; - sub_id = icl_dbus_subscribe_signal(signal_name, cb_container, _icl_cru_conn_cleanup, - _icl_on_cru_cb); - if (0 == sub_id) { - ERR("icl_dbus_subscribe_signal() Fail"); - _icl_cru_conn_cleanup(cb_container); - return IOTCON_ERROR_DBUS; + arg_repr = icl_repr_generate_json(repr, FALSE); + if (NULL == arg_repr) { + ERR("icl_repr_generate_json() Fail"); + iotcon_client_free(cb_container->resource); + free(cb_container); + return IOTCON_ERROR_REPRESENTATION; } - cb_container->id = sub_id; + arg_client = icl_dbus_client_to_gvariant(resource); + arg_query = icl_dbus_query_to_gvariant(query); + + ic_dbus_call_post(icl_dbus_get_object(), arg_client, arg_repr, arg_query, NULL, + _icl_on_post_cb, cb_container); - return ret; + free(arg_repr); + + return IOTCON_ERROR_NONE; } -static void _icl_on_delete_cb(GDBusConnection *connection, - const gchar *sender_name, - const gchar *object_path, - const gchar *interface_name, - const gchar *signal_name, - GVariant *parameters, +static void _icl_on_delete_cb(GObject *object, GAsyncResult *g_async_res, gpointer user_data) { + int res; + GVariant *result; + char *option_data; + GError *error = NULL; GVariantIter *options; unsigned short option_id; - char *option_data; iotcon_options_h header_options = NULL; - int res; icl_on_delete_s *cb_container = user_data; iotcon_on_delete_cb cb = cb_container->cb; - g_variant_get(parameters, "(a(qs)i)", &options, &res); + ic_dbus_call_delete_finish(IC_DBUS(object), &result, g_async_res, &error); + if (error) { + ERR("ic_dbus_call_delete_finish() Fail(%s)", error->message); + g_error_free(error); + iotcon_client_free(cb_container->resource); + free(cb_container); + return; + } + g_variant_get(result, "(a(qs)i)", &options, &res); - if (g_variant_iter_n_children(options)) { + if (IOTCON_ERROR_NONE != res && g_variant_iter_n_children(options)) { header_options = iotcon_options_new(); while (g_variant_iter_loop(options, "(q&s)", &option_id, &option_data)) iotcon_options_insert(header_options, option_id, option_data); } g_variant_iter_free(options); + res = icl_dbus_convert_daemon_error(res); + if (cb) cb(cb_container->resource, header_options, res, cb_container->user_data); if (header_options) iotcon_options_free(header_options); - icl_dbus_unsubscribe_signal(cb_container->id); -} - - -static void _icl_delete_conn_cleanup(icl_on_delete_s *cb_container) -{ iotcon_client_free(cb_container->resource); free(cb_container); } @@ -384,39 +337,13 @@ static void _icl_delete_conn_cleanup(icl_on_delete_s *cb_container) API int iotcon_delete(iotcon_client_h resource, iotcon_on_delete_cb cb, void *user_data) { - int ret; - GError *error = NULL; - unsigned int sub_id; - int signal_number; - char signal_name[IC_DBUS_SIGNAL_LENGTH] = {0}; - icl_on_delete_s *cb_container; GVariant *arg_client; + icl_on_delete_s *cb_container; RETV_IF(NULL == icl_dbus_get_object(), IOTCON_ERROR_DBUS); RETV_IF(NULL == resource, IOTCON_ERROR_INVALID_PARAMETER); RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER); - signal_number = icl_dbus_generate_signal_number(); - - arg_client = icl_dbus_client_to_gvariant(resource); - - ic_dbus_call_delete_sync(icl_dbus_get_object(), arg_client, signal_number, &ret, - NULL, &error); - if (error) { - ERR("ic_dbus_call_delete_sync() Fail(%s)", error->message); - g_error_free(error); - g_variant_unref(arg_client); - return IOTCON_ERROR_DBUS; - } - - if (IOTCON_ERROR_NONE != ret) { - ERR("iotcon-daemon Fail(%d)", ret); - return icl_dbus_convert_daemon_error(ret); - } - - snprintf(signal_name, sizeof(signal_name), "%s_%u", IC_DBUS_SIGNAL_DELETE, - signal_number); - cb_container = calloc(1, sizeof(icl_on_delete_s)); if (NULL == cb_container) { ERR("calloc() Fail(%d)", errno); @@ -433,17 +360,12 @@ API int iotcon_delete(iotcon_client_h resource, iotcon_on_delete_cb cb, void *us cb_container->cb = cb; cb_container->user_data = user_data; - sub_id = icl_dbus_subscribe_signal(signal_name, cb_container, _icl_delete_conn_cleanup, - _icl_on_delete_cb); - if (0 == sub_id) { - ERR("icl_dbus_subscribe_signal() Fail"); - _icl_delete_conn_cleanup(cb_container); - return IOTCON_ERROR_DBUS; - } + arg_client = icl_dbus_client_to_gvariant(resource); - cb_container->id = sub_id; + ic_dbus_call_delete(icl_dbus_get_object(), arg_client, NULL, _icl_on_delete_cb, + cb_container); - return ret; + return IOTCON_ERROR_NONE; } diff --git a/lib/icl-dbus-type.c b/lib/icl-dbus-type.c index a21ed79..f07bcd7 100644 --- a/lib/icl-dbus-type.c +++ b/lib/icl-dbus-type.c @@ -54,95 +54,90 @@ const char** icl_dbus_resource_types_to_array(iotcon_resource_types_h types) GVariant* icl_dbus_notimsg_to_gvariant(struct icl_notify_msg *msg) { char *repr_json = NULL; - GVariant *value; - GVariantBuilder *builder; + GVariantBuilder builder; - builder = g_variant_builder_new(G_VARIANT_TYPE("a(is)")); + g_variant_builder_init(&builder, G_VARIANT_TYPE("a(is)")); if (msg) { /* TODO Make repr_json using interface */ repr_json = icl_repr_generate_json(msg->repr, false); if (NULL == repr_json) { ERR("icl_repr_generate_json() Fail"); - g_variant_builder_unref(builder); + g_variant_builder_clear(&builder); return NULL; } - g_variant_builder_add(builder, "(is)", msg->error_code, repr_json); - } - value = g_variant_new("a(is)", builder); + g_variant_builder_add(&builder, "(is)", msg->error_code, repr_json); - free(repr_json); - g_variant_builder_unref(builder); + free(repr_json); + } - return value; + return g_variant_builder_end(&builder); } GVariant* icl_dbus_response_to_gvariant(struct icl_resource_response *response) { char *repr_json; + GVariant *value; GHashTableIter iter; - GVariantBuilder *options; + GVariantBuilder options; gpointer option_id, option_data; - GVariant *value; - - options = g_variant_builder_new(G_VARIANT_TYPE("a(qs)")); + g_variant_builder_init(&options, G_VARIANT_TYPE("a(qs)")); if (response->header_options) { g_hash_table_iter_init(&iter, response->header_options->hash); - while (g_hash_table_iter_next(&iter, &option_id, &option_data)) - g_variant_builder_add(options, "(qs)", GPOINTER_TO_INT(option_id), option_data); + while (g_hash_table_iter_next(&iter, &option_id, &option_data)) { + g_variant_builder_add(&options, "(qs)", GPOINTER_TO_INT(option_id), + option_data); + } } /* TODO Make repr_json using interface */ repr_json = icl_repr_generate_json(response->repr, false); if (NULL == repr_json) { ERR("icl_repr_generate_json() Fail"); - g_variant_builder_unref(options); + g_variant_builder_clear(&options); return NULL; } value = g_variant_new("(sia(qs)isii)", ic_utils_dbus_encode_str(response->new_uri_path), response->error_code, - options, + &options, response->result, repr_json, GPOINTER_TO_INT(response->request_handle), GPOINTER_TO_INT(response->resource_handle)); - g_variant_builder_unref(options); - return value; } GVariant* icl_dbus_client_to_gvariant(struct icl_remote_resource *resource) { - FN_CALL; GVariant *value; - GVariantBuilder *options; GHashTableIter iter; + GVariantBuilder options; gpointer option_id, option_data; - options = g_variant_builder_new(G_VARIANT_TYPE("a(qs)")); + g_variant_builder_init(&options, G_VARIANT_TYPE("a(qs)")); if (resource->header_options) { g_hash_table_iter_init(&iter, resource->header_options->hash); - while (g_hash_table_iter_next(&iter, &option_id, &option_data)) - g_variant_builder_add(options, "(qs)", GPOINTER_TO_INT(option_id), option_data); + while (g_hash_table_iter_next(&iter, &option_id, &option_data)) { + g_variant_builder_add(&options, "(qs)", GPOINTER_TO_INT(option_id), + option_data); + } } value = g_variant_new("(ssba(qs)iii)", resource->uri_path, resource->host, resource->is_observable, - options, + &options, resource->ifaces, resource->conn_type, GPOINTER_TO_INT(resource->observe_handle)); - g_variant_builder_unref(options); - return value; } @@ -192,41 +187,30 @@ GVariant* icl_dbus_platform_info_to_gvariant(iotcon_platform_info_s *platform_in GVariant* icl_dbus_query_to_gvariant(iotcon_query_h query) { - FN_CALL; - GVariant *query_value; - GVariantBuilder *builder; - GHashTableIter iter; gpointer key, value; + GHashTableIter iter; + GVariantBuilder builder; - builder = g_variant_builder_new(G_VARIANT_TYPE("a(ss)")); + g_variant_builder_init(&builder, G_VARIANT_TYPE("a(ss)")); if (query) { g_hash_table_iter_init(&iter, query->hash); while (g_hash_table_iter_next(&iter, &key, &value)) - g_variant_builder_add(builder, "(ss)", key, value); + g_variant_builder_add(&builder, "(ss)", key, value); } - query_value = g_variant_new("a(ss)", builder); - - g_variant_builder_unref(builder); - - return query_value; + return g_variant_builder_end(&builder); } GVariant* icl_dbus_observers_to_gvariant(iotcon_observers_h observers) { GList *node; - GVariant *obs; - GVariantBuilder *builder; + GVariantBuilder builder; - builder = g_variant_builder_new(G_VARIANT_TYPE("ai")); + g_variant_builder_init(&builder, G_VARIANT_TYPE("ai")); for (node = observers; node; node = node->next) - g_variant_builder_add(builder, "i", GPOINTER_TO_INT(node->data)); - - obs = g_variant_new("ai", builder); - - g_variant_builder_unref(builder); + g_variant_builder_add(&builder, "i", GPOINTER_TO_INT(node->data)); - return obs; + return g_variant_builder_end(&builder); }