5 * Copyright (C) 2007-2010 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 DBusMessage *get_properties(DBusConnection *conn,
31 DBusMessage *msg, void *data)
34 DBusMessageIter array, dict;
35 connman_bool_t offlinemode, tethering;
40 if (__connman_security_check_privilege(msg,
41 CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
42 return __connman_error_permission_denied(msg);
44 reply = dbus_message_new_method_return(msg);
48 dbus_message_iter_init_append(reply, &array);
50 connman_dbus_dict_open(&array, &dict);
52 str = __connman_profile_active_path();
54 connman_dbus_dict_append_basic(&dict, "ActiveProfile",
55 DBUS_TYPE_OBJECT_PATH, &str);
57 connman_dbus_dict_append_array(&dict, "Profiles",
58 DBUS_TYPE_OBJECT_PATH, __connman_profile_list, NULL);
59 connman_dbus_dict_append_array(&dict, "Services",
60 DBUS_TYPE_OBJECT_PATH, __connman_service_list, NULL);
61 connman_dbus_dict_append_array(&dict, "Technologies",
62 DBUS_TYPE_OBJECT_PATH, __connman_technology_list, NULL);
64 str = __connman_notifier_get_state();
65 connman_dbus_dict_append_basic(&dict, "State",
66 DBUS_TYPE_STRING, &str);
68 offlinemode = __connman_profile_get_offlinemode();
69 connman_dbus_dict_append_basic(&dict, "OfflineMode",
70 DBUS_TYPE_BOOLEAN, &offlinemode);
72 tethering = __connman_tethering_get_status();
73 connman_dbus_dict_append_basic(&dict, "Tethering",
74 DBUS_TYPE_BOOLEAN, &tethering);
76 connman_dbus_dict_append_array(&dict, "AvailableTechnologies",
77 DBUS_TYPE_STRING, __connman_notifier_list_registered, NULL);
78 connman_dbus_dict_append_array(&dict, "EnabledTechnologies",
79 DBUS_TYPE_STRING, __connman_notifier_list_enabled, NULL);
80 connman_dbus_dict_append_array(&dict, "ConnectedTechnologies",
81 DBUS_TYPE_STRING, __connman_notifier_list_connected, NULL);
83 str = __connman_service_default();
85 connman_dbus_dict_append_basic(&dict, "DefaultTechnology",
86 DBUS_TYPE_STRING, &str);
88 connman_dbus_dict_append_array(&dict, "AvailableDebugs",
89 DBUS_TYPE_STRING, __connman_debug_list_available, NULL);
90 connman_dbus_dict_append_array(&dict, "EnabledDebugs",
91 DBUS_TYPE_STRING, __connman_debug_list_enabled, NULL);
93 connman_dbus_dict_close(&array, &dict);
98 static DBusMessage *set_property(DBusConnection *conn,
99 DBusMessage *msg, void *data)
101 DBusMessageIter iter, value;
105 DBG("conn %p", conn);
107 if (dbus_message_iter_init(msg, &iter) == FALSE)
108 return __connman_error_invalid_arguments(msg);
110 dbus_message_iter_get_basic(&iter, &name);
111 dbus_message_iter_next(&iter);
112 dbus_message_iter_recurse(&iter, &value);
114 if (__connman_security_check_privilege(msg,
115 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
116 return __connman_error_permission_denied(msg);
118 type = dbus_message_iter_get_arg_type(&value);
120 if (g_str_equal(name, "OfflineMode") == TRUE) {
121 connman_bool_t offlinemode;
123 if (type != DBUS_TYPE_BOOLEAN)
124 return __connman_error_invalid_arguments(msg);
126 dbus_message_iter_get_basic(&value, &offlinemode);
128 __connman_profile_set_offlinemode(offlinemode, TRUE);
130 __connman_profile_save_default();
131 } else if (g_str_equal(name, "Tethering") == TRUE) {
132 connman_bool_t tethering;
134 if (type != DBUS_TYPE_BOOLEAN)
135 return __connman_error_invalid_arguments(msg);
137 dbus_message_iter_get_basic(&value, &tethering);
139 if (__connman_tethering_set_status(tethering) < 0)
140 return __connman_error_invalid_arguments(msg);
142 connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
143 CONNMAN_MANAGER_INTERFACE, "Tethering",
144 DBUS_TYPE_BOOLEAN, &tethering);
145 } else if (g_str_equal(name, "ActiveProfile") == TRUE) {
148 dbus_message_iter_get_basic(&value, &str);
150 return __connman_error_not_supported(msg);
152 return __connman_error_invalid_property(msg);
154 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
157 static DBusMessage *get_state(DBusConnection *conn,
158 DBusMessage *msg, void *data)
162 DBG("conn %p", conn);
164 if (__connman_security_check_privilege(msg,
165 CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
166 return __connman_error_permission_denied(msg);
168 str = __connman_notifier_get_state();
170 return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &str,
174 static DBusMessage *create_profile(DBusConnection *conn,
175 DBusMessage *msg, void *data)
177 const char *name, *path;
180 DBG("conn %p", conn);
182 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
185 if (__connman_security_check_privilege(msg,
186 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
187 return __connman_error_permission_denied(msg);
189 err = __connman_profile_create(name, &path);
191 return __connman_error_failed(msg, -err);
193 return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &path,
197 static DBusMessage *remove_profile(DBusConnection *conn,
198 DBusMessage *msg, void *data)
203 DBG("conn %p", conn);
205 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
208 if (__connman_security_check_privilege(msg,
209 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
210 return __connman_error_permission_denied(msg);
212 err = __connman_profile_remove(path);
214 return __connman_error_failed(msg, -err);
216 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
219 static DBusMessage *remove_provider(DBusConnection *conn,
220 DBusMessage *msg, void *data)
225 DBG("conn %p", conn);
227 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &path,
230 if (__connman_security_check_privilege(msg,
231 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
232 return __connman_error_permission_denied(msg);
234 err = __connman_provider_remove(path);
236 return __connman_error_failed(msg, -err);
238 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
241 static DBusMessage *request_scan(DBusConnection *conn,
242 DBusMessage *msg, void *data)
244 enum connman_service_type type;
248 DBG("conn %p", conn);
250 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
253 if (g_strcmp0(str, "") == 0)
254 type = CONNMAN_SERVICE_TYPE_UNKNOWN;
255 else if (g_strcmp0(str, "wifi") == 0)
256 type = CONNMAN_SERVICE_TYPE_WIFI;
257 else if (g_strcmp0(str, "wimax") == 0)
258 type = CONNMAN_SERVICE_TYPE_WIMAX;
260 return __connman_error_invalid_arguments(msg);
262 err = __connman_element_request_scan(type);
264 if (err == -EINPROGRESS) {
265 connman_error("Invalid return code from scan");
269 return __connman_error_failed(msg, -err);
272 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
275 static DBusConnection *connection = NULL;
277 static enum connman_service_type technology_type;
278 static connman_bool_t technology_enabled;
279 static DBusMessage *technology_pending = NULL;
280 static guint technology_timeout = 0;
282 static void technology_reply(int error)
286 if (technology_timeout > 0) {
287 g_source_remove(technology_timeout);
288 technology_timeout = 0;
291 if (technology_pending != NULL) {
295 reply = __connman_error_failed(technology_pending,
298 g_dbus_send_message(connection, reply);
300 g_dbus_send_reply(connection, technology_pending,
303 dbus_message_unref(technology_pending);
304 technology_pending = NULL;
307 technology_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
310 static gboolean technology_abort(gpointer user_data)
314 technology_timeout = 0;
316 technology_reply(ETIMEDOUT);
321 static void technology_notify(enum connman_service_type type,
322 connman_bool_t enabled)
324 DBG("type %d enabled %d", type, enabled);
326 if (type == technology_type && enabled == technology_enabled)
330 static struct connman_notifier technology_notifier = {
332 .priority = CONNMAN_NOTIFIER_PRIORITY_HIGH,
333 .service_enabled= technology_notify,
336 static DBusMessage *enable_technology(DBusConnection *conn,
337 DBusMessage *msg, void *data)
339 enum connman_service_type type;
343 DBG("conn %p", conn);
345 if (technology_pending != NULL)
346 return __connman_error_in_progress(msg);
348 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
351 if (g_strcmp0(str, "ethernet") == 0)
352 type = CONNMAN_SERVICE_TYPE_ETHERNET;
353 else if (g_strcmp0(str, "wifi") == 0)
354 type = CONNMAN_SERVICE_TYPE_WIFI;
355 else if (g_strcmp0(str, "wimax") == 0)
356 type = CONNMAN_SERVICE_TYPE_WIMAX;
357 else if (g_strcmp0(str, "bluetooth") == 0)
358 type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
359 else if (g_strcmp0(str, "cellular") == 0)
360 type = CONNMAN_SERVICE_TYPE_CELLULAR;
362 return __connman_error_invalid_arguments(msg);
364 if (__connman_notifier_is_registered(type) == FALSE)
365 return __connman_error_not_registered(msg);
367 if (__connman_notifier_is_enabled(type) == TRUE)
368 return __connman_error_already_enabled(msg);
370 technology_type = type;
371 technology_enabled = TRUE;
372 technology_pending = dbus_message_ref(msg);
374 err = __connman_element_enable_technology(type);
375 if (err < 0 && err != -EINPROGRESS)
376 technology_reply(-err);
378 technology_timeout = g_timeout_add_seconds(15,
379 technology_abort, NULL);
384 static DBusMessage *disable_technology(DBusConnection *conn,
385 DBusMessage *msg, void *data)
387 enum connman_service_type type;
391 DBG("conn %p", conn);
393 if (technology_pending != NULL)
394 return __connman_error_in_progress(msg);
396 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
399 if (g_strcmp0(str, "ethernet") == 0)
400 type = CONNMAN_SERVICE_TYPE_ETHERNET;
401 else if (g_strcmp0(str, "wifi") == 0)
402 type = CONNMAN_SERVICE_TYPE_WIFI;
403 else if (g_strcmp0(str, "wimax") == 0)
404 type = CONNMAN_SERVICE_TYPE_WIMAX;
405 else if (g_strcmp0(str, "bluetooth") == 0)
406 type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
407 else if (g_strcmp0(str, "cellular") == 0)
408 type = CONNMAN_SERVICE_TYPE_CELLULAR;
410 return __connman_error_invalid_arguments(msg);
412 if (__connman_notifier_is_registered(type) == FALSE)
413 return __connman_error_not_registered(msg);
415 if (__connman_notifier_is_enabled(type) == FALSE)
416 return __connman_error_already_disabled(msg);
418 technology_type = type;
419 technology_enabled = FALSE;
420 technology_pending = dbus_message_ref(msg);
422 err = __connman_element_disable_technology(type);
423 if (err < 0 && err != -EINPROGRESS)
424 technology_reply(-err);
426 technology_timeout = g_timeout_add_seconds(10,
427 technology_abort, NULL);
432 static DBusMessage *get_services(DBusConnection *conn,
433 DBusMessage *msg, void *data)
436 DBusMessageIter iter, array;
438 reply = dbus_message_new_method_return(msg);
442 dbus_message_iter_init_append(reply, &iter);
444 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
445 DBUS_STRUCT_BEGIN_CHAR_AS_STRING
446 DBUS_TYPE_OBJECT_PATH_AS_STRING
447 DBUS_TYPE_ARRAY_AS_STRING
448 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
449 DBUS_TYPE_STRING_AS_STRING
450 DBUS_TYPE_VARIANT_AS_STRING
451 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
452 DBUS_STRUCT_END_CHAR_AS_STRING, &array);
454 __connman_service_list_struct(&array);
456 dbus_message_iter_close_container(&iter, &array);
461 static DBusMessage *lookup_service(DBusConnection *conn,
462 DBusMessage *msg, void *data)
464 const char *pattern, *path;
467 DBG("conn %p", conn);
469 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern,
472 err = __connman_service_lookup(pattern, &path);
474 return __connman_error_failed(msg, -err);
476 return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &path,
480 static DBusMessage *connect_service(DBusConnection *conn,
481 DBusMessage *msg, void *data)
485 DBG("conn %p", conn);
487 if (__connman_security_check_privilege(msg,
488 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
489 return __connman_error_permission_denied(msg);
491 err = __connman_service_create_and_connect(msg);
493 if (err == -EINPROGRESS) {
494 connman_error("Invalid return code from connect");
498 return __connman_error_failed(msg, -err);
505 static DBusMessage *connect_provider(DBusConnection *conn,
506 DBusMessage *msg, void *data)
510 DBG("conn %p", conn);
512 if (__connman_security_check_privilege(msg,
513 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
514 return __connman_error_permission_denied(msg);
516 err = __connman_provider_create_and_connect(msg);
518 if (err == -EINPROGRESS) {
519 connman_error("Invalid return code from connect");
523 return __connman_error_failed(msg, -err);
529 static DBusMessage *register_agent(DBusConnection *conn,
530 DBusMessage *msg, void *data)
532 const char *sender, *path;
535 DBG("conn %p", conn);
537 sender = dbus_message_get_sender(msg);
539 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
542 err = __connman_agent_register(sender, path);
544 return __connman_error_failed(msg, -err);
546 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
549 static DBusMessage *unregister_agent(DBusConnection *conn,
550 DBusMessage *msg, void *data)
552 const char *sender, *path;
555 DBG("conn %p", conn);
557 sender = dbus_message_get_sender(msg);
559 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
562 err = __connman_agent_unregister(sender, path);
564 return __connman_error_failed(msg, -err);
566 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
569 static DBusMessage *register_counter(DBusConnection *conn,
570 DBusMessage *msg, void *data)
572 const char *sender, *path;
573 unsigned int accuracy, period;
576 DBG("conn %p", conn);
578 sender = dbus_message_get_sender(msg);
580 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
581 DBUS_TYPE_UINT32, &accuracy,
582 DBUS_TYPE_UINT32, &period,
585 /* FIXME: add handling of accuracy parameter */
587 err = __connman_counter_register(sender, path, period);
589 return __connman_error_failed(msg, -err);
591 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
594 static DBusMessage *unregister_counter(DBusConnection *conn,
595 DBusMessage *msg, void *data)
597 const char *sender, *path;
600 DBG("conn %p", conn);
602 sender = dbus_message_get_sender(msg);
604 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
607 err = __connman_counter_unregister(sender, path);
609 return __connman_error_failed(msg, -err);
611 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
614 static DBusMessage *request_session(DBusConnection *conn,
615 DBusMessage *msg, void *data)
617 const char *bearer, *sender, *service_path;
618 struct connman_service *service;
620 DBG("conn %p", conn);
622 sender = dbus_message_get_sender(msg);
624 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &bearer,
627 service = __connman_session_request(bearer, sender);
629 return __connman_error_failed(msg, EINVAL);
631 service_path = __connman_service_get_path(service);
633 return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &service_path,
637 static DBusMessage *release_session(DBusConnection *conn,
638 DBusMessage *msg, void *data)
643 DBG("conn %p", conn);
645 sender = dbus_message_get_sender(msg);
647 err = __connman_session_release(sender);
649 return __connman_error_failed(msg, -err);
651 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
654 static GDBusMethodTable manager_methods[] = {
655 { "GetProperties", "", "a{sv}", get_properties },
656 { "SetProperty", "sv", "", set_property },
657 { "GetState", "", "s", get_state },
658 { "CreateProfile", "s", "o", create_profile },
659 { "RemoveProfile", "o", "", remove_profile },
660 { "RemoveProvider", "s", "", remove_provider },
661 { "RequestScan", "s", "", request_scan },
662 { "EnableTechnology", "s", "", enable_technology,
663 G_DBUS_METHOD_FLAG_ASYNC },
664 { "DisableTechnology", "s", "", disable_technology,
665 G_DBUS_METHOD_FLAG_ASYNC },
666 { "GetServices", "", "a(oa{sv})", get_services },
667 { "LookupService", "s", "o", lookup_service, },
668 { "ConnectService", "a{sv}", "o", connect_service,
669 G_DBUS_METHOD_FLAG_ASYNC },
670 { "ConnectProvider", "a{sv}", "o", connect_provider,
671 G_DBUS_METHOD_FLAG_ASYNC },
672 { "RegisterAgent", "o", "", register_agent },
673 { "UnregisterAgent", "o", "", unregister_agent },
674 { "RegisterCounter", "ouu", "", register_counter },
675 { "UnregisterCounter", "o", "", unregister_counter },
676 { "RequestSession", "s", "o", request_session },
677 { "ReleaseSession", "s", "", release_session },
681 static GDBusSignalTable manager_signals[] = {
682 { "PropertyChanged", "sv" },
683 { "StateChanged", "s" },
687 static DBusMessage *nm_sleep(DBusConnection *conn,
688 DBusMessage *msg, void *data)
692 DBG("conn %p", conn);
694 reply = dbus_message_new_method_return(msg);
698 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
703 static DBusMessage *nm_wake(DBusConnection *conn,
704 DBusMessage *msg, void *data)
708 DBG("conn %p", conn);
710 reply = dbus_message_new_method_return(msg);
714 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
720 NM_STATE_UNKNOWN = 0,
724 NM_STATE_DISCONNECTED
727 static DBusMessage *nm_state(DBusConnection *conn,
728 DBusMessage *msg, void *data)
733 DBG("conn %p", conn);
735 reply = dbus_message_new_method_return(msg);
739 if (__connman_notifier_count_connected() > 0)
740 state = NM_STATE_CONNECTED;
742 state = NM_STATE_DISCONNECTED;
744 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &state,
750 static GDBusMethodTable nm_methods[] = {
751 { "sleep", "", "", nm_sleep },
752 { "wake", "", "", nm_wake },
753 { "state", "", "u", nm_state },
757 static gboolean nm_compat = FALSE;
759 int __connman_manager_init(gboolean compat)
763 connection = connman_dbus_get_connection();
764 if (connection == NULL)
767 if (connman_notifier_register(&technology_notifier) < 0)
768 connman_error("Failed to register technology notifier");
770 g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
771 CONNMAN_MANAGER_INTERFACE,
773 manager_signals, NULL, NULL, NULL);
775 if (compat == TRUE) {
776 g_dbus_register_interface(connection, NM_PATH, NM_INTERFACE,
777 nm_methods, NULL, NULL, NULL, NULL);
785 void __connman_manager_cleanup(void)
789 connman_notifier_unregister(&technology_notifier);
791 if (connection == NULL)
794 if (nm_compat == TRUE) {
795 g_dbus_unregister_interface(connection, NM_PATH, NM_INTERFACE);
798 g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
799 CONNMAN_MANAGER_INTERFACE);
801 dbus_connection_unref(connection);