5 * Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
32 #include <dbus/dbus.h>
36 #ifdef __TIZEN_PATCH__
39 static void gdbus_dbg(const char *format, ...)
45 vsyslog(LOG_DEBUG, format, ap);
57 #define DBUS_INTERFACE_OBJECT_MANAGER "org.freedesktop.DBus.ObjectManager"
59 #ifndef DBUS_ERROR_UNKNOWN_PROPERTY
60 #define DBUS_ERROR_UNKNOWN_PROPERTY "org.freedesktop.DBus.Error.UnknownProperty"
63 #ifndef DBUS_ERROR_PROPERTY_READ_ONLY
64 #define DBUS_ERROR_PROPERTY_READ_ONLY "org.freedesktop.DBus.Error.PropertyReadOnly"
68 unsigned int refcount;
76 gboolean pending_prop;
78 struct generic_data *parent;
81 struct interface_data {
83 const GDBusMethodTable *methods;
84 const GDBusSignalTable *signals;
85 const GDBusPropertyTable *properties;
88 GDBusDestroyFunction destroy;
91 struct security_data {
92 GDBusPendingReply pending;
94 const GDBusMethodTable *method;
95 void *iface_user_data;
98 struct property_data {
100 GDBusPendingPropertySet id;
101 DBusMessage *message;
104 static int global_flags = 0;
105 static struct generic_data *root;
106 static GSList *pending = NULL;
108 #ifdef __TIZEN_PATCH__
109 #define ADAPTER_INTERFACE "org.bluez.Adapter1"
111 static char *adapter_path = NULL;
114 static gboolean process_changes(gpointer user_data);
115 static void process_properties_from_interface(struct generic_data *data,
116 struct interface_data *iface);
117 static void process_property_changes(struct generic_data *data);
119 static void print_arguments(GString *gstr, const GDBusArgInfo *args,
120 const char *direction)
122 for (; args && args->name; args++) {
123 g_string_append_printf(gstr,
124 "<arg name=\"%s\" type=\"%s\"",
125 args->name, args->signature);
128 g_string_append_printf(gstr,
129 " direction=\"%s\"/>\n", direction);
131 g_string_append_printf(gstr, "/>\n");
136 #define G_DBUS_ANNOTATE(name_, value_) \
137 "<annotation name=\"org.freedesktop.DBus." name_ "\" " \
138 "value=\"" value_ "\"/>"
140 #define G_DBUS_ANNOTATE_DEPRECATED \
141 G_DBUS_ANNOTATE("Deprecated", "true")
143 #define G_DBUS_ANNOTATE_NOREPLY \
144 G_DBUS_ANNOTATE("Method.NoReply", "true")
146 static gboolean check_experimental(int flags, int flag)
151 return !(global_flags & G_DBUS_FLAG_ENABLE_EXPERIMENTAL);
154 static void generate_interface_xml(GString *gstr, struct interface_data *iface)
156 const GDBusMethodTable *method;
157 const GDBusSignalTable *signal;
158 const GDBusPropertyTable *property;
160 for (method = iface->methods; method && method->name; method++) {
161 if (check_experimental(method->flags,
162 G_DBUS_METHOD_FLAG_EXPERIMENTAL))
165 g_string_append_printf(gstr, "<method name=\"%s\">",
167 print_arguments(gstr, method->in_args, "in");
168 print_arguments(gstr, method->out_args, "out");
170 if (method->flags & G_DBUS_METHOD_FLAG_DEPRECATED)
171 g_string_append_printf(gstr,
172 G_DBUS_ANNOTATE_DEPRECATED);
174 if (method->flags & G_DBUS_METHOD_FLAG_NOREPLY)
175 g_string_append_printf(gstr, G_DBUS_ANNOTATE_NOREPLY);
177 g_string_append_printf(gstr, "</method>");
180 for (signal = iface->signals; signal && signal->name; signal++) {
181 if (check_experimental(signal->flags,
182 G_DBUS_SIGNAL_FLAG_EXPERIMENTAL))
185 g_string_append_printf(gstr, "<signal name=\"%s\">",
187 print_arguments(gstr, signal->args, NULL);
189 if (signal->flags & G_DBUS_SIGNAL_FLAG_DEPRECATED)
190 g_string_append_printf(gstr,
191 G_DBUS_ANNOTATE_DEPRECATED);
193 g_string_append_printf(gstr, "</signal>\n");
196 for (property = iface->properties; property && property->name;
198 if (check_experimental(property->flags,
199 G_DBUS_PROPERTY_FLAG_EXPERIMENTAL))
202 g_string_append_printf(gstr, "<property name=\"%s\""
203 " type=\"%s\" access=\"%s%s\">",
204 property->name, property->type,
205 property->get ? "read" : "",
206 property->set ? "write" : "");
208 if (property->flags & G_DBUS_PROPERTY_FLAG_DEPRECATED)
209 g_string_append_printf(gstr,
210 G_DBUS_ANNOTATE_DEPRECATED);
212 g_string_append_printf(gstr, "</property>");
216 static void generate_introspection_xml(DBusConnection *conn,
217 struct generic_data *data, const char *path)
224 g_free(data->introspect);
226 gstr = g_string_new(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE);
228 g_string_append_printf(gstr, "<node>");
230 for (list = data->interfaces; list; list = list->next) {
231 struct interface_data *iface = list->data;
233 g_string_append_printf(gstr, "<interface name=\"%s\">",
236 generate_interface_xml(gstr, iface);
238 g_string_append_printf(gstr, "</interface>");
241 if (!dbus_connection_list_registered(conn, path, &children))
244 for (i = 0; children[i]; i++)
245 g_string_append_printf(gstr, "<node name=\"%s\"/>",
248 dbus_free_string_array(children);
251 g_string_append_printf(gstr, "</node>");
253 data->introspect = g_string_free(gstr, FALSE);
256 static DBusMessage *introspect(DBusConnection *connection,
257 DBusMessage *message, void *user_data)
259 struct generic_data *data = user_data;
262 if (data->introspect == NULL)
263 generate_introspection_xml(connection, data,
264 dbus_message_get_path(message));
266 reply = dbus_message_new_method_return(message);
270 dbus_message_append_args(reply, DBUS_TYPE_STRING, &data->introspect,
276 static DBusHandlerResult process_message(DBusConnection *connection,
277 DBusMessage *message, const GDBusMethodTable *method,
278 void *iface_user_data)
282 reply = method->function(connection, message, iface_user_data);
284 if (method->flags & G_DBUS_METHOD_FLAG_NOREPLY ||
285 dbus_message_get_no_reply(message)) {
287 dbus_message_unref(reply);
288 return DBUS_HANDLER_RESULT_HANDLED;
291 if (method->flags & G_DBUS_METHOD_FLAG_ASYNC) {
293 return DBUS_HANDLER_RESULT_HANDLED;
297 return DBUS_HANDLER_RESULT_NEED_MEMORY;
299 g_dbus_send_message(connection, reply);
301 return DBUS_HANDLER_RESULT_HANDLED;
304 static GDBusPendingReply next_pending = 1;
305 static GSList *pending_security = NULL;
307 static const GDBusSecurityTable *security_table = NULL;
309 void g_dbus_pending_success(DBusConnection *connection,
310 GDBusPendingReply pending)
314 for (list = pending_security; list; list = list->next) {
315 struct security_data *secdata = list->data;
317 if (secdata->pending != pending)
320 pending_security = g_slist_remove(pending_security, secdata);
322 process_message(connection, secdata->message,
323 secdata->method, secdata->iface_user_data);
325 dbus_message_unref(secdata->message);
331 void g_dbus_pending_error_valist(DBusConnection *connection,
332 GDBusPendingReply pending, const char *name,
333 const char *format, va_list args)
337 for (list = pending_security; list; list = list->next) {
338 struct security_data *secdata = list->data;
340 if (secdata->pending != pending)
343 pending_security = g_slist_remove(pending_security, secdata);
345 g_dbus_send_error_valist(connection, secdata->message,
348 dbus_message_unref(secdata->message);
354 void g_dbus_pending_error(DBusConnection *connection,
355 GDBusPendingReply pending,
356 const char *name, const char *format, ...)
360 va_start(args, format);
362 g_dbus_pending_error_valist(connection, pending, name, format, args);
367 int polkit_check_authorization(DBusConnection *conn,
368 const char *action, gboolean interaction,
369 void (*function) (dbus_bool_t authorized,
371 void *user_data, int timeout);
373 struct builtin_security_data {
374 DBusConnection *conn;
375 GDBusPendingReply pending;
378 static void builtin_security_result(dbus_bool_t authorized, void *user_data)
380 struct builtin_security_data *data = user_data;
382 if (authorized == TRUE)
383 g_dbus_pending_success(data->conn, data->pending);
385 g_dbus_pending_error(data->conn, data->pending,
386 DBUS_ERROR_AUTH_FAILED, NULL);
391 static void builtin_security_function(DBusConnection *conn,
393 gboolean interaction,
394 GDBusPendingReply pending)
396 struct builtin_security_data *data;
398 data = g_new0(struct builtin_security_data, 1);
400 data->pending = pending;
402 if (polkit_check_authorization(conn, action, interaction,
403 builtin_security_result, data, 30000) < 0)
404 g_dbus_pending_error(conn, pending, NULL, NULL);
407 static gboolean check_privilege(DBusConnection *conn, DBusMessage *msg,
408 const GDBusMethodTable *method, void *iface_user_data)
410 const GDBusSecurityTable *security;
412 for (security = security_table; security && security->privilege;
414 struct security_data *secdata;
415 gboolean interaction;
417 if (security->privilege != method->privilege)
420 secdata = g_new(struct security_data, 1);
421 secdata->pending = next_pending++;
422 secdata->message = dbus_message_ref(msg);
423 secdata->method = method;
424 secdata->iface_user_data = iface_user_data;
426 pending_security = g_slist_prepend(pending_security, secdata);
428 if (security->flags & G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION)
433 if (!(security->flags & G_DBUS_SECURITY_FLAG_BUILTIN) &&
435 security->function(conn, security->action,
436 interaction, secdata->pending);
438 builtin_security_function(conn, security->action,
439 interaction, secdata->pending);
447 static GDBusPendingPropertySet next_pending_property = 1;
448 static GSList *pending_property_set;
450 static struct property_data *remove_pending_property_data(
451 GDBusPendingPropertySet id)
453 struct property_data *propdata;
456 for (l = pending_property_set; l != NULL; l = l->next) {
458 if (propdata->id != id)
467 pending_property_set = g_slist_delete_link(pending_property_set, l);
472 void g_dbus_pending_property_success(GDBusPendingPropertySet id)
474 struct property_data *propdata;
476 propdata = remove_pending_property_data(id);
477 if (propdata == NULL)
480 g_dbus_send_reply(propdata->conn, propdata->message,
482 dbus_message_unref(propdata->message);
486 void g_dbus_pending_property_error_valist(GDBusPendingReply id,
487 const char *name, const char *format,
490 struct property_data *propdata;
492 propdata = remove_pending_property_data(id);
493 if (propdata == NULL)
496 g_dbus_send_error_valist(propdata->conn, propdata->message, name,
499 dbus_message_unref(propdata->message);
503 void g_dbus_pending_property_error(GDBusPendingReply id, const char *name,
504 const char *format, ...)
508 va_start(args, format);
510 g_dbus_pending_property_error_valist(id, name, format, args);
515 static void reset_parent(gpointer data, gpointer user_data)
517 struct generic_data *child = data;
518 struct generic_data *parent = user_data;
520 child->parent = parent;
523 static void append_property(struct interface_data *iface,
524 const GDBusPropertyTable *p, DBusMessageIter *dict)
526 DBusMessageIter entry, value;
528 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, NULL,
530 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &p->name);
531 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, p->type,
534 p->get(p, &value, iface->user_data);
536 dbus_message_iter_close_container(&entry, &value);
537 dbus_message_iter_close_container(dict, &entry);
540 static void append_properties(struct interface_data *data,
541 DBusMessageIter *iter)
543 DBusMessageIter dict;
544 const GDBusPropertyTable *p;
546 dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
547 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
548 DBUS_TYPE_STRING_AS_STRING
549 DBUS_TYPE_VARIANT_AS_STRING
550 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
552 for (p = data->properties; p && p->name; p++) {
553 if (check_experimental(p->flags,
554 G_DBUS_PROPERTY_FLAG_EXPERIMENTAL))
560 if (p->exists != NULL && !p->exists(p, data->user_data))
563 append_property(data, p, &dict);
566 dbus_message_iter_close_container(iter, &dict);
569 static void append_interface(gpointer data, gpointer user_data)
571 struct interface_data *iface = data;
572 DBusMessageIter *array = user_data;
573 DBusMessageIter entry;
575 dbus_message_iter_open_container(array, DBUS_TYPE_DICT_ENTRY, NULL,
577 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &iface->name);
578 append_properties(data, &entry);
579 dbus_message_iter_close_container(array, &entry);
582 static void emit_interfaces_added(struct generic_data *data)
585 DBusMessageIter iter, array;
587 if (root == NULL || data == root)
590 signal = dbus_message_new_signal(root->path,
591 DBUS_INTERFACE_OBJECT_MANAGER,
596 dbus_message_iter_init_append(signal, &iter);
597 dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
600 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
601 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
602 DBUS_TYPE_STRING_AS_STRING
603 DBUS_TYPE_ARRAY_AS_STRING
604 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
605 DBUS_TYPE_STRING_AS_STRING
606 DBUS_TYPE_VARIANT_AS_STRING
607 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
608 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array);
610 g_slist_foreach(data->added, append_interface, &array);
611 g_slist_free(data->added);
614 dbus_message_iter_close_container(&iter, &array);
616 /* Use dbus_connection_send to avoid recursive calls to g_dbus_flush */
617 dbus_connection_send(data->conn, signal, NULL);
618 dbus_message_unref(signal);
621 static struct interface_data *find_interface(GSList *interfaces,
629 for (list = interfaces; list; list = list->next) {
630 struct interface_data *iface = list->data;
631 if (!strcmp(name, iface->name))
638 static gboolean g_dbus_args_have_signature(const GDBusArgInfo *args,
639 DBusMessage *message)
641 const char *sig = dbus_message_get_signature(message);
642 const char *p = NULL;
644 for (; args && args->signature && *sig; args++) {
647 for (; *sig && *p; sig++, p++) {
653 if (*sig || (p && *p) || (args && args->signature))
659 static void add_pending(struct generic_data *data)
661 if (data->process_id > 0)
664 data->process_id = g_idle_add(process_changes, data);
666 pending = g_slist_append(pending, data);
669 static gboolean remove_interface(struct generic_data *data, const char *name)
671 struct interface_data *iface;
673 iface = find_interface(data->interfaces, name);
677 process_properties_from_interface(data, iface);
679 data->interfaces = g_slist_remove(data->interfaces, iface);
681 #ifdef __TIZEN_PATCH__
682 if (g_strcmp0(iface->name, ADAPTER_INTERFACE) == 0) {
683 g_free(adapter_path);
688 if (iface->destroy) {
689 iface->destroy(iface->user_data);
690 iface->user_data = NULL;
694 * Interface being removed was just added, on the same mainloop
695 * iteration? Don't send any signal
697 if (g_slist_find(data->added, iface)) {
698 data->added = g_slist_remove(data->added, iface);
704 if (data->parent == NULL) {
710 data->removed = g_slist_prepend(data->removed, iface->name);
718 static struct generic_data *invalidate_parent_data(DBusConnection *conn,
719 const char *child_path)
721 struct generic_data *data = NULL, *child = NULL, *parent = NULL;
722 char *parent_path, *slash;
724 parent_path = g_strdup(child_path);
725 slash = strrchr(parent_path, '/');
729 if (slash == parent_path && parent_path[1] != '\0')
730 parent_path[1] = '\0';
734 if (!strlen(parent_path))
737 if (dbus_connection_get_object_path_data(conn, parent_path,
738 (void *) &data) == FALSE) {
742 parent = invalidate_parent_data(conn, parent_path);
750 g_free(data->introspect);
751 data->introspect = NULL;
753 if (!dbus_connection_get_object_path_data(conn, child_path,
757 if (child == NULL || g_slist_find(data->objects, child) != NULL)
760 data->objects = g_slist_prepend(data->objects, child);
761 child->parent = data;
768 static inline const GDBusPropertyTable *find_property(const GDBusPropertyTable *properties,
771 const GDBusPropertyTable *p;
773 for (p = properties; p && p->name; p++) {
774 if (strcmp(name, p->name) != 0)
777 if (check_experimental(p->flags,
778 G_DBUS_PROPERTY_FLAG_EXPERIMENTAL))
787 static DBusMessage *properties_get(DBusConnection *connection,
788 DBusMessage *message, void *user_data)
790 struct generic_data *data = user_data;
791 struct interface_data *iface;
792 const GDBusPropertyTable *property;
793 const char *interface, *name;
794 DBusMessageIter iter, value;
797 if (!dbus_message_get_args(message, NULL,
798 DBUS_TYPE_STRING, &interface,
799 DBUS_TYPE_STRING, &name,
803 iface = find_interface(data->interfaces, interface);
805 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
806 "No such interface '%s'", interface);
808 property = find_property(iface->properties, name);
809 if (property == NULL)
810 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
811 "No such property '%s'", name);
813 if (property->exists != NULL &&
814 !property->exists(property, iface->user_data))
815 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
816 "No such property '%s'", name);
818 if (property->get == NULL)
819 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
820 "Property '%s' is not readable", name);
822 reply = dbus_message_new_method_return(message);
826 dbus_message_iter_init_append(reply, &iter);
827 dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
828 property->type, &value);
830 if (!property->get(property, &value, iface->user_data)) {
831 dbus_message_unref(reply);
835 dbus_message_iter_close_container(&iter, &value);
840 static DBusMessage *properties_get_all(DBusConnection *connection,
841 DBusMessage *message, void *user_data)
843 struct generic_data *data = user_data;
844 struct interface_data *iface;
845 const char *interface;
846 DBusMessageIter iter;
849 if (!dbus_message_get_args(message, NULL,
850 DBUS_TYPE_STRING, &interface,
854 iface = find_interface(data->interfaces, interface);
856 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
857 "No such interface '%s'", interface);
859 reply = dbus_message_new_method_return(message);
863 dbus_message_iter_init_append(reply, &iter);
865 append_properties(iface, &iter);
870 static DBusMessage *properties_set(DBusConnection *connection,
871 DBusMessage *message, void *user_data)
873 struct generic_data *data = user_data;
874 DBusMessageIter iter, sub;
875 struct interface_data *iface;
876 const GDBusPropertyTable *property;
877 const char *name, *interface;
878 struct property_data *propdata;
879 gboolean valid_signature;
882 if (!dbus_message_iter_init(message, &iter))
883 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
884 "No arguments given");
886 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
887 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
888 "Invalid argument type: '%c'",
889 dbus_message_iter_get_arg_type(&iter));
891 dbus_message_iter_get_basic(&iter, &interface);
892 dbus_message_iter_next(&iter);
894 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
895 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
896 "Invalid argument type: '%c'",
897 dbus_message_iter_get_arg_type(&iter));
899 dbus_message_iter_get_basic(&iter, &name);
900 dbus_message_iter_next(&iter);
902 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
903 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
904 "Invalid argument type: '%c'",
905 dbus_message_iter_get_arg_type(&iter));
907 dbus_message_iter_recurse(&iter, &sub);
909 iface = find_interface(data->interfaces, interface);
911 return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
912 "No such interface '%s'", interface);
914 property = find_property(iface->properties, name);
915 if (property == NULL)
916 return g_dbus_create_error(message,
917 DBUS_ERROR_UNKNOWN_PROPERTY,
918 "No such property '%s'", name);
920 if (property->set == NULL)
921 return g_dbus_create_error(message,
922 DBUS_ERROR_PROPERTY_READ_ONLY,
923 "Property '%s' is not writable", name);
925 if (property->exists != NULL &&
926 !property->exists(property, iface->user_data))
927 return g_dbus_create_error(message,
928 DBUS_ERROR_UNKNOWN_PROPERTY,
929 "No such property '%s'", name);
931 signature = dbus_message_iter_get_signature(&sub);
932 valid_signature = strcmp(signature, property->type) ? FALSE : TRUE;
933 dbus_free(signature);
934 if (!valid_signature)
935 return g_dbus_create_error(message,
936 DBUS_ERROR_INVALID_SIGNATURE,
937 "Invalid signature for '%s'", name);
939 propdata = g_new(struct property_data, 1);
940 propdata->id = next_pending_property++;
941 propdata->message = dbus_message_ref(message);
942 propdata->conn = connection;
943 pending_property_set = g_slist_prepend(pending_property_set, propdata);
945 property->set(property, &sub, propdata->id, iface->user_data);
950 static const GDBusMethodTable properties_methods[] = {
951 { GDBUS_METHOD("Get",
952 GDBUS_ARGS({ "interface", "s" }, { "name", "s" }),
953 GDBUS_ARGS({ "value", "v" }),
955 { GDBUS_ASYNC_METHOD("Set",
956 GDBUS_ARGS({ "interface", "s" }, { "name", "s" },
960 { GDBUS_METHOD("GetAll",
961 GDBUS_ARGS({ "interface", "s" }),
962 GDBUS_ARGS({ "properties", "a{sv}" }),
963 properties_get_all) },
967 static const GDBusSignalTable properties_signals[] = {
968 { GDBUS_SIGNAL("PropertiesChanged",
969 GDBUS_ARGS({ "interface", "s" },
970 { "changed_properties", "a{sv}" },
971 { "invalidated_properties", "as"})) },
975 static void append_name(gpointer data, gpointer user_data)
978 DBusMessageIter *iter = user_data;
980 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &name);
983 static void emit_interfaces_removed(struct generic_data *data)
986 DBusMessageIter iter, array;
988 if (root == NULL || data == root)
991 signal = dbus_message_new_signal(root->path,
992 DBUS_INTERFACE_OBJECT_MANAGER,
993 "InterfacesRemoved");
997 dbus_message_iter_init_append(signal, &iter);
998 dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
1000 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1001 DBUS_TYPE_STRING_AS_STRING, &array);
1003 g_slist_foreach(data->removed, append_name, &array);
1004 g_slist_free_full(data->removed, g_free);
1005 data->removed = NULL;
1007 dbus_message_iter_close_container(&iter, &array);
1009 /* Use dbus_connection_send to avoid recursive calls to g_dbus_flush */
1010 dbus_connection_send(data->conn, signal, NULL);
1011 dbus_message_unref(signal);
1014 static void remove_pending(struct generic_data *data)
1016 if (data->process_id > 0) {
1017 g_source_remove(data->process_id);
1018 data->process_id = 0;
1021 pending = g_slist_remove(pending, data);
1024 static gboolean process_changes(gpointer user_data)
1026 struct generic_data *data = user_data;
1028 remove_pending(data);
1030 if (data->added != NULL)
1031 emit_interfaces_added(data);
1033 /* Flush pending properties */
1034 if (data->pending_prop == TRUE)
1035 process_property_changes(data);
1037 if (data->removed != NULL)
1038 emit_interfaces_removed(data);
1040 data->process_id = 0;
1045 static void generic_unregister(DBusConnection *connection, void *user_data)
1047 struct generic_data *data = user_data;
1048 struct generic_data *parent = data->parent;
1051 parent->objects = g_slist_remove(parent->objects, data);
1053 if (data->process_id > 0) {
1054 g_source_remove(data->process_id);
1055 data->process_id = 0;
1056 process_changes(data);
1059 g_slist_foreach(data->objects, reset_parent, data->parent);
1060 g_slist_free(data->objects);
1062 dbus_connection_unref(data->conn);
1063 g_free(data->introspect);
1068 static DBusHandlerResult generic_message(DBusConnection *connection,
1069 DBusMessage *message, void *user_data)
1071 struct generic_data *data = user_data;
1072 struct interface_data *iface;
1073 const GDBusMethodTable *method;
1074 const char *interface;
1076 interface = dbus_message_get_interface(message);
1078 iface = find_interface(data->interfaces, interface);
1080 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1082 for (method = iface->methods; method &&
1083 method->name && method->function; method++) {
1085 if (dbus_message_is_method_call(message, iface->name,
1086 method->name) == FALSE)
1089 if (check_experimental(method->flags,
1090 G_DBUS_METHOD_FLAG_EXPERIMENTAL))
1091 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1093 if (g_dbus_args_have_signature(method->in_args,
1097 if (check_privilege(connection, message, method,
1098 iface->user_data) == TRUE)
1099 return DBUS_HANDLER_RESULT_HANDLED;
1100 #ifdef __TIZEN_PATCH__
1102 gdbus_dbg("%s: %s.%s()", dbus_message_get_path(message),
1103 iface->name, method->name);
1106 return process_message(connection, message, method,
1110 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1113 static DBusObjectPathVTable generic_table = {
1114 .unregister_function = generic_unregister,
1115 .message_function = generic_message,
1118 static const GDBusMethodTable introspect_methods[] = {
1119 { GDBUS_METHOD("Introspect", NULL,
1120 GDBUS_ARGS({ "xml", "s" }), introspect) },
1124 static void append_interfaces(struct generic_data *data, DBusMessageIter *iter)
1126 DBusMessageIter array;
1128 dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
1129 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1130 DBUS_TYPE_STRING_AS_STRING
1131 DBUS_TYPE_ARRAY_AS_STRING
1132 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1133 DBUS_TYPE_STRING_AS_STRING
1134 DBUS_TYPE_VARIANT_AS_STRING
1135 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
1136 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array);
1138 g_slist_foreach(data->interfaces, append_interface, &array);
1140 dbus_message_iter_close_container(iter, &array);
1143 static void append_object(gpointer data, gpointer user_data)
1145 struct generic_data *child = data;
1146 DBusMessageIter *array = user_data;
1147 DBusMessageIter entry;
1149 dbus_message_iter_open_container(array, DBUS_TYPE_DICT_ENTRY, NULL,
1151 dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
1153 append_interfaces(child, &entry);
1154 dbus_message_iter_close_container(array, &entry);
1156 g_slist_foreach(child->objects, append_object, user_data);
1159 static DBusMessage *get_objects(DBusConnection *connection,
1160 DBusMessage *message, void *user_data)
1162 struct generic_data *data = user_data;
1164 DBusMessageIter iter;
1165 DBusMessageIter array;
1167 reply = dbus_message_new_method_return(message);
1171 dbus_message_iter_init_append(reply, &iter);
1173 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1174 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1175 DBUS_TYPE_OBJECT_PATH_AS_STRING
1176 DBUS_TYPE_ARRAY_AS_STRING
1177 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1178 DBUS_TYPE_STRING_AS_STRING
1179 DBUS_TYPE_ARRAY_AS_STRING
1180 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1181 DBUS_TYPE_STRING_AS_STRING
1182 DBUS_TYPE_VARIANT_AS_STRING
1183 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
1184 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
1185 DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
1188 g_slist_foreach(data->objects, append_object, &array);
1190 dbus_message_iter_close_container(&iter, &array);
1195 #ifdef __TIZEN_PATCH__
1196 static DBusMessage *default_adapter(DBusConnection *conn,
1197 DBusMessage *msg, void *data)
1202 return g_dbus_create_error(msg,
1203 "org.bluez.Error" ".NoSuchAdapter",
1206 reply = dbus_message_new_method_return(msg);
1210 dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &adapter_path,
1217 static const GDBusMethodTable manager_methods[] = {
1218 { GDBUS_METHOD("GetManagedObjects", NULL,
1219 GDBUS_ARGS({ "objects", "a{oa{sa{sv}}}" }), get_objects) },
1220 #ifdef __TIZEN_PATCH__
1221 { GDBUS_METHOD("DefaultAdapter",
1222 NULL, GDBUS_ARGS({ "adapter", "o" }),
1228 static const GDBusSignalTable manager_signals[] = {
1229 { GDBUS_SIGNAL("InterfacesAdded",
1230 GDBUS_ARGS({ "object", "o" },
1231 { "interfaces", "a{sa{sv}}" })) },
1232 { GDBUS_SIGNAL("InterfacesRemoved",
1233 GDBUS_ARGS({ "object", "o" }, { "interfaces", "as" })) },
1237 static gboolean add_interface(struct generic_data *data,
1239 const GDBusMethodTable *methods,
1240 const GDBusSignalTable *signals,
1241 const GDBusPropertyTable *properties,
1243 GDBusDestroyFunction destroy)
1245 struct interface_data *iface;
1246 const GDBusMethodTable *method;
1247 const GDBusSignalTable *signal;
1248 const GDBusPropertyTable *property;
1250 for (method = methods; method && method->name; method++) {
1251 if (!check_experimental(method->flags,
1252 G_DBUS_METHOD_FLAG_EXPERIMENTAL))
1256 for (signal = signals; signal && signal->name; signal++) {
1257 if (!check_experimental(signal->flags,
1258 G_DBUS_SIGNAL_FLAG_EXPERIMENTAL))
1262 for (property = properties; property && property->name; property++) {
1263 if (!check_experimental(property->flags,
1264 G_DBUS_PROPERTY_FLAG_EXPERIMENTAL))
1268 /* Nothing to register */
1272 iface = g_new0(struct interface_data, 1);
1273 iface->name = g_strdup(name);
1274 iface->methods = methods;
1275 iface->signals = signals;
1276 iface->properties = properties;
1277 iface->user_data = user_data;
1278 iface->destroy = destroy;
1280 data->interfaces = g_slist_append(data->interfaces, iface);
1281 if (data->parent == NULL)
1284 data->added = g_slist_append(data->added, iface);
1291 static struct generic_data *object_path_ref(DBusConnection *connection,
1294 struct generic_data *data;
1296 if (dbus_connection_get_object_path_data(connection, path,
1297 (void *) &data) == TRUE) {
1304 data = g_new0(struct generic_data, 1);
1305 data->conn = dbus_connection_ref(connection);
1306 data->path = g_strdup(path);
1309 data->introspect = g_strdup(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE "<node></node>");
1311 if (!dbus_connection_register_object_path(connection, path,
1312 &generic_table, data)) {
1313 dbus_connection_unref(data->conn);
1315 g_free(data->introspect);
1320 invalidate_parent_data(connection, path);
1322 add_interface(data, DBUS_INTERFACE_INTROSPECTABLE, introspect_methods,
1323 NULL, NULL, data, NULL);
1328 static void object_path_unref(DBusConnection *connection, const char *path)
1330 struct generic_data *data = NULL;
1332 if (dbus_connection_get_object_path_data(connection, path,
1333 (void *) &data) == FALSE)
1341 if (data->refcount > 0)
1344 remove_interface(data, DBUS_INTERFACE_INTROSPECTABLE);
1345 remove_interface(data, DBUS_INTERFACE_PROPERTIES);
1347 invalidate_parent_data(data->conn, data->path);
1349 dbus_connection_unregister_object_path(data->conn, data->path);
1352 static gboolean check_signal(DBusConnection *conn, const char *path,
1353 const char *interface, const char *name,
1354 const GDBusArgInfo **args)
1356 struct generic_data *data = NULL;
1357 struct interface_data *iface;
1358 const GDBusSignalTable *signal;
1361 if (!dbus_connection_get_object_path_data(conn, path,
1362 (void *) &data) || data == NULL) {
1363 error("dbus_connection_emit_signal: path %s isn't registered",
1368 iface = find_interface(data->interfaces, interface);
1369 if (iface == NULL) {
1370 error("dbus_connection_emit_signal: %s does not implement %s",
1375 for (signal = iface->signals; signal && signal->name; signal++) {
1376 if (strcmp(signal->name, name) != 0)
1379 if (signal->flags & G_DBUS_SIGNAL_FLAG_EXPERIMENTAL) {
1380 const char *env = g_getenv("GDBUS_EXPERIMENTAL");
1381 if (g_strcmp0(env, "1") != 0)
1385 *args = signal->args;
1389 error("No signal named %s on interface %s", name, interface);
1393 gboolean g_dbus_register_interface(DBusConnection *connection,
1394 const char *path, const char *name,
1395 const GDBusMethodTable *methods,
1396 const GDBusSignalTable *signals,
1397 const GDBusPropertyTable *properties,
1399 GDBusDestroyFunction destroy)
1401 struct generic_data *data;
1403 data = object_path_ref(connection, path);
1407 if (find_interface(data->interfaces, name)) {
1408 object_path_unref(connection, path);
1412 #ifdef __TIZEN_PATCH__
1413 if (g_strcmp0(name, ADAPTER_INTERFACE) == 0)
1414 adapter_path = g_strdup(path);
1417 if (!add_interface(data, name, methods, signals, properties, user_data,
1419 object_path_unref(connection, path);
1423 if (properties != NULL && !find_interface(data->interfaces,
1424 DBUS_INTERFACE_PROPERTIES))
1425 add_interface(data, DBUS_INTERFACE_PROPERTIES,
1426 properties_methods, properties_signals, NULL,
1429 g_free(data->introspect);
1430 data->introspect = NULL;
1435 gboolean g_dbus_unregister_interface(DBusConnection *connection,
1436 const char *path, const char *name)
1438 struct generic_data *data = NULL;
1443 if (dbus_connection_get_object_path_data(connection, path,
1444 (void *) &data) == FALSE)
1450 if (remove_interface(data, name) == FALSE)
1453 g_free(data->introspect);
1454 data->introspect = NULL;
1456 object_path_unref(connection, data->path);
1461 gboolean g_dbus_register_security(const GDBusSecurityTable *security)
1463 if (security_table != NULL)
1466 security_table = security;
1471 gboolean g_dbus_unregister_security(const GDBusSecurityTable *security)
1473 security_table = NULL;
1478 DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name,
1479 const char *format, va_list args)
1484 vsnprintf(str, sizeof(str), format, args);
1488 return dbus_message_new_error(message, name, str);
1491 DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name,
1492 const char *format, ...)
1497 va_start(args, format);
1499 reply = g_dbus_create_error_valist(message, name, format, args);
1506 DBusMessage *g_dbus_create_reply_valist(DBusMessage *message,
1507 int type, va_list args)
1511 reply = dbus_message_new_method_return(message);
1515 if (dbus_message_append_args_valist(reply, type, args) == FALSE) {
1516 dbus_message_unref(reply);
1523 DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...)
1528 va_start(args, type);
1530 reply = g_dbus_create_reply_valist(message, type, args);
1537 static void g_dbus_flush(DBusConnection *connection)
1541 for (l = pending; l;) {
1542 struct generic_data *data = l->data;
1545 if (data->conn != connection)
1548 process_changes(data);
1552 gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message)
1554 dbus_bool_t result = FALSE;
1556 if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL)
1557 dbus_message_set_no_reply(message, TRUE);
1558 else if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL) {
1559 const char *path = dbus_message_get_path(message);
1560 const char *interface = dbus_message_get_interface(message);
1561 const char *name = dbus_message_get_member(message);
1562 const GDBusArgInfo *args;
1564 if (!check_signal(connection, path, interface, name, &args))
1568 /* Flush pending signal to guarantee message order */
1569 g_dbus_flush(connection);
1571 result = dbus_connection_send(connection, message, NULL);
1574 dbus_message_unref(message);
1579 gboolean g_dbus_send_message_with_reply(DBusConnection *connection,
1580 DBusMessage *message,
1581 DBusPendingCall **call, int timeout)
1585 /* Flush pending signal to guarantee message order */
1586 g_dbus_flush(connection);
1588 ret = dbus_connection_send_with_reply(connection, message, call,
1591 if (ret == TRUE && call != NULL && *call == NULL) {
1592 error("Unable to send message (passing fd blocked?)");
1599 gboolean g_dbus_send_error_valist(DBusConnection *connection,
1600 DBusMessage *message, const char *name,
1601 const char *format, va_list args)
1605 error = g_dbus_create_error_valist(message, name, format, args);
1609 return g_dbus_send_message(connection, error);
1612 gboolean g_dbus_send_error(DBusConnection *connection, DBusMessage *message,
1613 const char *name, const char *format, ...)
1618 va_start(args, format);
1620 result = g_dbus_send_error_valist(connection, message, name,
1628 gboolean g_dbus_send_reply_valist(DBusConnection *connection,
1629 DBusMessage *message, int type, va_list args)
1633 reply = dbus_message_new_method_return(message);
1637 if (dbus_message_append_args_valist(reply, type, args) == FALSE) {
1638 dbus_message_unref(reply);
1642 return g_dbus_send_message(connection, reply);
1645 gboolean g_dbus_send_reply(DBusConnection *connection,
1646 DBusMessage *message, int type, ...)
1651 va_start(args, type);
1653 result = g_dbus_send_reply_valist(connection, message, type, args);
1660 gboolean g_dbus_emit_signal(DBusConnection *connection,
1661 const char *path, const char *interface,
1662 const char *name, int type, ...)
1667 va_start(args, type);
1669 result = g_dbus_emit_signal_valist(connection, path, interface,
1677 #ifdef GATT_NO_RELAY
1678 static gboolean g_dbus_emit_signal_valist_to_dest(DBusConnection *connection,
1679 const char *dest, const char *path, const char *interface,
1680 const char *name, int type, va_list args)
1682 DBusMessage *signal;
1684 const GDBusArgInfo *args_info;
1686 if (!check_signal(connection, path, interface, name, &args_info))
1689 signal = dbus_message_new_signal(path, interface, name);
1690 if (signal == NULL) {
1691 error("Unable to allocate new %s.%s signal", interface, name);
1695 ret = dbus_message_append_args_valist(signal, type, args);
1699 if (g_dbus_args_have_signature(args_info, signal) == FALSE) {
1700 error("%s.%s: got unexpected signature '%s'", interface, name,
1701 dbus_message_get_signature(signal));
1706 ret = dbus_message_set_destination(signal, dest);
1708 error("Fail to set destination");
1710 return g_dbus_send_message(connection, signal);
1713 dbus_message_unref(signal);
1718 gboolean g_dbus_emit_signal_to_dest(DBusConnection *connection,
1719 const char *dest, const char *path,
1720 const char *interface, const char *name, int type, ...)
1725 va_start(args, type);
1727 result = g_dbus_emit_signal_valist_to_dest(connection, dest, path,
1728 interface, name, type, args);
1736 gboolean g_dbus_emit_signal_valist(DBusConnection *connection,
1737 const char *path, const char *interface,
1738 const char *name, int type, va_list args)
1740 DBusMessage *signal;
1742 const GDBusArgInfo *args_info;
1744 if (!check_signal(connection, path, interface, name, &args_info))
1747 signal = dbus_message_new_signal(path, interface, name);
1748 if (signal == NULL) {
1749 error("Unable to allocate new %s.%s signal", interface, name);
1753 ret = dbus_message_append_args_valist(signal, type, args);
1757 if (g_dbus_args_have_signature(args_info, signal) == FALSE) {
1758 error("%s.%s: got unexpected signature '%s'", interface, name,
1759 dbus_message_get_signature(signal));
1764 return g_dbus_send_message(connection, signal);
1767 dbus_message_unref(signal);
1772 static void process_properties_from_interface(struct generic_data *data,
1773 struct interface_data *iface)
1776 DBusMessage *signal;
1777 DBusMessageIter iter, dict, array;
1778 GSList *invalidated;
1780 data->pending_prop = FALSE;
1782 if (iface->pending_prop == NULL)
1785 signal = dbus_message_new_signal(data->path,
1786 DBUS_INTERFACE_PROPERTIES, "PropertiesChanged");
1787 if (signal == NULL) {
1788 error("Unable to allocate new " DBUS_INTERFACE_PROPERTIES
1789 ".PropertiesChanged signal");
1793 iface->pending_prop = g_slist_reverse(iface->pending_prop);
1795 dbus_message_iter_init_append(signal, &iter);
1796 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface->name);
1797 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1798 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1799 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
1800 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
1804 for (l = iface->pending_prop; l != NULL; l = l->next) {
1805 GDBusPropertyTable *p = l->data;
1810 if (p->exists != NULL && !p->exists(p, iface->user_data)) {
1811 invalidated = g_slist_prepend(invalidated, p);
1815 append_property(iface, p, &dict);
1818 dbus_message_iter_close_container(&iter, &dict);
1820 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1821 DBUS_TYPE_STRING_AS_STRING, &array);
1822 for (l = invalidated; l != NULL; l = g_slist_next(l)) {
1823 GDBusPropertyTable *p = l->data;
1825 dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
1828 g_slist_free(invalidated);
1829 dbus_message_iter_close_container(&iter, &array);
1831 g_slist_free(iface->pending_prop);
1832 iface->pending_prop = NULL;
1834 /* Use dbus_connection_send to avoid recursive calls to g_dbus_flush */
1835 dbus_connection_send(data->conn, signal, NULL);
1836 dbus_message_unref(signal);
1839 static void process_property_changes(struct generic_data *data)
1843 for (l = data->interfaces; l != NULL; l = l->next) {
1844 struct interface_data *iface = l->data;
1846 process_properties_from_interface(data, iface);
1850 void g_dbus_emit_property_changed_full(DBusConnection *connection,
1851 const char *path, const char *interface,
1853 GDbusPropertyChangedFlags flags)
1855 const GDBusPropertyTable *property;
1856 struct generic_data *data;
1857 struct interface_data *iface;
1862 if (!dbus_connection_get_object_path_data(connection, path,
1863 (void **) &data) || data == NULL)
1866 iface = find_interface(data->interfaces, interface);
1871 * If ObjectManager is attached, don't emit property changed if
1872 * interface is not yet published
1874 if (root && g_slist_find(data->added, iface))
1877 property = find_property(iface->properties, name);
1878 if (property == NULL) {
1879 error("Could not find property %s in %p", name,
1884 if (g_slist_find(iface->pending_prop, (void *) property) != NULL)
1887 data->pending_prop = TRUE;
1888 iface->pending_prop = g_slist_prepend(iface->pending_prop,
1891 if (flags & G_DBUS_PROPERTY_CHANGED_FLAG_FLUSH)
1892 process_property_changes(data);
1897 void g_dbus_emit_property_changed(DBusConnection *connection, const char *path,
1898 const char *interface, const char *name)
1900 g_dbus_emit_property_changed_full(connection, path, interface, name, 0);
1903 gboolean g_dbus_get_properties(DBusConnection *connection, const char *path,
1904 const char *interface, DBusMessageIter *iter)
1906 struct generic_data *data;
1907 struct interface_data *iface;
1912 if (!dbus_connection_get_object_path_data(connection, path,
1913 (void **) &data) || data == NULL)
1916 iface = find_interface(data->interfaces, interface);
1920 append_properties(iface, iter);
1925 gboolean g_dbus_attach_object_manager(DBusConnection *connection)
1927 struct generic_data *data;
1929 data = object_path_ref(connection, "/");
1933 add_interface(data, DBUS_INTERFACE_OBJECT_MANAGER,
1934 manager_methods, manager_signals,
1941 gboolean g_dbus_detach_object_manager(DBusConnection *connection)
1943 if (!g_dbus_unregister_interface(connection, "/",
1944 DBUS_INTERFACE_OBJECT_MANAGER))
1952 void g_dbus_set_flags(int flags)
1954 global_flags = flags;
1957 int g_dbus_get_flags(void)
1959 return global_flags;