static GBusType g_default_bus_type = G_BUS_TYPE_SYSTEM;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
-void dbus_handle_set_default_bus_type(GBusType bus_type)
+void gdbus_set_default_bus_type(GBusType bus_type)
{
if (bus_type != G_BUS_TYPE_SYSTEM && bus_type != G_BUS_TYPE_SESSION)
return ;
pthread_mutex_unlock(&g_mutex);
}
-GBusType dbus_handle_get_default_bus_type(void)
+GBusType gdbus_get_default_bus_type(void)
{
GBusType type;
/* global shared bus : system, session */
static dbus_handle_s g_dh[2];
-static dbus_handle_s *_dbus_handle_get_connection(GBusType bus_type);
+static dbus_handle_s *_gdbus_get_connection(GBusType bus_type);
-dbus_handle_s * _dbus_handle_get_default_connection(void)
+dbus_handle_s * _gdbus_get_default_connection(void)
{
- return _dbus_handle_get_connection(dbus_handle_get_default_bus_type());
+ return _gdbus_get_connection(gdbus_get_default_bus_type());
}
-#define dbus_handle_lock(handle) do {\
+#define gdbus_lock(handle) do {\
assert(handle);\
pthread_mutex_lock(&((handle)->mutex));\
} while (0);
-#define dbus_handle_unlock(handle) do {\
+#define gdbus_unlock(handle) do {\
assert(handle);\
pthread_mutex_unlock(&(handle)->mutex);\
} while (0);
-#define dcl_dbus_handle() dbus_handle_s *dh = (dbus_handle_s *)handle;
-#define dcl_dbus_handle_null_check() dbus_handle_s *dh = (dbus_handle_s *)handle;\
+#define dcl_gdbus() dbus_handle_s *dh = (dbus_handle_s *)handle;
+#define dcl_gdbus_null_check() dbus_handle_s *dh = (dbus_handle_s *)handle;\
if (!dh) {\
_E("dbus handle is null\n");\
return 0;\
}
-dbus_object_handle_s * _dbus_handle_lookup_object(GList *list_obj, const char *obj_path);
-dbus_interface_s * _dbus_handle_lookup_interface(GList *list_iface, const char *iface_name);
-dbus_method_s * _dbus_handle_lookup_method(GList *list_methods, const char *method_name);
+dbus_object_handle_s * _gdbus_lookup_object(GList *list_obj, const char *obj_path);
+dbus_interface_s * _gdbus_lookup_interface(GList *list_iface, const char *iface_name);
+dbus_method_s * _gdbus_lookup_method(GList *list_methods, const char *method_name);
dbus_interface_s *_iface_u_to_s(const dbus_interface_u *iface_u)
{
}
/* ref cout is 1 */
-static dbus_handle_s *_dbus_handle_get_connection(GBusType bus_type)
+static dbus_handle_s *_gdbus_get_connection(GBusType bus_type)
{
int ibus = bus_type - 1;
dbus_handle_s *dh = NULL;
}
dh = &g_dh[ibus];
- dbus_handle_lock(dh);
+ gdbus_lock(dh);
if (!dh->conn) {
dh->conn = _get_bus(bus_type);
if (!dh->conn) {
- dbus_handle_unlock(dh);
+ gdbus_unlock(dh);
return NULL;
}
dh->priv = FALSE;
dh->bus_type = bus_type;
}
- dbus_handle_unlock(dh);
+ gdbus_unlock(dh);
return dh;
}
/* ref cout is 1 */
-static dbus_handle_s *_dbus_handle_get_connection_private(GBusType bus_type)
+static dbus_handle_s *_gdbus_get_connection_private(GBusType bus_type)
{
dbus_handle_s * dh;
return NULL;
}
- dbus_handle_lock(dh);
+ gdbus_lock(dh);
if (!dh->conn) {
dh->conn = _get_bus_private(bus_type);
goto err;
}
- dbus_handle_unlock(dh);
+ gdbus_unlock(dh);
return dh;
err:
if (dh) {
- dbus_handle_unlock(dh);
+ gdbus_unlock(dh);
free(dh);
}
return NULL;
}
-dbus_handle_h dbus_handle_get_connection(GBusType bus_type, gboolean priv)
+dbus_handle_h gdbus_get_connection(GBusType bus_type, gboolean priv)
{
dbus_handle_s *dh = NULL;
int i;
for (i = 0 ; i < 3; ++i) {
/* private */
if (priv)
- dh = _dbus_handle_get_connection_private(bus_type);
+ dh = _gdbus_get_connection_private(bus_type);
/* shared */
else
- dh = _dbus_handle_get_connection(bus_type);
+ dh = _gdbus_get_connection(bus_type);
if (dh)
break;
return dh;
}
-static void _dbus_handle_add_bus_name(dbus_handle_s *handle, const char *name, guint id)
+static void _gdbus_add_bus_name(dbus_handle_s *handle, const char *name, guint id)
{
dbus_name *dn = NULL;
int locked = 0;
// todo : delete lock ?
if (locked != EBUSY)
- dbus_handle_unlock(handle);
+ gdbus_unlock(handle);
}
static gint _compare_dbus_name(gconstpointer a, gconstpointer b)
return strcmp(bus_name, (const char *)b);
}
-dbus_name * _dbus_handle_lookup_dbus_name(GList *list_name, const char *bus_name)
+dbus_name * _gdbus_lookup_dbus_name(GList *list_name, const char *bus_name)
{
if (!list_name || !bus_name)
return NULL;
#define dh_to_ds(x) ((dbus_handle_s*)x)
/* remove dbus_name from dbus handle */
-static void _dbus_handle_remove_bus_name(dbus_handle_s *handle, const char *bus_name)
+static void _gdbus_remove_bus_name(dbus_handle_s *handle, const char *bus_name)
{
- dcl_dbus_handle();
+ dcl_gdbus();
dbus_name *dn = NULL;
if (!bus_name) {
return ;
}
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return ;
}
}
- dbus_handle_lock(dh);
- dn = _dbus_handle_lookup_dbus_name(dh->list_names, bus_name);
+ gdbus_lock(dh);
+ dn = _gdbus_lookup_dbus_name(dh->list_names, bus_name);
if (!dn) {
_E("failed to find dbus name %s", bus_name);
goto out;
dh->list_names = g_list_remove(dh->list_names, dn);
free(dn);
out:
- dbus_handle_unlock(dh);
+ gdbus_unlock(dh);
}
//extern void booting_done(void);
_E("%s:%d:dbus handle is null\n", __func__, __LINE__);
return ;
}
- _dbus_handle_remove_bus_name(dh, name);
+ _gdbus_remove_bus_name(dh, name);
}
-int dbus_handle_request_bus_name(dbus_handle_h handle,
+int gdbus_request_name(dbus_handle_h handle,
const char *bus_name,
GBusNameAcquiredCallback acquired_handler,
GBusNameLostCallback lost_handler)
{
- dcl_dbus_handle();
+ dcl_gdbus();
int id = -1;
GList *item = NULL;
/* get shared connection */
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
- dbus_handle_lock(dh);
+ gdbus_lock(dh);
if (!dh->conn) {
_E("failed to register name: connection is null\n");
goto out;
goto out;
}
- _dbus_handle_add_bus_name(dh, bus_name, id);
+ _gdbus_add_bus_name(dh, bus_name, id);
out:
- dbus_handle_unlock(dh);
+ gdbus_unlock(dh);
return id;
}
/* !! _name_lost handler callback is disabled by g_bus_unown_name : ubuntu */
-int dbus_handle_release_bus_name(dbus_handle_h handle, const char *bus_name)
+int gdbus_release_name(dbus_handle_h handle, const char *bus_name)
{
- dcl_dbus_handle();
+ dcl_gdbus();
dbus_name *dn = NULL;
if (!bus_name) {
}
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
- dn = _dbus_handle_lookup_dbus_name(dh->list_names, bus_name);
+ dn = _gdbus_lookup_dbus_name(dh->list_names, bus_name);
if (!dn) {
_E("failed to find bus_name %s on dbus handle", bus_name);
return -1;
/* _name_lost handler is disabled by g_bus_unown_name : ubuntu */
g_bus_unown_name(dn->id);
- dbus_handle_lock(dh);
+ gdbus_lock(dh);
dh->list_names = g_list_remove(dh->list_names, dn);
free(dn);
- dbus_handle_unlock(dh);
+ gdbus_unlock(dh);
return 0;
}
-int dbus_handle_free_connection(dbus_handle_h handle)
+void gdbus_unwatch_name(guint id)
{
- dcl_dbus_handle();
+ if (id == 0) {
+ _E("wrong id %d", id);
+ return;
+ }
+ g_bus_unwatch_name(id);
+}
+
+// g_strfreev(strv)
+char **gdbus_get_owner_list(dbus_handle_h handle, const char *bus_name)
+{
+ dcl_gdbus();
+ GError *err = NULL;
+ GVariant *reply = NULL;
+ GVariantIter *iter = NULL;
+ gchar **strv = NULL;
+ gchar *str = NULL;
+ int i = 0;
+
+ if (!bus_name) {
+ _E("wrong parameter bus_name is null");
+ return NULL;
+ }
+
+ if (!dh) {
+ dh = _gdbus_get_default_connection();
+ if (!dh) {
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
+ return NULL;
+ }
+ }
+
+ reply = g_dbus_connection_call_sync(dh->conn,
+ "org.freedesktop.DBus",
+ "/",
+ "org.freedesktop.DBus",
+ "ListQueuedOwners",
+ g_variant_new("(s)", bus_name),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_REPLY_TIMEOUT,
+ NULL,
+ &err);
+ if (!reply || err) {
+ _E("failed to g_dbus_connection_call_sync:%s", err->message);
+ g_error_free(err);
+ return NULL;
+ }
+
+ g_variant_get(reply, "(as)", &iter);
+ strv = g_new(gchar *, g_variant_iter_n_children(iter) + 1);
+
+ i = 0;
+ while (g_variant_iter_loop(iter, "s", &str))
+ strv[i++] = g_strdup(str);
+ strv[i] = NULL;
+
+ g_variant_iter_free(iter);
+ g_variant_unref(reply);
+
+ return strv;
+}
+
+int gdbus_free_connection(dbus_handle_h handle)
+{
+ dcl_gdbus();
dbus_handle_s *pdh = NULL;
GError *err = NULL;
GList *item = NULL;
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
pdh = dh;
/* disable dbus handler */
- dbus_handle_lock(dh);
+ gdbus_lock(dh);
if (!pdh->conn) {
_E("conn is null");
free(pdh);
g_object_unref(pdh->conn);
- dbus_handle_unlock(dh);
+ gdbus_unlock(dh);
if (dh->priv)
free(dh);
return strcmp(pa->member, (const char*)b);
}
-dbus_object_handle_s * _dbus_handle_lookup_object(GList *list_obj, const char *obj_path)
+dbus_object_handle_s * _gdbus_lookup_object(GList *list_obj, const char *obj_path)
{
if (!list_obj || !obj_path)
return NULL;
return (dbus_object_handle_s *)item->data;
}
-dbus_interface_s * _dbus_handle_lookup_interface(GList *list_iface, const char *iface_name)
+dbus_interface_s * _gdbus_lookup_interface(GList *list_iface, const char *iface_name)
{
if (!list_iface || !iface_name)
return NULL;
return (dbus_interface_s *)item->data;
}
-dbus_interface_s * _dbus_handle_lookup_interface_by_id(GList *list_iface, guint id)
+dbus_interface_s * _gdbus_lookup_interface_by_id(GList *list_iface, guint id)
{
if (!list_iface || !id)
return NULL;
return (dbus_interface_s *)item->data;
}
-dbus_method_s * _dbus_handle_lookup_method(GList *list_methods, const char *method_name)
+dbus_method_s * _gdbus_lookup_method(GList *list_methods, const char *method_name)
{
if (!list_methods || !method_name)
return NULL;
}
}
-static int _dbus_handle_attach_object(dbus_handle_s *dh, const char *obj_path, dbus_interface_s *iface)
+static int _gdbus_attach_object(dbus_handle_s *dh, const char *obj_path, dbus_interface_s *iface)
{
dbus_object_handle_s *oh = NULL;
/* find object handle */
if (dh->list_object)
- oh = _dbus_handle_lookup_object(dh->list_object, obj_path);
+ oh = _gdbus_lookup_object(dh->list_object, obj_path);
if (!oh) {
oh = (dbus_object_handle_s*)calloc(1, sizeof(dbus_object_handle_s));
GVariant *reply = NULL;
/* todo: ghash ? */
- methods = _dbus_handle_lookup_method(iface_s->list_methods, name);
+ methods = _gdbus_lookup_method(iface_s->list_methods, name);
if (methods) {
reply = methods->func(conn, sender, path, iface, name, param, invocation, get_dh_from_oh(iface_s->oh));
/*
before register object, attach object into dbus handle
-_dbus_handle_attach_object()
+_gdbus_attach_object()
*/
-static int _dbus_handle_register_dbus_object(dbus_handle_h handle, const char *obj_path, dbus_interface_s *iface)
+static int _gdbus_register_object(dbus_handle_h handle, const char *obj_path, dbus_interface_s *iface)
{
- dcl_dbus_handle();
+ dcl_gdbus();
int ret = 0;
char *buf = NULL;
GError *err = NULL;
return -1;
}
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
if interface is constructed by multiple methods,
also it is not possible to make methods struct at once,
-use dbus_handle_add_dbus_object(), dbus_handle_register_dbus_object_all().
+use gdbus_add_object(), gdbus_register_object_all().
return reg_id
*/
-int dbus_handle_register_dbus_object(dbus_handle_h handle, const char *obj_path, const dbus_interface_u *iface_u)
+int gdbus_register_object(dbus_handle_h handle, const char *obj_path, const dbus_interface_u *iface_u)
{
- dcl_dbus_handle();
+ dcl_gdbus();
int ret = 0;
dbus_interface_s *iface = NULL;
return -1;
}
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
/* check registered interface */
if (dh->list_object) {
- dbus_object_handle_s *oh = _dbus_handle_lookup_object(dh->list_object, obj_path);
+ dbus_object_handle_s *oh = _gdbus_lookup_object(dh->list_object, obj_path);
if (oh) {
- dbus_interface_s *ih = _dbus_handle_lookup_interface(oh->list_ifaces, iface_u->name);
+ dbus_interface_s *ih = _gdbus_lookup_interface(oh->list_ifaces, iface_u->name);
if (ih) {
_E("path %s, interface %s already registered", obj_path, iface_u->name);
return -1;
}
/* attach interface before register object */
- ret = _dbus_handle_attach_object(dh, obj_path, iface);
+ ret = _gdbus_attach_object(dh, obj_path, iface);
if (ret < 0) {
_E("failed to attach object");
goto err;
}
- ret = _dbus_handle_register_dbus_object(dh, obj_path, iface);
+ ret = _gdbus_register_object(dh, obj_path, iface);
if (ret <= 0) {
_E("failed to register dbus object%d", ret);
goto err;
return ret;
}
+int gdbus_unregister_object(dbus_handle_h handle, const char *obj_path)
+{
+ dcl_gdbus();
+ dbus_object_handle_s *oh = NULL;
+ int ret = 0;
+
+ if (!obj_path)
+ return -1;
+
+ if (!dh) {
+ dh = _gdbus_get_default_connection();
+ if (!dh) {
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
+ return -1;
+ }
+ }
+ if (!dh->list_object) {
+ _E("list_object is empty");
+ return 0;
+ }
+
+ oh = _gdbus_lookup_object(dh->list_object, obj_path);
+ if (!oh) {
+ _E("no object with name %s", obj_path);
+ return -1;
+ }
+
+ /* unregister every interface of object*/
+ for (GList *item = g_list_first(oh->list_ifaces); item != NULL; item = g_list_next(item)) {
+ dbus_interface_s *ih = item->data;
+ if (!ih) {
+ _E("this is error");
+ assert(0);
+ }
+
+ /* remove ih from list_ifaces */
+ if (!ih->reg_id) {
+ item = g_list_previous(item);
+
+ /* remove and free link */
+ oh->list_ifaces = g_list_remove(oh->list_ifaces, ih);
+
+ /* free list_methods */
+ g_list_free(ih->list_methods);
+
+ /* free data */
+ free(ih);
+ continue;
+ }
+
+ /* unregister object by id */
+ ret = g_dbus_connection_unregister_object(dh->conn, ih->reg_id);
+ if (!ret)
+ _E("failed to unregister object %s, interface %s, regid %d", oh->path, ih->name, ih->reg_id);
+ }
+
+ return 0;
+}
+
int dbus_handle_unregister_dbus_object(dbus_handle_h handle, const char *obj_path)
{
- dcl_dbus_handle();
+ dcl_gdbus();
dbus_object_handle_s *oh = NULL;
int ret = 0;
return -1;
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
return 0;
}
- oh = _dbus_handle_lookup_object(dh->list_object, obj_path);
+ oh = _gdbus_lookup_object(dh->list_object, obj_path);
if (!oh) {
_E("no object with name %s", obj_path);
return -1;
/*
add object temporarily.
-dbus_handle_register_dbus_object_all register every objects on connection.
+gdbus_register_object_all register every objects on connection.
return registered method count
*/
+int gdbus_add_object(dbus_handle_h handle, const char *obj_path, const dbus_interface_u *iface_u)
+{
+ dcl_gdbus();
+ dbus_object_handle_s *oh = NULL;
+ dbus_interface_s *ih = NULL;
+ int cnt;
+
+ if (!obj_path || !iface_u) {
+ _E("wrong parameter path %s, iface_u %p\n", obj_path, iface_u);
+ return -1;
+ }
+ if (iface_u && (!iface_u->name || !iface_u->methods)) {
+ _E("wrong parameter path %s, iface_u %p\n", obj_path, iface_u);
+ return -1;
+ }
+
+ cnt = iface_u->nr_methods;
+
+ if (!dh) {
+ dh = _gdbus_get_default_connection();
+ if (!dh) {
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
+ return -1;
+ }
+ }
+
+ if (!dh->conn) {
+ _E("failed to register method. connection is null\n");
+ return -1;
+ }
+
+ /* if there are no object list, just add */
+ if (!dh->list_object) {
+ if (_gdbus_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
+ _E("failed to attach object");
+ return -1;
+ }
+ goto out;
+ }
+
+ oh = _gdbus_lookup_object(dh->list_object, obj_path);
+ /* if there are no matched object, just add */
+ if (!oh) {
+ if (_gdbus_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
+ _E("failed to attach object");
+ return -1;
+ }
+ goto out;
+ }
+
+ /* this is an error, interface must have one or more item ? */
+ if (!oh->list_ifaces) {
+ _E("error. list_ifaces is null\n");
+ assert(0);
+ goto out;
+ }
+
+ ih = _gdbus_lookup_interface(oh->list_ifaces, iface_u->name);
+ /* if there are no matched interface, just add */
+ if (!ih) {
+ if (_gdbus_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
+ _E("failed to attach object");
+ return -1;
+ }
+ goto out;
+ }
+
+ /* todo:
+ 1. unregister interface
+ 2. update interface and methods
+ 3. register interface
+ */
+ if (ih->reg_id) {
+ _E("interface already registered, ignore new interface");
+ return -1;
+ }
+
+ /* attach new methods */
+ cnt = 0;
+ for (int i = 0; i < iface_u->nr_methods; ++i) {
+ GList *item = g_list_find_custom(g_list_first(ih->list_methods), iface_u->methods[i].member, _compare_dbus_method);
+ if (!item) {
+ //_D("attached %s", iface_u->methods[i].member);
+ ih->list_methods = g_list_prepend(ih->list_methods, (void*)(iface_u->methods + i));
+ ++cnt;
+ }
+ }
+
+ if (cnt)
+ ih->modified = TRUE;
+
+out:
+ /*todo: delete debugging log */
+ //if (dh && dh->list_object)
+ // _D("obj list len %d", g_list_length(dh->list_object));
+ //if (oh && oh->list_ifaces)
+ // _D("iface list len %d", g_list_length(oh->list_ifaces));
+ //if (ih && ih->list_methods)
+ // _D("method list len %d", g_list_length(ih->list_methods));
+
+ return cnt;
+}
+
int dbus_handle_add_dbus_object(dbus_handle_h handle, const char *obj_path, const dbus_interface_u *iface_u)
{
- dcl_dbus_handle();
+ dcl_gdbus();
dbus_object_handle_s *oh = NULL;
dbus_interface_s *ih = NULL;
int cnt;
cnt = iface_u->nr_methods;
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
/* if there are no object list, just add */
if (!dh->list_object) {
- if (_dbus_handle_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
+ if (_gdbus_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
_E("failed to attach object");
return -1;
}
goto out;
}
- oh = _dbus_handle_lookup_object(dh->list_object, obj_path);
+ oh = _gdbus_lookup_object(dh->list_object, obj_path);
/* if there are no matched object, just add */
if (!oh) {
- if (_dbus_handle_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
+ if (_gdbus_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
_E("failed to attach object");
return -1;
}
goto out;
}
- ih = _dbus_handle_lookup_interface(oh->list_ifaces, iface_u->name);
+ ih = _gdbus_lookup_interface(oh->list_ifaces, iface_u->name);
/* if there are no matched interface, just add */
if (!ih) {
- if (_dbus_handle_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
+ if (_gdbus_attach_object(dh, obj_path, _iface_u_to_s(iface_u))) {
_E("failed to attach object");
return -1;
}
return cnt;
}
+int gdbus_register_object_all(dbus_handle_h handle)
+{
+ dcl_gdbus();
+ dbus_object_handle_s *oh = NULL;
+ dbus_interface_s *ih = NULL;
+ int ret_dbus = 0;
+
+ if (!dh) {
+ dh = _gdbus_get_default_connection();
+ if (!dh) {
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
+ return -1;
+ }
+ }
+ if (!dh->conn) {
+ _E("connection is null\n");
+ return -1;
+ }
+
+ if (!dh->list_object) {
+ _E("obj list is empty");
+ return -1;
+ }
+
+ /*if (dh && dh->list_object)
+ _D("obj list len %d", g_list_length(dh->list_object));*/
+
+ for (GList *item = g_list_first(dh->list_object); item != NULL; item = g_list_next(item)) {
+ oh = (dbus_object_handle_s *)item->data;
+
+ if (!oh) {
+ _E("something wrong");
+ assert(0);
+ }
+ if (!oh->list_ifaces) {
+ _E("path %s: list_ifaces are null", oh->path);
+ goto err;
+ }
+
+ //_D("iface list len %d", g_list_length(oh->list_ifaces));
+
+ for (GList *li = g_list_first(oh->list_ifaces); li != NULL; li = g_list_next(li)) {
+ ih = (dbus_interface_s *)li->data;
+
+ /* if there are no modification, goto next */
+ if (!ih->modified)
+ continue;
+
+ /* todo: if already registered interface, unregister first */
+
+ /*_E("interface %s:", ih->name);
+ if (ih && ih->list_methods)
+ _D("method list len %d", g_list_length(ih->list_methods));*/
+
+ ret_dbus = _gdbus_register_object(dh, oh->path, ih);
+ if (ret_dbus <= 0)
+ _E("failed to register dbus object%d", ret_dbus);
+
+ }
+ }
+ return 0;
+err:
+
+ // todo: delete all updates
+
+ return -1;
+}
+
int dbus_handle_register_dbus_object_all(dbus_handle_h handle)
{
- dcl_dbus_handle();
+ dcl_gdbus();
dbus_object_handle_s *oh = NULL;
dbus_interface_s *ih = NULL;
int ret_dbus = 0;
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
if (ih && ih->list_methods)
_D("method list len %d", g_list_length(ih->list_methods));*/
- ret_dbus = _dbus_handle_register_dbus_object(dh, oh->path, ih);
+ ret_dbus = _gdbus_register_object(dh, oh->path, ih);
if (ret_dbus <= 0)
_E("failed to register dbus object%d", ret_dbus);
return -1;
}
-guint subscribe_dbus_signal(dbus_handle_h handle, const char *path,
+guint gdbus_signal_subscribe(dbus_handle_h handle, const char *path,
const char *iface, const char *name,
GDBusSignalCallback cb, void *data,
destroy_notified free_func)
{
- dcl_dbus_handle();
+ dcl_gdbus();
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return 0;
}
}
return g_dbus_connection_signal_subscribe(dh->conn, NULL, iface, name, path, NULL, G_DBUS_SIGNAL_FLAGS_NONE, cb, data, free_func);
}
-void unsubscribe_dbus_signal(dbus_handle_h handle, guint id)
+void gdbus_signal_unsubscribe(dbus_handle_h handle, guint id)
{
- dcl_dbus_handle();
+ dcl_gdbus();
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return;
}
}
g_main_loop_quit(ctx->loop);
}
-sig_ctx *dbus_handle_new_signal_ctx(void)
+sig_ctx *gdbus_signal_ctx_new(void)
{
sig_ctx *ctx;
return ctx;
}
-void dbus_handle_free_signal_ctx(sig_ctx *ctx)
+void gdbus_signal_ctx_free(sig_ctx *ctx)
{
if (!ctx)
return ;
ctx->param = NULL;
}
if (ctx->sig_id) {
- unsubscribe_dbus_signal(NULL, ctx->sig_id);
+ gdbus_signal_unsubscribe(NULL, ctx->sig_id);
ctx->sig_id = 0;
}
if (ctx->timeout_src) {
/* if cb return FALSE, source will be destroyed */
ctx->timeout_src = NULL;
- unsubscribe_dbus_signal(NULL, ctx->sig_id);
+ gdbus_signal_unsubscribe(NULL, ctx->sig_id);
ctx->sig_id = 0;
g_main_loop_quit(ctx->loop);
#define CTX_MAX_TIMEOUT 25000
-int dbus_handle_signal_ctx_add_timeout(sig_ctx *ctx, int timeout_msec)
+int gdbus_signal_ctx_add_timeout(sig_ctx *ctx, int timeout_msec)
{
GSource *src = NULL;
return 0;
}
-guint subscribe_dbus_signal_ctx(dbus_handle_h handle, sig_ctx *ctx,
+guint gdbus_signal_ctx_subscribe(dbus_handle_h handle, sig_ctx *ctx,
const char *sender, const char *path,
const char *iface, const char *name,
GDBusSignalCallback _cb)
{
- dcl_dbus_handle();
+ dcl_gdbus();
if (!ctx) {
_E("wrong param ctx is null");
}
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
_E("failed to get default connection, bustype:%d",
- (int)dbus_handle_get_default_bus_type());
+ (int)gdbus_get_default_bus_type());
return 0;
}
}
return ctx->sig_id;
}
-int dbus_handle_signal_ctx_wait(sig_ctx *ctx)
+int gdbus_signal_ctx_wait(sig_ctx *ctx)
{
if (!ctx || !ctx->loop)
return -EINVAL;
return TRUE;
}
-int dbus_handle_emit_dbus_signal(const char *dest,
+int gdbus_signal_emit(const char *dest,
const char *path,
const char *iface,
const char *name,
GError *err = NULL;
gboolean ret = 0;
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
return ret;
}
-int dbus_handle_emit_dbus_signal_sync(const char *dest,
+int gdbus_signal_emit_sync(const char *dest,
const char *path,
const char *iface,
const char *name,
GError *err = NULL;
gboolean ret = 0;
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
return ret;
}
-int dbus_handle_flush_sync(dbus_handle_h handle)
+int gdbus_flush_sync(dbus_handle_h handle)
{
- dcl_dbus_handle();
+ dcl_gdbus();
GError *err = NULL;
gboolean ret = 0;
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return 0;
}
}
return ret;
}
-int dbus_handle_method_sync_with_reply_var(const char *dest,
+int gdbus_call_sync_with_reply(const char *dest,
const char *path,
const char *iface,
const char *method,
return -EINVAL;
}
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
if (param)
g_variant_unref(param);
return -ECOMM;
return ret;
}
-int dbus_handle_method_sync_with_reply_var_timeout(const char *dest, const char *path,
+int gdbus_call_sync_with_reply_timeout(const char *dest, const char *path,
const char *iface, const char *method, GVariant *param, GVariant **out_reply, int timeout)
{
GError *err = NULL;
return -EINVAL;
}
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
if (param)
g_variant_unref(param);
return -ECOMM;
return 0;
}
-int dbus_handle_method_sync_pairs(const char *dest,
+int gdbus_call_pairs_sync_with_reply_int(const char *dest,
const char *path,
const char *iface,
const char *method,
return -1;
}
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
return ret;
}
-int dbus_handle_method_async_pairs(const char *dest,
+int gdbus_call_pairs_async(const char *dest,
const char *path,
const char *iface,
const char *method,
return -1;
}
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
return 0;
}
-gint* dbus_handle_get_unix_fd_list(GDBusMethodInvocation *invocation, int *size)
+gint* gdbus_get_unix_fd_list(GDBusMethodInvocation *invocation, int *size)
{
GUnixFDList *fd_list = NULL;
int length = 0;
return g_unix_fd_list_steal_fds(fd_list, NULL);
}
-int dbus_handle_method_with_unix_fd_list_sync_with_reply_var(const char *dest,
+int gdbus_call_unix_fd_list_sync_with_reply(const char *dest,
const char *path,
const char *iface,
const char *method,
return -EINVAL;
}
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -EAGAIN;
}
return ret;
}
-int dbus_handle_method_sync_var(const char *dest,
+int gdbus_call_sync_with_reply_int(const char *dest,
const char *path,
const char *iface,
const char *method,
return -EINVAL;
}
- ret = dbus_handle_method_sync_with_reply_var(dest, path, iface, method, param, &reply);
+ ret = gdbus_call_sync_with_reply(dest, path, iface, method, param, &reply);
if (ret < 0)
return ret;
return ret;
}
-int dbus_handle_method_async_var(const char *dest,
+int gdbus_call_async(const char *dest,
const char *path,
const char *iface,
const char *method,
return -1;
}
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
free(data);
}
-int dbus_handle_method_async_with_reply_var(const char *dest,
+int gdbus_call_async_with_reply(const char *dest,
const char *path,
const char *iface,
const char *method,
return -1;
}
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -EPERM;
}
return ret;
}
-int dbus_handle_method_async_pairs_with_reply(const char *dest,
+int gdbus_call_pairs_async_with_reply(const char *dest,
const char *path,
const char *iface,
const char *method,
return -1;
}
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -EPERM;
}
return ret;
}
-int dbus_connection_get_sender_pid(GDBusConnection *conn, const char * sender)
+int gdbus_connection_get_sender_pid(GDBusConnection *conn, const char * sender)
{
GError *err = NULL;
GVariant *reply = NULL;
return pid;
}
-int dbus_handle_get_sender_pid(dbus_handle_h handle, const char * sender)
+int gdbus_get_sender_pid(dbus_handle_h handle, const char * sender)
{
- dcl_dbus_handle();
+ dcl_gdbus();
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
return -1;
}
- return dbus_connection_get_sender_pid(dh->conn, sender);
+ return gdbus_connection_get_sender_pid(dh->conn, sender);
}
-int dbus_handle_get_sender_credentials(dbus_handle_h handle, const char *name, GDBusCredentials *creds)
+int gdbus_get_sender_credentials(dbus_handle_h handle, const char *name, GDBusCredentials *creds)
{
- dcl_dbus_handle();
+ dcl_gdbus();
GVariant *reply = NULL;
GError *err = NULL;
GVariantIter *iter = NULL;
GVariant *sub;
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return -1;
}
}
// free(data);
}
-int dbus_handle_watch_name(const char *name,
+int gdbus_watch_name(const char *name,
GBusNameAppearedCallback name_appeared_handler,
GBusNameVanishedCallback name_vanished_handler,
void *user_data,
return -1;
}
- id = g_bus_watch_name(dbus_handle_get_default_bus_type(),
+ id = g_bus_watch_name(gdbus_get_default_bus_type(),
name,
G_BUS_NAME_WATCHER_FLAGS_NONE,
name_appeared_handler,
return id;
}
-void dbus_handle_unwatch_name(guint id)
-{
- if (id == 0) {
- _E("wrong id %d", id);
- return;
- }
- g_bus_unwatch_name(id);
-}
-
int _get_cmdline_name(pid_t pid, char *cmdline, size_t cmdline_size)
{
int fd, ret_file;
return 0;
}
-// g_strfreev(strv)
-char **dbus_handle_get_owner_list(dbus_handle_h handle, const char *bus_name)
-{
- dcl_dbus_handle();
- GError *err = NULL;
- GVariant *reply = NULL;
- GVariantIter *iter = NULL;
- gchar **strv = NULL;
- gchar *str = NULL;
- int i = 0;
-
- if (!bus_name) {
- _E("wrong parameter bus_name is null");
- return NULL;
- }
-
- if (!dh) {
- dh = _dbus_handle_get_default_connection();
- if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
- return NULL;
- }
- }
-
- reply = g_dbus_connection_call_sync(dh->conn,
- "org.freedesktop.DBus",
- "/",
- "org.freedesktop.DBus",
- "ListQueuedOwners",
- g_variant_new("(s)", bus_name),
- NULL,
- G_DBUS_CALL_FLAGS_NONE,
- DBUS_REPLY_TIMEOUT,
- NULL,
- &err);
- if (!reply || err) {
- _E("failed to g_dbus_connection_call_sync:%s", err->message);
- g_error_free(err);
- return NULL;
- }
-
- g_variant_get(reply, "(as)", &iter);
- strv = g_new(gchar *, g_variant_iter_n_children(iter) + 1);
-
- i = 0;
- while (g_variant_iter_loop(iter, "s", &str))
- strv[i++] = g_strdup(str);
- strv[i] = NULL;
-
- g_variant_iter_free(iter);
- g_variant_unref(reply);
-
- return strv;
-}
-
-void dbus_handle_check_owner_name(dbus_handle_h handle, const char *owner_name)
+void gdbus_check_name_owner(dbus_handle_h handle, const char *owner_name)
{
- dcl_dbus_handle();
+ dcl_gdbus();
char exe_name[PATH_MAX];
int pid;
char **strv = NULL;
int i;
if (!dh) {
- dh = _dbus_handle_get_default_connection();
+ dh = _gdbus_get_default_connection();
if (!dh) {
- _E("failed to get default connection, bustype:%d", (int)dbus_handle_get_default_bus_type());
+ _E("failed to get default connection, bustype:%d", (int)gdbus_get_default_bus_type());
return ;
}
}
- strv = dbus_handle_get_owner_list(dh, owner_name);
+ strv = gdbus_get_owner_list(dh, owner_name);
if (!strv) {
_E("failed to get owner list of %s", owner_name);
return ;
}
for (i = 0; strv[i] != NULL; ++i) {
- pid = dbus_handle_get_sender_pid(dh, strv[i]);
+ pid = gdbus_get_sender_pid(dh, strv[i]);
if (_get_cmdline_name(pid, exe_name, PATH_MAX) != 0)
break;
_I("%s(%d)", exe_name, pid);
_I("%s %s", "org.freedesktop.systemd1.Unit", "ActiveState");
- ret = dbus_handle_method_sync_with_reply_var("org.freedesktop.systemd1",
+ ret = gdbus_call_sync_with_reply("org.freedesktop.systemd1",
"/org/freedesktop/systemd1/unit/default_2etarget",
"org.freedesktop.DBus.Properties",
"Get",
return ret;
}
-GVariant *dbus_handle_make_simple_array(const char *sig, int *param)
+GVariant *gdbus_make_simple_array(const char *sig, int *param)
{
GVariantBuilder *builder = NULL;
GVariant *var = NULL;