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 void append_profiles(DBusMessageIter *dict)
32 DBusMessageIter entry, value, iter;
33 const char *key = "Profiles";
35 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
38 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
40 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
41 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
44 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
45 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
46 __connman_profile_list(&iter);
47 dbus_message_iter_close_container(&value, &iter);
49 dbus_message_iter_close_container(&entry, &value);
51 dbus_message_iter_close_container(dict, &entry);
54 static void append_services(DBusMessageIter *dict)
56 DBusMessageIter entry, value, iter;
57 const char *key = "Services";
59 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
62 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
64 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
65 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
68 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
69 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
70 __connman_service_list(&iter);
71 dbus_message_iter_close_container(&value, &iter);
73 dbus_message_iter_close_container(&entry, &value);
75 dbus_message_iter_close_container(dict, &entry);
79 static void append_providers(DBusMessageIter *dict)
81 DBusMessageIter entry, value, iter;
82 const char *key = "Providers";
84 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
87 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
89 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
90 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
93 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
94 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
95 __connman_provider_list(&iter);
96 dbus_message_iter_close_container(&value, &iter);
98 dbus_message_iter_close_container(&entry, &value);
100 dbus_message_iter_close_container(dict, &entry);
103 static void append_devices(DBusMessageIter *dict)
105 DBusMessageIter entry, value, iter;
106 const char *key = "Devices";
108 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
111 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
113 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
114 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
117 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
118 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
119 __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter);
120 dbus_message_iter_close_container(&value, &iter);
122 dbus_message_iter_close_container(&entry, &value);
124 dbus_message_iter_close_container(dict, &entry);
127 static void append_available_technologies(DBusMessageIter *dict)
129 DBusMessageIter entry, value, iter;
130 const char *key = "AvailableTechnologies";
132 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
135 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
137 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
138 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
141 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
142 DBUS_TYPE_STRING_AS_STRING, &iter);
143 __connman_notifier_list_registered(&iter);
144 dbus_message_iter_close_container(&value, &iter);
146 dbus_message_iter_close_container(&entry, &value);
148 dbus_message_iter_close_container(dict, &entry);
151 static void append_enabled_technologies(DBusMessageIter *dict)
153 DBusMessageIter entry, value, iter;
154 const char *key = "EnabledTechnologies";
156 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
159 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
161 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
162 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
165 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
166 DBUS_TYPE_STRING_AS_STRING, &iter);
167 __connman_notifier_list_enabled(&iter);
168 dbus_message_iter_close_container(&value, &iter);
170 dbus_message_iter_close_container(&entry, &value);
172 dbus_message_iter_close_container(dict, &entry);
175 static void append_connected_technologies(DBusMessageIter *dict)
177 DBusMessageIter entry, value, iter;
178 const char *key = "ConnectedTechnologies";
180 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
183 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
185 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
186 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
189 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
190 DBUS_TYPE_STRING_AS_STRING, &iter);
191 __connman_notifier_list_connected(&iter);
192 dbus_message_iter_close_container(&value, &iter);
194 dbus_message_iter_close_container(&entry, &value);
196 dbus_message_iter_close_container(dict, &entry);
199 static void append_available_debugs(DBusMessageIter *dict)
201 DBusMessageIter entry, value, iter;
202 const char *key = "AvailableDebugs";
204 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
207 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
209 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
210 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
213 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
214 DBUS_TYPE_STRING_AS_STRING, &iter);
215 __connman_debug_list_available(&iter);
216 dbus_message_iter_close_container(&value, &iter);
218 dbus_message_iter_close_container(&entry, &value);
220 dbus_message_iter_close_container(dict, &entry);
223 static void append_enabled_debugs(DBusMessageIter *dict)
225 DBusMessageIter entry, value, iter;
226 const char *key = "EnabledDebugs";
228 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
231 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
233 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
234 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING,
237 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
238 DBUS_TYPE_STRING_AS_STRING, &iter);
239 __connman_debug_list_enabled(&iter);
240 dbus_message_iter_close_container(&value, &iter);
242 dbus_message_iter_close_container(&entry, &value);
244 dbus_message_iter_close_container(dict, &entry);
247 static DBusMessage *get_properties(DBusConnection *conn,
248 DBusMessage *msg, void *data)
251 DBusMessageIter array, dict;
252 connman_bool_t offlinemode;
255 DBG("conn %p", conn);
257 if (__connman_security_check_privilege(msg,
258 CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
259 return __connman_error_permission_denied(msg);
261 reply = dbus_message_new_method_return(msg);
265 dbus_message_iter_init_append(reply, &array);
267 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
268 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
269 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
270 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
272 str = __connman_profile_active_path();
274 connman_dbus_dict_append_variant(&dict, "ActiveProfile",
275 DBUS_TYPE_OBJECT_PATH, &str);
277 append_profiles(&dict);
278 append_services(&dict);
279 append_providers(&dict);
281 append_devices(&dict);
283 if (__connman_element_count(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION) > 0)
288 connman_dbus_dict_append_variant(&dict, "State",
289 DBUS_TYPE_STRING, &str);
291 offlinemode = __connman_profile_get_offlinemode();
292 connman_dbus_dict_append_variant(&dict, "OfflineMode",
293 DBUS_TYPE_BOOLEAN, &offlinemode);
295 append_available_technologies(&dict);
296 append_enabled_technologies(&dict);
297 append_connected_technologies(&dict);
299 str = __connman_service_default();
301 connman_dbus_dict_append_variant(&dict, "DefaultTechnology",
302 DBUS_TYPE_STRING, &str);
304 append_available_debugs(&dict);
305 append_enabled_debugs(&dict);
307 dbus_message_iter_close_container(&array, &dict);
312 static DBusMessage *set_property(DBusConnection *conn,
313 DBusMessage *msg, void *data)
315 DBusMessageIter iter, value;
319 DBG("conn %p", conn);
321 if (dbus_message_iter_init(msg, &iter) == FALSE)
322 return __connman_error_invalid_arguments(msg);
324 dbus_message_iter_get_basic(&iter, &name);
325 dbus_message_iter_next(&iter);
326 dbus_message_iter_recurse(&iter, &value);
328 if (__connman_security_check_privilege(msg,
329 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
330 return __connman_error_permission_denied(msg);
332 type = dbus_message_iter_get_arg_type(&value);
334 if (g_str_equal(name, "OfflineMode") == TRUE) {
335 connman_bool_t offlinemode;
337 if (type != DBUS_TYPE_BOOLEAN)
338 return __connman_error_invalid_arguments(msg);
340 dbus_message_iter_get_basic(&value, &offlinemode);
342 __connman_profile_set_offlinemode(offlinemode);
344 __connman_profile_save_default();
345 } else if (g_str_equal(name, "ActiveProfile") == TRUE) {
348 dbus_message_iter_get_basic(&value, &str);
350 return __connman_error_not_supported(msg);
352 return __connman_error_invalid_property(msg);
354 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
357 static DBusMessage *get_state(DBusConnection *conn,
358 DBusMessage *msg, void *data)
362 DBG("conn %p", conn);
364 if (__connman_security_check_privilege(msg,
365 CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
366 return __connman_error_permission_denied(msg);
368 if (__connman_element_count(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION) > 0)
373 return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &str,
377 static DBusMessage *create_profile(DBusConnection *conn,
378 DBusMessage *msg, void *data)
380 const char *name, *path;
383 DBG("conn %p", conn);
385 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
388 if (__connman_security_check_privilege(msg,
389 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
390 return __connman_error_permission_denied(msg);
392 err = __connman_profile_create(name, &path);
394 return __connman_error_failed(msg, -err);
396 return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &path,
400 static DBusMessage *remove_profile(DBusConnection *conn,
401 DBusMessage *msg, void *data)
406 DBG("conn %p", conn);
408 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
411 if (__connman_security_check_privilege(msg,
412 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
413 return __connman_error_permission_denied(msg);
415 err = __connman_profile_remove(path);
417 return __connman_error_failed(msg, -err);
419 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
422 static DBusMessage *remove_provider(DBusConnection *conn,
423 DBusMessage *msg, void *data)
428 DBG("conn %p", conn);
430 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &path,
433 if (__connman_security_check_privilege(msg,
434 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
435 return __connman_error_permission_denied(msg);
437 err = __connman_provider_remove(path);
439 return __connman_error_failed(msg, -err);
441 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
444 static DBusMessage *request_scan(DBusConnection *conn,
445 DBusMessage *msg, void *data)
447 enum connman_service_type type;
451 DBG("conn %p", conn);
453 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
456 if (g_strcmp0(str, "") == 0)
457 type = CONNMAN_SERVICE_TYPE_UNKNOWN;
458 else if (g_strcmp0(str, "wifi") == 0)
459 type = CONNMAN_SERVICE_TYPE_WIFI;
460 else if (g_strcmp0(str, "wimax") == 0)
461 type = CONNMAN_SERVICE_TYPE_WIMAX;
463 return __connman_error_invalid_arguments(msg);
465 err = __connman_element_request_scan(type);
467 if (err == -EINPROGRESS) {
468 connman_error("Invalid return code from scan");
472 return __connman_error_failed(msg, -err);
475 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
478 static DBusConnection *connection = NULL;
480 static enum connman_service_type technology_type;
481 static connman_bool_t technology_enabled;
482 static DBusMessage *technology_pending = NULL;
483 static guint technology_timeout = 0;
485 static void technology_reply(int error)
489 if (technology_timeout > 0) {
490 g_source_remove(technology_timeout);
491 technology_timeout = 0;
494 if (technology_pending != NULL) {
498 reply = __connman_error_failed(technology_pending,
501 g_dbus_send_message(connection, reply);
503 g_dbus_send_reply(connection, technology_pending,
506 dbus_message_unref(technology_pending);
507 technology_pending = NULL;
510 technology_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
513 static gboolean technology_abort(gpointer user_data)
517 technology_timeout = 0;
519 technology_reply(ETIMEDOUT);
524 static void technology_notify(enum connman_service_type type,
525 connman_bool_t enabled)
527 DBG("type %d enabled %d", type, enabled);
529 if (type == technology_type && enabled == technology_enabled)
533 static struct connman_notifier technology_notifier = {
535 .priority = CONNMAN_NOTIFIER_PRIORITY_HIGH,
536 .service_enabled= technology_notify,
539 static DBusMessage *enable_technology(DBusConnection *conn,
540 DBusMessage *msg, void *data)
542 enum connman_service_type type;
546 DBG("conn %p", conn);
548 if (technology_pending != NULL)
549 return __connman_error_in_progress(msg);
551 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
554 if (g_strcmp0(str, "ethernet") == 0)
555 type = CONNMAN_SERVICE_TYPE_ETHERNET;
556 else if (g_strcmp0(str, "wifi") == 0)
557 type = CONNMAN_SERVICE_TYPE_WIFI;
558 else if (g_strcmp0(str, "wimax") == 0)
559 type = CONNMAN_SERVICE_TYPE_WIMAX;
560 else if (g_strcmp0(str, "bluetooth") == 0)
561 type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
562 else if (g_strcmp0(str, "cellular") == 0)
563 type = CONNMAN_SERVICE_TYPE_CELLULAR;
565 return __connman_error_invalid_arguments(msg);
567 if (__connman_notifier_is_enabled(type) == TRUE)
568 return __connman_error_already_enabled(msg);
570 technology_type = type;
571 technology_enabled = TRUE;
572 technology_pending = dbus_message_ref(msg);
574 err = __connman_element_enable_technology(type);
575 if (err < 0 && err != -EINPROGRESS)
576 technology_reply(-err);
578 technology_timeout = g_timeout_add_seconds(15,
579 technology_abort, NULL);
584 static DBusMessage *disable_technology(DBusConnection *conn,
585 DBusMessage *msg, void *data)
587 enum connman_service_type type;
591 DBG("conn %p", conn);
593 if (technology_pending != NULL)
594 return __connman_error_in_progress(msg);
596 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
599 if (g_strcmp0(str, "ethernet") == 0)
600 type = CONNMAN_SERVICE_TYPE_ETHERNET;
601 else if (g_strcmp0(str, "wifi") == 0)
602 type = CONNMAN_SERVICE_TYPE_WIFI;
603 else if (g_strcmp0(str, "wimax") == 0)
604 type = CONNMAN_SERVICE_TYPE_WIMAX;
605 else if (g_strcmp0(str, "bluetooth") == 0)
606 type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
607 else if (g_strcmp0(str, "cellular") == 0)
608 type = CONNMAN_SERVICE_TYPE_CELLULAR;
610 return __connman_error_invalid_arguments(msg);
612 if (__connman_notifier_is_enabled(type) == FALSE)
613 return __connman_error_already_disabled(msg);
615 technology_type = type;
616 technology_enabled = FALSE;
617 technology_pending = dbus_message_ref(msg);
619 err = __connman_element_disable_technology(type);
620 if (err < 0 && err != -EINPROGRESS)
621 technology_reply(-err);
623 technology_timeout = g_timeout_add_seconds(10,
624 technology_abort, NULL);
629 static DBusMessage *connect_service(DBusConnection *conn,
630 DBusMessage *msg, void *data)
634 DBG("conn %p", conn);
636 if (__connman_security_check_privilege(msg,
637 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
638 return __connman_error_permission_denied(msg);
640 err = __connman_service_create_and_connect(msg);
642 if (err == -EINPROGRESS) {
643 connman_error("Invalid return code from connect");
647 return __connman_error_failed(msg, -err);
654 static DBusMessage *connect_provider(DBusConnection *conn,
655 DBusMessage *msg, void *data)
659 DBG("conn %p", conn);
661 if (__connman_security_check_privilege(msg,
662 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
663 return __connman_error_permission_denied(msg);
665 err = __connman_provider_create_and_connect(msg);
667 if (err == -EINPROGRESS) {
668 connman_error("Invalid return code from connect");
672 return __connman_error_failed(msg, -err);
678 static DBusMessage *register_agent(DBusConnection *conn,
679 DBusMessage *msg, void *data)
681 const char *sender, *path;
684 DBG("conn %p", conn);
686 sender = dbus_message_get_sender(msg);
688 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
691 err = __connman_agent_register(sender, path);
693 return __connman_error_failed(msg, -err);
695 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
698 static DBusMessage *unregister_agent(DBusConnection *conn,
699 DBusMessage *msg, void *data)
701 const char *sender, *path;
704 DBG("conn %p", conn);
706 sender = dbus_message_get_sender(msg);
708 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
711 err = __connman_agent_unregister(sender, path);
713 return __connman_error_failed(msg, -err);
715 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
718 static GDBusMethodTable manager_methods[] = {
719 { "GetProperties", "", "a{sv}", get_properties },
720 { "SetProperty", "sv", "", set_property },
721 { "GetState", "", "s", get_state },
722 { "CreateProfile", "s", "o", create_profile },
723 { "RemoveProfile", "o", "", remove_profile },
724 { "RemoveProvider", "s", "", remove_provider },
725 { "RequestScan", "s", "", request_scan },
726 { "EnableTechnology", "s", "", enable_technology,
727 G_DBUS_METHOD_FLAG_ASYNC },
728 { "DisableTechnology", "s", "", disable_technology,
729 G_DBUS_METHOD_FLAG_ASYNC },
730 { "ConnectService", "a{sv}", "o", connect_service,
731 G_DBUS_METHOD_FLAG_ASYNC },
732 { "ConnectProvider", "a{sv}", "o", connect_provider,
733 G_DBUS_METHOD_FLAG_ASYNC },
734 { "RegisterAgent", "o", "", register_agent },
735 { "UnregisterAgent", "o", "", unregister_agent },
739 static GDBusSignalTable manager_signals[] = {
740 { "PropertyChanged", "sv" },
741 { "StateChanged", "s" },
745 static DBusMessage *nm_sleep(DBusConnection *conn,
746 DBusMessage *msg, void *data)
750 DBG("conn %p", conn);
752 reply = dbus_message_new_method_return(msg);
756 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
761 static DBusMessage *nm_wake(DBusConnection *conn,
762 DBusMessage *msg, void *data)
766 DBG("conn %p", conn);
768 reply = dbus_message_new_method_return(msg);
772 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
778 NM_STATE_UNKNOWN = 0,
782 NM_STATE_DISCONNECTED
785 static DBusMessage *nm_state(DBusConnection *conn,
786 DBusMessage *msg, void *data)
791 DBG("conn %p", conn);
793 reply = dbus_message_new_method_return(msg);
797 if (__connman_element_count(NULL, CONNMAN_ELEMENT_TYPE_CONNECTION) > 0)
798 state = NM_STATE_CONNECTED;
800 state = NM_STATE_DISCONNECTED;
802 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &state,
808 static GDBusMethodTable nm_methods[] = {
809 { "sleep", "", "", nm_sleep },
810 { "wake", "", "", nm_wake },
811 { "state", "", "u", nm_state },
815 static gboolean nm_compat = FALSE;
817 int __connman_manager_init(gboolean compat)
821 connection = connman_dbus_get_connection();
822 if (connection == NULL)
825 if (connman_notifier_register(&technology_notifier) < 0)
826 connman_error("Failed to register technology notifier");
828 g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
829 CONNMAN_MANAGER_INTERFACE,
831 manager_signals, NULL, NULL, NULL);
833 if (compat == TRUE) {
834 g_dbus_register_interface(connection, NM_PATH, NM_INTERFACE,
835 nm_methods, NULL, NULL, NULL, NULL);
843 void __connman_manager_cleanup(void)
847 connman_notifier_unregister(&technology_notifier);
849 if (connection == NULL)
852 if (nm_compat == TRUE) {
853 g_dbus_unregister_interface(connection, NM_PATH, NM_INTERFACE);
856 g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
857 CONNMAN_MANAGER_INTERFACE);
859 dbus_connection_unref(connection);