5 * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
32 dbus_bool_t connman_dbus_validate_ident(const char *ident)
39 for (i = 0; i < strlen(ident); i++) {
40 if (ident[i] >= '0' && ident[i] <= '9')
42 if (ident[i] >= 'a' && ident[i] <= 'z')
44 if (ident[i] >= 'A' && ident[i] <= 'Z')
52 char *connman_dbus_encode_string(const char *value)
62 str = g_string_new(NULL);
66 for (i = 0; i < size; i++) {
67 const char tmp = value[i];
68 if ((tmp < '0' || tmp > '9') && (tmp < 'A' || tmp > 'Z') &&
69 (tmp < 'a' || tmp > 'z'))
70 g_string_append_printf(str, "_%02x", tmp);
72 str = g_string_append_c(str, tmp);
75 return g_string_free(str, FALSE);
78 void connman_dbus_property_append_basic(DBusMessageIter *iter,
79 const char *key, int type, void *val)
81 DBusMessageIter value;
82 const char *signature;
84 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
87 case DBUS_TYPE_BOOLEAN:
88 signature = DBUS_TYPE_BOOLEAN_AS_STRING;
90 case DBUS_TYPE_STRING:
91 signature = DBUS_TYPE_STRING_AS_STRING;
94 signature = DBUS_TYPE_BYTE_AS_STRING;
96 case DBUS_TYPE_UINT16:
97 signature = DBUS_TYPE_UINT16_AS_STRING;
100 signature = DBUS_TYPE_INT16_AS_STRING;
102 case DBUS_TYPE_UINT32:
103 signature = DBUS_TYPE_UINT32_AS_STRING;
105 case DBUS_TYPE_INT32:
106 signature = DBUS_TYPE_INT32_AS_STRING;
108 case DBUS_TYPE_UINT64:
109 signature = DBUS_TYPE_UINT64_AS_STRING;
111 case DBUS_TYPE_INT64:
112 signature = DBUS_TYPE_INT64_AS_STRING;
114 case DBUS_TYPE_OBJECT_PATH:
115 signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
118 signature = DBUS_TYPE_VARIANT_AS_STRING;
122 dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
124 dbus_message_iter_append_basic(&value, type, val);
125 dbus_message_iter_close_container(iter, &value);
128 void connman_dbus_property_append_dict(DBusMessageIter *iter, const char *key,
129 connman_dbus_append_cb_t function, void *user_data)
131 DBusMessageIter value, dict;
133 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
135 dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
136 DBUS_TYPE_ARRAY_AS_STRING
137 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
138 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
139 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &value);
141 connman_dbus_dict_open(&value, &dict);
143 function(&dict, user_data);
144 connman_dbus_dict_close(&value, &dict);
146 dbus_message_iter_close_container(iter, &value);
149 void connman_dbus_property_append_fixed_array(DBusMessageIter *iter,
150 const char *key, int type, void *val, int len)
152 DBusMessageIter value, array;
153 const char *variant_sig, *array_sig;
157 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
158 array_sig = DBUS_TYPE_BYTE_AS_STRING;
164 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
166 dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
167 variant_sig, &value);
169 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
171 dbus_message_iter_append_fixed_array(&array, type, val, len);
172 dbus_message_iter_close_container(&value, &array);
174 dbus_message_iter_close_container(iter, &value);
177 void connman_dbus_property_append_array(DBusMessageIter *iter,
178 const char *key, int type,
179 connman_dbus_append_cb_t function, void *user_data)
181 DBusMessageIter value, array;
182 const char *variant_sig, *array_sig;
185 case DBUS_TYPE_STRING:
186 variant_sig = DBUS_TYPE_ARRAY_AS_STRING
187 DBUS_TYPE_STRING_AS_STRING;
188 array_sig = DBUS_TYPE_STRING_AS_STRING;
190 case DBUS_TYPE_OBJECT_PATH:
191 variant_sig = DBUS_TYPE_ARRAY_AS_STRING
192 DBUS_TYPE_OBJECT_PATH_AS_STRING;
193 array_sig = DBUS_TYPE_OBJECT_PATH_AS_STRING;
195 case DBUS_TYPE_DICT_ENTRY:
196 variant_sig = DBUS_TYPE_ARRAY_AS_STRING
197 DBUS_STRUCT_BEGIN_CHAR_AS_STRING
198 DBUS_TYPE_ARRAY_AS_STRING
199 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
200 DBUS_TYPE_STRING_AS_STRING
201 DBUS_TYPE_VARIANT_AS_STRING
202 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
203 DBUS_STRUCT_END_CHAR_AS_STRING;
204 array_sig = DBUS_STRUCT_BEGIN_CHAR_AS_STRING
205 DBUS_TYPE_ARRAY_AS_STRING
206 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
207 DBUS_TYPE_STRING_AS_STRING
208 DBUS_TYPE_VARIANT_AS_STRING
209 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
210 DBUS_STRUCT_END_CHAR_AS_STRING;
216 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
218 dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
219 variant_sig, &value);
221 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
224 function(&array, user_data);
225 dbus_message_iter_close_container(&value, &array);
227 dbus_message_iter_close_container(iter, &value);
230 static DBusConnection *connection = NULL;
232 dbus_bool_t connman_dbus_property_changed_basic(const char *path,
233 const char *interface, const char *key,
237 DBusMessageIter iter;
242 signal = dbus_message_new_signal(path, interface, "PropertyChanged");
246 dbus_message_iter_init_append(signal, &iter);
247 connman_dbus_property_append_basic(&iter, key, type, val);
249 return g_dbus_send_message(connection, signal);
252 dbus_bool_t connman_dbus_property_changed_dict(const char *path,
253 const char *interface, const char *key,
254 connman_dbus_append_cb_t function, void *user_data)
257 DBusMessageIter iter;
262 signal = dbus_message_new_signal(path, interface, "PropertyChanged");
266 dbus_message_iter_init_append(signal, &iter);
267 connman_dbus_property_append_dict(&iter, key, function, user_data);
269 return g_dbus_send_message(connection, signal);
272 dbus_bool_t connman_dbus_property_changed_array(const char *path,
273 const char *interface, const char *key, int type,
274 connman_dbus_append_cb_t function, void *user_data)
277 DBusMessageIter iter;
282 signal = dbus_message_new_signal(path, interface, "PropertyChanged");
286 dbus_message_iter_init_append(signal, &iter);
287 connman_dbus_property_append_array(&iter, key, type,
288 function, user_data);
290 return g_dbus_send_message(connection, signal);
293 dbus_bool_t connman_dbus_setting_changed_basic(const char *owner,
294 const char *path, const char *key,
298 DBusMessageIter array, dict;
303 msg = dbus_message_new_method_call(owner, path,
304 CONNMAN_NOTIFICATION_INTERFACE,
309 dbus_message_iter_init_append(msg, &array);
310 connman_dbus_dict_open(&array, &dict);
312 connman_dbus_dict_append_basic(&dict, key, type, val);
314 connman_dbus_dict_close(&array, &dict);
316 return g_dbus_send_message(connection, msg);
319 dbus_bool_t connman_dbus_setting_changed_dict(const char *owner,
320 const char *path, const char *key,
321 connman_dbus_append_cb_t function,
325 DBusMessageIter array, dict;
330 msg = dbus_message_new_method_call(owner, path,
331 CONNMAN_NOTIFICATION_INTERFACE,
336 dbus_message_iter_init_append(msg, &array);
337 connman_dbus_dict_open(&array, &dict);
339 connman_dbus_dict_append_dict(&dict, key, function, user_data);
341 connman_dbus_dict_close(&array, &dict);
343 return g_dbus_send_message(connection, msg);
346 dbus_bool_t connman_dbus_setting_changed_array(const char *owner,
347 const char *path, const char *key, int type,
348 connman_dbus_append_cb_t function,
352 DBusMessageIter array, dict;
357 msg = dbus_message_new_method_call(owner, path,
358 CONNMAN_NOTIFICATION_INTERFACE,
363 dbus_message_iter_init_append(msg, &array);
364 connman_dbus_dict_open(&array, &dict);
366 connman_dbus_dict_append_array(&dict, key, type, function, user_data);
368 connman_dbus_dict_close(&array, &dict);
370 return g_dbus_send_message(connection, msg);
373 dbus_bool_t __connman_dbus_append_objpath_dict_array(DBusMessage *msg,
374 connman_dbus_append_cb_t function, void *user_data)
376 DBusMessageIter iter, array;
378 if (!msg || !function)
381 dbus_message_iter_init_append(msg, &iter);
382 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
383 DBUS_STRUCT_BEGIN_CHAR_AS_STRING
384 DBUS_TYPE_OBJECT_PATH_AS_STRING
385 DBUS_TYPE_ARRAY_AS_STRING
386 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
387 DBUS_TYPE_STRING_AS_STRING
388 DBUS_TYPE_VARIANT_AS_STRING
389 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
390 DBUS_STRUCT_END_CHAR_AS_STRING, &array);
392 function(&array, user_data);
394 dbus_message_iter_close_container(&iter, &array);
399 dbus_bool_t __connman_dbus_append_objpath_array(DBusMessage *msg,
400 connman_dbus_append_cb_t function, void *user_data)
402 DBusMessageIter iter, array;
404 if (!msg || !function)
407 dbus_message_iter_init_append(msg, &iter);
408 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
409 DBUS_TYPE_OBJECT_PATH_AS_STRING, &array);
411 function(&array, user_data);
413 dbus_message_iter_close_container(&iter, &array);
418 struct callback_data {
423 static void get_connection_unix_user_reply(DBusPendingCall *call,
426 struct callback_data *data = user_data;
427 connman_dbus_get_connection_unix_user_cb_t cb = data->cb;
428 DBusMessageIter iter;
431 unsigned int uid = 0;
433 reply = dbus_pending_call_steal_reply(call);
435 if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
436 DBG("Failed to retrieve UID");
441 if (!dbus_message_has_signature(reply, "u")) {
442 DBG("Message signature is wrong");
447 dbus_message_iter_init(reply, &iter);
448 dbus_message_iter_get_basic(&iter, &uid);
451 (*cb)(uid, data->user_data, err);
453 dbus_message_unref(reply);
455 dbus_pending_call_unref(call);
458 int connman_dbus_get_connection_unix_user(DBusConnection *connection,
459 const char *bus_name,
460 connman_dbus_get_connection_unix_user_cb_t func,
463 struct callback_data *data;
464 DBusPendingCall *call;
465 DBusMessage *msg = NULL;
468 data = g_try_new0(struct callback_data, 1);
470 DBG("Can't allocate data structure");
474 msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
476 "GetConnectionUnixUser");
478 DBG("Can't allocate new message");
483 dbus_message_append_args(msg, DBUS_TYPE_STRING, &bus_name,
486 if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
487 DBG("Failed to execute method call");
493 DBG("D-Bus connection not available");
499 data->user_data = user_data;
501 dbus_pending_call_set_notify(call, get_connection_unix_user_reply,
504 dbus_message_unref(msg);
509 dbus_message_unref(msg);
515 static unsigned char *parse_context(DBusMessage *msg)
517 DBusMessageIter iter, array;
518 unsigned char *ctx, *p;
521 dbus_message_iter_init(msg, &iter);
522 dbus_message_iter_recurse(&iter, &array);
523 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_BYTE) {
526 dbus_message_iter_next(&array);
532 ctx = g_try_malloc0(size + 1);
538 dbus_message_iter_init(msg, &iter);
539 dbus_message_iter_recurse(&iter, &array);
540 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_BYTE) {
541 dbus_message_iter_get_basic(&array, p);
544 dbus_message_iter_next(&array);
550 static void selinux_get_context_reply(DBusPendingCall *call, void *user_data)
552 struct callback_data *data = user_data;
553 connman_dbus_get_context_cb_t cb = data->cb;
555 unsigned char *context = NULL;
558 reply = dbus_pending_call_steal_reply(call);
560 if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
561 DBG("Failed to retrieve SELinux context");
566 if (!dbus_message_has_signature(reply, "ay")) {
567 DBG("Message signature is wrong");
572 context = parse_context(reply);
575 (*cb)(context, data->user_data, err);
579 dbus_message_unref(reply);
581 dbus_pending_call_unref(call);
584 int connman_dbus_get_selinux_context(DBusConnection *connection,
586 connman_dbus_get_context_cb_t func,
589 struct callback_data *data;
590 DBusPendingCall *call;
591 DBusMessage *msg = NULL;
597 data = g_try_new0(struct callback_data, 1);
599 DBG("Can't allocate data structure");
603 msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
605 "GetConnectionSELinuxSecurityContext");
607 DBG("Can't allocate new message");
612 dbus_message_append_args(msg, DBUS_TYPE_STRING, &service,
615 if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
616 DBG("Failed to execute method call");
622 DBG("D-Bus connection not available");
628 data->user_data = user_data;
630 dbus_pending_call_set_notify(call, selinux_get_context_reply,
633 dbus_message_unref(msg);
638 dbus_message_unref(msg);
644 void connman_dbus_reply_pending(DBusMessage *pending,
645 int error, const char *path)
651 reply = __connman_error_failed(pending, error);
653 g_dbus_send_message(connection, reply);
657 sender = dbus_message_get_interface(pending);
659 path = dbus_message_get_path(pending);
661 DBG("sender %s path %s", sender, path);
663 if (g_strcmp0(sender, CONNMAN_MANAGER_INTERFACE) == 0)
664 g_dbus_send_reply(connection, pending,
665 DBUS_TYPE_OBJECT_PATH, &path,
668 g_dbus_send_reply(connection, pending,
672 dbus_message_unref(pending);
676 DBusConnection *connman_dbus_get_connection(void)
681 return dbus_connection_ref(connection);
684 int __connman_dbus_init(DBusConnection *conn)
690 return g_dbus_attach_object_manager(conn);
693 void __connman_dbus_cleanup(void)