e2e00e53e0810ab42e35b1b927ee29240478ecce
[platform/upstream/connman.git] / src / technology.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2007-2012  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 <gdbus.h>
30
31 #include "connman.h"
32
33 static DBusConnection *connection;
34
35 static GSList *technology_list = NULL;
36
37 /*
38  * List of devices with no technology associated with them either because of
39  * no compiled in support or the driver is not yet loaded.
40 */
41 static GSList *techless_device_list = NULL;
42 static GHashTable *rfkill_list;
43
44 static connman_bool_t global_offlinemode;
45
46 struct connman_rfkill {
47         unsigned int index;
48         enum connman_service_type type;
49         connman_bool_t softblock;
50         connman_bool_t hardblock;
51 };
52
53 struct connman_technology {
54         int refcount;
55         enum connman_service_type type;
56         char *path;
57         GSList *device_list;
58         int enabled;
59         char *regdom;
60         connman_bool_t connected;
61
62         connman_bool_t tethering;
63         char *tethering_ident;
64         char *tethering_passphrase;
65
66         connman_bool_t enable_persistent; /* Save the tech state */
67
68         struct connman_technology_driver *driver;
69         void *driver_data;
70
71         DBusMessage *pending_reply;
72         guint pending_timeout;
73
74         GSList *scan_pending;
75 };
76
77 static GSList *driver_list = NULL;
78
79 static gint compare_priority(gconstpointer a, gconstpointer b)
80 {
81         const struct connman_technology_driver *driver1 = a;
82         const struct connman_technology_driver *driver2 = b;
83
84         return driver2->priority - driver1->priority;
85 }
86
87 static void rfkill_check(gpointer key, gpointer value, gpointer user_data)
88 {
89         struct connman_rfkill *rfkill = value;
90         enum connman_service_type type = GPOINTER_TO_INT(user_data);
91
92         /* Calling _technology_rfkill_add will update the tech. */
93         if (rfkill->type == type)
94                 __connman_technology_add_rfkill(rfkill->index, type,
95                                 rfkill->softblock, rfkill->hardblock);
96 }
97
98 /**
99  * connman_technology_driver_register:
100  * @driver: Technology driver definition
101  *
102  * Register a new technology driver
103  *
104  * Returns: %0 on success
105  */
106 int connman_technology_driver_register(struct connman_technology_driver *driver)
107 {
108         GSList *list;
109         struct connman_device *device;
110         enum connman_service_type type;
111
112         DBG("Registering %s driver", driver->name);
113
114         driver_list = g_slist_insert_sorted(driver_list, driver,
115                                                         compare_priority);
116
117         if (techless_device_list == NULL)
118                 goto check_rfkill;
119
120         /*
121          * Check for technology less devices if this driver
122          * can service any of them.
123         */
124         for (list = techless_device_list; list; list = list->next) {
125                 device = list->data;
126
127                 type = __connman_device_get_service_type(device);
128                 if (type != driver->type)
129                         continue;
130
131                 techless_device_list = g_slist_remove(techless_device_list,
132                                                                 device);
133
134                 __connman_technology_add_device(device);
135         }
136
137 check_rfkill:
138         /* Check for orphaned rfkill switches. */
139         g_hash_table_foreach(rfkill_list, rfkill_check,
140                                         GINT_TO_POINTER(driver->type));
141
142         return 0;
143 }
144
145 /**
146  * connman_technology_driver_unregister:
147  * @driver: Technology driver definition
148  *
149  * Remove a previously registered technology driver
150  */
151 void connman_technology_driver_unregister(struct connman_technology_driver *driver)
152 {
153         GSList *list;
154         struct connman_technology *technology;
155
156         DBG("Unregistering driver %p name %s", driver, driver->name);
157
158         for (list = technology_list; list; list = list->next) {
159                 technology = list->data;
160
161                 if (technology->driver == NULL)
162                         continue;
163
164                 if (technology->type == driver->type) {
165                         technology->driver->remove(technology);
166                         technology->driver = NULL;
167                 }
168         }
169
170         driver_list = g_slist_remove(driver_list, driver);
171 }
172
173 static void tethering_changed(struct connman_technology *technology)
174 {
175         connman_bool_t tethering = technology->tethering;
176
177         connman_dbus_property_changed_basic(technology->path,
178                                 CONNMAN_TECHNOLOGY_INTERFACE, "Tethering",
179                                                 DBUS_TYPE_BOOLEAN, &tethering);
180 }
181
182 void connman_technology_tethering_notify(struct connman_technology *technology,
183                                                         connman_bool_t enabled)
184 {
185         GSList *list;
186
187         DBG("technology %p enabled %u", technology, enabled);
188
189         if (technology->tethering == enabled)
190                 return;
191
192         technology->tethering = enabled;
193
194         tethering_changed(technology);
195
196         if (enabled == TRUE)
197                 __connman_tethering_set_enabled();
198         else {
199                 for (list = technology_list; list; list = list->next) {
200                         struct connman_technology *other_tech = list->data;
201                         if (other_tech->tethering == TRUE)
202                                 break;
203                 }
204                 if (list == NULL)
205                         __connman_tethering_set_disabled();
206         }
207 }
208
209 static int set_tethering(struct connman_technology *technology,
210                                 connman_bool_t enabled)
211 {
212         const char *ident, *passphrase, *bridge;
213
214         ident = technology->tethering_ident;
215         passphrase = technology->tethering_passphrase;
216
217         if (technology->driver == NULL ||
218                         technology->driver->set_tethering == NULL)
219                 return -EOPNOTSUPP;
220
221         bridge = __connman_tethering_get_bridge();
222         if (bridge == NULL)
223                 return -EOPNOTSUPP;
224
225         if (technology->type == CONNMAN_SERVICE_TYPE_WIFI &&
226             (ident == NULL || passphrase == NULL))
227                 return -EINVAL;
228
229         return technology->driver->set_tethering(technology, ident, passphrase,
230                                                         bridge, enabled);
231 }
232
233 void connman_technology_regdom_notify(struct connman_technology *technology,
234                                                         const char *alpha2)
235 {
236         DBG("");
237
238         if (alpha2 == NULL)
239                 connman_error("Failed to set regulatory domain");
240         else
241                 DBG("Regulatory domain set to %s", alpha2);
242
243         g_free(technology->regdom);
244         technology->regdom = g_strdup(alpha2);
245 }
246
247 int connman_technology_set_regdom(const char *alpha2)
248 {
249         GSList *list;
250
251         for (list = technology_list; list; list = list->next) {
252                 struct connman_technology *technology = list->data;
253
254                 if (technology->driver == NULL)
255                         continue;
256
257                 if (technology->driver->set_regdom)
258                         technology->driver->set_regdom(technology, alpha2);
259         }
260
261         return 0;
262 }
263
264 static void free_rfkill(gpointer data)
265 {
266         struct connman_rfkill *rfkill = data;
267
268         g_free(rfkill);
269 }
270
271 static const char *get_name(enum connman_service_type type)
272 {
273         switch (type) {
274         case CONNMAN_SERVICE_TYPE_UNKNOWN:
275         case CONNMAN_SERVICE_TYPE_SYSTEM:
276         case CONNMAN_SERVICE_TYPE_GPS:
277         case CONNMAN_SERVICE_TYPE_VPN:
278         case CONNMAN_SERVICE_TYPE_GADGET:
279                 break;
280         case CONNMAN_SERVICE_TYPE_ETHERNET:
281                 return "Wired";
282         case CONNMAN_SERVICE_TYPE_WIFI:
283                 return "WiFi";
284         case CONNMAN_SERVICE_TYPE_WIMAX:
285                 return "WiMAX";
286         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
287                 return "Bluetooth";
288         case CONNMAN_SERVICE_TYPE_CELLULAR:
289                 return "Cellular";
290         }
291
292         return NULL;
293 }
294
295 static void save_state(struct connman_technology *technology)
296 {
297         GKeyFile *keyfile;
298         gchar *identifier;
299
300         DBG("technology %p", technology);
301
302         keyfile = __connman_storage_load_global();
303         if (keyfile == NULL)
304                 keyfile = g_key_file_new();
305
306         identifier = g_strdup_printf("%s", get_name(technology->type));
307         if (identifier == NULL)
308                 goto done;
309
310         g_key_file_set_boolean(keyfile, identifier, "Enable",
311                                 technology->enable_persistent);
312
313 done:
314         g_free(identifier);
315
316         __connman_storage_save_global(keyfile);
317
318         g_key_file_free(keyfile);
319
320         return;
321 }
322
323 static void load_state(struct connman_technology *technology)
324 {
325         GKeyFile *keyfile;
326         gchar *identifier;
327         GError *error = NULL;
328         connman_bool_t enable;
329
330         DBG("technology %p", technology);
331
332         keyfile = __connman_storage_load_global();
333         /* Fallback on disabling technology if file not found. */
334         if (keyfile == NULL) {
335                 if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET)
336                         /* We enable ethernet by default */
337                         technology->enable_persistent = TRUE;
338                 else
339                         technology->enable_persistent = FALSE;
340                 return;
341         }
342
343         identifier = g_strdup_printf("%s", get_name(technology->type));
344         if (identifier == NULL)
345                 goto done;
346
347         enable = g_key_file_get_boolean(keyfile, identifier, "Enable", &error);
348         if (error == NULL)
349                 technology->enable_persistent = enable;
350         else {
351                 if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET)
352                         technology->enable_persistent = TRUE;
353                 else
354                         technology->enable_persistent = FALSE;
355
356                 save_state(technology);
357                 g_clear_error(&error);
358         }
359 done:
360         g_free(identifier);
361
362         g_key_file_free(keyfile);
363
364         return;
365 }
366
367 connman_bool_t __connman_technology_get_offlinemode(void)
368 {
369         return global_offlinemode;
370 }
371
372 static void connman_technology_save_offlinemode()
373 {
374         GKeyFile *keyfile;
375
376         keyfile = __connman_storage_load_global();
377         if (keyfile == NULL)
378                 keyfile = g_key_file_new();
379
380         g_key_file_set_boolean(keyfile, "global",
381                                         "OfflineMode", global_offlinemode);
382
383         __connman_storage_save_global(keyfile);
384
385         g_key_file_free(keyfile);
386
387         return;
388 }
389
390 static connman_bool_t connman_technology_load_offlinemode()
391 {
392         GKeyFile *keyfile;
393         GError *error = NULL;
394         connman_bool_t offlinemode;
395
396         /* If there is a error, we enable offlinemode */
397         keyfile = __connman_storage_load_global();
398         if (keyfile == NULL)
399                 return FALSE;
400
401         offlinemode = g_key_file_get_boolean(keyfile, "global",
402                                                 "OfflineMode", &error);
403         if (error != NULL) {
404                 offlinemode = FALSE;
405                 g_clear_error(&error);
406         }
407
408         g_key_file_free(keyfile);
409
410         return offlinemode;
411 }
412
413 static void append_properties(DBusMessageIter *iter,
414                 struct connman_technology *technology)
415 {
416         DBusMessageIter dict;
417         const char *str;
418         connman_bool_t powered;
419
420         connman_dbus_dict_open(iter, &dict);
421
422         str = get_name(technology->type);
423         if (str != NULL)
424                 connman_dbus_dict_append_basic(&dict, "Name",
425                                                 DBUS_TYPE_STRING, &str);
426
427         str = __connman_service_type2string(technology->type);
428         if (str != NULL)
429                 connman_dbus_dict_append_basic(&dict, "Type",
430                                                 DBUS_TYPE_STRING, &str);
431
432         __sync_synchronize();
433         if (technology->enabled > 0)
434                 powered = TRUE;
435         else
436                 powered = FALSE;
437         connman_dbus_dict_append_basic(&dict, "Powered",
438                                         DBUS_TYPE_BOOLEAN, &powered);
439
440         connman_dbus_dict_append_basic(&dict, "Connected",
441                                         DBUS_TYPE_BOOLEAN,
442                                         &technology->connected);
443
444         connman_dbus_dict_append_basic(&dict, "Tethering",
445                                         DBUS_TYPE_BOOLEAN,
446                                         &technology->tethering);
447
448         if (technology->tethering_ident != NULL)
449                 connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
450                                                 DBUS_TYPE_STRING,
451                                                 &technology->tethering_ident);
452
453         if (technology->tethering_passphrase != NULL)
454                 connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
455                                                 DBUS_TYPE_STRING,
456                                                 &technology->tethering_passphrase);
457
458         connman_dbus_dict_close(iter, &dict);
459 }
460
461 static void technology_added_signal(struct connman_technology *technology)
462 {
463         DBusMessage *signal;
464         DBusMessageIter iter;
465
466         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
467                         CONNMAN_MANAGER_INTERFACE, "TechnologyAdded");
468         if (signal == NULL)
469                 return;
470
471         dbus_message_iter_init_append(signal, &iter);
472         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
473                                                         &technology->path);
474         append_properties(&iter, technology);
475
476         dbus_connection_send(connection, signal, NULL);
477         dbus_message_unref(signal);
478 }
479
480 static void technology_removed_signal(struct connman_technology *technology)
481 {
482         g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
483                         CONNMAN_MANAGER_INTERFACE, "TechnologyRemoved",
484                         DBUS_TYPE_OBJECT_PATH, &technology->path,
485                         DBUS_TYPE_INVALID);
486 }
487
488 static DBusMessage *get_properties(DBusConnection *conn,
489                                         DBusMessage *message, void *user_data)
490 {
491         struct connman_technology *technology = user_data;
492         DBusMessage *reply;
493         DBusMessageIter iter;
494
495         reply = dbus_message_new_method_return(message);
496         if (reply == NULL)
497                 return NULL;
498
499         dbus_message_iter_init_append(reply, &iter);
500         append_properties(&iter, technology);
501
502         return reply;
503 }
504
505 void __connman_technology_list_struct(DBusMessageIter *array)
506 {
507         GSList *list;
508         DBusMessageIter entry;
509
510         for (list = technology_list; list; list = list->next) {
511                 struct connman_technology *technology = list->data;
512
513                 if (technology->path == NULL)
514                         continue;
515
516                 dbus_message_iter_open_container(array, DBUS_TYPE_STRUCT,
517                                 NULL, &entry);
518                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
519                                 &technology->path);
520                 append_properties(&entry, technology);
521                 dbus_message_iter_close_container(array, &entry);
522         }
523 }
524
525 static gboolean technology_pending_reply(gpointer user_data)
526 {
527         struct connman_technology *technology = user_data;
528         DBusMessage *reply;
529
530         /* Power request timedout, send ETIMEDOUT. */
531         if (technology->pending_reply != NULL) {
532                 reply = __connman_error_failed(technology->pending_reply, ETIMEDOUT);
533                 if (reply != NULL)
534                         g_dbus_send_message(connection, reply);
535
536                 dbus_message_unref(technology->pending_reply);
537                 technology->pending_reply = NULL;
538                 technology->pending_timeout = 0;
539         }
540
541         return FALSE;
542 }
543
544 static int technology_enable(struct connman_technology *technology,
545                 DBusMessage *msg)
546 {
547         GSList *list;
548         int err = 0;
549         int ret = -ENODEV;
550         DBusMessage *reply;
551
552         DBG("technology %p enable", technology);
553
554         __sync_synchronize();
555         if (technology->enabled > 0) {
556                 err = -EALREADY;
557                 goto done;
558         }
559
560         if (technology->pending_reply != NULL) {
561                 err = -EBUSY;
562                 goto done;
563         }
564
565         if (msg != NULL) {
566                 /*
567                  * This is a bit of a trick. When msg is not NULL it means
568                  * thats technology_enable was invoked from the manager API.
569                  * Hence we save the state here.
570                  */
571                 technology->enable_persistent = TRUE;
572                 save_state(technology);
573         }
574
575         __connman_rfkill_block(technology->type, FALSE);
576
577         /*
578          * An empty device list means that devices in the technology
579          * were rfkill blocked. The unblock above will enable the devs.
580          */
581         if (technology->device_list == NULL) {
582                 ret = 0;
583                 goto done;
584         }
585
586         for (list = technology->device_list; list; list = list->next) {
587                 struct connman_device *device = list->data;
588
589                 err = __connman_device_enable(device);
590                 /*
591                  * err = 0 : Device was enabled right away.
592                  * If atleast one device gets enabled, we consider
593                  * the technology to be enabled.
594                  */
595                 if (err == 0)
596                         ret = 0;
597         }
598
599 done:
600         if (ret == 0) {
601                 if (msg != NULL)
602                         g_dbus_send_reply(connection, msg, DBUS_TYPE_INVALID);
603                 return ret;
604         }
605
606         if (msg != NULL) {
607                 if (err == -EINPROGRESS) {
608                         technology->pending_reply = dbus_message_ref(msg);
609                         technology->pending_timeout = g_timeout_add_seconds(10,
610                                         technology_pending_reply, technology);
611                 } else {
612                         if (err == -EALREADY)
613                                 reply = __connman_error_already_enabled(msg);
614                         else
615                                 reply = __connman_error_failed(msg, -err);
616                         if (reply != NULL)
617                                 g_dbus_send_message(connection, reply);
618                 }
619         }
620
621         return err;
622 }
623
624 static int technology_disable(struct connman_technology *technology,
625                 DBusMessage *msg)
626 {
627         GSList *list;
628         int err = 0;
629         int ret = -ENODEV;
630         DBusMessage *reply;
631
632         DBG("technology %p disable", technology);
633
634         __sync_synchronize();
635         if (technology->enabled == 0) {
636                 err = -EALREADY;
637                 goto done;
638         }
639
640         if (technology->pending_reply != NULL) {
641                 err = -EBUSY;
642                 goto done;
643         }
644
645         if (technology->tethering == TRUE)
646                 set_tethering(technology, FALSE);
647
648         if (msg != NULL) {
649                 technology->enable_persistent = FALSE;
650                 save_state(technology);
651         }
652
653         __connman_rfkill_block(technology->type, TRUE);
654
655         for (list = technology->device_list; list; list = list->next) {
656                 struct connman_device *device = list->data;
657
658                 err = __connman_device_disable(device);
659                 if (err == 0)
660                         ret = 0;
661         }
662
663 done:
664         if (ret == 0) {
665                 if (msg != NULL)
666                         g_dbus_send_reply(connection, msg, DBUS_TYPE_INVALID);
667                 return ret;
668         }
669
670         if (msg != NULL) {
671                 if (err == -EINPROGRESS) {
672                         technology->pending_reply = dbus_message_ref(msg);
673                         technology->pending_timeout = g_timeout_add_seconds(10,
674                                         technology_pending_reply, technology);
675                 } else {
676                         if (err == -EALREADY)
677                                 reply = __connman_error_already_disabled(msg);
678                         else
679                                 reply = __connman_error_failed(msg, -err);
680                         if (reply != NULL)
681                                 g_dbus_send_message(connection, reply);
682                 }
683         }
684
685         return err;
686 }
687
688 static DBusMessage *set_property(DBusConnection *conn,
689                                         DBusMessage *msg, void *data)
690 {
691         struct connman_technology *technology = data;
692         DBusMessageIter iter, value;
693         const char *name;
694         int type;
695
696         DBG("conn %p", conn);
697
698         if (dbus_message_iter_init(msg, &iter) == FALSE)
699                 return __connman_error_invalid_arguments(msg);
700
701         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
702                 return __connman_error_invalid_arguments(msg);
703
704         dbus_message_iter_get_basic(&iter, &name);
705         dbus_message_iter_next(&iter);
706
707         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
708                 return __connman_error_invalid_arguments(msg);
709
710         dbus_message_iter_recurse(&iter, &value);
711
712         type = dbus_message_iter_get_arg_type(&value);
713
714         DBG("property %s", name);
715
716         if (g_str_equal(name, "Tethering") == TRUE) {
717                 int err;
718                 connman_bool_t tethering;
719
720                 if (type != DBUS_TYPE_BOOLEAN)
721                         return __connman_error_invalid_arguments(msg);
722
723                 dbus_message_iter_get_basic(&value, &tethering);
724
725                 if (technology->tethering == tethering)
726                         return __connman_error_in_progress(msg);
727
728                 err = set_tethering(technology, tethering);
729                 if (err < 0)
730                         return __connman_error_failed(msg, -err);
731
732         } else if (g_str_equal(name, "TetheringIdentifier") == TRUE) {
733                 const char *str;
734
735                 dbus_message_iter_get_basic(&value, &str);
736
737                 if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
738                         return __connman_error_not_supported(msg);
739
740                 technology->tethering_ident = g_strdup(str);
741         } else if (g_str_equal(name, "TetheringPassphrase") == TRUE) {
742                 const char *str;
743
744                 dbus_message_iter_get_basic(&value, &str);
745
746                 if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
747                         return __connman_error_not_supported(msg);
748
749                 if (strlen(str) < 8)
750                         return __connman_error_invalid_arguments(msg);
751
752                 technology->tethering_passphrase = g_strdup(str);
753         } else if (g_str_equal(name, "Powered") == TRUE) {
754                 connman_bool_t enable;
755
756                 if (type != DBUS_TYPE_BOOLEAN)
757                         return __connman_error_invalid_arguments(msg);
758
759                 dbus_message_iter_get_basic(&value, &enable);
760                 if (enable == TRUE)
761                         technology_enable(technology, msg);
762                 else
763                         technology_disable(technology, msg);
764
765         } else
766                 return __connman_error_invalid_property(msg);
767
768         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
769 }
770
771 static struct connman_technology *technology_find(enum connman_service_type type)
772 {
773         GSList *list;
774
775         DBG("type %d", type);
776
777         for (list = technology_list; list; list = list->next) {
778                 struct connman_technology *technology = list->data;
779
780                 if (technology->type == type)
781                         return technology;
782         }
783
784         return NULL;
785 }
786
787 static void reply_scan_pending(struct connman_technology *technology, int err)
788 {
789         DBusMessage *reply;
790
791         DBG("technology %p err %d", technology, err);
792
793         while (technology->scan_pending != NULL) {
794                 DBusMessage *msg = technology->scan_pending->data;
795
796                 DBG("reply to %s", dbus_message_get_sender(msg));
797
798                 if (err == 0)
799                         reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
800                 else
801                         reply = __connman_error_failed(msg, -err);
802                 g_dbus_send_message(connection, reply);
803                 dbus_message_unref(msg);
804
805                 technology->scan_pending =
806                         g_slist_delete_link(technology->scan_pending,
807                                         technology->scan_pending);
808         }
809 }
810
811 void __connman_technology_scan_started(struct connman_device *device)
812 {
813         DBG("device %p", device);
814 }
815
816 void __connman_technology_scan_stopped(struct connman_device *device)
817 {
818         int count = 0;
819         struct connman_technology *technology;
820         enum connman_service_type type;
821         GSList *list;
822
823         type = __connman_device_get_service_type(device);
824         technology = technology_find(type);
825
826         DBG("technology %p device %p", technology, device);
827
828         if (technology == NULL)
829                 return;
830
831         for (list = technology->device_list; list != NULL; list = list->next) {
832                 struct connman_device *other_device = list->data;
833
834                 if (device == other_device)
835                         continue;
836
837                 if (__connman_device_get_service_type(other_device) != type)
838                         continue;
839
840                 if (connman_device_get_scanning(other_device) == TRUE)
841                         count += 1;
842         }
843
844         if (count == 0)
845                 reply_scan_pending(technology, 0);
846 }
847
848 void __connman_technology_notify_regdom_by_device(struct connman_device *device,
849                                                 int result, const char *alpha2)
850 {
851         struct connman_technology *technology;
852         enum connman_service_type type;
853
854         type = __connman_device_get_service_type(device);
855         technology = technology_find(type);
856
857         if (technology == NULL)
858                 return;
859
860         connman_technology_regdom_notify(technology, alpha2);
861 }
862
863 static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data)
864 {
865         struct connman_technology *technology = data;
866         int err;
867
868         DBG ("technology %p request from %s", technology,
869                         dbus_message_get_sender(msg));
870
871         dbus_message_ref(msg);
872         technology->scan_pending =
873                 g_slist_prepend(technology->scan_pending, msg);
874
875         err = __connman_device_request_scan(technology->type);
876         if (err < 0)
877                 reply_scan_pending(technology, err);
878
879         return NULL;
880 }
881
882 static const GDBusMethodTable technology_methods[] = {
883         { GDBUS_DEPRECATED_METHOD("GetProperties",
884                         NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
885                         get_properties) },
886         { GDBUS_METHOD("SetProperty",
887                         GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
888                         NULL, set_property) },
889         { GDBUS_ASYNC_METHOD("Scan", NULL, NULL, scan) },
890         { },
891 };
892
893 static const GDBusSignalTable technology_signals[] = {
894         { GDBUS_SIGNAL("PropertyChanged",
895                         GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
896         { },
897 };
898
899 static struct connman_technology *technology_get(enum connman_service_type type)
900 {
901         struct connman_technology *technology;
902         struct connman_technology_driver *driver = NULL;
903         const char *str;
904         GSList *list;
905         int err;
906
907         DBG("type %d", type);
908
909         str = __connman_service_type2string(type);
910         if (str == NULL)
911                 return NULL;
912
913         technology = technology_find(type);
914         if (technology != NULL) {
915                 __sync_fetch_and_add(&technology->refcount, 1);
916                 return technology;
917         }
918
919         /* First check if we have a driver for this technology type */
920         for (list = driver_list; list; list = list->next) {
921                 driver = list->data;
922
923                 if (driver->type == type)
924                         break;
925                 else
926                         driver = NULL;
927         }
928
929         if (driver == NULL) {
930                 DBG("No matching driver found for %s.",
931                                 __connman_service_type2string(type));
932                 return NULL;
933         }
934
935         technology = g_try_new0(struct connman_technology, 1);
936         if (technology == NULL)
937                 return NULL;
938
939         technology->refcount = 1;
940
941         technology->type = type;
942         technology->path = g_strdup_printf("%s/technology/%s",
943                                                         CONNMAN_PATH, str);
944
945         technology->device_list = NULL;
946
947         technology->pending_reply = NULL;
948
949         load_state(technology);
950
951         if (g_dbus_register_interface(connection, technology->path,
952                                         CONNMAN_TECHNOLOGY_INTERFACE,
953                                         technology_methods, technology_signals,
954                                         NULL, technology, NULL) == FALSE) {
955                 connman_error("Failed to register %s", technology->path);
956                 g_free(technology);
957                 return NULL;
958         }
959
960         technology_list = g_slist_append(technology_list, technology);
961
962         technology_added_signal(technology);
963
964         technology->driver = driver;
965         err = driver->probe(technology);
966         if (err != 0)
967                 DBG("Driver probe failed for technology %p", technology);
968
969         DBG("technology %p", technology);
970
971         return technology;
972 }
973
974 static void technology_put(struct connman_technology *technology)
975 {
976         DBG("technology %p", technology);
977
978         if (__sync_sub_and_fetch(&technology->refcount, 1) > 0)
979                 return;
980
981         reply_scan_pending(technology, -EINTR);
982
983         if (technology->driver) {
984                 technology->driver->remove(technology);
985                 technology->driver = NULL;
986         }
987
988         technology_list = g_slist_remove(technology_list, technology);
989
990         technology_removed_signal(technology);
991
992         g_dbus_unregister_interface(connection, technology->path,
993                                                 CONNMAN_TECHNOLOGY_INTERFACE);
994
995         g_slist_free(technology->device_list);
996
997         g_free(technology->path);
998         g_free(technology->regdom);
999         g_free(technology);
1000 }
1001
1002 void __connman_technology_add_interface(enum connman_service_type type,
1003                                 int index, const char *name, const char *ident)
1004 {
1005         struct connman_technology *technology;
1006
1007         switch (type) {
1008         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1009         case CONNMAN_SERVICE_TYPE_SYSTEM:
1010                 return;
1011         case CONNMAN_SERVICE_TYPE_ETHERNET:
1012         case CONNMAN_SERVICE_TYPE_WIFI:
1013         case CONNMAN_SERVICE_TYPE_WIMAX:
1014         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1015         case CONNMAN_SERVICE_TYPE_CELLULAR:
1016         case CONNMAN_SERVICE_TYPE_GPS:
1017         case CONNMAN_SERVICE_TYPE_VPN:
1018         case CONNMAN_SERVICE_TYPE_GADGET:
1019                 break;
1020         }
1021
1022         connman_info("Adding interface %s [ %s ]", name,
1023                                 __connman_service_type2string(type));
1024
1025         technology = technology_find(type);
1026
1027         if (technology == NULL || technology->driver == NULL
1028                         || technology->driver->add_interface == NULL)
1029                 return;
1030
1031         technology->driver->add_interface(technology,
1032                                         index, name, ident);
1033 }
1034
1035 void __connman_technology_remove_interface(enum connman_service_type type,
1036                                 int index, const char *name, const char *ident)
1037 {
1038         struct connman_technology *technology;
1039
1040         switch (type) {
1041         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1042         case CONNMAN_SERVICE_TYPE_SYSTEM:
1043                 return;
1044         case CONNMAN_SERVICE_TYPE_ETHERNET:
1045         case CONNMAN_SERVICE_TYPE_WIFI:
1046         case CONNMAN_SERVICE_TYPE_WIMAX:
1047         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1048         case CONNMAN_SERVICE_TYPE_CELLULAR:
1049         case CONNMAN_SERVICE_TYPE_GPS:
1050         case CONNMAN_SERVICE_TYPE_VPN:
1051         case CONNMAN_SERVICE_TYPE_GADGET:
1052                 break;
1053         }
1054
1055         connman_info("Remove interface %s [ %s ]", name,
1056                                 __connman_service_type2string(type));
1057
1058         technology = technology_find(type);
1059
1060         if (technology == NULL || technology->driver == NULL)
1061                 return;
1062
1063         if (technology->driver->remove_interface)
1064                 technology->driver->remove_interface(technology, index);
1065 }
1066
1067 int __connman_technology_add_device(struct connman_device *device)
1068 {
1069         struct connman_technology *technology;
1070         enum connman_service_type type;
1071
1072         DBG("device %p", device);
1073
1074         type = __connman_device_get_service_type(device);
1075
1076         technology = technology_get(type);
1077         if (technology == NULL) {
1078                 /*
1079                  * Since no driver can be found for this device at the moment we
1080                  * add it to the techless device list.
1081                 */
1082                 techless_device_list = g_slist_prepend(techless_device_list,
1083                                                                 device);
1084
1085                 return -ENXIO;
1086         }
1087
1088         if (technology->enable_persistent && !global_offlinemode) {
1089                 int err = __connman_device_enable(device);
1090                 /*
1091                  * connman_technology_add_device() calls __connman_device_enable()
1092                  * but since the device is already enabled, the calls does not
1093                  * propagate through to connman_technology_enabled via
1094                  * connman_device_set_powered.
1095                  */
1096                 if (err == -EALREADY)
1097                         __connman_technology_enabled(type);
1098         }
1099         /* if technology persistent state is offline */
1100         if (!technology->enable_persistent)
1101                 __connman_device_disable(device);
1102
1103         technology->device_list = g_slist_append(technology->device_list,
1104                                                                 device);
1105
1106         return 0;
1107 }
1108
1109 int __connman_technology_remove_device(struct connman_device *device)
1110 {
1111         struct connman_technology *technology;
1112         enum connman_service_type type;
1113
1114         DBG("device %p", device);
1115
1116         type = __connman_device_get_service_type(device);
1117
1118         technology = technology_find(type);
1119         if (technology == NULL) {
1120                 techless_device_list = g_slist_remove(techless_device_list,
1121                                                                 device);
1122                 return -ENXIO;
1123         }
1124
1125         technology->device_list = g_slist_remove(technology->device_list,
1126                                                                 device);
1127         technology_put(technology);
1128
1129         return 0;
1130 }
1131
1132 static void powered_changed(struct connman_technology *technology)
1133 {
1134         connman_bool_t powered;
1135
1136         __sync_synchronize();
1137         if (technology->enabled >0)
1138                 powered = TRUE;
1139         else
1140                 powered = FALSE;
1141
1142         connman_dbus_property_changed_basic(technology->path,
1143                         CONNMAN_TECHNOLOGY_INTERFACE, "Powered",
1144                         DBUS_TYPE_BOOLEAN, &powered);
1145 }
1146
1147 int __connman_technology_enabled(enum connman_service_type type)
1148 {
1149         struct connman_technology *technology;
1150
1151         technology = technology_find(type);
1152         if (technology == NULL)
1153                 return -ENXIO;
1154
1155         if (__sync_fetch_and_add(&technology->enabled, 1) != 0)
1156                 return -EALREADY;
1157
1158         powered_changed(technology);
1159
1160         if (technology->pending_reply != NULL) {
1161                 g_dbus_send_reply(connection, technology->pending_reply, DBUS_TYPE_INVALID);
1162                 dbus_message_unref(technology->pending_reply);
1163                 g_source_remove(technology->pending_timeout);
1164                 technology->pending_reply = NULL;
1165                 technology->pending_timeout = 0;
1166         }
1167
1168         return 0;
1169 }
1170
1171 int __connman_technology_disabled(enum connman_service_type type)
1172 {
1173         struct connman_technology *technology;
1174
1175         technology = technology_find(type);
1176         if (technology == NULL)
1177                 return -ENXIO;
1178
1179         if (__sync_fetch_and_sub(&technology->enabled, 1) != 1)
1180                 return -EINPROGRESS;
1181
1182         if (technology->pending_reply != NULL) {
1183                 g_dbus_send_reply(connection, technology->pending_reply, DBUS_TYPE_INVALID);
1184                 dbus_message_unref(technology->pending_reply);
1185                 g_source_remove(technology->pending_timeout);
1186                 technology->pending_reply = NULL;
1187                 technology->pending_timeout = 0;
1188         }
1189
1190         powered_changed(technology);
1191
1192         return 0;
1193 }
1194
1195 int __connman_technology_set_offlinemode(connman_bool_t offlinemode)
1196 {
1197         GSList *list;
1198         int err = -EINVAL;
1199
1200         if (global_offlinemode == offlinemode)
1201                 return 0;
1202
1203         DBG("offlinemode %s", offlinemode ? "On" : "Off");
1204
1205         /*
1206          * This is a bit tricky. When you set offlinemode, there is no
1207          * way to differentiate between attempting offline mode and
1208          * resuming offlinemode from last saved profile. We need that
1209          * information in rfkill_update, otherwise it falls back on the
1210          * technology's persistent state. Hence we set the offline mode here
1211          * but save it & call the notifier only if its successful.
1212          */
1213
1214         global_offlinemode = offlinemode;
1215
1216         /* Traverse technology list, enable/disable each technology. */
1217         for (list = technology_list; list; list = list->next) {
1218                 struct connman_technology *technology = list->data;
1219
1220                 if (offlinemode)
1221                         err = technology_disable(technology, NULL);
1222
1223                 if (!offlinemode && technology->enable_persistent)
1224                         err = technology_enable(technology, NULL);
1225         }
1226
1227         if (err == 0 || err == -EINPROGRESS || err == -EALREADY) {
1228                 connman_technology_save_offlinemode();
1229                 __connman_notifier_offlinemode(offlinemode);
1230         } else
1231                 global_offlinemode = connman_technology_load_offlinemode();
1232
1233         return err;
1234 }
1235
1236 void __connman_technology_set_connected(enum connman_service_type type,
1237                 connman_bool_t connected)
1238 {
1239         struct connman_technology *technology;
1240
1241         technology = technology_find(type);
1242         if (technology == NULL)
1243                 return;
1244
1245         DBG("technology %p connected %d", technology, connected);
1246
1247         technology->connected = connected;
1248
1249         connman_dbus_property_changed_basic(technology->path,
1250                         CONNMAN_TECHNOLOGY_INTERFACE, "Connected",
1251                         DBUS_TYPE_BOOLEAN, &connected);
1252 }
1253
1254 int __connman_technology_add_rfkill(unsigned int index,
1255                                         enum connman_service_type type,
1256                                                 connman_bool_t softblock,
1257                                                 connman_bool_t hardblock)
1258 {
1259         struct connman_technology *technology;
1260         struct connman_rfkill *rfkill;
1261
1262         DBG("index %u type %d soft %u hard %u", index, type,
1263                                                         softblock, hardblock);
1264
1265         rfkill = g_hash_table_lookup(rfkill_list, &index);
1266         if (rfkill != NULL)
1267                 goto done;
1268
1269         rfkill = g_try_new0(struct connman_rfkill, 1);
1270         if (rfkill == NULL)
1271                 return -ENOMEM;
1272
1273         rfkill->index = index;
1274         rfkill->type = type;
1275         rfkill->softblock = softblock;
1276         rfkill->hardblock = hardblock;
1277
1278         g_hash_table_insert(rfkill_list, &rfkill->index, rfkill);
1279
1280 done:
1281         technology = technology_get(type);
1282         /* If there is no driver for this type, ignore it. */
1283         if (technology == NULL)
1284                 return -ENXIO;
1285
1286         if (hardblock) {
1287                 DBG("%s is switched off.", get_name(type));
1288                 return 0;
1289         }
1290
1291         /*
1292          * If Offline mode is on, we softblock the device if it isnt already.
1293          * If Offline mode is off, we rely on the persistent state of tech.
1294          */
1295         if (global_offlinemode) {
1296                 if (!softblock)
1297                         return __connman_rfkill_block(type, TRUE);
1298         } else {
1299                 if (technology->enable_persistent && softblock)
1300                         return __connman_rfkill_block(type, FALSE);
1301                 /* if technology persistent state is offline */
1302                 if (!technology->enable_persistent && !softblock)
1303                         return __connman_rfkill_block(type, TRUE);
1304         }
1305
1306         return 0;
1307 }
1308
1309 int __connman_technology_update_rfkill(unsigned int index,
1310                                         enum connman_service_type type,
1311                                                 connman_bool_t softblock,
1312                                                 connman_bool_t hardblock)
1313 {
1314         struct connman_technology *technology;
1315         struct connman_rfkill *rfkill;
1316
1317         DBG("index %u soft %u hard %u", index, softblock, hardblock);
1318
1319         rfkill = g_hash_table_lookup(rfkill_list, &index);
1320         if (rfkill == NULL)
1321                 return -ENXIO;
1322
1323         if (rfkill->softblock == softblock &&
1324                 rfkill->hardblock == hardblock)
1325                 return 0;
1326
1327         rfkill->softblock = softblock;
1328         rfkill->hardblock = hardblock;
1329
1330         if (hardblock) {
1331                 DBG("%s is switched off.", get_name(type));
1332                 return 0;
1333         }
1334
1335         technology = technology_find(type);
1336         /* If there is no driver for this type, ignore it. */
1337         if (technology == NULL)
1338                 return -ENXIO;
1339
1340         if (!global_offlinemode) {
1341                 if (technology->enable_persistent && softblock)
1342                         return __connman_rfkill_block(type, FALSE);
1343                 if (!technology->enable_persistent && !softblock)
1344                         return __connman_rfkill_block(type, TRUE);
1345         }
1346
1347         return 0;
1348 }
1349
1350 int __connman_technology_remove_rfkill(unsigned int index,
1351                                         enum connman_service_type type)
1352 {
1353         struct connman_technology *technology;
1354         struct connman_rfkill *rfkill;
1355
1356         DBG("index %u", index);
1357
1358         rfkill = g_hash_table_lookup(rfkill_list, &index);
1359         if (rfkill == NULL)
1360                 return -ENXIO;
1361
1362         g_hash_table_remove(rfkill_list, &index);
1363
1364         technology = technology_find(type);
1365         if (technology == NULL)
1366                 return -ENXIO;
1367
1368         technology_put(technology);
1369
1370         return 0;
1371 }
1372
1373 int __connman_technology_init(void)
1374 {
1375         DBG("");
1376
1377         connection = connman_dbus_get_connection();
1378
1379         rfkill_list = g_hash_table_new_full(g_int_hash, g_int_equal,
1380                                                         NULL, free_rfkill);
1381
1382         global_offlinemode = connman_technology_load_offlinemode();
1383
1384         /* This will create settings file if it is missing */
1385         connman_technology_save_offlinemode();
1386
1387         return 0;
1388 }
1389
1390 void __connman_technology_cleanup(void)
1391 {
1392         DBG("");
1393
1394         g_hash_table_destroy(rfkill_list);
1395
1396         dbus_connection_unref(connection);
1397 }