5 * Copyright (C) 2007-2009 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
30 static connman_bool_t global_offlinemode = FALSE;
32 connman_bool_t __connman_manager_get_offlinemode(void)
34 return global_offlinemode;
37 static void append_profiles(DBusMessageIter *dict)
39 DBusMessageIter entry, value, iter;
40 const char *key = "Profiles";
42 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
45 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
47 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
48 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
51 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
52 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
53 __connman_profile_list(&iter);
54 dbus_message_iter_close_container(&value, &iter);
56 dbus_message_iter_close_container(&entry, &value);
58 dbus_message_iter_close_container(dict, &entry);
61 static void append_services(DBusMessageIter *dict)
63 DBusMessageIter entry, value, iter;
64 const char *key = "Services";
66 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
69 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
71 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
72 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
75 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
76 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
77 __connman_service_list(&iter);
78 dbus_message_iter_close_container(&value, &iter);
80 dbus_message_iter_close_container(&entry, &value);
82 dbus_message_iter_close_container(dict, &entry);
85 static void append_devices(DBusMessageIter *dict)
87 DBusMessageIter entry, value, iter;
88 const char *key = "Devices";
90 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
93 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
95 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
96 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
99 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
100 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
101 __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter);
102 dbus_message_iter_close_container(&value, &iter);
104 dbus_message_iter_close_container(&entry, &value);
106 dbus_message_iter_close_container(dict, &entry);
109 static void append_connections(DBusMessageIter *dict)
111 DBusMessageIter entry, value, iter;
112 const char *key = "Connections";
114 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
117 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
119 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
120 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
123 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
124 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
125 __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION, &iter);
126 dbus_message_iter_close_container(&value, &iter);
128 dbus_message_iter_close_container(&entry, &value);
130 dbus_message_iter_close_container(dict, &entry);
133 static void append_available_technologies(DBusMessageIter *dict)
135 DBusMessageIter entry, value, iter;
136 const char *key = "AvailableTechnologies";
138 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
141 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
143 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
144 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
147 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
148 DBUS_TYPE_STRING_AS_STRING, &iter);
149 __connman_notifier_list_registered(&iter);
150 dbus_message_iter_close_container(&value, &iter);
152 dbus_message_iter_close_container(&entry, &value);
154 dbus_message_iter_close_container(dict, &entry);
157 static void append_enabled_technologies(DBusMessageIter *dict)
159 DBusMessageIter entry, value, iter;
160 const char *key = "EnabledTechnologies";
162 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
165 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
167 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
168 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
171 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
172 DBUS_TYPE_STRING_AS_STRING, &iter);
173 __connman_notifier_list_enabled(&iter);
174 dbus_message_iter_close_container(&value, &iter);
176 dbus_message_iter_close_container(&entry, &value);
178 dbus_message_iter_close_container(dict, &entry);
181 static void append_connected_technologies(DBusMessageIter *dict)
183 DBusMessageIter entry, value, iter;
184 const char *key = "ConnectedTechnologies";
186 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
189 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
191 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
192 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
195 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
196 DBUS_TYPE_STRING_AS_STRING, &iter);
197 __connman_notifier_list_connected(&iter);
198 dbus_message_iter_close_container(&value, &iter);
200 dbus_message_iter_close_container(&entry, &value);
202 dbus_message_iter_close_container(dict, &entry);
205 static DBusMessage *get_properties(DBusConnection *conn,
206 DBusMessage *msg, void *data)
209 DBusMessageIter array, dict;
212 DBG("conn %p", conn);
214 if (__connman_security_check_privilege(msg,
215 CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
216 return __connman_error_permission_denied(msg);
218 reply = dbus_message_new_method_return(msg);
222 dbus_message_iter_init_append(reply, &array);
224 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
225 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
226 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
227 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
229 str = __connman_profile_active_path();
231 connman_dbus_dict_append_variant(&dict, "ActiveProfile",
232 DBUS_TYPE_OBJECT_PATH, &str);
234 append_profiles(&dict);
235 append_services(&dict);
237 append_devices(&dict);
238 append_connections(&dict);
240 if (__connman_element_count(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION) > 0)
245 connman_dbus_dict_append_variant(&dict, "State",
246 DBUS_TYPE_STRING, &str);
248 connman_dbus_dict_append_variant(&dict, "OfflineMode",
249 DBUS_TYPE_BOOLEAN, &global_offlinemode);
251 append_available_technologies(&dict);
252 append_enabled_technologies(&dict);
253 append_connected_technologies(&dict);
255 str = __connman_service_default();
257 connman_dbus_dict_append_variant(&dict, "DefaultTechnology",
258 DBUS_TYPE_STRING, &str);
260 dbus_message_iter_close_container(&array, &dict);
265 static DBusMessage *set_property(DBusConnection *conn,
266 DBusMessage *msg, void *data)
268 DBusMessageIter iter, value;
271 DBG("conn %p", conn);
273 if (dbus_message_iter_init(msg, &iter) == FALSE)
274 return __connman_error_invalid_arguments(msg);
276 dbus_message_iter_get_basic(&iter, &name);
277 dbus_message_iter_next(&iter);
278 dbus_message_iter_recurse(&iter, &value);
280 if (__connman_security_check_privilege(msg,
281 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
282 return __connman_error_permission_denied(msg);
284 if (g_str_equal(name, "OfflineMode") == TRUE) {
285 connman_bool_t offlinemode;
287 dbus_message_iter_get_basic(&value, &offlinemode);
289 if (global_offlinemode == offlinemode)
290 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
292 global_offlinemode = offlinemode;
294 __connman_device_set_offlinemode(offlinemode);
295 } else if (g_str_equal(name, "ActiveProfile") == TRUE) {
298 dbus_message_iter_get_basic(&value, &str);
300 return __connman_error_not_supported(msg);
302 return __connman_error_invalid_property(msg);
304 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
307 static DBusMessage *get_state(DBusConnection *conn,
308 DBusMessage *msg, void *data)
312 DBG("conn %p", conn);
314 if (__connman_security_check_privilege(msg,
315 CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
316 return __connman_error_permission_denied(msg);
318 if (__connman_element_count(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION) > 0)
323 return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &str,
327 static DBusMessage *add_profile(DBusConnection *conn,
328 DBusMessage *msg, void *data)
332 DBG("conn %p", conn);
334 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
337 return __connman_error_not_supported(msg);
340 static DBusMessage *remove_profile(DBusConnection *conn,
341 DBusMessage *msg, void *data)
345 DBG("conn %p", conn);
347 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
350 return __connman_error_not_supported(msg);
353 static DBusMessage *request_scan(DBusConnection *conn,
354 DBusMessage *msg, void *data)
356 enum connman_device_type type;
360 DBG("conn %p", conn);
362 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
365 if (g_strcmp0(str, "") == 0)
366 type = CONNMAN_DEVICE_TYPE_UNKNOWN;
367 else if (g_strcmp0(str, "wifi") == 0)
368 type = CONNMAN_DEVICE_TYPE_WIFI;
369 else if (g_strcmp0(str, "wimax") == 0)
370 type = CONNMAN_DEVICE_TYPE_WIMAX;
372 return __connman_error_invalid_arguments(msg);
374 err = __connman_element_request_scan(type);
376 if (err == -EINPROGRESS) {
377 connman_error("Invalid return code from scan");
381 return __connman_error_failed(msg, -err);
384 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
387 static DBusMessage *enable_technology(DBusConnection *conn,
388 DBusMessage *msg, void *data)
390 enum connman_device_type type;
394 DBG("conn %p", conn);
396 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
399 if (g_strcmp0(str, "ethernet") == 0)
400 type = CONNMAN_DEVICE_TYPE_ETHERNET;
401 else if (g_strcmp0(str, "wifi") == 0)
402 type = CONNMAN_DEVICE_TYPE_WIFI;
403 else if (g_strcmp0(str, "wimax") == 0)
404 type = CONNMAN_DEVICE_TYPE_WIMAX;
405 else if (g_strcmp0(str, "bluetooth") == 0)
406 type = CONNMAN_DEVICE_TYPE_BLUETOOTH;
407 else if (g_strcmp0(str, "gps") == 0)
408 type = CONNMAN_DEVICE_TYPE_GPS;
410 return __connman_error_invalid_arguments(msg);
412 err = __connman_element_enable_technology(type);
414 if (err == -EINPROGRESS) {
415 connman_error("Invalid return code from enable");
419 return __connman_error_failed(msg, -err);
422 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
425 static DBusMessage *disable_technology(DBusConnection *conn,
426 DBusMessage *msg, void *data)
428 enum connman_device_type type;
432 DBG("conn %p", conn);
434 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
437 if (g_strcmp0(str, "ethernet") == 0)
438 type = CONNMAN_DEVICE_TYPE_ETHERNET;
439 else if (g_strcmp0(str, "wifi") == 0)
440 type = CONNMAN_DEVICE_TYPE_WIFI;
441 else if (g_strcmp0(str, "wimax") == 0)
442 type = CONNMAN_DEVICE_TYPE_WIMAX;
443 else if (g_strcmp0(str, "bluetooth") == 0)
444 type = CONNMAN_DEVICE_TYPE_BLUETOOTH;
445 else if (g_strcmp0(str, "gps") == 0)
446 type = CONNMAN_DEVICE_TYPE_GPS;
448 return __connman_error_invalid_arguments(msg);
450 err = __connman_element_disable_technology(type);
452 if (err == -EINPROGRESS) {
453 connman_error("Invalid return code from disable");
457 return __connman_error_failed(msg, -err);
460 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
463 static DBusMessage *connect_service(DBusConnection *conn,
464 DBusMessage *msg, void *data)
468 DBG("conn %p", conn);
470 if (__connman_security_check_privilege(msg,
471 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
472 return __connman_error_permission_denied(msg);
474 err = __connman_service_create_and_connect(msg);
476 if (err == -EINPROGRESS) {
477 connman_error("Invalid return code from connect");
481 return __connman_error_failed(msg, -err);
487 static DBusMessage *register_agent(DBusConnection *conn,
488 DBusMessage *msg, void *data)
491 const char *sender, *path;
493 DBG("conn %p", conn);
495 sender = dbus_message_get_sender(msg);
497 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
500 reply = dbus_message_new_method_return(msg);
504 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
506 __connman_agent_register(sender, path);
511 static DBusMessage *unregister_agent(DBusConnection *conn,
512 DBusMessage *msg, void *data)
515 const char *sender, *path;
517 DBG("conn %p", conn);
519 sender = dbus_message_get_sender(msg);
521 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
524 reply = dbus_message_new_method_return(msg);
528 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
530 __connman_agent_unregister(sender, path);
535 static GDBusMethodTable manager_methods[] = {
536 { "GetProperties", "", "a{sv}", get_properties },
537 { "SetProperty", "sv", "", set_property },
538 { "GetState", "", "s", get_state },
539 { "AddProfile", "s", "o", add_profile },
540 { "RemoveProfile", "o", "", remove_profile },
541 { "RequestScan", "s", "", request_scan },
542 { "EnableTechnology", "s", "", enable_technology },
543 { "DisableTechnology", "s", "", disable_technology },
544 { "ConnectService", "a{sv}", "o", connect_service,
545 G_DBUS_METHOD_FLAG_ASYNC },
546 { "RegisterAgent", "o", "", register_agent },
547 { "UnregisterAgent", "o", "", unregister_agent },
551 static GDBusSignalTable manager_signals[] = {
552 { "PropertyChanged", "sv" },
553 { "StateChanged", "s" },
557 static DBusMessage *nm_sleep(DBusConnection *conn,
558 DBusMessage *msg, void *data)
562 DBG("conn %p", conn);
564 reply = dbus_message_new_method_return(msg);
568 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
573 static DBusMessage *nm_wake(DBusConnection *conn,
574 DBusMessage *msg, void *data)
578 DBG("conn %p", conn);
580 reply = dbus_message_new_method_return(msg);
584 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
590 NM_STATE_UNKNOWN = 0,
594 NM_STATE_DISCONNECTED
597 static DBusMessage *nm_state(DBusConnection *conn,
598 DBusMessage *msg, void *data)
603 DBG("conn %p", conn);
605 reply = dbus_message_new_method_return(msg);
609 state = NM_STATE_DISCONNECTED;
611 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &state,
617 static GDBusMethodTable nm_methods[] = {
618 { "sleep", "", "", nm_sleep },
619 { "wake", "", "", nm_wake },
620 { "state", "", "u", nm_state },
624 static DBusConnection *connection = NULL;
625 static gboolean nm_compat = FALSE;
627 int __connman_manager_init(DBusConnection *conn, gboolean compat)
629 DBG("conn %p", conn);
631 connection = dbus_connection_ref(conn);
632 if (connection == NULL)
635 g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
636 CONNMAN_MANAGER_INTERFACE,
638 manager_signals, NULL, NULL, NULL);
640 if (compat == TRUE) {
641 g_dbus_register_interface(connection, NM_PATH, NM_INTERFACE,
642 nm_methods, NULL, NULL, NULL, NULL);
650 void __connman_manager_cleanup(void)
652 DBG("conn %p", connection);
654 if (nm_compat == TRUE) {
655 g_dbus_unregister_interface(connection, NM_PATH, NM_INTERFACE);
658 g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
659 CONNMAN_MANAGER_INTERFACE);
661 dbus_connection_unref(connection);