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
33 static DBusConnection *connection = NULL;
35 struct connman_device {
36 struct connman_element element;
37 enum connman_device_type type;
38 enum connman_device_mode mode;
39 connman_bool_t secondary;
40 connman_bool_t powered;
41 connman_bool_t carrier;
42 connman_bool_t scanning;
43 connman_bool_t disconnected;
44 connman_uint16_t scan_interval;
51 unsigned int connections;
53 struct connman_ipconfig *ipconfig;
55 struct connman_device_driver *driver;
58 connman_bool_t registered;
61 struct connman_network *network;
68 static gboolean device_scan_trigger(gpointer user_data)
70 struct connman_device *device = user_data;
72 DBG("device %p", device);
74 if (device->driver == NULL) {
75 device->scan_timeout = 0;
79 if (device->driver->scan)
80 device->driver->scan(device);
85 static const char *type2description(enum connman_device_type type)
88 case CONNMAN_DEVICE_TYPE_UNKNOWN:
89 case CONNMAN_DEVICE_TYPE_VENDOR:
91 case CONNMAN_DEVICE_TYPE_ETHERNET:
93 case CONNMAN_DEVICE_TYPE_WIFI:
95 case CONNMAN_DEVICE_TYPE_WIMAX:
97 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
99 case CONNMAN_DEVICE_TYPE_GPS:
101 case CONNMAN_DEVICE_TYPE_MBM:
102 case CONNMAN_DEVICE_TYPE_HSO:
103 case CONNMAN_DEVICE_TYPE_NOZOMI:
104 case CONNMAN_DEVICE_TYPE_HUAWEI:
105 case CONNMAN_DEVICE_TYPE_NOVATEL:
112 static const char *type2string(enum connman_device_type type)
115 case CONNMAN_DEVICE_TYPE_UNKNOWN:
116 case CONNMAN_DEVICE_TYPE_VENDOR:
118 case CONNMAN_DEVICE_TYPE_ETHERNET:
120 case CONNMAN_DEVICE_TYPE_WIFI:
122 case CONNMAN_DEVICE_TYPE_WIMAX:
124 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
126 case CONNMAN_DEVICE_TYPE_GPS:
128 case CONNMAN_DEVICE_TYPE_MBM:
129 case CONNMAN_DEVICE_TYPE_HSO:
130 case CONNMAN_DEVICE_TYPE_HUAWEI:
131 case CONNMAN_DEVICE_TYPE_NOZOMI:
132 case CONNMAN_DEVICE_TYPE_NOVATEL:
139 static int set_connected(struct connman_device *device,
140 connman_bool_t connected)
142 if (connected == TRUE) {
143 enum connman_element_type type = CONNMAN_ELEMENT_TYPE_UNKNOWN;
144 struct connman_element *element;
146 device->disconnected = TRUE;
148 switch (device->element.ipv4.method) {
149 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
150 case CONNMAN_IPCONFIG_METHOD_OFF:
152 case CONNMAN_IPCONFIG_METHOD_STATIC:
153 type = CONNMAN_ELEMENT_TYPE_IPV4;
155 case CONNMAN_IPCONFIG_METHOD_DHCP:
156 type = CONNMAN_ELEMENT_TYPE_DHCP;
160 element = connman_element_create(NULL);
161 if (element != NULL) {
162 struct connman_service *service;
164 element->type = type;
165 element->index = device->element.index;
167 if (connman_element_register(element,
168 &device->element) < 0)
169 connman_element_unref(element);
171 device->disconnected = FALSE;
173 service = __connman_service_lookup_from_device(device);
174 __connman_service_indicate_state(service,
175 CONNMAN_SERVICE_STATE_CONFIGURATION);
178 struct connman_service *service;
180 connman_element_unregister_children(&device->element);
182 device->disconnected = TRUE;
184 service = __connman_service_lookup_from_device(device);
185 __connman_service_indicate_state(service,
186 CONNMAN_SERVICE_STATE_IDLE);
192 static int set_carrier(struct connman_device *device, connman_bool_t carrier)
194 struct connman_service *service;
197 __connman_profile_add_device(device);
199 __connman_profile_remove_device(device);
201 service = __connman_service_lookup_from_device(device);
202 __connman_service_set_carrier(service, carrier);
204 return set_connected(device, carrier);
207 static int powered_changed(struct connman_device *device)
210 DBusMessageIter entry, value;
211 const char *key = "Powered";
213 signal = dbus_message_new_signal(device->element.path,
214 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
218 dbus_message_iter_init_append(signal, &entry);
220 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
222 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
223 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
224 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN,
226 dbus_message_iter_close_container(&entry, &value);
228 g_dbus_send_message(connection, signal);
233 static int set_powered(struct connman_device *device, connman_bool_t powered)
235 struct connman_device_driver *driver = device->driver;
238 DBG("device %p powered %d", device, powered);
240 if (device->powered == powered)
246 if (powered == TRUE) {
247 if (driver->enable) {
248 err = driver->enable(device);
249 __connman_notifier_device_type_increase(device->type);
253 g_hash_table_remove_all(device->networks);
255 set_carrier(device, FALSE);
257 if (driver->disable) {
258 err = driver->disable(device);
259 __connman_notifier_device_type_decrease(device->type);
265 device->powered = powered;
266 powered_changed(device);
272 static void append_path(gpointer key, gpointer value, gpointer user_data)
274 struct connman_element *element = value;
275 DBusMessageIter *iter = user_data;
277 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
281 static void append_networks(struct connman_device *device,
282 DBusMessageIter *entry)
284 DBusMessageIter value, iter;
285 const char *key = "Networks";
287 dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
289 dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
290 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
293 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
294 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
295 g_hash_table_foreach(device->networks, append_path, &iter);
296 dbus_message_iter_close_container(&value, &iter);
298 dbus_message_iter_close_container(entry, &value);
301 static DBusMessage *get_properties(DBusConnection *conn,
302 DBusMessage *msg, void *data)
304 struct connman_device *device = data;
306 DBusMessageIter array, dict, entry;
309 DBG("conn %p", conn);
311 if (__connman_security_check_privilege(msg,
312 CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
313 return __connman_error_permission_denied(msg);
315 reply = dbus_message_new_method_return(msg);
319 dbus_message_iter_init_append(reply, &array);
321 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
322 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
323 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
324 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
326 if (device->name != NULL)
327 connman_dbus_dict_append_variant(&dict, "Name",
328 DBUS_TYPE_STRING, &device->name);
330 str = type2string(device->type);
332 connman_dbus_dict_append_variant(&dict, "Type",
333 DBUS_TYPE_STRING, &str);
335 if (device->address != NULL)
336 connman_dbus_dict_append_variant(&dict, "Address",
337 DBUS_TYPE_STRING, &device->address);
339 if (device->interface != NULL)
340 connman_dbus_dict_append_variant(&dict, "Interface",
341 DBUS_TYPE_STRING, &device->interface);
343 connman_dbus_dict_append_variant(&dict, "Powered",
344 DBUS_TYPE_BOOLEAN, &device->powered);
346 if (device->driver && device->driver->scan)
347 connman_dbus_dict_append_variant(&dict, "Scanning",
348 DBUS_TYPE_BOOLEAN, &device->scanning);
350 switch (device->mode) {
351 case CONNMAN_DEVICE_MODE_UNKNOWN:
353 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
354 __connman_element_append_ipv4(&device->element, &dict);
356 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
357 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
358 if (device->scan_interval > 0)
359 connman_dbus_dict_append_variant(&dict, "ScanInterval",
360 DBUS_TYPE_UINT16, &device->scan_interval);
362 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
364 append_networks(device, &entry);
365 dbus_message_iter_close_container(&dict, &entry);
369 dbus_message_iter_close_container(&array, &dict);
374 static gboolean powered_timeout(gpointer user_data)
376 struct connman_device *device = user_data;
378 DBG("device %p", device);
382 if (device->pending != NULL) {
385 reply = __connman_error_operation_timeout(device->pending);
387 g_dbus_send_message(connection, reply);
389 dbus_message_unref(device->pending);
390 device->pending = NULL;
396 static DBusMessage *set_property(DBusConnection *conn,
397 DBusMessage *msg, void *data)
399 struct connman_device *device = data;
400 DBusMessageIter iter, value;
404 DBG("conn %p", conn);
406 if (dbus_message_iter_init(msg, &iter) == FALSE)
407 return __connman_error_invalid_arguments(msg);
409 dbus_message_iter_get_basic(&iter, &name);
410 dbus_message_iter_next(&iter);
411 dbus_message_iter_recurse(&iter, &value);
413 if (__connman_security_check_privilege(msg,
414 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
415 return __connman_error_permission_denied(msg);
417 type = dbus_message_iter_get_arg_type(&value);
419 if (g_str_equal(name, "Powered") == TRUE) {
420 connman_bool_t powered;
423 if (type != DBUS_TYPE_BOOLEAN)
424 return __connman_error_invalid_arguments(msg);
426 dbus_message_iter_get_basic(&value, &powered);
428 if (device->powered == powered)
429 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
431 if (device->pending != NULL)
432 return __connman_error_in_progress(msg);
434 err = set_powered(device, powered);
436 if (err != -EINPROGRESS)
437 return __connman_error_failed(msg, -err);
439 device->pending = dbus_message_ref(msg);
441 device->timeout = g_timeout_add_seconds(15,
442 powered_timeout, device);
446 } else if (g_str_equal(name, "ScanInterval") == TRUE) {
447 connman_uint16_t interval;
449 switch (device->mode) {
450 case CONNMAN_DEVICE_MODE_UNKNOWN:
451 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
452 return __connman_error_invalid_arguments(msg);
453 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
454 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
458 if (type != DBUS_TYPE_UINT16)
459 return __connman_error_invalid_arguments(msg);
461 dbus_message_iter_get_basic(&value, &interval);
463 device->scan_interval = interval;
465 if (device->scan_timeout > 0) {
466 g_source_remove(device->scan_timeout);
467 device->scan_timeout = 0;
470 if (device->scan_interval > 0) {
471 guint interval = device->scan_interval;
472 device->scan_timeout = g_timeout_add_seconds(interval,
473 device_scan_trigger, device);
475 } else if (g_str_has_prefix(name, "IPv4.") == TRUE) {
478 switch (device->mode) {
479 case CONNMAN_DEVICE_MODE_UNKNOWN:
480 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
481 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
482 return __connman_error_invalid_arguments(msg);
483 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
487 err = __connman_ipconfig_set_ipv4(device->ipconfig,
490 return __connman_error_failed(msg, -err);
492 return __connman_error_invalid_property(msg);
494 __connman_storage_save_device(device);
496 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
499 static char *build_group(const unsigned char *ssid, unsigned int ssid_len,
500 const char *mode, const char *security)
505 str = g_string_sized_new((ssid_len * 2) + 24);
509 if (ssid_len > 0 && ssid[0] != '\0') {
510 for (i = 0; i < ssid_len; i++)
511 g_string_append_printf(str, "%02x", ssid[i]);
514 g_string_append_printf(str, "_%s_%s", mode, security);
516 return g_string_free(str, FALSE);
519 static void convert_name(const char *ssid, char *name,
520 unsigned int ssid_len)
524 for (i = 0; i < ssid_len; i++) {
525 if (g_ascii_isprint(ssid[i]))
532 static struct connman_network *find_network(struct connman_device *device,
533 const void *ssid, const char *address,
534 const char *security, const char *mode)
536 GHashTableIter network_iter;
542 g_hash_table_iter_init(&network_iter, device->networks);
543 while (g_hash_table_iter_next(&network_iter, &key, &value) == TRUE) {
544 const void *tmp_ssid;
545 const char *tmp_security, *tmp_mode, *tmp_address;
546 unsigned int tmp_ssid_size;
548 tmp_ssid = connman_network_get_blob(value, "WiFi.SSID",
550 tmp_security = connman_network_get_string(value,
552 tmp_mode = connman_network_get_string(value, "WiFi.Mode");
553 tmp_address = connman_network_get_string(value, "Address");
555 if (tmp_ssid_size < 1)
558 if (tmp_ssid && memcmp(ssid, tmp_ssid, tmp_ssid_size))
561 if (security && tmp_security &&
562 g_strcmp0(security, tmp_security) != 0)
565 if (mode && tmp_mode && g_strcmp0(mode, tmp_mode) != 0)
568 if (address && tmp_address &&
569 g_strcmp0(address, tmp_address) != 0)
572 return connman_network_ref(value);
578 static DBusMessage *join_network(DBusConnection *conn,
579 DBusMessage *msg, void *data)
581 struct connman_device *device = data;
582 struct connman_network *network, *found_network;
583 enum connman_network_type type;
584 unsigned int ssid_size;
585 const char *group, *mode, *security, *address;
587 DBusMessageIter iter, array;
590 DBG("conn %p", conn);
592 if (__connman_security_check_privilege(msg,
593 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
594 return __connman_error_permission_denied(msg);
596 if (!device->driver || !device->driver->join)
597 return __connman_error_not_supported(msg);
599 dbus_message_iter_init(msg, &iter);
600 dbus_message_iter_recurse(&iter, &array);
602 switch (device->type) {
603 case CONNMAN_DEVICE_TYPE_WIFI:
604 type = CONNMAN_NETWORK_TYPE_WIFI;
607 return __connman_error_not_supported(msg);
610 network = connman_network_create("00_00_00_00_00_00", type);
612 return __connman_error_failed(msg, ENOMEM);
614 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
615 DBusMessageIter entry, value;
616 const char *key, *str;
618 dbus_message_iter_recurse(&array, &entry);
619 dbus_message_iter_get_basic(&entry, &key);
621 dbus_message_iter_next(&entry);
622 dbus_message_iter_recurse(&entry, &value);
624 switch (dbus_message_iter_get_arg_type(&value)) {
625 case DBUS_TYPE_STRING:
626 dbus_message_iter_get_basic(&value, &str);
627 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
630 connman_network_set_blob(network, key,
632 name = g_try_malloc0(strlen(str) + 1);
634 return __connman_error_failed(msg,
637 convert_name((char *) str, name, strlen(str));
638 connman_network_set_name(network, name);
642 connman_network_set_string(network, key, str);
646 dbus_message_iter_next(&array);
649 ssid = connman_network_get_blob(network, "WiFi.SSID", &ssid_size);
650 security = connman_network_get_string(network, "WiFi.Security");
651 mode = connman_network_get_string(network, "WiFi.Mode");
652 address = connman_network_get_string(network, "Address");
654 found_network = find_network(device, ssid, address, security, mode);
655 if (found_network != NULL) {
656 const char* passphrase;
658 passphrase = connman_network_get_string(network,
660 if (passphrase != NULL)
661 connman_network_set_string(found_network,
664 connman_network_unref(network);
665 network = found_network;
667 err = __connman_network_connect(found_network);
669 connman_network_unref(found_network);
672 return __connman_error_failed(msg, -err);
674 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
677 group = build_group(ssid, ssid_size, mode, security);
679 index = connman_device_get_index(device);
680 connman_network_set_index(network, index);
682 connman_network_set_protocol(network, CONNMAN_NETWORK_PROTOCOL_IP);
684 if (connman_device_get_disconnected(device) == FALSE)
685 __connman_device_disconnect(device);
687 err = device->driver->join(device, network);
689 connman_network_unref(network);
692 return __connman_error_failed(msg, -err);
694 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
697 static DBusMessage *create_network(DBusConnection *conn,
698 DBusMessage *msg, void *data)
700 DBG("conn %p", conn);
702 if (__connman_security_check_privilege(msg,
703 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
704 return __connman_error_permission_denied(msg);
706 return __connman_error_invalid_arguments(msg);
709 static DBusMessage *remove_network(DBusConnection *conn,
710 DBusMessage *msg, void *data)
712 DBG("conn %p", conn);
714 if (__connman_security_check_privilege(msg,
715 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
716 return __connman_error_permission_denied(msg);
718 return __connman_error_invalid_arguments(msg);
721 static DBusMessage *propose_scan(DBusConnection *conn,
722 DBusMessage *msg, void *data)
724 struct connman_device *device = data;
727 DBG("conn %p", conn);
729 switch (device->mode) {
730 case CONNMAN_DEVICE_MODE_UNKNOWN:
731 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
732 return __connman_error_not_supported(msg);
733 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
734 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
738 if (!device->driver || !device->driver->scan)
739 return __connman_error_not_supported(msg);
741 if (device->powered == FALSE)
742 return __connman_error_failed(msg, EINVAL);
744 err = device->driver->scan(device);
746 return __connman_error_failed(msg, -err);
748 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
751 static GDBusMethodTable device_methods[] = {
752 { "GetProperties", "", "a{sv}", get_properties },
753 { "SetProperty", "sv", "", set_property,
754 G_DBUS_METHOD_FLAG_ASYNC },
755 { "JoinNetwork", "a{sv}", "", join_network },
756 { "CreateNetwork", "a{sv}", "o", create_network },
757 { "RemoveNetwork", "o", "", remove_network },
758 { "ProposeScan", "", "", propose_scan },
762 static GDBusSignalTable device_signals[] = {
763 { "PropertyChanged", "sv" },
767 static void append_devices(DBusMessageIter *entry)
769 DBusMessageIter value, iter;
770 const char *key = "Devices";
772 dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
774 dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
775 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
778 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
779 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
780 __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter);
781 dbus_message_iter_close_container(&value, &iter);
783 dbus_message_iter_close_container(entry, &value);
786 static void emit_devices_signal(void)
789 DBusMessageIter entry;
791 signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
792 CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
796 dbus_message_iter_init_append(signal, &entry);
798 append_devices(&entry);
800 g_dbus_send_message(connection, signal);
803 static int register_interface(struct connman_element *element)
805 struct connman_device *device = element->device;
807 DBG("element %p name %s", element, element->name);
809 if (g_dbus_register_interface(connection, element->path,
810 CONNMAN_DEVICE_INTERFACE,
811 device_methods, device_signals,
812 NULL, device, NULL) == FALSE) {
813 connman_error("Failed to register %s device", element->path);
817 device->registered = TRUE;
819 emit_devices_signal();
824 static void unregister_interface(struct connman_element *element)
826 struct connman_device *device = element->device;
828 DBG("element %p name %s", element, element->name);
830 device->registered = FALSE;
832 emit_devices_signal();
834 g_dbus_unregister_interface(connection, element->path,
835 CONNMAN_DEVICE_INTERFACE);
838 static void device_enable(struct connman_device *device)
840 DBG("device %p", device);
842 if (device->powered == TRUE)
845 if (device->driver->enable) {
846 if (device->driver->enable(device) == 0)
847 device->powered = TRUE;
848 __connman_notifier_device_type_increase(device->type);
852 static void device_disable(struct connman_device *device)
854 DBG("device %p", device);
856 if (device->powered == FALSE)
859 g_hash_table_remove_all(device->networks);
861 if (device->driver->disable) {
862 if (device->driver->disable(device) == 0)
863 device->powered = FALSE;
864 __connman_notifier_device_type_decrease(device->type);
868 static int setup_device(struct connman_device *device)
872 DBG("device %p", device);
874 err = register_interface(&device->element);
876 if (device->driver->remove)
877 device->driver->remove(device);
878 device->driver = NULL;
882 switch (device->mode) {
883 case CONNMAN_DEVICE_MODE_UNKNOWN:
884 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
885 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
887 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
888 if (device->carrier == TRUE && device->secondary == FALSE)
889 __connman_profile_add_device(device);
893 device_enable(device);
898 static void probe_driver(struct connman_element *element, gpointer user_data)
900 struct connman_device_driver *driver = user_data;
902 DBG("element %p name %s", element, element->name);
904 if (element->device == NULL)
907 if (element->device->driver != NULL)
910 if (driver->type != element->device->type)
913 if (driver->probe(element->device) < 0)
916 element->device->driver = driver;
918 setup_device(element->device);
921 static void remove_device(struct connman_device *device)
923 DBG("device %p", device);
925 device_disable(device);
927 switch (device->mode) {
928 case CONNMAN_DEVICE_MODE_UNKNOWN:
929 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
930 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
932 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
933 if (device->secondary == FALSE)
934 __connman_profile_remove_device(device);
938 unregister_interface(&device->element);
940 if (device->driver->remove)
941 device->driver->remove(device);
943 device->driver = NULL;
946 static void remove_driver(struct connman_element *element, gpointer user_data)
948 struct connman_device_driver *driver = user_data;
950 DBG("element %p name %s", element, element->name);
952 if (element->device == NULL)
955 if (element->device->driver == driver)
956 remove_device(element->device);
959 connman_bool_t __connman_device_has_driver(struct connman_device *device)
961 if (device == NULL || device->driver == NULL)
964 return device->registered;
967 static GSList *driver_list = NULL;
969 static gint compare_priority(gconstpointer a, gconstpointer b)
971 const struct connman_device_driver *driver1 = a;
972 const struct connman_device_driver *driver2 = b;
974 return driver2->priority - driver1->priority;
978 * connman_device_driver_register:
979 * @driver: device driver definition
981 * Register a new device driver
983 * Returns: %0 on success
985 int connman_device_driver_register(struct connman_device_driver *driver)
987 DBG("driver %p name %s", driver, driver->name);
989 driver_list = g_slist_insert_sorted(driver_list, driver,
992 __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
993 probe_driver, driver);
999 * connman_device_driver_unregister:
1000 * @driver: device driver definition
1002 * Remove a previously registered device driver
1004 void connman_device_driver_unregister(struct connman_device_driver *driver)
1006 DBG("driver %p name %s", driver, driver->name);
1008 driver_list = g_slist_remove(driver_list, driver);
1010 __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
1011 remove_driver, driver);
1014 static void unregister_network(gpointer data)
1016 struct connman_network *network = data;
1018 DBG("network %p", network);
1020 connman_element_unregister((struct connman_element *) network);
1022 connman_network_unref(network);
1025 static void device_destruct(struct connman_element *element)
1027 struct connman_device *device = element->device;
1029 DBG("element %p name %s", element, element->name);
1031 if (device->timeout > 0) {
1032 g_source_remove(device->timeout);
1033 device->timeout = 0;
1036 if (device->pending != NULL) {
1037 dbus_message_unref(device->pending);
1038 device->pending = NULL;
1041 g_free(device->ident);
1042 g_free(device->node);
1043 g_free(device->name);
1044 g_free(device->address);
1045 g_free(device->control);
1046 g_free(device->interface);
1048 connman_ipconfig_unref(device->ipconfig);
1050 g_free(device->last_network);
1052 g_hash_table_destroy(device->networks);
1053 device->networks = NULL;
1057 * connman_device_create:
1058 * @node: device node name (for example an address)
1059 * @type: device type
1061 * Allocate a new device of given #type and assign the #node name to it.
1063 * Returns: a newly-allocated #connman_device structure
1065 struct connman_device *connman_device_create(const char *node,
1066 enum connman_device_type type)
1068 struct connman_device *device;
1071 DBG("node %s type %d", node, type);
1073 device = g_try_new0(struct connman_device, 1);
1077 DBG("device %p", device);
1079 __connman_element_initialize(&device->element);
1081 device->element.name = g_strdup(node);
1082 device->element.type = CONNMAN_ELEMENT_TYPE_DEVICE;
1084 device->element.device = device;
1085 device->element.destruct = device_destruct;
1087 str = type2string(type);
1089 connman_element_set_string(&device->element,
1090 CONNMAN_PROPERTY_ID_TYPE, str);
1092 device->element.ipv4.method = CONNMAN_IPCONFIG_METHOD_DHCP;
1094 device->type = type;
1095 device->name = g_strdup(type2description(device->type));
1096 device->mode = CONNMAN_DEVICE_MODE_UNKNOWN;
1097 device->secondary = FALSE;
1100 case CONNMAN_DEVICE_TYPE_UNKNOWN:
1101 case CONNMAN_DEVICE_TYPE_VENDOR:
1102 device->scan_interval = 0;
1104 case CONNMAN_DEVICE_TYPE_ETHERNET:
1105 case CONNMAN_DEVICE_TYPE_WIFI:
1106 device->scan_interval = 300;
1108 case CONNMAN_DEVICE_TYPE_WIMAX:
1109 device->scan_interval = 0;
1111 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
1112 device->scan_interval = 0;
1114 case CONNMAN_DEVICE_TYPE_GPS:
1115 device->scan_interval = 0;
1117 case CONNMAN_DEVICE_TYPE_MBM:
1118 case CONNMAN_DEVICE_TYPE_HSO:
1119 case CONNMAN_DEVICE_TYPE_NOZOMI:
1120 case CONNMAN_DEVICE_TYPE_HUAWEI:
1121 case CONNMAN_DEVICE_TYPE_NOVATEL:
1122 device->scan_interval = 0;
1126 device->ipconfig = connman_ipconfig_create();
1127 if (device->ipconfig == NULL) {
1128 connman_device_unref(device);
1132 device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
1133 g_free, unregister_network);
1139 * connman_device_ref:
1140 * @device: device structure
1142 * Increase reference counter of device
1144 struct connman_device *connman_device_ref(struct connman_device *device)
1146 if (connman_element_ref(&device->element) == NULL)
1153 * connman_device_unref:
1154 * @device: device structure
1156 * Decrease reference counter of device
1158 void connman_device_unref(struct connman_device *device)
1160 connman_element_unref(&device->element);
1163 const char *__connman_device_get_type(struct connman_device *device)
1165 return type2string(device->type);
1169 * connman_device_get_type:
1170 * @device: device structure
1172 * Get type of device
1174 enum connman_device_type connman_device_get_type(struct connman_device *device)
1176 return device->type;
1180 * connman_device_get_name:
1181 * @device: device structure
1183 * Get unique name of device
1185 const char *connman_device_get_name(struct connman_device *device)
1187 return device->element.name;
1191 * connman_device_get_path:
1192 * @device: device structure
1194 * Get path name of device
1196 const char *connman_device_get_path(struct connman_device *device)
1198 return device->element.path;
1202 * connman_device_set_index:
1203 * @device: device structure
1204 * @index: index number
1206 * Set index number of device
1208 void connman_device_set_index(struct connman_device *device, int index)
1210 device->element.index = index;
1214 * connman_device_get_index:
1215 * @device: device structure
1217 * Get index number of device
1219 int connman_device_get_index(struct connman_device *device)
1221 return device->element.index;
1225 * connman_device_set_interface:
1226 * @device: device structure
1227 * @interface: interface name
1228 * @control: control interface
1230 * Set interface name of device
1232 void connman_device_set_interface(struct connman_device *device,
1233 const char *interface, const char *control)
1235 g_free(device->element.devname);
1236 device->element.devname = g_strdup(interface);
1238 g_free(device->interface);
1239 device->interface = g_strdup(interface);
1241 g_free(device->control);
1242 device->control = g_strdup(control);
1244 if (device->name == NULL) {
1245 const char *str = type2description(device->type);
1246 if (str != NULL && device->interface != NULL)
1247 device->name = g_strdup_printf("%s (%s)", str,
1252 const char *connman_device_get_control(struct connman_device *device)
1254 return device->control;
1258 * connman_device_set_ident:
1259 * @device: device structure
1260 * @ident: unique identifier
1262 * Set unique identifier of device
1264 void connman_device_set_ident(struct connman_device *device,
1267 g_free(device->ident);
1268 device->ident = g_strdup(ident);
1271 const char *__connman_device_get_ident(struct connman_device *device)
1273 return device->ident;
1277 * connman_device_set_mode:
1278 * @device: device structure
1279 * @mode: network mode
1281 * Change network mode of device
1283 void connman_device_set_mode(struct connman_device *device,
1284 enum connman_device_mode mode)
1286 device->mode = mode;
1290 * connman_device_get_mode:
1291 * @device: device structure
1293 * Get network mode of device
1295 enum connman_device_mode connman_device_get_mode(struct connman_device *device)
1297 return device->mode;
1301 * connman_device_set_secondary:
1302 * @device: device structure
1303 * @secondary: secondary value
1305 * Change secondary value of device
1307 void connman_device_set_secondary(struct connman_device *device,
1308 connman_bool_t secondary)
1310 device->secondary = secondary;
1314 * connman_device_get_secondary:
1315 * @device: device structure
1317 * Get secondary value of device
1319 connman_bool_t connman_device_get_secondary(struct connman_device *device)
1321 return device->secondary;
1325 * connman_device_set_powered:
1326 * @device: device structure
1327 * @powered: powered state
1329 * Change power state of device
1331 int connman_device_set_powered(struct connman_device *device,
1332 connman_bool_t powered)
1334 DBG("driver %p powered %d", device, powered);
1336 if (device->timeout > 0) {
1337 g_source_remove(device->timeout);
1338 device->timeout = 0;
1341 if (device->pending != NULL) {
1342 g_dbus_send_reply(connection, device->pending,
1345 dbus_message_unref(device->pending);
1346 device->pending = NULL;
1349 if (device->powered == powered)
1352 device->powered = powered;
1354 if (device->registered == FALSE)
1357 powered_changed(device);
1359 if (powered == FALSE)
1362 if (device->scan_timeout > 0) {
1363 g_source_remove(device->scan_timeout);
1364 device->scan_timeout = 0;
1367 if (device->scan_interval > 0) {
1368 guint interval = device->scan_interval;
1369 device->scan_timeout = g_timeout_add_seconds(interval,
1370 device_scan_trigger, device);
1373 if (device->driver->scan)
1374 device->driver->scan(device);
1380 * connman_device_set_carrier:
1381 * @device: device structure
1382 * @carrier: carrier state
1384 * Change carrier state of device (only for device without scanning)
1386 int connman_device_set_carrier(struct connman_device *device,
1387 connman_bool_t carrier)
1389 DBG("device %p carrier %d", device, carrier);
1391 switch (device->mode) {
1392 case CONNMAN_DEVICE_MODE_UNKNOWN:
1393 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1394 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1396 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1400 if (device->carrier == carrier)
1403 device->carrier = carrier;
1405 return set_carrier(device, device->carrier);
1408 int __connman_device_connect(struct connman_device *device)
1410 DBG("device %p", device);
1412 if (device->disconnected == FALSE)
1415 if (device->driver && device->driver->connect)
1416 device->driver->connect(device);
1421 int __connman_device_disconnect(struct connman_device *device)
1423 GHashTableIter iter;
1424 gpointer key, value;
1426 DBG("device %p", device);
1428 connman_device_set_disconnected(device, TRUE);
1430 g_hash_table_iter_init(&iter, device->networks);
1432 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1433 struct connman_network *network = value;
1435 if (connman_network_get_connected(network) == TRUE ||
1436 connman_network_get_associating(network) == TRUE)
1437 __connman_network_disconnect(network);
1440 if (device->driver && device->driver->disconnect)
1441 device->driver->disconnect(device);
1446 static void mark_network_unavailable(gpointer key, gpointer value,
1449 struct connman_network *network = value;
1451 if (connman_network_get_connected(network) == TRUE)
1454 connman_network_set_available(network, FALSE);
1457 static gboolean remove_unavailable_network(gpointer key, gpointer value,
1460 struct connman_network *network = value;
1462 if (connman_network_get_connected(network) == TRUE)
1465 if (connman_network_get_available(network) == TRUE)
1472 * connman_device_set_scanning:
1473 * @device: device structure
1474 * @scanning: scanning state
1476 * Change scanning state of device
1478 int connman_device_set_scanning(struct connman_device *device,
1479 connman_bool_t scanning)
1481 DBusMessage *signal;
1482 DBusMessageIter entry, value;
1483 const char *key = "Scanning";
1485 DBG("device %p scanning %d", device, scanning);
1487 if (!device->driver || !device->driver->scan)
1490 if (device->scanning == scanning)
1493 device->scanning = scanning;
1495 signal = dbus_message_new_signal(device->element.path,
1496 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
1500 dbus_message_iter_init_append(signal, &entry);
1502 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
1504 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
1505 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
1506 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &scanning);
1507 dbus_message_iter_close_container(&entry, &value);
1509 g_dbus_send_message(connection, signal);
1511 if (scanning == TRUE) {
1512 if (device->scan_timeout > 0) {
1513 g_source_remove(device->scan_timeout);
1514 device->scan_timeout = 0;
1517 if (device->scan_interval > 0) {
1518 guint interval = device->scan_interval;
1519 device->scan_timeout = g_timeout_add_seconds(interval,
1520 device_scan_trigger, device);
1523 g_hash_table_foreach(device->networks,
1524 mark_network_unavailable, NULL);
1528 g_hash_table_foreach_remove(device->networks,
1529 remove_unavailable_network, NULL);
1531 if (device->connections > 0)
1534 if (device->disconnected == TRUE)
1541 * connman_device_set_disconnected:
1542 * @device: device structure
1543 * @disconnected: disconnected state
1545 * Change disconnected state of device (only for device with networks)
1547 int connman_device_set_disconnected(struct connman_device *device,
1548 connman_bool_t disconnected)
1550 DBG("device %p disconnected %d", device, disconnected);
1552 switch (device->mode) {
1553 case CONNMAN_DEVICE_MODE_UNKNOWN:
1554 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1556 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1557 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1561 if (device->disconnected == disconnected)
1564 device->disconnected = disconnected;
1570 * connman_device_get_disconnected:
1571 * @device: device structure
1573 * Get device disconnected state
1575 connman_bool_t connman_device_get_disconnected(struct connman_device *device)
1577 return device->disconnected;
1581 * connman_device_set_connected:
1582 * @device: device structure
1583 * @connected: connected state
1585 * Change connected state of device (for Ethernet like devices)
1587 int connman_device_set_connected(struct connman_device *device,
1588 connman_bool_t connected)
1590 DBG("device %p connected %d", device, connected);
1592 switch (device->mode) {
1593 case CONNMAN_DEVICE_MODE_UNKNOWN:
1594 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1595 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1597 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1601 if (device->carrier == FALSE)
1604 return set_connected(device, connected);
1608 * connman_device_set_string:
1609 * @device: device structure
1610 * @key: unique identifier
1611 * @value: string value
1613 * Set string value for specific key
1615 int connman_device_set_string(struct connman_device *device,
1616 const char *key, const char *value)
1618 DBG("device %p key %s value %s", device, key, value);
1620 if (g_str_equal(key, "Address") == TRUE) {
1621 g_free(device->address);
1622 device->address = g_strdup(value);
1623 } else if (g_str_equal(key, "Name") == TRUE) {
1624 g_free(device->name);
1625 device->name = g_strdup(value);
1626 } else if (g_str_equal(key, "Node") == TRUE) {
1627 g_free(device->node);
1628 device->node = g_strdup(value);
1631 return connman_element_set_string(&device->element, key, value);
1635 * connman_device_get_string:
1636 * @device: device structure
1637 * @key: unique identifier
1639 * Get string value for specific key
1641 const char *connman_device_get_string(struct connman_device *device,
1644 DBG("device %p key %s", device, key);
1646 if (g_str_equal(key, "Address") == TRUE)
1647 return device->address;
1648 else if (g_str_equal(key, "Name") == TRUE)
1649 return device->name;
1650 else if (g_str_equal(key, "Node") == TRUE)
1651 return device->node;
1653 return connman_element_get_string(&device->element, key);
1656 static void set_offlinemode(struct connman_element *element, gpointer user_data)
1658 struct connman_device *device = element->device;
1659 connman_bool_t offlinemode = GPOINTER_TO_UINT(user_data);
1660 connman_bool_t powered;
1662 DBG("element %p name %s", element, element->name);
1667 powered = (offlinemode == TRUE) ? FALSE : TRUE;
1669 if (device->powered == powered)
1672 set_powered(device, powered);
1675 int __connman_device_set_offlinemode(connman_bool_t offlinemode)
1677 DBG("offlinmode %d", offlinemode);
1679 __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
1680 set_offlinemode, GUINT_TO_POINTER(offlinemode));
1682 __connman_notifier_offline_mode(offlinemode);
1687 void __connman_device_increase_connections(struct connman_device *device)
1689 device->connections++;
1692 void __connman_device_decrease_connections(struct connman_device *device)
1694 device->connections--;
1698 * connman_device_add_network:
1699 * @device: device structure
1700 * @network: network structure
1702 * Add new network to the device
1704 int connman_device_add_network(struct connman_device *device,
1705 struct connman_network *network)
1707 const char *identifier = connman_network_get_identifier(network);
1710 DBG("device %p network %p", device, network);
1712 switch (device->mode) {
1713 case CONNMAN_DEVICE_MODE_UNKNOWN:
1714 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1716 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1717 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1721 __connman_network_set_device(network, device);
1723 __connman_storage_load_network(network);
1725 err = connman_element_register((struct connman_element *) network,
1728 __connman_network_set_device(network, NULL);
1732 g_hash_table_insert(device->networks, g_strdup(identifier),
1739 * connman_device_get_network:
1740 * @device: device structure
1741 * @identifier: network identifier
1743 * Get network for given identifier
1745 struct connman_network *connman_device_get_network(struct connman_device *device,
1746 const char *identifier)
1748 DBG("device %p identifier %s", device, identifier);
1750 return g_hash_table_lookup(device->networks, identifier);
1754 * connman_device_remove_network:
1755 * @device: device structure
1756 * @identifier: network identifier
1758 * Remove network for given identifier
1760 int connman_device_remove_network(struct connman_device *device,
1761 const char *identifier)
1763 DBG("device %p identifier %s", device, identifier);
1765 g_hash_table_remove(device->networks, identifier);
1770 void __connman_device_set_network(struct connman_device *device,
1771 struct connman_network *network)
1775 if (device->network == network)
1778 if (device->network != NULL)
1779 connman_network_unref(device->network);
1781 if (network != NULL) {
1782 name = connman_network_get_string(network,
1783 CONNMAN_PROPERTY_ID_NAME);
1784 g_free(device->last_network);
1785 device->last_network = g_strdup(name);
1787 device->network = connman_network_ref(network);
1789 g_free(device->last_network);
1790 device->last_network = NULL;
1792 device->network = NULL;
1797 * connman_device_register:
1798 * @device: device structure
1800 * Register device with the system
1802 int connman_device_register(struct connman_device *device)
1804 __connman_storage_load_device(device);
1806 switch (device->mode) {
1807 case CONNMAN_DEVICE_MODE_UNKNOWN:
1808 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1810 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1811 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1812 __connman_storage_init_network(device);
1816 return connman_element_register(&device->element, NULL);
1820 * connman_device_unregister:
1821 * @device: device structure
1823 * Unregister device with the system
1825 void connman_device_unregister(struct connman_device *device)
1827 __connman_storage_save_device(device);
1829 connman_element_unregister(&device->element);
1833 * connman_device_get_data:
1834 * @device: device structure
1836 * Get private device data pointer
1838 void *connman_device_get_data(struct connman_device *device)
1840 return device->driver_data;
1844 * connman_device_set_data:
1845 * @device: device structure
1846 * @data: data pointer
1848 * Set private device data pointer
1850 void connman_device_set_data(struct connman_device *device, void *data)
1852 device->driver_data = data;
1855 static gboolean match_driver(struct connman_device *device,
1856 struct connman_device_driver *driver)
1858 if (device->type == driver->type ||
1859 driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1865 static int device_probe(struct connman_element *element)
1867 struct connman_device *device = element->device;
1870 DBG("element %p name %s", element, element->name);
1875 if (device->driver != NULL)
1878 for (list = driver_list; list; list = list->next) {
1879 struct connman_device_driver *driver = list->data;
1881 if (match_driver(device, driver) == FALSE)
1884 DBG("driver %p name %s", driver, driver->name);
1886 if (driver->probe(device) == 0) {
1887 device->driver = driver;
1892 if (device->driver == NULL)
1895 return setup_device(device);
1898 static void device_remove(struct connman_element *element)
1900 struct connman_device *device = element->device;
1902 DBG("element %p name %s", element, element->name);
1907 if (device->driver == NULL)
1910 remove_device(device);
1913 static struct connman_driver device_driver = {
1915 .type = CONNMAN_ELEMENT_TYPE_DEVICE,
1916 .priority = CONNMAN_DRIVER_PRIORITY_LOW,
1917 .probe = device_probe,
1918 .remove = device_remove,
1921 static int device_load(struct connman_device *device)
1924 gchar *pathname, *identifier, *data = NULL;
1928 DBG("device %p", device);
1930 pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1931 __connman_profile_active_ident());
1932 if (pathname == NULL)
1935 keyfile = g_key_file_new();
1937 if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1944 if (g_key_file_load_from_data(keyfile, data, length,
1945 0, NULL) == FALSE) {
1952 identifier = g_strdup_printf("device_%s", device->element.name);
1953 if (identifier == NULL)
1956 switch (device->mode) {
1957 case CONNMAN_DEVICE_MODE_UNKNOWN:
1958 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
1960 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
1961 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
1962 val = g_key_file_get_integer(keyfile, identifier,
1963 "ScanInterval", NULL);
1965 device->scan_interval = val;
1970 g_key_file_free(keyfile);
1977 static int device_save(struct connman_device *device)
1980 gchar *pathname, *identifier = NULL, *data = NULL;
1983 DBG("device %p", device);
1985 pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR,
1986 __connman_profile_active_ident());
1987 if (pathname == NULL)
1990 keyfile = g_key_file_new();
1992 if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1996 if (g_key_file_load_from_data(keyfile, data, length,
2004 identifier = g_strdup_printf("device_%s", device->element.name);
2005 if (identifier == NULL)
2008 switch (device->mode) {
2009 case CONNMAN_DEVICE_MODE_UNKNOWN:
2010 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
2012 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
2013 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
2014 if (device->scan_interval > 0)
2015 g_key_file_set_integer(keyfile, identifier,
2016 "ScanInterval", device->scan_interval);
2020 data = g_key_file_to_data(keyfile, &length, NULL);
2022 if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
2023 connman_error("Failed to store device information");
2028 g_key_file_free(keyfile);
2036 static struct connman_storage device_storage = {
2038 .priority = CONNMAN_STORAGE_PRIORITY_LOW,
2039 .device_load = device_load,
2040 .device_save = device_save,
2043 int __connman_device_init(void)
2047 connection = connman_dbus_get_connection();
2049 if (connman_storage_register(&device_storage) < 0)
2050 connman_error("Failed to register device storage");
2052 return connman_driver_register(&device_driver);
2055 void __connman_device_cleanup(void)
2059 connman_driver_unregister(&device_driver);
2061 connman_storage_unregister(&device_storage);
2063 dbus_connection_unref(connection);