device: Remove redundant connection numbers check
[framework/connectivity/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         __connman_service_auto_connect();
833
834         return 0;
835 }
836
837 /**
838  * connman_device_set_disconnected:
839  * @device: device structure
840  * @disconnected: disconnected state
841  *
842  * Change disconnected state of device (only for device with networks)
843  */
844 int connman_device_set_disconnected(struct connman_device *device,
845                                                 connman_bool_t disconnected)
846 {
847         DBG("device %p disconnected %d", device, disconnected);
848
849         if (device->disconnected == disconnected)
850                 return -EALREADY;
851
852         device->disconnected = disconnected;
853
854         if (disconnected == TRUE)
855                 force_scan_trigger(device);
856
857         return 0;
858 }
859
860 /**
861  * connman_device_get_disconnected:
862  * @device: device structure
863  *
864  * Get device disconnected state
865  */
866 connman_bool_t connman_device_get_disconnected(struct connman_device *device)
867 {
868         return device->disconnected;
869 }
870
871 /**
872  * connman_device_set_string:
873  * @device: device structure
874  * @key: unique identifier
875  * @value: string value
876  *
877  * Set string value for specific key
878  */
879 int connman_device_set_string(struct connman_device *device,
880                                         const char *key, const char *value)
881 {
882         DBG("device %p key %s value %s", device, key, value);
883
884         if (g_str_equal(key, "Address") == TRUE) {
885                 g_free(device->address);
886                 device->address = g_strdup(value);
887         } else if (g_str_equal(key, "Name") == TRUE) {
888                 g_free(device->name);
889                 device->name = g_strdup(value);
890         } else if (g_str_equal(key, "Node") == TRUE) {
891                 g_free(device->node);
892                 device->node = g_strdup(value);
893         } else if (g_str_equal(key, "Path") == TRUE) {
894                 g_free(device->path);
895                 device->path = g_strdup(value);
896         } else {
897                 return -EINVAL;
898         }
899
900         return 0;
901 }
902
903 /**
904  * connman_device_get_string:
905  * @device: device structure
906  * @key: unique identifier
907  *
908  * Get string value for specific key
909  */
910 const char *connman_device_get_string(struct connman_device *device,
911                                                         const char *key)
912 {
913         DBG("device %p key %s", device, key);
914
915         if (g_str_equal(key, "Address") == TRUE)
916                 return device->address;
917         else if (g_str_equal(key, "Name") == TRUE)
918                 return device->name;
919         else if (g_str_equal(key, "Node") == TRUE)
920                 return device->node;
921         else if (g_str_equal(key, "Interface") == TRUE)
922                 return device->interface;
923         else if (g_str_equal(key, "Path") == TRUE)
924                 return device->path;
925
926         return NULL;
927 }
928
929 void __connman_device_increase_connections(struct connman_device *device)
930 {
931         if (device == NULL)
932                 return;
933
934         device->connections++;
935 }
936
937 void __connman_device_decrease_connections(struct connman_device *device)
938 {
939         if (device == NULL)
940                 return;
941
942         device->connections--;
943
944         if (device->connections == 0)
945                 device->backoff_interval = SCAN_INITIAL_DELAY;
946 }
947
948 /**
949  * connman_device_add_network:
950  * @device: device structure
951  * @network: network structure
952  *
953  * Add new network to the device
954  */
955 int connman_device_add_network(struct connman_device *device,
956                                         struct connman_network *network)
957 {
958         const char *identifier = connman_network_get_identifier(network);
959
960         DBG("device %p network %p", device, network);
961
962         if (identifier == NULL)
963                 return -EINVAL;
964
965         connman_network_ref(network);
966
967         __connman_network_set_device(network, device);
968
969         g_hash_table_insert(device->networks, g_strdup(identifier),
970                                                                 network);
971
972         return 0;
973 }
974
975 /**
976  * connman_device_get_network:
977  * @device: device structure
978  * @identifier: network identifier
979  *
980  * Get network for given identifier
981  */
982 struct connman_network *connman_device_get_network(struct connman_device *device,
983                                                         const char *identifier)
984 {
985         DBG("device %p identifier %s", device, identifier);
986
987         return g_hash_table_lookup(device->networks, identifier);
988 }
989
990 /**
991  * connman_device_remove_network:
992  * @device: device structure
993  * @identifier: network identifier
994  *
995  * Remove network for given identifier
996  */
997 int connman_device_remove_network(struct connman_device *device,
998                                                 struct connman_network *network)
999 {
1000         const char *identifier;
1001
1002         DBG("device %p network %p", device, network);
1003
1004         if (network == NULL)
1005                 return 0;
1006
1007         identifier = connman_network_get_identifier(network);
1008         g_hash_table_remove(device->networks, identifier);
1009
1010         return 0;
1011 }
1012
1013 void connman_device_remove_all_networks(struct connman_device *device)
1014 {
1015         g_hash_table_remove_all(device->networks);
1016 }
1017
1018 void __connman_device_set_network(struct connman_device *device,
1019                                         struct connman_network *network)
1020 {
1021         const char *name;
1022
1023         if (device == NULL)
1024                 return;
1025
1026         if (device->network == network)
1027                 return;
1028
1029         if (network != NULL) {
1030                 name = connman_network_get_string(network, "Name");
1031                 g_free(device->last_network);
1032                 device->last_network = g_strdup(name);
1033
1034                 device->network = network;
1035         } else {
1036                 g_free(device->last_network);
1037                 device->last_network = NULL;
1038
1039                 device->network = NULL;
1040         }
1041 }
1042
1043 void __connman_device_set_reconnect(struct connman_device *device,
1044                                                 connman_bool_t reconnect)
1045 {
1046         device->reconnect = reconnect;
1047 }
1048
1049 connman_bool_t  __connman_device_get_reconnect(
1050                                 struct connman_device *device)
1051 {
1052         return device->reconnect;
1053 }
1054
1055 static gboolean match_driver(struct connman_device *device,
1056                                         struct connman_device_driver *driver)
1057 {
1058         if (device->type == driver->type ||
1059                         driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1060                 return TRUE;
1061
1062         return FALSE;
1063 }
1064
1065 /**
1066  * connman_device_register:
1067  * @device: device structure
1068  *
1069  * Register device with the system
1070  */
1071 int connman_device_register(struct connman_device *device)
1072 {
1073         GSList *list;
1074
1075         DBG("device %p name %s", device, device->name);
1076
1077         if (device->driver != NULL)
1078                 return -EALREADY;
1079
1080         for (list = driver_list; list; list = list->next) {
1081                 struct connman_device_driver *driver = list->data;
1082
1083                 if (match_driver(device, driver) == FALSE)
1084                         continue;
1085
1086                 DBG("driver %p name %s", driver, driver->name);
1087
1088                 if (driver->probe(device) == 0) {
1089                         device->driver = driver;
1090                         break;
1091                 }
1092         }
1093
1094         if (device->driver == NULL)
1095                 return 0;
1096
1097         return __connman_technology_add_device(device);
1098 }
1099
1100 /**
1101  * connman_device_unregister:
1102  * @device: device structure
1103  *
1104  * Unregister device with the system
1105  */
1106 void connman_device_unregister(struct connman_device *device)
1107 {
1108         DBG("device %p name %s", device, device->name);
1109
1110         if (device->driver == NULL)
1111                 return;
1112
1113         remove_device(device);
1114 }
1115
1116 /**
1117  * connman_device_get_data:
1118  * @device: device structure
1119  *
1120  * Get private device data pointer
1121  */
1122 void *connman_device_get_data(struct connman_device *device)
1123 {
1124         return device->driver_data;
1125 }
1126
1127 /**
1128  * connman_device_set_data:
1129  * @device: device structure
1130  * @data: data pointer
1131  *
1132  * Set private device data pointer
1133  */
1134 void connman_device_set_data(struct connman_device *device, void *data)
1135 {
1136         device->driver_data = data;
1137 }
1138
1139 struct connman_device *__connman_device_find_device(
1140                                 enum connman_service_type type)
1141 {
1142         GSList *list;
1143
1144         for (list = device_list; list != NULL; list = list->next) {
1145                 struct connman_device *device = list->data;
1146                 enum connman_service_type service_type =
1147                         __connman_device_get_service_type(device);
1148
1149                 if (service_type != type)
1150                         continue;
1151
1152                 return device;
1153         }
1154
1155         return NULL;
1156 }
1157
1158 int __connman_device_request_scan(enum connman_service_type type)
1159 {
1160         GSList *list;
1161         int err;
1162
1163         switch (type) {
1164         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1165         case CONNMAN_SERVICE_TYPE_SYSTEM:
1166         case CONNMAN_SERVICE_TYPE_ETHERNET:
1167         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1168         case CONNMAN_SERVICE_TYPE_CELLULAR:
1169         case CONNMAN_SERVICE_TYPE_GPS:
1170         case CONNMAN_SERVICE_TYPE_VPN:
1171         case CONNMAN_SERVICE_TYPE_GADGET:
1172                 return 0;
1173         case CONNMAN_SERVICE_TYPE_WIFI:
1174         case CONNMAN_SERVICE_TYPE_WIMAX:
1175                 break;
1176         }
1177
1178         for (list = device_list; list != NULL; list = list->next) {
1179                 struct connman_device *device = list->data;
1180                 enum connman_service_type service_type =
1181                         __connman_device_get_service_type(device);
1182
1183                 if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN &&
1184                                 service_type != type) {
1185                         continue;
1186                 }
1187
1188                 err = device_scan(device);
1189                 if (err < 0 && err != -EINPROGRESS) {
1190                         DBG("err %d", err);
1191                         /* XXX maybe only a continue? */
1192                         return err;
1193                 }
1194         }
1195
1196         return 0;
1197 }
1198
1199 connman_bool_t __connman_device_isfiltered(const char *devname)
1200 {
1201         char **pattern;
1202
1203         if (device_filter == NULL)
1204                 goto nodevice;
1205
1206         for (pattern = device_filter; *pattern; pattern++) {
1207                 if (g_pattern_match_simple(*pattern, devname) == FALSE) {
1208                         DBG("ignoring device %s (match)", devname);
1209                         return TRUE;
1210                 }
1211         }
1212
1213 nodevice:
1214         if (g_pattern_match_simple("dummy*", devname) == TRUE) {
1215                 DBG("ignoring dummy networking devices");
1216                 return TRUE;
1217         }
1218
1219         if (nodevice_filter == NULL)
1220                 return FALSE;
1221
1222         for (pattern = nodevice_filter; *pattern; pattern++) {
1223                 if (g_pattern_match_simple(*pattern, devname) == TRUE) {
1224                         DBG("ignoring device %s (no match)", devname);
1225                         return TRUE;
1226                 }
1227         }
1228
1229         return FALSE;
1230 }
1231
1232 int __connman_device_init(const char *device, const char *nodevice)
1233 {
1234         DBG("");
1235
1236         if (device != NULL)
1237                 device_filter = g_strsplit(device, ",", -1);
1238
1239         if (nodevice != NULL)
1240                 nodevice_filter = g_strsplit(nodevice, ",", -1);
1241
1242         return 0;
1243 }
1244
1245 void __connman_device_cleanup(void)
1246 {
1247         DBG("");
1248
1249         g_strfreev(nodevice_filter);
1250         g_strfreev(device_filter);
1251 }