wifi: Add support to multi scan type
[platform/upstream/connman.git] / src / device.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
6  *
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.
10  *
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.
15  *
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
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <errno.h>
27 #include <string.h>
28
29 #include "connman.h"
30
31 static GSList *device_list = NULL;
32 static gchar **device_filter = NULL;
33 static gchar **nodevice_filter = NULL;
34
35 enum connman_pending_type {
36         PENDING_NONE    = 0,
37         PENDING_ENABLE  = 1,
38         PENDING_DISABLE = 2,
39 };
40
41 struct connman_device {
42         gint refcount;
43         enum connman_device_type type;
44         enum connman_pending_type powered_pending;      /* Indicates a pending
45                                                         enable/disable request */
46         connman_bool_t powered;
47         connman_bool_t scanning;
48         connman_bool_t disconnected;
49         connman_bool_t reconnect;
50         connman_uint16_t scan_interval;
51         connman_uint16_t backoff_interval;
52         char *name;
53         char *node;
54         char *address;
55         char *interface;
56         char *ident;
57         char *path;
58         char *devname;
59         int phyindex;
60         int index;
61         unsigned int connections;
62         guint scan_timeout;
63         guint pending_timeout;
64
65         struct connman_device_driver *driver;
66         void *driver_data;
67
68         char *last_network;
69         struct connman_network *network;
70         GHashTable *networks;
71 };
72
73 #define SCAN_INITIAL_DELAY 10
74
75 static gboolean device_scan_trigger(gpointer user_data)
76 {
77         struct connman_device *device = user_data;
78
79         DBG("device %p", device);
80
81         if (device->driver == NULL) {
82                 device->scan_timeout = 0;
83                 return FALSE;
84         }
85
86         if (device->driver->scan)
87                 device->driver->scan(device);
88
89         return TRUE;
90 }
91
92 static void clear_scan_trigger(struct connman_device *device)
93 {
94         if (device->scan_timeout > 0) {
95                 g_source_remove(device->scan_timeout);
96                 device->scan_timeout = 0;
97         }
98 }
99
100 static void reset_scan_trigger(struct connman_device *device)
101 {
102         clear_scan_trigger(device);
103
104         if (device->scan_interval > 0) {
105                 guint interval;
106
107                 if (g_hash_table_size(device->networks) == 0) {
108                         if (device->backoff_interval >= device->scan_interval)
109                                 device->backoff_interval = SCAN_INITIAL_DELAY;
110                         interval = device->backoff_interval;
111                 } else
112                         interval = device->scan_interval;
113
114                 DBG("interval %d", interval);
115
116                 device->scan_timeout = g_timeout_add_seconds(interval,
117                                         device_scan_trigger, device);
118
119                 device->backoff_interval *= 2;
120                 if (device->backoff_interval > device->scan_interval)
121                         device->backoff_interval = device->scan_interval;
122         }
123 }
124
125 static void force_scan_trigger(struct connman_device *device)
126 {
127         clear_scan_trigger(device);
128
129         device->scan_timeout = g_timeout_add_seconds(5,
130                                         device_scan_trigger, device);
131 }
132
133 void connman_device_schedule_scan(struct connman_device *device)
134 {
135         reset_scan_trigger(device);
136 }
137
138 static const char *type2description(enum connman_device_type type)
139 {
140         switch (type) {
141         case CONNMAN_DEVICE_TYPE_UNKNOWN:
142         case CONNMAN_DEVICE_TYPE_VENDOR:
143                 break;
144         case CONNMAN_DEVICE_TYPE_ETHERNET:
145                 return "Ethernet";
146         case CONNMAN_DEVICE_TYPE_WIFI:
147                 return "Wireless";
148         case CONNMAN_DEVICE_TYPE_WIMAX:
149                 return "WiMAX";
150         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
151                 return "Bluetooth";
152         case CONNMAN_DEVICE_TYPE_GPS:
153                 return "GPS";
154         case CONNMAN_DEVICE_TYPE_CELLULAR:
155                 return "Cellular";
156         case CONNMAN_DEVICE_TYPE_GADGET:
157                 return "Gadget";
158
159         }
160
161         return NULL;
162 }
163
164 static const char *type2string(enum connman_device_type type)
165 {
166         switch (type) {
167         case CONNMAN_DEVICE_TYPE_UNKNOWN:
168         case CONNMAN_DEVICE_TYPE_VENDOR:
169                 break;
170         case CONNMAN_DEVICE_TYPE_ETHERNET:
171                 return "ethernet";
172         case CONNMAN_DEVICE_TYPE_WIFI:
173                 return "wifi";
174         case CONNMAN_DEVICE_TYPE_WIMAX:
175                 return "wimax";
176         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
177                 return "bluetooth";
178         case CONNMAN_DEVICE_TYPE_GPS:
179                 return "gps";
180         case CONNMAN_DEVICE_TYPE_CELLULAR:
181                 return "cellular";
182         case CONNMAN_DEVICE_TYPE_GADGET:
183                 return "gadget";
184
185         }
186
187         return NULL;
188 }
189
190 enum connman_service_type __connman_device_get_service_type(struct connman_device *device)
191 {
192         enum connman_device_type type = connman_device_get_type(device);
193
194         switch (type) {
195         case CONNMAN_DEVICE_TYPE_UNKNOWN:
196         case CONNMAN_DEVICE_TYPE_VENDOR:
197         case CONNMAN_DEVICE_TYPE_GPS:
198                 break;
199         case CONNMAN_DEVICE_TYPE_ETHERNET:
200                 return CONNMAN_SERVICE_TYPE_ETHERNET;
201         case CONNMAN_DEVICE_TYPE_WIFI:
202                 return CONNMAN_SERVICE_TYPE_WIFI;
203         case CONNMAN_DEVICE_TYPE_WIMAX:
204                 return CONNMAN_SERVICE_TYPE_WIMAX;
205         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
206                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
207         case CONNMAN_DEVICE_TYPE_CELLULAR:
208                 return CONNMAN_SERVICE_TYPE_CELLULAR;
209         case CONNMAN_DEVICE_TYPE_GADGET:
210                 return CONNMAN_SERVICE_TYPE_GADGET;
211
212         }
213
214         return CONNMAN_SERVICE_TYPE_UNKNOWN;
215 }
216
217 static gboolean device_pending_reset(gpointer user_data)
218 {
219         struct connman_device *device = user_data;
220
221         DBG("device %p", device);
222
223         /* Power request timedout, reset power pending state. */
224         device->pending_timeout = 0;
225         device->powered_pending = PENDING_NONE;
226
227         return FALSE;
228 }
229
230 int __connman_device_enable(struct connman_device *device)
231 {
232         int err;
233
234         DBG("device %p", device);
235
236         if (!device->driver || !device->driver->enable)
237                 return -EOPNOTSUPP;
238
239         /* There is an ongoing power disable request. */
240         if (device->powered_pending == PENDING_DISABLE)
241                 return -EBUSY;
242
243         if (device->powered_pending == PENDING_ENABLE)
244                 return -EALREADY;
245
246         if (device->powered_pending == PENDING_NONE && device->powered == TRUE)
247                 return -EALREADY;
248
249         device->powered_pending = PENDING_ENABLE;
250
251         err = device->driver->enable(device);
252         /*
253          * device gets enabled right away.
254          * Invoke the callback
255          */
256         if (err == 0) {
257                 connman_device_set_powered(device, TRUE);
258                 goto done;
259         }
260
261         if (err == -EALREADY) {
262                 /* If device is already powered, but connman is not updated */
263                 connman_device_set_powered(device, TRUE);
264                 goto done;
265         }
266         /*
267          * if err == -EINPROGRESS, then the DBus call to the respective daemon
268          * was successful. We set a 4 sec timeout so if the daemon never
269          * returns a reply, we would reset the pending request.
270          */
271         if (err == -EINPROGRESS)
272                 device->pending_timeout = g_timeout_add_seconds(4,
273                                         device_pending_reset, device);
274 done:
275         return err;
276 }
277
278 int __connman_device_disable(struct connman_device *device)
279 {
280         int err;
281
282         DBG("device %p", device);
283
284         if (!device->driver || !device->driver->disable)
285                 return -EOPNOTSUPP;
286
287         /* Ongoing power enable request */
288         if (device->powered_pending == PENDING_ENABLE)
289                 return -EBUSY;
290
291         if (device->powered_pending == PENDING_DISABLE)
292                 return -EALREADY;
293
294         if (device->powered_pending == PENDING_NONE && device->powered == FALSE)
295                 return -EALREADY;
296
297         device->powered_pending = PENDING_DISABLE;
298         device->reconnect = FALSE;
299
300         clear_scan_trigger(device);
301
302         err = device->driver->disable(device);
303         if (err == 0) {
304                 connman_device_set_powered(device, FALSE);
305                 goto done;
306         }
307
308         if (err == -EALREADY) {
309                 connman_device_set_powered(device, FALSE);
310                 goto done;
311         }
312
313         if (err == -EINPROGRESS)
314                 device->pending_timeout = g_timeout_add_seconds(4,
315                                         device_pending_reset, device);
316 done:
317         return err;
318 }
319
320 static void probe_driver(struct connman_device_driver *driver)
321 {
322         GSList *list;
323
324         DBG("driver %p name %s", driver, driver->name);
325
326         for (list = device_list; list != NULL; list = list->next) {
327                 struct connman_device *device = list->data;
328
329                 if (device->driver != NULL)
330                         continue;
331
332                 if (driver->type != device->type)
333                         continue;
334
335                 if (driver->probe(device) < 0)
336                         continue;
337
338                 device->driver = driver;
339
340                 __connman_technology_add_device(device);
341         }
342 }
343
344 static void remove_device(struct connman_device *device)
345 {
346         DBG("device %p", device);
347
348         __connman_device_disable(device);
349
350         __connman_technology_remove_device(device);
351
352         if (device->driver->remove)
353                 device->driver->remove(device);
354
355         device->driver = NULL;
356 }
357
358 static void remove_driver(struct connman_device_driver *driver)
359 {
360         GSList *list;
361
362         DBG("driver %p name %s", driver, driver->name);
363
364         for (list = device_list; list != NULL; list = list->next) {
365                 struct connman_device *device = list->data;
366
367                 if (device->driver == driver)
368                         remove_device(device);
369         }
370 }
371
372 connman_bool_t __connman_device_has_driver(struct connman_device *device)
373 {
374         if (device == NULL || device->driver == NULL)
375                 return FALSE;
376
377         return TRUE;
378 }
379
380 static GSList *driver_list = NULL;
381
382 static gint compare_priority(gconstpointer a, gconstpointer b)
383 {
384         const struct connman_device_driver *driver1 = a;
385         const struct connman_device_driver *driver2 = b;
386
387         return driver2->priority - driver1->priority;
388 }
389
390 /**
391  * connman_device_driver_register:
392  * @driver: device driver definition
393  *
394  * Register a new device driver
395  *
396  * Returns: %0 on success
397  */
398 int connman_device_driver_register(struct connman_device_driver *driver)
399 {
400         DBG("driver %p name %s", driver, driver->name);
401
402         driver_list = g_slist_insert_sorted(driver_list, driver,
403                                                         compare_priority);
404         probe_driver(driver);
405
406         return 0;
407 }
408
409 /**
410  * connman_device_driver_unregister:
411  * @driver: device driver definition
412  *
413  * Remove a previously registered device driver
414  */
415 void connman_device_driver_unregister(struct connman_device_driver *driver)
416 {
417         DBG("driver %p name %s", driver, driver->name);
418
419         driver_list = g_slist_remove(driver_list, driver);
420
421         remove_driver(driver);
422 }
423
424 static void free_network(gpointer data)
425 {
426         struct connman_network *network = data;
427
428         DBG("network %p", network);
429
430         __connman_network_set_device(network, NULL);
431
432         connman_network_unref(network);
433 }
434
435 static void device_destruct(struct connman_device *device)
436 {
437         DBG("device %p name %s", device, device->name);
438
439         clear_scan_trigger(device);
440
441         g_free(device->ident);
442         g_free(device->node);
443         g_free(device->name);
444         g_free(device->address);
445         g_free(device->interface);
446         g_free(device->path);
447         g_free(device->devname);
448
449         g_free(device->last_network);
450
451         g_hash_table_destroy(device->networks);
452         device->networks = NULL;
453
454         g_free(device);
455 }
456
457 /**
458  * connman_device_create:
459  * @node: device node name (for example an address)
460  * @type: device type
461  *
462  * Allocate a new device of given #type and assign the #node name to it.
463  *
464  * Returns: a newly-allocated #connman_device structure
465  */
466 struct connman_device *connman_device_create(const char *node,
467                                                 enum connman_device_type type)
468 {
469         struct connman_device *device;
470         connman_bool_t bg_scan;
471
472         DBG("node %s type %d", node, type);
473
474         device = g_try_new0(struct connman_device, 1);
475         if (device == NULL)
476                 return NULL;
477
478         DBG("device %p", device);
479
480         device->refcount = 1;
481
482         bg_scan = connman_setting_get_bool("BackgroundScanning");
483
484         device->type = type;
485         device->name = g_strdup(type2description(device->type));
486
487         device->phyindex = -1;
488
489         device->backoff_interval = SCAN_INITIAL_DELAY;
490
491         switch (type) {
492         case CONNMAN_DEVICE_TYPE_UNKNOWN:
493         case CONNMAN_DEVICE_TYPE_ETHERNET:
494         case CONNMAN_DEVICE_TYPE_WIMAX:
495         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
496         case CONNMAN_DEVICE_TYPE_CELLULAR:
497         case CONNMAN_DEVICE_TYPE_GPS:
498         case CONNMAN_DEVICE_TYPE_GADGET:
499         case CONNMAN_DEVICE_TYPE_VENDOR:
500                 device->scan_interval = 0;
501                 break;
502         case CONNMAN_DEVICE_TYPE_WIFI:
503                 if (bg_scan == TRUE)
504                         device->scan_interval = 300;
505                 else
506                         device->scan_interval = 0;
507                 break;
508         }
509
510         device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
511                                                 g_free, free_network);
512
513         device_list = g_slist_append(device_list, device);
514
515         return device;
516 }
517
518 /**
519  * connman_device_ref:
520  * @device: device structure
521  *
522  * Increase reference counter of device
523  */
524 struct connman_device *connman_device_ref(struct connman_device *device)
525 {
526         DBG("%p", device);
527
528         g_atomic_int_inc(&device->refcount);
529
530         return device;
531 }
532
533 /**
534  * connman_device_unref:
535  * @device: device structure
536  *
537  * Decrease reference counter of device
538  */
539 void connman_device_unref(struct connman_device *device)
540 {
541         if (g_atomic_int_dec_and_test(&device->refcount) == FALSE)
542                 return;
543
544         if (device->driver) {
545                 device->driver->remove(device);
546                 device->driver = NULL;
547         }
548
549         device_list = g_slist_remove(device_list, device);
550
551         device_destruct(device);
552 }
553
554 const char *__connman_device_get_type(struct connman_device *device)
555 {
556         return type2string(device->type);
557 }
558
559 /**
560  * connman_device_get_type:
561  * @device: device structure
562  *
563  * Get type of device
564  */
565 enum connman_device_type connman_device_get_type(struct connman_device *device)
566 {
567         return device->type;
568 }
569
570 /**
571  * connman_device_set_index:
572  * @device: device structure
573  * @index: index number
574  *
575  * Set index number of device
576  */
577 void connman_device_set_index(struct connman_device *device, int index)
578 {
579         device->index = index;
580 }
581
582 /**
583  * connman_device_get_index:
584  * @device: device structure
585  *
586  * Get index number of device
587  */
588 int connman_device_get_index(struct connman_device *device)
589 {
590         return device->index;
591 }
592
593 int __connman_device_get_phyindex(struct connman_device *device)
594 {
595         return device->phyindex;
596 }
597
598 void __connman_device_set_phyindex(struct connman_device *device,
599                                                         int phyindex)
600 {
601         device->phyindex = phyindex;
602 }
603
604 /**
605  * connman_device_set_interface:
606  * @device: device structure
607  * @interface: interface name
608  *
609  * Set interface name of device
610  */
611 void connman_device_set_interface(struct connman_device *device,
612                                                 const char *interface)
613 {
614         g_free(device->devname);
615         device->devname = g_strdup(interface);
616
617         g_free(device->interface);
618         device->interface = g_strdup(interface);
619
620         if (device->name == NULL) {
621                 const char *str = type2description(device->type);
622                 if (str != NULL && device->interface != NULL)
623                         device->name = g_strdup_printf("%s (%s)", str,
624                                                         device->interface);
625         }
626 }
627
628 /**
629  * connman_device_set_ident:
630  * @device: device structure
631  * @ident: unique identifier
632  *
633  * Set unique identifier of device
634  */
635 void connman_device_set_ident(struct connman_device *device,
636                                                         const char *ident)
637 {
638         g_free(device->ident);
639         device->ident = g_strdup(ident);
640 }
641
642 const char *connman_device_get_ident(struct connman_device *device)
643 {
644         return device->ident;
645 }
646
647 /**
648  * connman_device_set_powered:
649  * @device: device structure
650  * @powered: powered state
651  *
652  * Change power state of device
653  */
654 int connman_device_set_powered(struct connman_device *device,
655                                                 connman_bool_t powered)
656 {
657         enum connman_service_type type;
658
659         DBG("driver %p powered %d", device, powered);
660
661         if (device->powered == powered)
662                 return -EALREADY;
663
664         if (device->pending_timeout) {
665                 /* Reset pending request */
666                 g_source_remove(device->pending_timeout);
667                 device->pending_timeout = 0;
668         }
669
670         device->powered_pending = PENDING_NONE;
671
672         device->powered = powered;
673
674         type = __connman_device_get_service_type(device);
675
676         if (device->powered == TRUE)
677                 __connman_technology_enabled(type);
678         else
679                 __connman_technology_disabled(type);
680
681         if (powered == FALSE) {
682                 device->connections = 0;
683                 return 0;
684         }
685
686         connman_device_set_disconnected(device, FALSE);
687         device->scanning = FALSE;
688
689         reset_scan_trigger(device);
690
691         if (device->driver && device->driver->scan_fast)
692                 device->driver->scan_fast(device);
693         else if (device->driver && device->driver->scan)
694                 device->driver->scan(device);
695
696         return 0;
697 }
698
699 static int device_scan(struct connman_device *device)
700 {
701         if (!device->driver || !device->driver->scan)
702                 return -EOPNOTSUPP;
703
704         if (device->powered == FALSE)
705                 return -ENOLINK;
706
707         reset_scan_trigger(device);
708
709         return device->driver->scan(device);
710 }
711
712 int __connman_device_disconnect(struct connman_device *device)
713 {
714         GHashTableIter iter;
715         gpointer key, value;
716
717         DBG("device %p", device);
718
719         connman_device_set_disconnected(device, TRUE);
720
721         g_hash_table_iter_init(&iter, device->networks);
722
723         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
724                 struct connman_network *network = value;
725
726                 if (connman_network_get_connecting(network) == TRUE) {
727                         /*
728                          * Skip network in the process of connecting.
729                          * This is a workaround for WiFi networks serviced
730                          * by the supplicant plugin that hold a reference
731                          * to the network.  If we disconnect the network
732                          * here then the referenced object will not be
733                          * registered and usage (like launching DHCP client)
734                          * will fail.  There is nothing to be gained by
735                          * removing the network here anyway.
736                          */
737                         connman_warn("Skipping disconnect of %s, network is connecting.",
738                                 connman_network_get_identifier(network));
739                         continue;
740                 }
741
742                 __connman_network_disconnect(network);
743         }
744
745         return 0;
746 }
747
748 static void mark_network_available(gpointer key, gpointer value,
749                                                         gpointer user_data)
750 {
751         struct connman_network *network = value;
752
753         connman_network_set_available(network, TRUE);
754 }
755
756 static void mark_network_unavailable(gpointer key, gpointer value,
757                                                         gpointer user_data)
758 {
759         struct connman_network *network = value;
760
761         if (connman_network_get_connected(network) == TRUE)
762                 return;
763
764         connman_network_set_available(network, FALSE);
765 }
766
767 static gboolean remove_unavailable_network(gpointer key, gpointer value,
768                                                         gpointer user_data)
769 {
770         struct connman_network *network = value;
771
772         if (connman_network_get_connected(network) == TRUE)
773                 return FALSE;
774
775         if (connman_network_get_available(network) == TRUE)
776                 return FALSE;
777
778         return TRUE;
779 }
780
781 void __connman_device_cleanup_networks(struct connman_device *device)
782 {
783         g_hash_table_foreach_remove(device->networks,
784                                         remove_unavailable_network, NULL);
785 }
786
787 connman_bool_t __connman_device_scanning(struct connman_device *device)
788 {
789         return device->scanning;
790 }
791
792 void connman_device_reset_scanning(struct connman_device *device)
793 {
794         device->scanning = FALSE;
795
796         g_hash_table_foreach(device->networks,
797                                 mark_network_available, NULL);
798
799 }
800
801 /**
802  * connman_device_set_scanning:
803  * @device: device structure
804  * @scanning: scanning state
805  *
806  * Change scanning state of device
807  */
808 int connman_device_set_scanning(struct connman_device *device,
809                                                 connman_bool_t scanning)
810 {
811         DBG("device %p scanning %d", device, scanning);
812
813         if (!device->driver || !device->driver->scan)
814                 return -EINVAL;
815
816         if (device->scanning == scanning)
817                 return -EALREADY;
818
819         device->scanning = scanning;
820
821         if (scanning == TRUE) {
822                 reset_scan_trigger(device);
823
824                 g_hash_table_foreach(device->networks,
825                                         mark_network_unavailable, NULL);
826
827                 return 0;
828         }
829
830         __connman_device_cleanup_networks(device);
831
832         if (device->connections > 0)
833                 return 0;
834
835         __connman_service_auto_connect();
836
837         return 0;
838 }
839
840 /**
841  * connman_device_set_disconnected:
842  * @device: device structure
843  * @disconnected: disconnected state
844  *
845  * Change disconnected state of device (only for device with networks)
846  */
847 int connman_device_set_disconnected(struct connman_device *device,
848                                                 connman_bool_t disconnected)
849 {
850         DBG("device %p disconnected %d", device, disconnected);
851
852         if (device->disconnected == disconnected)
853                 return -EALREADY;
854
855         device->disconnected = disconnected;
856
857         if (disconnected == TRUE)
858                 force_scan_trigger(device);
859
860         return 0;
861 }
862
863 /**
864  * connman_device_get_disconnected:
865  * @device: device structure
866  *
867  * Get device disconnected state
868  */
869 connman_bool_t connman_device_get_disconnected(struct connman_device *device)
870 {
871         return device->disconnected;
872 }
873
874 /**
875  * connman_device_set_string:
876  * @device: device structure
877  * @key: unique identifier
878  * @value: string value
879  *
880  * Set string value for specific key
881  */
882 int connman_device_set_string(struct connman_device *device,
883                                         const char *key, const char *value)
884 {
885         DBG("device %p key %s value %s", device, key, value);
886
887         if (g_str_equal(key, "Address") == TRUE) {
888                 g_free(device->address);
889                 device->address = g_strdup(value);
890         } else if (g_str_equal(key, "Name") == TRUE) {
891                 g_free(device->name);
892                 device->name = g_strdup(value);
893         } else if (g_str_equal(key, "Node") == TRUE) {
894                 g_free(device->node);
895                 device->node = g_strdup(value);
896         } else if (g_str_equal(key, "Path") == TRUE) {
897                 g_free(device->path);
898                 device->path = g_strdup(value);
899         } else {
900                 return -EINVAL;
901         }
902
903         return 0;
904 }
905
906 /**
907  * connman_device_get_string:
908  * @device: device structure
909  * @key: unique identifier
910  *
911  * Get string value for specific key
912  */
913 const char *connman_device_get_string(struct connman_device *device,
914                                                         const char *key)
915 {
916         DBG("device %p key %s", device, key);
917
918         if (g_str_equal(key, "Address") == TRUE)
919                 return device->address;
920         else if (g_str_equal(key, "Name") == TRUE)
921                 return device->name;
922         else if (g_str_equal(key, "Node") == TRUE)
923                 return device->node;
924         else if (g_str_equal(key, "Interface") == TRUE)
925                 return device->interface;
926         else if (g_str_equal(key, "Path") == TRUE)
927                 return device->path;
928
929         return NULL;
930 }
931
932 void __connman_device_increase_connections(struct connman_device *device)
933 {
934         if (device == NULL)
935                 return;
936
937         device->connections++;
938 }
939
940 void __connman_device_decrease_connections(struct connman_device *device)
941 {
942         if (device == NULL)
943                 return;
944
945         device->connections--;
946
947         if (device->connections == 0)
948                 device->backoff_interval = SCAN_INITIAL_DELAY;
949 }
950
951 /**
952  * connman_device_add_network:
953  * @device: device structure
954  * @network: network structure
955  *
956  * Add new network to the device
957  */
958 int connman_device_add_network(struct connman_device *device,
959                                         struct connman_network *network)
960 {
961         const char *identifier = connman_network_get_identifier(network);
962
963         DBG("device %p network %p", device, network);
964
965         if (identifier == NULL)
966                 return -EINVAL;
967
968         connman_network_ref(network);
969
970         __connman_network_set_device(network, device);
971
972         g_hash_table_insert(device->networks, g_strdup(identifier),
973                                                                 network);
974
975         return 0;
976 }
977
978 /**
979  * connman_device_get_network:
980  * @device: device structure
981  * @identifier: network identifier
982  *
983  * Get network for given identifier
984  */
985 struct connman_network *connman_device_get_network(struct connman_device *device,
986                                                         const char *identifier)
987 {
988         DBG("device %p identifier %s", device, identifier);
989
990         return g_hash_table_lookup(device->networks, identifier);
991 }
992
993 /**
994  * connman_device_remove_network:
995  * @device: device structure
996  * @identifier: network identifier
997  *
998  * Remove network for given identifier
999  */
1000 int connman_device_remove_network(struct connman_device *device,
1001                                                 struct connman_network *network)
1002 {
1003         const char *identifier;
1004
1005         DBG("device %p network %p", device, network);
1006
1007         if (network == NULL)
1008                 return 0;
1009
1010         identifier = connman_network_get_identifier(network);
1011         g_hash_table_remove(device->networks, identifier);
1012
1013         return 0;
1014 }
1015
1016 void connman_device_remove_all_networks(struct connman_device *device)
1017 {
1018         g_hash_table_remove_all(device->networks);
1019 }
1020
1021 void __connman_device_set_network(struct connman_device *device,
1022                                         struct connman_network *network)
1023 {
1024         const char *name;
1025
1026         if (device == NULL)
1027                 return;
1028
1029         if (device->network == network)
1030                 return;
1031
1032         if (network != NULL) {
1033                 name = connman_network_get_string(network, "Name");
1034                 g_free(device->last_network);
1035                 device->last_network = g_strdup(name);
1036
1037                 device->network = network;
1038         } else {
1039                 g_free(device->last_network);
1040                 device->last_network = NULL;
1041
1042                 device->network = NULL;
1043         }
1044 }
1045
1046 void __connman_device_set_reconnect(struct connman_device *device,
1047                                                 connman_bool_t reconnect)
1048 {
1049         device->reconnect = reconnect;
1050 }
1051
1052 connman_bool_t  __connman_device_get_reconnect(
1053                                 struct connman_device *device)
1054 {
1055         return device->reconnect;
1056 }
1057
1058 static gboolean match_driver(struct connman_device *device,
1059                                         struct connman_device_driver *driver)
1060 {
1061         if (device->type == driver->type ||
1062                         driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1063                 return TRUE;
1064
1065         return FALSE;
1066 }
1067
1068 /**
1069  * connman_device_register:
1070  * @device: device structure
1071  *
1072  * Register device with the system
1073  */
1074 int connman_device_register(struct connman_device *device)
1075 {
1076         GSList *list;
1077
1078         DBG("device %p name %s", device, device->name);
1079
1080         if (device->driver != NULL)
1081                 return -EALREADY;
1082
1083         for (list = driver_list; list; list = list->next) {
1084                 struct connman_device_driver *driver = list->data;
1085
1086                 if (match_driver(device, driver) == FALSE)
1087                         continue;
1088
1089                 DBG("driver %p name %s", driver, driver->name);
1090
1091                 if (driver->probe(device) == 0) {
1092                         device->driver = driver;
1093                         break;
1094                 }
1095         }
1096
1097         if (device->driver == NULL)
1098                 return 0;
1099
1100         return __connman_technology_add_device(device);
1101 }
1102
1103 /**
1104  * connman_device_unregister:
1105  * @device: device structure
1106  *
1107  * Unregister device with the system
1108  */
1109 void connman_device_unregister(struct connman_device *device)
1110 {
1111         DBG("device %p name %s", device, device->name);
1112
1113         if (device->driver == NULL)
1114                 return;
1115
1116         remove_device(device);
1117 }
1118
1119 /**
1120  * connman_device_get_data:
1121  * @device: device structure
1122  *
1123  * Get private device data pointer
1124  */
1125 void *connman_device_get_data(struct connman_device *device)
1126 {
1127         return device->driver_data;
1128 }
1129
1130 /**
1131  * connman_device_set_data:
1132  * @device: device structure
1133  * @data: data pointer
1134  *
1135  * Set private device data pointer
1136  */
1137 void connman_device_set_data(struct connman_device *device, void *data)
1138 {
1139         device->driver_data = data;
1140 }
1141
1142 struct connman_device *__connman_device_find_device(
1143                                 enum connman_service_type type)
1144 {
1145         GSList *list;
1146
1147         for (list = device_list; list != NULL; list = list->next) {
1148                 struct connman_device *device = list->data;
1149                 enum connman_service_type service_type =
1150                         __connman_device_get_service_type(device);
1151
1152                 if (service_type != type)
1153                         continue;
1154
1155                 return device;
1156         }
1157
1158         return NULL;
1159 }
1160
1161 int __connman_device_request_scan(enum connman_service_type type)
1162 {
1163         GSList *list;
1164         int err;
1165
1166         switch (type) {
1167         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1168         case CONNMAN_SERVICE_TYPE_SYSTEM:
1169         case CONNMAN_SERVICE_TYPE_ETHERNET:
1170         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1171         case CONNMAN_SERVICE_TYPE_CELLULAR:
1172         case CONNMAN_SERVICE_TYPE_GPS:
1173         case CONNMAN_SERVICE_TYPE_VPN:
1174         case CONNMAN_SERVICE_TYPE_GADGET:
1175                 return 0;
1176         case CONNMAN_SERVICE_TYPE_WIFI:
1177         case CONNMAN_SERVICE_TYPE_WIMAX:
1178                 break;
1179         }
1180
1181         for (list = device_list; list != NULL; list = list->next) {
1182                 struct connman_device *device = list->data;
1183                 enum connman_service_type service_type =
1184                         __connman_device_get_service_type(device);
1185
1186                 if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN &&
1187                                 service_type != type) {
1188                         continue;
1189                 }
1190
1191                 err = device_scan(device);
1192                 if (err < 0 && err != -EINPROGRESS) {
1193                         DBG("err %d", err);
1194                         /* XXX maybe only a continue? */
1195                         return err;
1196                 }
1197         }
1198
1199         return 0;
1200 }
1201
1202 connman_bool_t __connman_device_isfiltered(const char *devname)
1203 {
1204         char **pattern;
1205
1206         if (device_filter == NULL)
1207                 goto nodevice;
1208
1209         for (pattern = device_filter; *pattern; pattern++) {
1210                 if (g_pattern_match_simple(*pattern, devname) == FALSE) {
1211                         DBG("ignoring device %s (match)", devname);
1212                         return TRUE;
1213                 }
1214         }
1215
1216 nodevice:
1217         if (g_pattern_match_simple("dummy*", devname) == TRUE) {
1218                 DBG("ignoring dummy networking devices");
1219                 return TRUE;
1220         }
1221
1222         if (nodevice_filter == NULL)
1223                 return FALSE;
1224
1225         for (pattern = nodevice_filter; *pattern; pattern++) {
1226                 if (g_pattern_match_simple(*pattern, devname) == TRUE) {
1227                         DBG("ignoring device %s (no match)", devname);
1228                         return TRUE;
1229                 }
1230         }
1231
1232         return FALSE;
1233 }
1234
1235 int __connman_device_init(const char *device, const char *nodevice)
1236 {
1237         DBG("");
1238
1239         if (device != NULL)
1240                 device_filter = g_strsplit(device, ",", -1);
1241
1242         if (nodevice != NULL)
1243                 nodevice_filter = g_strsplit(nodevice, ",", -1);
1244
1245         return 0;
1246 }
1247
1248 void __connman_device_cleanup(void)
1249 {
1250         DBG("");
1251
1252         g_strfreev(nodevice_filter);
1253         g_strfreev(device_filter);
1254 }