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
31 struct connman_device {
32 struct connman_element element;
33 enum connman_device_type type;
34 enum connman_device_mode mode;
35 enum connman_device_policy policy;
42 struct connman_device_driver *driver;
48 static const char *type2description(enum connman_device_type type)
51 case CONNMAN_DEVICE_TYPE_UNKNOWN:
52 case CONNMAN_DEVICE_TYPE_VENDOR:
54 case CONNMAN_DEVICE_TYPE_ETHERNET:
56 case CONNMAN_DEVICE_TYPE_WIFI:
58 case CONNMAN_DEVICE_TYPE_WIMAX:
60 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
62 case CONNMAN_DEVICE_TYPE_HSO:
63 case CONNMAN_DEVICE_TYPE_HUAWEI:
64 case CONNMAN_DEVICE_TYPE_NOVATEL:
71 static const char *type2string(enum connman_device_type type)
74 case CONNMAN_DEVICE_TYPE_UNKNOWN:
75 case CONNMAN_DEVICE_TYPE_VENDOR:
77 case CONNMAN_DEVICE_TYPE_ETHERNET:
79 case CONNMAN_DEVICE_TYPE_WIFI:
81 case CONNMAN_DEVICE_TYPE_WIMAX:
83 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
85 case CONNMAN_DEVICE_TYPE_HSO:
86 case CONNMAN_DEVICE_TYPE_HUAWEI:
87 case CONNMAN_DEVICE_TYPE_NOVATEL:
94 static const char *policy2string(enum connman_device_policy policy)
97 case CONNMAN_DEVICE_POLICY_UNKNOWN:
99 case CONNMAN_DEVICE_POLICY_IGNORE:
101 case CONNMAN_DEVICE_POLICY_OFF:
103 case CONNMAN_DEVICE_POLICY_AUTO:
105 case CONNMAN_DEVICE_POLICY_MANUAL:
112 static enum connman_device_policy string2policy(const char *policy)
114 if (g_str_equal(policy, "ignore") == TRUE)
115 return CONNMAN_DEVICE_POLICY_IGNORE;
116 else if (g_str_equal(policy, "off") == TRUE)
117 return CONNMAN_DEVICE_POLICY_OFF;
118 else if (g_str_equal(policy, "auto") == TRUE)
119 return CONNMAN_DEVICE_POLICY_AUTO;
120 else if (g_str_equal(policy, "manual") == TRUE)
121 return CONNMAN_DEVICE_POLICY_MANUAL;
123 return CONNMAN_DEVICE_POLICY_UNKNOWN;
126 static int set_powered(struct connman_device *device, gboolean powered)
128 struct connman_device_driver *driver = device->driver;
131 DBG("device %p powered %d", device, powered);
136 if (powered == TRUE) {
138 err = driver->enable(device);
142 g_hash_table_remove_all(device->networks);
145 err = driver->disable(device);
153 static int set_policy(DBusConnection *connection,
154 struct connman_device *device,
155 enum connman_device_policy policy)
158 DBusMessageIter entry, value;
159 const char *str, *key = "Policy";
162 DBG("device %p policy %d", device, policy);
164 if (device->policy == policy)
168 case CONNMAN_DEVICE_POLICY_UNKNOWN:
170 case CONNMAN_DEVICE_POLICY_IGNORE:
172 case CONNMAN_DEVICE_POLICY_OFF:
173 if (device->powered == TRUE)
174 err = set_powered(device, FALSE);
176 case CONNMAN_DEVICE_POLICY_AUTO:
177 case CONNMAN_DEVICE_POLICY_MANUAL:
178 if (device->powered == FALSE)
179 err = set_powered(device, TRUE);
186 device->policy = policy;
188 signal = dbus_message_new_signal(device->element.path,
189 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
193 dbus_message_iter_init_append(signal, &entry);
195 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
197 str = policy2string(policy);
199 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
200 DBUS_TYPE_STRING_AS_STRING, &value);
201 dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
202 dbus_message_iter_close_container(&entry, &value);
204 g_dbus_send_message(connection, signal);
209 static void append_networks(struct connman_device *device,
210 DBusMessageIter *entry)
212 DBusMessageIter value, iter;
213 const char *key = "Networks";
215 dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
217 dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
218 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
221 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
222 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
223 __connman_element_list((struct connman_element *) device,
224 CONNMAN_ELEMENT_TYPE_NETWORK, &iter);
225 dbus_message_iter_close_container(&value, &iter);
227 dbus_message_iter_close_container(entry, &value);
230 static DBusMessage *get_properties(DBusConnection *conn,
231 DBusMessage *msg, void *data)
233 struct connman_device *device = data;
235 DBusMessageIter array, dict, entry;
238 DBG("conn %p", conn);
240 reply = dbus_message_new_method_return(msg);
244 dbus_message_iter_init_append(reply, &array);
246 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
247 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
248 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
249 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
251 str = type2description(device->type);
252 if (str != NULL && device->interface != NULL) {
253 char *name = g_strdup_printf("%s (%s)", str, device->interface);
255 connman_dbus_dict_append_variant(&dict, "Name",
256 DBUS_TYPE_STRING, &name);
260 str = type2string(device->type);
262 connman_dbus_dict_append_variant(&dict, "Type",
263 DBUS_TYPE_STRING, &str);
265 if (device->interface != NULL)
266 connman_dbus_dict_append_variant(&dict, "Interface",
267 DBUS_TYPE_STRING, &device->interface);
269 str = policy2string(device->policy);
271 connman_dbus_dict_append_variant(&dict, "Policy",
272 DBUS_TYPE_STRING, &str);
274 connman_dbus_dict_append_variant(&dict, "Powered",
275 DBUS_TYPE_BOOLEAN, &device->powered);
277 if (device->driver && device->driver->scan)
278 connman_dbus_dict_append_variant(&dict, "Scanning",
279 DBUS_TYPE_BOOLEAN, &device->scanning);
281 switch (device->mode) {
282 case CONNMAN_DEVICE_MODE_UNKNOWN:
283 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
285 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
286 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
287 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
289 append_networks(device, &entry);
290 dbus_message_iter_close_container(&dict, &entry);
294 dbus_message_iter_close_container(&array, &dict);
299 static DBusMessage *set_property(DBusConnection *conn,
300 DBusMessage *msg, void *data)
302 struct connman_device *device = data;
303 DBusMessageIter iter, value;
306 DBG("conn %p", conn);
308 if (dbus_message_iter_init(msg, &iter) == FALSE)
309 return __connman_error_invalid_arguments(msg);
311 dbus_message_iter_get_basic(&iter, &name);
312 dbus_message_iter_next(&iter);
313 dbus_message_iter_recurse(&iter, &value);
315 if (__connman_security_check_privileges(msg) < 0)
316 return __connman_error_permission_denied(msg);
318 if (g_str_equal(name, "Powered") == TRUE) {
322 dbus_message_iter_get_basic(&value, &powered);
324 if (device->powered == powered)
325 return __connman_error_invalid_arguments(msg);
327 err = set_powered(device, powered);
328 if (err < 0 && err != -EINPROGRESS)
329 return __connman_error_failed(msg);
330 } else if (g_str_equal(name, "Policy") == TRUE) {
331 enum connman_device_policy policy;
335 dbus_message_iter_get_basic(&value, &str);
336 policy = string2policy(str);
337 if (policy == CONNMAN_DEVICE_POLICY_UNKNOWN)
338 return __connman_error_invalid_arguments(msg);
340 err = set_policy(conn, device, policy);
342 return __connman_error_failed(msg);
345 __connman_element_store(&device->element);
347 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
350 static DBusMessage *create_network(DBusConnection *conn,
351 DBusMessage *msg, void *data)
353 DBG("conn %p", conn);
355 if (__connman_security_check_privileges(msg) < 0)
356 return __connman_error_permission_denied(msg);
358 return __connman_error_invalid_arguments(msg);
361 static DBusMessage *remove_network(DBusConnection *conn,
362 DBusMessage *msg, void *data)
364 DBG("conn %p", conn);
366 if (__connman_security_check_privileges(msg) < 0)
367 return __connman_error_permission_denied(msg);
369 return __connman_error_invalid_arguments(msg);
372 static DBusMessage *propose_scan(DBusConnection *conn,
373 DBusMessage *msg, void *data)
375 struct connman_device *device = data;
378 DBG("conn %p", conn);
380 switch (device->mode) {
381 case CONNMAN_DEVICE_MODE_UNKNOWN:
382 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
383 return __connman_error_not_supported(msg);
384 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
385 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
389 if (!device->driver || !device->driver->scan)
390 return __connman_error_not_supported(msg);
392 err = device->driver->scan(device);
394 return __connman_error_failed(msg);
396 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
399 static GDBusMethodTable device_methods[] = {
400 { "GetProperties", "", "a{sv}", get_properties },
401 { "SetProperty", "sv", "", set_property },
402 { "CreateNetwork", "a{sv}", "o", create_network },
403 { "RemoveNetwork", "o", "", remove_network },
404 { "ProposeScan", "", "", propose_scan },
408 static GDBusSignalTable device_signals[] = {
409 { "PropertyChanged", "sv" },
413 static DBusConnection *connection;
415 static void append_devices(DBusMessageIter *entry)
417 DBusMessageIter value, iter;
418 const char *key = "Devices";
420 dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
422 dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
423 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
426 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
427 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
428 __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter);
429 dbus_message_iter_close_container(&value, &iter);
431 dbus_message_iter_close_container(entry, &value);
434 static void emit_devices_signal(void)
437 DBusMessageIter entry;
439 signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
440 CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
444 dbus_message_iter_init_append(signal, &entry);
446 append_devices(&entry);
448 g_dbus_send_message(connection, signal);
451 static int register_interface(struct connman_element *element)
453 struct connman_device *device = element->device;
455 DBG("element %p name %s", element, element->name);
457 if (g_dbus_register_interface(connection, element->path,
458 CONNMAN_DEVICE_INTERFACE,
459 device_methods, device_signals,
460 NULL, device, NULL) == FALSE) {
461 connman_error("Failed to register %s device", element->path);
465 emit_devices_signal();
470 static void unregister_interface(struct connman_element *element)
472 DBG("element %p name %s", element, element->name);
474 emit_devices_signal();
476 g_dbus_unregister_interface(connection, element->path,
477 CONNMAN_DEVICE_INTERFACE);
480 static void device_enable(struct connman_device *device)
482 DBG("device %p", device);
484 if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE ||
485 device->policy == CONNMAN_DEVICE_POLICY_OFF)
488 if (device->powered == TRUE)
491 if (device->driver->enable)
492 device->driver->enable(device);
495 static void device_disable(struct connman_device *device)
497 DBG("device %p", device);
499 if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE)
502 if (device->powered == FALSE)
505 g_hash_table_remove_all(device->networks);
507 if (device->driver->disable)
508 device->driver->disable(device);
511 static GSList *driver_list = NULL;
513 static gint compare_priority(gconstpointer a, gconstpointer b)
515 const struct connman_device_driver *driver1 = a;
516 const struct connman_device_driver *driver2 = b;
518 return driver2->priority - driver1->priority;
522 * connman_device_driver_register:
523 * @driver: device driver definition
525 * Register a new device driver
527 * Returns: %0 on success
529 int connman_device_driver_register(struct connman_device_driver *driver)
531 DBG("driver %p name %s", driver, driver->name);
533 driver_list = g_slist_insert_sorted(driver_list, driver,
536 //__connman_driver_rescan(&device_driver);
541 static void remove_driver(struct connman_element *element, gpointer user_data)
543 struct connman_device_driver *driver = user_data;
545 DBG("element %p name %s", element, element->name);
547 if (element->device == NULL)
550 if (element->device->driver == driver) {
551 device_disable(element->device);
554 driver->remove(element->device);
556 element->device->driver = NULL;
561 * connman_device_driver_unregister:
562 * @driver: device driver definition
564 * Remove a previously registered device driver
566 void connman_device_driver_unregister(struct connman_device_driver *driver)
568 DBG("driver %p name %s", driver, driver->name);
570 driver_list = g_slist_remove(driver_list, driver);
572 __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE,
573 remove_driver, driver);
576 static void unregister_network(gpointer data)
578 struct connman_network *network = data;
580 DBG("network %p", network);
582 connman_element_unregister((struct connman_element *) network);
584 connman_network_unref(network);
587 static void device_destruct(struct connman_element *element)
589 struct connman_device *device = element->device;
591 DBG("element %p name %s", element, element->name);
593 g_free(device->path);
594 g_free(device->interface);
596 g_hash_table_destroy(device->networks);
597 device->networks = NULL;
601 * connman_device_create:
602 * @node: device node name (for example an address)
605 * Allocate a new device of given #type and assign the #node name to it.
607 * Returns: a newly-allocated #connman_device structure
609 struct connman_device *connman_device_create(const char *node,
610 enum connman_device_type type)
612 struct connman_device *device;
614 DBG("node %s type %d", node, type);
616 device = g_try_new0(struct connman_device, 1);
620 DBG("device %p", device);
622 device->element.refcount = 1;
624 device->element.name = g_strdup(node);
625 device->element.type = CONNMAN_ELEMENT_TYPE_DEVICE;
626 device->element.index = -1;
629 case CONNMAN_DEVICE_TYPE_UNKNOWN:
630 case CONNMAN_DEVICE_TYPE_VENDOR:
631 case CONNMAN_DEVICE_TYPE_WIFI:
632 case CONNMAN_DEVICE_TYPE_WIMAX:
633 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
634 case CONNMAN_DEVICE_TYPE_HSO:
635 case CONNMAN_DEVICE_TYPE_HUAWEI:
636 case CONNMAN_DEVICE_TYPE_NOVATEL:
637 device->element.subtype = CONNMAN_ELEMENT_SUBTYPE_UNKNOWN;
639 case CONNMAN_DEVICE_TYPE_ETHERNET:
640 device->element.subtype = CONNMAN_ELEMENT_SUBTYPE_ETHERNET;
644 device->element.device = device;
645 device->element.destruct = device_destruct;
648 device->mode = CONNMAN_DEVICE_MODE_UNKNOWN;
649 device->policy = CONNMAN_DEVICE_POLICY_AUTO;
651 device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
652 g_free, unregister_network);
658 * connman_device_ref:
659 * @device: device structure
661 * Increase reference counter of device
663 struct connman_device *connman_device_ref(struct connman_device *device)
665 if (connman_element_ref(&device->element) == NULL)
672 * connman_device_unref:
673 * @device: device structure
675 * Decrease reference counter of device
677 void connman_device_unref(struct connman_device *device)
679 connman_element_unref(&device->element);
683 * connman_device_set_path:
684 * @device: device structure
687 * Set path name of device
689 void connman_device_set_path(struct connman_device *device, const char *path)
691 g_free(device->element.devpath);
692 device->element.devpath = g_strdup(path);
694 g_free(device->path);
695 device->path = g_strdup(path);
699 * connman_device_get_path:
700 * @device: device structure
702 * Get path name of device
704 const char *connman_device_get_path(struct connman_device *device)
710 * connman_device_set_index:
711 * @device: device structure
712 * @index: index number
714 * Set index number of device
716 void connman_device_set_index(struct connman_device *device, int index)
718 device->element.index = index;
722 * connman_device_get_index:
723 * @device: device structure
725 * Get index number of device
727 int connman_device_get_index(struct connman_device *device)
729 return device->element.index;
733 * connman_device_set_interface:
734 * @device: device structure
735 * @interface: interface name
737 * Set interface name of device
739 void connman_device_set_interface(struct connman_device *device,
740 const char *interface)
742 g_free(device->element.devname);
743 device->element.devname = g_strdup(interface);
745 g_free(device->interface);
746 device->interface = g_strdup(interface);
750 * connman_device_get_interface:
751 * @device: device structure
753 * Get interface name of device
755 const char *connman_device_get_interface(struct connman_device *device)
757 return device->interface;
761 * connman_device_set_policy:
762 * @device: device structure
763 * @policy: power and connection policy
765 * Change power and connection policy of device
767 void connman_device_set_policy(struct connman_device *device,
768 enum connman_device_policy policy)
770 device->policy = policy;
774 * connman_device_set_mode:
775 * @device: device structure
776 * @mode: network mode
778 * Change network mode of device
780 void connman_device_set_mode(struct connman_device *device,
781 enum connman_device_mode mode)
787 * connman_device_set_powered:
788 * @device: device structure
789 * @powered: powered state
791 * Change power state of device
793 int connman_device_set_powered(struct connman_device *device,
794 connman_bool_t powered)
797 DBusMessageIter entry, value;
798 const char *key = "Powered";
800 DBG("driver %p powered %d", device, powered);
802 if (device->powered == powered)
805 device->powered = powered;
807 signal = dbus_message_new_signal(device->element.path,
808 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
812 dbus_message_iter_init_append(signal, &entry);
814 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
816 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
817 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
818 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &powered);
819 dbus_message_iter_close_container(&entry, &value);
821 g_dbus_send_message(connection, signal);
827 * connman_device_set_carrier:
828 * @device: device structure
829 * @carrier: carrier state
831 * Change carrier state of device (only for device without scanning)
833 int connman_device_set_carrier(struct connman_device *device,
834 connman_bool_t carrier)
836 DBG("driver %p carrier %d", device, carrier);
838 switch (device->mode) {
839 case CONNMAN_DEVICE_MODE_UNKNOWN:
840 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
841 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
843 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
847 if (device->carrier == carrier)
850 device->carrier = carrier;
852 if (carrier == TRUE) {
853 struct connman_element *element;
855 element = connman_element_create(NULL);
856 if (element != NULL) {
857 element->type = CONNMAN_ELEMENT_TYPE_DHCP;
858 element->subtype = device->element.subtype;
859 element->index = device->element.index;
861 if (connman_element_register(element,
862 &device->element) < 0)
863 connman_element_unref(element);
866 connman_element_unregister_children(&device->element);
872 * connman_device_set_scanning:
873 * @device: device structure
874 * @scanning: scanning state
876 * Change scanning state of device
878 int connman_device_set_scanning(struct connman_device *device,
879 connman_bool_t scanning)
882 DBusMessageIter entry, value;
883 const char *key = "Scanning";
885 DBG("driver %p scanning %d", device, scanning);
887 if (!device->driver || !device->driver->scan)
890 if (device->scanning == scanning)
893 device->scanning = scanning;
895 signal = dbus_message_new_signal(device->element.path,
896 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
900 dbus_message_iter_init_append(signal, &entry);
902 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
904 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
905 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
906 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &scanning);
907 dbus_message_iter_close_container(&entry, &value);
909 g_dbus_send_message(connection, signal);
915 * connman_device_add_network:
916 * @device: device structure
917 * @network: network structure
919 * Add new network to the device
921 int connman_device_add_network(struct connman_device *device,
922 struct connman_network *network)
924 const char *identifier = connman_network_get_identifier(network);
927 DBG("device %p network %p", device, network);
929 switch (device->mode) {
930 case CONNMAN_DEVICE_MODE_UNKNOWN:
931 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
933 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
934 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
938 __connman_network_set_device(network, device);
940 err = connman_element_register((struct connman_element *) network,
943 __connman_network_set_device(network, NULL);
947 g_hash_table_insert(device->networks, g_strdup(identifier),
954 * connman_device_get_network:
955 * @device: device structure
956 * @identifier: network identifier
958 * Get network for given identifier
960 struct connman_network *connman_device_get_network(struct connman_device *device,
961 const char *identifier)
963 DBG("device %p identifier %s", device, identifier);
965 return g_hash_table_lookup(device->networks, identifier);
969 * connman_device_remove_network:
970 * @device: device structure
971 * @identifier: network identifier
973 * Remove network for given identifier
975 int connman_device_remove_network(struct connman_device *device,
976 const char *identifier)
978 DBG("device %p identifier %s", device, identifier);
980 g_hash_table_remove(device->networks, identifier);
986 * connman_device_register:
987 * @device: device structure
989 * Register device with the system
991 int connman_device_register(struct connman_device *device)
993 return connman_element_register(&device->element, NULL);
997 * connman_device_unregister:
998 * @device: device structure
1000 * Unregister device with the system
1002 void connman_device_unregister(struct connman_device *device)
1004 connman_element_unregister(&device->element);
1008 * connman_device_get_data:
1009 * @device: device structure
1011 * Get private device data pointer
1013 void *connman_device_get_data(struct connman_device *device)
1015 return device->driver_data;
1019 * connman_device_set_data:
1020 * @device: device structure
1021 * @data: data pointer
1023 * Set private device data pointer
1025 void connman_device_set_data(struct connman_device *device, void *data)
1027 device->driver_data = data;
1030 static gboolean match_driver(struct connman_device *device,
1031 struct connman_device_driver *driver)
1033 if (device->type == driver->type ||
1034 driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1040 static int device_probe(struct connman_element *element)
1042 struct connman_device *device = element->device;
1046 DBG("element %p name %s", element, element->name);
1051 for (list = driver_list; list; list = list->next) {
1052 struct connman_device_driver *driver = list->data;
1054 if (match_driver(device, driver) == FALSE)
1057 DBG("driver %p name %s", driver, driver->name);
1059 if (driver->probe(device) == 0) {
1060 device->driver = driver;
1065 if (device->driver == NULL)
1068 err = register_interface(element);
1070 if (device->driver->remove)
1071 device->driver->remove(device);
1075 device_enable(device);
1080 static void device_remove(struct connman_element *element)
1082 struct connman_device *device = element->device;
1084 DBG("element %p name %s", element, element->name);
1089 if (device->driver == NULL)
1092 device_disable(device);
1094 unregister_interface(element);
1096 if (device->driver->remove)
1097 device->driver->remove(device);
1100 static struct connman_driver device_driver = {
1102 .type = CONNMAN_ELEMENT_TYPE_DEVICE,
1103 .priority = CONNMAN_DRIVER_PRIORITY_LOW,
1104 .probe = device_probe,
1105 .remove = device_remove,
1108 int __connman_device_init(void)
1112 connection = connman_dbus_get_connection();
1114 return connman_driver_register(&device_driver);
1117 void __connman_device_cleanup(void)
1121 connman_driver_unregister(&device_driver);
1123 dbus_connection_unref(connection);