[connman]Added DBus method for wifi Specific AP Scan.
[platform/upstream/connman.git] / src / technology.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2007-2013  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 bool global_offlinemode;
45
46 struct connman_rfkill {
47         unsigned int index;
48         enum connman_service_type type;
49         bool softblock;
50         bool hardblock;
51 };
52
53 struct connman_technology {
54         int refcount;
55         enum connman_service_type type;
56         char *path;
57         GSList *device_list;
58         bool enabled;
59         char *regdom;
60         bool connected;
61
62         bool tethering;
63         bool tethering_persistent; /* Tells the save status, needed
64                                               * as offline mode might set
65                                               * tethering OFF.
66                                               */
67         char *tethering_ident;
68         char *tethering_passphrase;
69         bool tethering_hidden;
70
71         bool enable_persistent; /* Save the tech state */
72
73         GSList *driver_list;
74
75         DBusMessage *pending_reply;
76         guint pending_timeout;
77
78         GSList *scan_pending;
79
80         bool rfkill_driven;
81         bool softblocked;
82         bool hardblocked;
83         bool dbus_registered;
84 };
85
86 static GSList *driver_list = NULL;
87
88 static int technology_enabled(struct connman_technology *technology);
89 static int technology_disabled(struct connman_technology *technology);
90
91 static gint compare_priority(gconstpointer a, gconstpointer b)
92 {
93         const struct connman_technology_driver *driver1 = a;
94         const struct connman_technology_driver *driver2 = b;
95
96         return driver2->priority - driver1->priority;
97 }
98
99 static void rfkill_check(gpointer key, gpointer value, gpointer user_data)
100 {
101         struct connman_rfkill *rfkill = value;
102         enum connman_service_type type = GPOINTER_TO_INT(user_data);
103
104         /* Calling _technology_rfkill_add will update the tech. */
105         if (rfkill->type == type)
106                 __connman_technology_add_rfkill(rfkill->index, type,
107                                 rfkill->softblock, rfkill->hardblock);
108 }
109
110 bool
111 connman_technology_is_tethering_allowed(enum connman_service_type type)
112 {
113         static char *allowed_default[] = { "wifi", "bluetooth", "gadget",
114                                            NULL };
115         const char *type_str = __connman_service_type2string(type);
116         char **allowed;
117         int i;
118
119         if (!type_str)
120                 return false;
121
122         allowed = connman_setting_get_string_list("TetheringTechnologies");
123         if (!allowed)
124                 allowed = allowed_default;
125
126         for (i = 0; allowed[i]; i++) {
127                 if (g_strcmp0(allowed[i], type_str) == 0)
128                         return true;
129         }
130
131         return false;
132 }
133
134 static const char *get_name(enum connman_service_type type)
135 {
136         switch (type) {
137         case CONNMAN_SERVICE_TYPE_UNKNOWN:
138         case CONNMAN_SERVICE_TYPE_SYSTEM:
139         case CONNMAN_SERVICE_TYPE_GPS:
140         case CONNMAN_SERVICE_TYPE_VPN:
141                 break;
142         case CONNMAN_SERVICE_TYPE_GADGET:
143                 return "Gadget";
144         case CONNMAN_SERVICE_TYPE_ETHERNET:
145                 return "Wired";
146         case CONNMAN_SERVICE_TYPE_WIFI:
147                 return "WiFi";
148         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
149                 return "Bluetooth";
150         case CONNMAN_SERVICE_TYPE_CELLULAR:
151                 return "Cellular";
152         case CONNMAN_SERVICE_TYPE_P2P:
153                 return "P2P";
154         }
155
156         return NULL;
157 }
158
159 static void technology_save(struct connman_technology *technology)
160 {
161         GKeyFile *keyfile;
162         gchar *identifier;
163         const char *name = get_name(technology->type);
164
165         DBG("technology %p type %d name %s", technology, technology->type,
166                                                                         name);
167         if (!name)
168                 return;
169
170         keyfile = __connman_storage_load_global();
171         if (!keyfile)
172                 keyfile = g_key_file_new();
173
174         identifier = g_strdup_printf("%s", name);
175         if (!identifier)
176                 goto done;
177
178         g_key_file_set_boolean(keyfile, identifier, "Enable",
179                                 technology->enable_persistent);
180
181         g_key_file_set_boolean(keyfile, identifier, "Tethering",
182                                 technology->tethering_persistent);
183
184         g_key_file_set_boolean(keyfile, identifier, "Hidden",
185                                 technology->tethering_hidden);
186
187         if (technology->tethering_ident)
188                 g_key_file_set_string(keyfile, identifier,
189                                         "Tethering.Identifier",
190                                         technology->tethering_ident);
191
192         if (technology->tethering_passphrase)
193                 g_key_file_set_string(keyfile, identifier,
194                                         "Tethering.Passphrase",
195                                         technology->tethering_passphrase);
196
197 done:
198         g_free(identifier);
199
200         __connman_storage_save_global(keyfile);
201
202         g_key_file_free(keyfile);
203
204         return;
205 }
206
207 static void tethering_changed(struct connman_technology *technology)
208 {
209         dbus_bool_t tethering = technology->tethering;
210
211         connman_dbus_property_changed_basic(technology->path,
212                                 CONNMAN_TECHNOLOGY_INTERFACE, "Tethering",
213                                                 DBUS_TYPE_BOOLEAN, &tethering);
214
215         technology_save(technology);
216 }
217
218 void connman_technology_tethering_notify(struct connman_technology *technology,
219                                                         bool enabled)
220 {
221         DBG("technology %p enabled %u", technology, enabled);
222
223         if (technology->tethering == enabled)
224                 return;
225
226         technology->tethering = enabled;
227
228         tethering_changed(technology);
229
230         if (enabled)
231                 __connman_tethering_set_enabled();
232         else
233                 __connman_tethering_set_disabled();
234 }
235
236 static int set_tethering(struct connman_technology *technology,
237                                 bool enabled)
238 {
239         int result = -EOPNOTSUPP;
240         int err;
241         const char *ident, *passphrase, *bridge;
242         GSList *tech_drivers;
243         bool hidden;
244
245         ident = technology->tethering_ident;
246         passphrase = technology->tethering_passphrase;
247         hidden = technology->tethering_hidden;
248
249         __sync_synchronize();
250         if (!technology->enabled)
251                 return -EACCES;
252
253         bridge = __connman_tethering_get_bridge();
254         if (!bridge)
255                 return -EOPNOTSUPP;
256
257         if (technology->type == CONNMAN_SERVICE_TYPE_WIFI && (!ident))
258                 return -EINVAL;
259
260         for (tech_drivers = technology->driver_list; tech_drivers;
261              tech_drivers = g_slist_next(tech_drivers)) {
262                 struct connman_technology_driver *driver = tech_drivers->data;
263
264                 if (!driver || !driver->set_tethering)
265                         continue;
266
267                 err = driver->set_tethering(technology, ident, passphrase,
268                                 bridge, enabled, hidden);
269
270                 if (result == -EINPROGRESS)
271                         continue;
272
273                 if (err == -EINPROGRESS || err == 0) {
274                         result = err;
275                         continue;
276                 }
277         }
278
279         return result;
280 }
281
282 void connman_technology_regdom_notify(struct connman_technology *technology,
283                                                         const char *alpha2)
284 {
285         DBG("");
286
287         if (!alpha2)
288                 connman_error("Failed to set regulatory domain");
289         else
290                 DBG("Regulatory domain set to %s", alpha2);
291
292         g_free(technology->regdom);
293         technology->regdom = g_strdup(alpha2);
294 }
295
296 static int set_regdom_by_device(struct connman_technology *technology,
297                                                         const char *alpha2)
298 {
299         GSList *list;
300
301         for (list = technology->device_list; list; list = list->next) {
302                 struct connman_device *device = list->data;
303
304                 if (connman_device_set_regdom(device, alpha2) != 0)
305                         return -ENOTSUP;
306         }
307
308         return 0;
309 }
310
311 int connman_technology_set_regdom(const char *alpha2)
312 {
313         GSList *list, *tech_drivers;
314
315         for (list = technology_list; list; list = list->next) {
316                 struct connman_technology *technology = list->data;
317
318                 if (set_regdom_by_device(technology, alpha2) != 0) {
319
320                         for (tech_drivers = technology->driver_list;
321                              tech_drivers;
322                              tech_drivers = g_slist_next(tech_drivers)) {
323
324                                 struct connman_technology_driver *driver =
325                                         tech_drivers->data;
326
327                                 if (driver->set_regdom)
328                                         driver->set_regdom(technology, alpha2);
329                         }
330                 }
331         }
332
333         return 0;
334 }
335
336 static struct connman_technology *technology_find(enum connman_service_type type)
337 {
338         GSList *list;
339
340         DBG("type %d", type);
341
342         for (list = technology_list; list; list = list->next) {
343                 struct connman_technology *technology = list->data;
344
345                 if (technology->type == type)
346                         return technology;
347         }
348
349         return NULL;
350 }
351
352 bool connman_technology_get_wifi_tethering(const char **ssid,
353                                                         const char **psk)
354 {
355         struct connman_technology *technology;
356
357         if (!ssid || !psk)
358                 return false;
359
360         *ssid = *psk = NULL;
361
362         technology = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
363         if (!technology)
364                 return false;
365
366         if (!technology->tethering)
367                 return false;
368
369         *ssid = technology->tethering_ident;
370         *psk = technology->tethering_passphrase;
371
372         return true;
373 }
374
375 static void free_rfkill(gpointer data)
376 {
377         struct connman_rfkill *rfkill = data;
378
379         g_free(rfkill);
380 }
381
382 static void technology_load(struct connman_technology *technology)
383 {
384         GKeyFile *keyfile;
385         gchar *identifier;
386         GError *error = NULL;
387         bool enable, need_saving = false;
388
389         DBG("technology %p", technology);
390
391         keyfile = __connman_storage_load_global();
392         /* Fallback on disabling technology if file not found. */
393         if (!keyfile) {
394                 if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET)
395                         /* We enable ethernet by default */
396                         technology->enable_persistent = true;
397                 else
398                         technology->enable_persistent = false;
399                 return;
400         }
401
402         identifier = g_strdup_printf("%s", get_name(technology->type));
403         if (!identifier)
404                 goto done;
405
406         enable = g_key_file_get_boolean(keyfile, identifier, "Enable", &error);
407         if (!error)
408                 technology->enable_persistent = enable;
409         else {
410                 if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET)
411                         technology->enable_persistent = true;
412                 else
413                         technology->enable_persistent = false;
414
415                 need_saving = true;
416                 g_clear_error(&error);
417         }
418
419         enable = g_key_file_get_boolean(keyfile, identifier,
420                                         "Tethering", &error);
421         if (!error)
422                 technology->tethering_persistent = enable;
423         else {
424                 need_saving = true;
425                 g_clear_error(&error);
426         }
427
428         if (need_saving)
429                 technology_save(technology);
430
431         technology->tethering_ident = g_key_file_get_string(keyfile,
432                                 identifier, "Tethering.Identifier", NULL);
433
434         technology->tethering_passphrase = g_key_file_get_string(keyfile,
435                                 identifier, "Tethering.Passphrase", NULL);
436 done:
437         g_free(identifier);
438
439         g_key_file_free(keyfile);
440
441         return;
442 }
443
444 bool __connman_technology_get_offlinemode(void)
445 {
446         return global_offlinemode;
447 }
448
449 static void connman_technology_save_offlinemode(void)
450 {
451         GKeyFile *keyfile;
452
453         keyfile = __connman_storage_load_global();
454         if (!keyfile)
455                 keyfile = g_key_file_new();
456
457         g_key_file_set_boolean(keyfile, "global",
458                                         "OfflineMode", global_offlinemode);
459
460         __connman_storage_save_global(keyfile);
461
462         g_key_file_free(keyfile);
463
464         return;
465 }
466
467 static bool connman_technology_load_offlinemode(void)
468 {
469         GKeyFile *keyfile;
470         GError *error = NULL;
471         bool offlinemode;
472
473         /* If there is a error, we enable offlinemode */
474         keyfile = __connman_storage_load_global();
475         if (!keyfile)
476                 return false;
477
478         offlinemode = g_key_file_get_boolean(keyfile, "global",
479                                                 "OfflineMode", &error);
480         if (error) {
481                 offlinemode = false;
482                 g_clear_error(&error);
483         }
484
485         g_key_file_free(keyfile);
486
487         return offlinemode;
488 }
489
490 static void append_properties(DBusMessageIter *iter,
491                 struct connman_technology *technology)
492 {
493         DBusMessageIter dict;
494         dbus_bool_t val;
495         const char *str;
496
497         connman_dbus_dict_open(iter, &dict);
498
499         str = get_name(technology->type);
500         if (str)
501                 connman_dbus_dict_append_basic(&dict, "Name",
502                                                 DBUS_TYPE_STRING, &str);
503
504         str = __connman_service_type2string(technology->type);
505         if (str)
506                 connman_dbus_dict_append_basic(&dict, "Type",
507                                                 DBUS_TYPE_STRING, &str);
508
509         __sync_synchronize();
510         val = technology->enabled;
511         connman_dbus_dict_append_basic(&dict, "Powered",
512                                         DBUS_TYPE_BOOLEAN,
513                                         &val);
514
515         val = technology->connected;
516         connman_dbus_dict_append_basic(&dict, "Connected",
517                                         DBUS_TYPE_BOOLEAN,
518                                         &val);
519
520         val = technology->tethering;
521         connman_dbus_dict_append_basic(&dict, "Tethering",
522                                         DBUS_TYPE_BOOLEAN,
523                                         &val);
524
525         if (technology->tethering_ident)
526                 connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
527                                         DBUS_TYPE_STRING,
528                                         &technology->tethering_ident);
529
530         if (technology->tethering_passphrase)
531                 connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
532                                         DBUS_TYPE_STRING,
533                                         &technology->tethering_passphrase);
534
535         val = technology->tethering_hidden;
536         connman_dbus_dict_append_basic(&dict, "Hidden",
537                                         DBUS_TYPE_BOOLEAN,
538                                         &val);
539
540         connman_dbus_dict_close(iter, &dict);
541 }
542
543 static void technology_added_signal(struct connman_technology *technology)
544 {
545         DBusMessage *signal;
546         DBusMessageIter iter;
547
548         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
549                         CONNMAN_MANAGER_INTERFACE, "TechnologyAdded");
550         if (!signal)
551                 return;
552
553         dbus_message_iter_init_append(signal, &iter);
554         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
555                                                         &technology->path);
556         append_properties(&iter, technology);
557
558         dbus_connection_send(connection, signal, NULL);
559         dbus_message_unref(signal);
560 }
561
562 static void technology_removed_signal(struct connman_technology *technology)
563 {
564         g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
565                         CONNMAN_MANAGER_INTERFACE, "TechnologyRemoved",
566                         DBUS_TYPE_OBJECT_PATH, &technology->path,
567                         DBUS_TYPE_INVALID);
568 }
569
570 static DBusMessage *get_properties(DBusConnection *conn,
571                                         DBusMessage *message, void *user_data)
572 {
573         struct connman_technology *technology = user_data;
574         DBusMessage *reply;
575         DBusMessageIter iter;
576
577         reply = dbus_message_new_method_return(message);
578         if (!reply)
579                 return NULL;
580
581         dbus_message_iter_init_append(reply, &iter);
582         append_properties(&iter, technology);
583
584         return reply;
585 }
586
587 void __connman_technology_list_struct(DBusMessageIter *array)
588 {
589         GSList *list;
590         DBusMessageIter entry;
591
592         for (list = technology_list; list; list = list->next) {
593                 struct connman_technology *technology = list->data;
594
595                 if (!technology->path ||
596                                 (technology->rfkill_driven &&
597                                  technology->hardblocked))
598                         continue;
599
600                 dbus_message_iter_open_container(array, DBUS_TYPE_STRUCT,
601                                 NULL, &entry);
602                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
603                                 &technology->path);
604                 append_properties(&entry, technology);
605                 dbus_message_iter_close_container(array, &entry);
606         }
607 }
608
609 static gboolean technology_pending_reply(gpointer user_data)
610 {
611         struct connman_technology *technology = user_data;
612         DBusMessage *reply;
613
614         /* Power request timedout, send ETIMEDOUT. */
615         if (technology->pending_reply) {
616                 reply = __connman_error_failed(technology->pending_reply, ETIMEDOUT);
617                 if (reply)
618                         g_dbus_send_message(connection, reply);
619
620                 dbus_message_unref(technology->pending_reply);
621                 technology->pending_reply = NULL;
622                 technology->pending_timeout = 0;
623         }
624
625         return FALSE;
626 }
627
628 static int technology_affect_devices(struct connman_technology *technology,
629                                                 bool enable_device)
630 {
631         int err = 0, err_dev;
632         GSList *list;
633
634         if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
635                 if (enable_device)
636                         __connman_technology_enabled(technology->type);
637                 else
638                         __connman_technology_disabled(technology->type);
639                 return 0;
640         }
641
642         for (list = technology->device_list; list; list = list->next) {
643                 struct connman_device *device = list->data;
644
645                 if (enable_device)
646                         err_dev = __connman_device_enable(device);
647                 else
648                         err_dev = __connman_device_disable(device);
649
650                 if (err_dev < 0 && err_dev != -EALREADY)
651                         err = err_dev;
652         }
653
654         return err;
655 }
656
657 static void powered_changed(struct connman_technology *technology)
658 {
659         dbus_bool_t enabled;
660
661         if (!technology->dbus_registered)
662                 return;
663
664         if (technology->pending_reply) {
665                 g_dbus_send_reply(connection,
666                                 technology->pending_reply, DBUS_TYPE_INVALID);
667                 dbus_message_unref(technology->pending_reply);
668                 technology->pending_reply = NULL;
669
670                 g_source_remove(technology->pending_timeout);
671                 technology->pending_timeout = 0;
672         }
673
674         __sync_synchronize();
675         enabled = technology->enabled;
676 #if defined TIZEN_EXT
677         DBG("ConnMan, Powered : %s, %s",
678                         enabled ? "TRUE" : "FALSE",technology->path);
679 #endif
680         connman_dbus_property_changed_basic(technology->path,
681                         CONNMAN_TECHNOLOGY_INTERFACE, "Powered",
682                         DBUS_TYPE_BOOLEAN, &enabled);
683 }
684
685 static void enable_tethering(struct connman_technology *technology)
686 {
687         int ret;
688
689         if (!connman_setting_get_bool("PersistentTetheringMode"))
690                 return;
691
692         ret = set_tethering(technology, true);
693         if (ret < 0 && ret != -EALREADY)
694                 DBG("Cannot enable tethering yet for %s (%d/%s)",
695                         get_name(technology->type),
696                         -ret, strerror(-ret));
697 }
698
699 static int technology_enabled(struct connman_technology *technology)
700 {
701         __sync_synchronize();
702         if (technology->enabled)
703                 return -EALREADY;
704
705         technology->enabled = true;
706
707         if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
708                 struct connman_technology *p2p;
709
710                 p2p = technology_find(CONNMAN_SERVICE_TYPE_P2P);
711                 if (p2p && !p2p->enabled && p2p->enable_persistent)
712                         technology_enabled(p2p);
713         }
714
715         if (technology->tethering_persistent)
716                 enable_tethering(technology);
717
718         powered_changed(technology);
719
720         return 0;
721 }
722
723 static int technology_enable(struct connman_technology *technology)
724 {
725         int err = 0;
726         int err_dev;
727
728         DBG("technology %p enable", technology);
729
730         __sync_synchronize();
731
732         if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
733                 struct connman_technology *wifi;
734
735                 wifi = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
736                 if (wifi && wifi->enabled)
737                         return technology_enabled(technology);
738                 return 0;
739         }
740
741         if (technology->enabled)
742                 return -EALREADY;
743
744         if (technology->pending_reply)
745                 return -EBUSY;
746
747         if (connman_setting_get_bool("PersistentTetheringMode") &&
748                                         technology->tethering)
749                 set_tethering(technology, true);
750
751         if (technology->rfkill_driven)
752                 err = __connman_rfkill_block(technology->type, false);
753
754         err_dev = technology_affect_devices(technology, true);
755
756         if (!technology->rfkill_driven)
757                 err = err_dev;
758
759         return err;
760 }
761
762 static int technology_disabled(struct connman_technology *technology)
763 {
764         __sync_synchronize();
765         if (!technology->enabled)
766                 return -EALREADY;
767
768         technology->enabled = false;
769
770         powered_changed(technology);
771
772         return 0;
773 }
774
775 static int technology_disable(struct connman_technology *technology)
776 {
777         int err;
778
779         DBG("technology %p disable", technology);
780
781         __sync_synchronize();
782
783         if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
784                 technology->enable_persistent = false;
785                 return technology_disabled(technology);
786         } else if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
787                 struct connman_technology *p2p;
788
789                 p2p = technology_find(CONNMAN_SERVICE_TYPE_P2P);
790                 if (p2p && p2p->enabled) {
791                         p2p->enable_persistent = true;
792                         technology_disabled(p2p);
793                 }
794         }
795
796         if (!technology->enabled)
797                 return -EALREADY;
798
799         if (technology->pending_reply)
800                 return -EBUSY;
801
802         if (technology->tethering)
803                 set_tethering(technology, false);
804
805         err = technology_affect_devices(technology, false);
806
807         if (technology->rfkill_driven)
808                 err = __connman_rfkill_block(technology->type, true);
809
810         return err;
811 }
812
813 static DBusMessage *set_powered(struct connman_technology *technology,
814                                 DBusMessage *msg, bool powered)
815 {
816         DBusMessage *reply = NULL;
817         int err = 0;
818
819         if (technology->rfkill_driven && technology->hardblocked) {
820                 err = -EACCES;
821                 goto make_reply;
822         }
823
824         if (powered)
825                 err = technology_enable(technology);
826         else
827                 err = technology_disable(technology);
828
829         if (err != -EBUSY) {
830                 technology->enable_persistent = powered;
831                 technology_save(technology);
832         }
833
834 make_reply:
835         if (err == -EINPROGRESS) {
836                 technology->pending_reply = dbus_message_ref(msg);
837                 technology->pending_timeout = g_timeout_add_seconds(10,
838                                         technology_pending_reply, technology);
839         } else if (err == -EALREADY) {
840                 if (powered)
841                         reply = __connman_error_already_enabled(msg);
842                 else
843                         reply = __connman_error_already_disabled(msg);
844         } else if (err < 0)
845                 reply = __connman_error_failed(msg, -err);
846         else
847                 reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
848
849         return reply;
850 }
851
852 static DBusMessage *set_property(DBusConnection *conn,
853                                         DBusMessage *msg, void *data)
854 {
855         struct connman_technology *technology = data;
856         DBusMessageIter iter, value;
857         const char *name;
858         int type;
859
860         DBG("conn %p", conn);
861
862         if (!dbus_message_iter_init(msg, &iter))
863                 return __connman_error_invalid_arguments(msg);
864
865         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
866                 return __connman_error_invalid_arguments(msg);
867
868         dbus_message_iter_get_basic(&iter, &name);
869         dbus_message_iter_next(&iter);
870
871         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
872                 return __connman_error_invalid_arguments(msg);
873
874         dbus_message_iter_recurse(&iter, &value);
875
876         type = dbus_message_iter_get_arg_type(&value);
877
878         DBG("property %s", name);
879
880         if (technology->type == CONNMAN_SERVICE_TYPE_WIFI && technology->connected) {
881                 uid_t uid;
882                 if (connman_dbus_get_connection_unix_user_sync(conn,
883                                                 dbus_message_get_sender(msg),
884                                                 &uid) < 0) {
885                         DBG("Can not get unix user id!");
886                         return __connman_error_permission_denied(msg);
887                 }
888
889                 if (!__connman_service_is_user_allowed(CONNMAN_SERVICE_TYPE_WIFI, uid)) {
890                         DBG("Not allow this user to operate wifi technology now!");
891                         return __connman_error_permission_denied(msg);
892                 }
893         }
894
895         if (g_str_equal(name, "Tethering")) {
896                 dbus_bool_t tethering;
897                 int err;
898
899                 if (type != DBUS_TYPE_BOOLEAN)
900                         return __connman_error_invalid_arguments(msg);
901
902                 if (!connman_technology_is_tethering_allowed(technology->type)) {
903                         DBG("%s tethering not allowed by config file",
904                                 __connman_service_type2string(technology->type));
905                         return __connman_error_not_supported(msg);
906                 }
907
908                 dbus_message_iter_get_basic(&value, &tethering);
909
910                 if (technology->tethering == tethering) {
911                         if (!tethering)
912                                 return __connman_error_already_disabled(msg);
913                         else
914                                 return __connman_error_already_enabled(msg);
915                 }
916
917                 err = set_tethering(technology, tethering);
918                 if (err < 0)
919                         return __connman_error_failed(msg, -err);
920
921                 technology->tethering_persistent = tethering;
922
923                 technology_save(technology);
924
925         } else if (g_str_equal(name, "TetheringIdentifier")) {
926                 const char *str;
927
928                 dbus_message_iter_get_basic(&value, &str);
929
930                 if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
931                         return __connman_error_not_supported(msg);
932
933                 if (strlen(str) < 1 || strlen(str) > 32)
934                         return __connman_error_invalid_arguments(msg);
935
936                 if (g_strcmp0(technology->tethering_ident, str) != 0) {
937                         g_free(technology->tethering_ident);
938                         technology->tethering_ident = g_strdup(str);
939                         technology_save(technology);
940
941                         connman_dbus_property_changed_basic(technology->path,
942                                                 CONNMAN_TECHNOLOGY_INTERFACE,
943                                                 "TetheringIdentifier",
944                                                 DBUS_TYPE_STRING,
945                                                 &technology->tethering_ident);
946                 }
947         } else if (g_str_equal(name, "TetheringPassphrase")) {
948                 const char *str;
949
950                 dbus_message_iter_get_basic(&value, &str);
951
952                 if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
953                         return __connman_error_not_supported(msg);
954
955                 if (strlen(str) < 8 || strlen(str) > 63) {
956                         if (g_str_equal(str, "")) {
957                                 technology->tethering_passphrase = NULL;
958
959                                 connman_dbus_property_changed_basic(technology->path,
960                                                 CONNMAN_TECHNOLOGY_INTERFACE,
961                                                 "TetheringPassphrase",
962                                                 DBUS_TYPE_STRING,
963                                                 &str);
964                         }
965                         else
966                                 return __connman_error_passphrase_required(msg);
967                 } else {
968                         if (g_strcmp0(technology->tethering_passphrase, str) != 0) {
969                                 g_free(technology->tethering_passphrase);
970                                 technology->tethering_passphrase = g_strdup(str);
971                                 technology_save(technology);
972
973                                 connman_dbus_property_changed_basic(technology->path,
974                                                 CONNMAN_TECHNOLOGY_INTERFACE,
975                                                 "TetheringPassphrase",
976                                                 DBUS_TYPE_STRING,
977                                                 &technology->tethering_passphrase);
978                         }
979                 }
980         } else if (g_str_equal(name, "Hidden")) {
981                 dbus_bool_t hidden;
982
983                 if (type != DBUS_TYPE_BOOLEAN)
984                         return __connman_error_invalid_arguments(msg);
985
986                 dbus_message_iter_get_basic(&value, &hidden);
987
988                 if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
989                         return __connman_error_not_supported(msg);
990
991                 technology->tethering_hidden = hidden;
992                 technology_save(technology);
993
994                 connman_dbus_property_changed_basic(technology->path,
995                                         CONNMAN_TECHNOLOGY_INTERFACE,
996                                         "Hidden",
997                                         DBUS_TYPE_BOOLEAN,
998                                         &hidden);
999         } else if (g_str_equal(name, "Powered")) {
1000                 dbus_bool_t enable;
1001
1002                 if (type != DBUS_TYPE_BOOLEAN)
1003                         return __connman_error_invalid_arguments(msg);
1004
1005                 dbus_message_iter_get_basic(&value, &enable);
1006
1007                 return set_powered(technology, msg, enable);
1008         } else
1009                 return __connman_error_invalid_property(msg);
1010
1011         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1012 }
1013
1014 static void reply_scan_pending(struct connman_technology *technology, int err)
1015 {
1016         DBusMessage *reply;
1017
1018         DBG("technology %p err %d", technology, err);
1019
1020         while (technology->scan_pending) {
1021                 DBusMessage *msg = technology->scan_pending->data;
1022
1023                 DBG("reply to %s", dbus_message_get_sender(msg));
1024
1025                 if (err == 0)
1026                         reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1027                 else
1028                         reply = __connman_error_failed(msg, -err);
1029                 g_dbus_send_message(connection, reply);
1030                 dbus_message_unref(msg);
1031
1032                 technology->scan_pending =
1033                         g_slist_delete_link(technology->scan_pending,
1034                                         technology->scan_pending);
1035         }
1036 }
1037
1038 #if defined TIZEN_EXT
1039 dbus_bool_t __connman_technology_notify_scan_changed(const char *key, void *val)
1040 {
1041         DBG("key %s", key);
1042         DBusMessage *signal;
1043         DBusMessageIter iter;
1044         dbus_bool_t result = FALSE;
1045
1046         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
1047                         CONNMAN_MANAGER_INTERFACE, "ScanChanged");
1048         if (!signal)
1049                 return result;
1050
1051         dbus_message_iter_init_append(signal, &iter);
1052         connman_dbus_property_append_basic(&iter, key, DBUS_TYPE_BOOLEAN, val);
1053
1054         result = dbus_connection_send(connection, signal, NULL);
1055         dbus_message_unref(signal);
1056
1057         DBG("Successfuly sent signal");
1058
1059         return result;
1060 }
1061 #endif
1062
1063 void __connman_technology_scan_started(struct connman_device *device)
1064 {
1065         DBG("device %p", device);
1066 #if defined TIZEN_EXT
1067         dbus_bool_t status = 1;
1068         __connman_technology_notify_scan_changed("scan_started", &status);
1069 #endif
1070 }
1071
1072 void __connman_technology_scan_stopped(struct connman_device *device,
1073                                         enum connman_service_type type)
1074 {
1075         int count = 0;
1076         struct connman_technology *technology;
1077         GSList *list;
1078
1079         technology = technology_find(type);
1080
1081         DBG("technology %p device %p", technology, device);
1082
1083         if (!technology)
1084                 return;
1085
1086         for (list = technology->device_list; list; list = list->next) {
1087                 struct connman_device *other_device = list->data;
1088
1089                 if (device == other_device)
1090                         continue;
1091
1092                 if (__connman_device_get_service_type(other_device) != type)
1093                         continue;
1094
1095                 if (connman_device_get_scanning(other_device))
1096                         count += 1;
1097         }
1098
1099 #if defined TIZEN_EXT
1100         if (count == 0) {
1101                 DBusMessage *signal;
1102                 dbus_bool_t status = 0;
1103                 __connman_technology_notify_scan_changed("scan_done", &status);
1104
1105                 signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
1106                                                                                 CONNMAN_MANAGER_INTERFACE, "ScanDone");
1107                 if (!signal)
1108                         return;
1109
1110                 dbus_connection_send(connection, signal, NULL);
1111                 dbus_message_unref(signal);
1112                 reply_scan_pending(technology, 0);
1113         }
1114 #else
1115         if (count == 0)
1116                 reply_scan_pending(technology, 0);
1117 #endif
1118 }
1119
1120 void __connman_technology_notify_regdom_by_device(struct connman_device *device,
1121                                                 int result, const char *alpha2)
1122 {
1123         bool regdom_set = false;
1124         struct connman_technology *technology;
1125         enum connman_service_type type;
1126         GSList *tech_drivers;
1127
1128         type = __connman_device_get_service_type(device);
1129         technology = technology_find(type);
1130
1131         if (!technology)
1132                 return;
1133
1134         if (result < 0) {
1135
1136                 for (tech_drivers = technology->driver_list;
1137                      tech_drivers;
1138                      tech_drivers = g_slist_next(tech_drivers)) {
1139                         struct connman_technology_driver *driver =
1140                                 tech_drivers->data;
1141
1142                         if (driver->set_regdom) {
1143                                 driver->set_regdom(technology, alpha2);
1144                                 regdom_set = true;
1145                         }
1146
1147                 }
1148
1149                 if (!regdom_set)
1150                         alpha2 = NULL;
1151         }
1152
1153         connman_technology_regdom_notify(technology, alpha2);
1154 }
1155
1156 static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data)
1157 {
1158         struct connman_technology *technology = data;
1159         int err;
1160
1161         DBG("technology %p request from %s", technology,
1162                         dbus_message_get_sender(msg));
1163
1164         dbus_message_ref(msg);
1165         technology->scan_pending =
1166                 g_slist_prepend(technology->scan_pending, msg);
1167
1168         err = __connman_device_request_scan(technology->type);
1169         if (err < 0)
1170                 reply_scan_pending(technology, err);
1171
1172         return NULL;
1173 }
1174
1175 #if defined TIZEN_EXT
1176 static DBusMessage *specific_scan(DBusConnection *conn, DBusMessage *msg, void *data)
1177 {
1178         struct connman_technology *technology = data;
1179         GSList *specific_scan_list = NULL;
1180         int scan_type = 0;
1181         const char *name = NULL;
1182         unsigned int freq = 0;
1183         DBusMessageIter iter, dict;
1184         int err;
1185
1186         DBG("technology %p request from %s", technology,
1187                         dbus_message_get_sender(msg));
1188
1189         if (!dbus_message_iter_init(msg, &iter))
1190                 return __connman_error_invalid_arguments(msg);
1191
1192         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
1193                 return __connman_error_invalid_arguments(msg);
1194
1195         dbus_message_iter_recurse(&iter, &dict);
1196         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1197                 DBusMessageIter entry, value2;
1198                 const char *key;
1199                 int type;
1200
1201                 dbus_message_iter_recurse(&dict, &entry);
1202                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
1203                         return __connman_error_invalid_arguments(msg);
1204
1205                 dbus_message_iter_get_basic(&entry, &key);
1206                 dbus_message_iter_next(&entry);
1207
1208                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
1209                         return __connman_error_invalid_arguments(msg);
1210
1211                 dbus_message_iter_recurse(&entry, &value2);
1212                 type = dbus_message_iter_get_arg_type(&value2);
1213                 if (g_str_equal(key, "SSID")) {
1214                         if (type != DBUS_TYPE_STRING)
1215                                 return __connman_error_invalid_arguments(msg);
1216
1217                         scan_type = 1; /* SSID based scan */
1218                         dbus_message_iter_get_basic(&value2, &name);
1219                         DBG("name %s", name);
1220                         specific_scan_list = g_slist_append(specific_scan_list, g_strdup(name));
1221                 } else if (g_str_equal(key, "Frequency")) {
1222                         if (type != DBUS_TYPE_UINT16) {
1223                                 g_slist_free_full(specific_scan_list, g_free);
1224                                 return __connman_error_invalid_arguments(msg);
1225                         }
1226
1227                         scan_type = 2; /* Frequency based scan */
1228                         dbus_message_iter_get_basic(&value2, &freq);
1229                         DBG("freq %d", freq);
1230                         specific_scan_list = g_slist_append(specific_scan_list, GINT_TO_POINTER(freq));
1231                 }
1232                 dbus_message_iter_next(&dict);
1233         }
1234
1235         dbus_message_ref(msg);
1236         technology->scan_pending =
1237                 g_slist_prepend(technology->scan_pending, msg);
1238
1239         err = __connman_device_request_specific_scan(technology->type, scan_type, specific_scan_list);
1240         if (err < 0)
1241                 reply_scan_pending(technology, err);
1242
1243         g_slist_free_full(specific_scan_list, g_free);
1244         return NULL;
1245 }
1246
1247 static DBusMessage *get_scan_state(DBusConnection *conn, DBusMessage *msg, void *data)
1248 {
1249         DBusMessage *reply;
1250         DBusMessageIter iter, dict;
1251         GSList *list;
1252         struct connman_technology *technology = data;
1253         dbus_bool_t scanning = false;
1254
1255         DBG("technology %p", technology);
1256
1257         for (list = technology->device_list; list; list = list->next) {
1258                 struct connman_device *device = list->data;
1259                 scanning = connman_device_get_scanning(device);
1260                 if(scanning)
1261                         break;
1262         }
1263
1264         DBG("scanning : %d", scanning);
1265         reply = dbus_message_new_method_return(msg);
1266         if (!reply)
1267                 return NULL;
1268
1269         dbus_message_iter_init_append(reply, &iter);
1270
1271         connman_dbus_dict_open(&iter, &dict);
1272         connman_dbus_dict_append_basic(&dict, "Scanstate",
1273                                         DBUS_TYPE_BOOLEAN,
1274                                         &scanning);
1275
1276         connman_dbus_dict_close(&iter, &dict);
1277
1278         return reply;
1279 }
1280 #endif
1281
1282 static const GDBusMethodTable technology_methods[] = {
1283         { GDBUS_DEPRECATED_METHOD("GetProperties",
1284                         NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
1285                         get_properties) },
1286         { GDBUS_ASYNC_METHOD("SetProperty",
1287                         GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
1288                         NULL, set_property) },
1289         { GDBUS_ASYNC_METHOD("Scan", NULL, NULL, scan) },
1290         { GDBUS_ASYNC_METHOD("SpecificScan", GDBUS_ARGS({ "specificscan", "a{sv}" }),
1291                         NULL, specific_scan) },
1292 #if defined TIZEN_EXT
1293         { GDBUS_METHOD("GetScanState", NULL, GDBUS_ARGS({ "scan_state", "a{sv}" }),
1294                         get_scan_state) },
1295 #endif
1296         { },
1297 };
1298
1299 static const GDBusSignalTable technology_signals[] = {
1300         { GDBUS_SIGNAL("PropertyChanged",
1301                         GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
1302         { GDBUS_SIGNAL("DhcpConnected",
1303                         GDBUS_ARGS({ "aptype", "s" },
1304                                 { "ipaddr", "s" },
1305                                 { "macaddr", "s" },
1306                                 { "hostname", "s" })) },
1307         { GDBUS_SIGNAL("DhcpLeaseDeleted",
1308                         GDBUS_ARGS({ "aptype", "s" },
1309                                 { "ipaddr", "s" },
1310                                 { "macaddr", "s" },
1311                                 { "hostname", "s" })) },
1312         { },
1313 };
1314
1315 static bool technology_dbus_register(struct connman_technology *technology)
1316 {
1317         if (technology->dbus_registered ||
1318                                 (technology->rfkill_driven &&
1319                                  technology->hardblocked))
1320                 return true;
1321
1322         if (!g_dbus_register_interface(connection, technology->path,
1323                                         CONNMAN_TECHNOLOGY_INTERFACE,
1324                                         technology_methods, technology_signals,
1325                                         NULL, technology, NULL)) {
1326                 connman_error("Failed to register %s", technology->path);
1327                 return false;
1328         }
1329
1330         technology_added_signal(technology);
1331         technology->dbus_registered = true;
1332
1333         return true;
1334 }
1335
1336 static void technology_dbus_unregister(struct connman_technology *technology)
1337 {
1338         if (!technology->dbus_registered)
1339                 return;
1340
1341         technology_removed_signal(technology);
1342         g_dbus_unregister_interface(connection, technology->path,
1343                 CONNMAN_TECHNOLOGY_INTERFACE);
1344
1345         technology->dbus_registered = false;
1346 }
1347
1348 static void technology_put(struct connman_technology *technology)
1349 {
1350         DBG("technology %p", technology);
1351
1352         if (__sync_sub_and_fetch(&technology->refcount, 1) > 0)
1353                 return;
1354
1355         reply_scan_pending(technology, -EINTR);
1356
1357         while (technology->driver_list) {
1358                 struct connman_technology_driver *driver;
1359
1360                 driver = technology->driver_list->data;
1361
1362                 if (driver->remove)
1363                         driver->remove(technology);
1364
1365                 technology->driver_list =
1366                         g_slist_delete_link(technology->driver_list,
1367                                         technology->driver_list);
1368         }
1369
1370         technology_list = g_slist_remove(technology_list, technology);
1371
1372         technology_dbus_unregister(technology);
1373
1374         g_slist_free(technology->device_list);
1375
1376         g_free(technology->path);
1377         g_free(technology->regdom);
1378         g_free(technology->tethering_ident);
1379         g_free(technology->tethering_passphrase);
1380         g_free(technology);
1381 }
1382
1383 static struct connman_technology *technology_get(enum connman_service_type type)
1384 {
1385         GSList *tech_drivers = NULL;
1386         struct connman_technology_driver *driver;
1387         struct connman_technology *technology;
1388         const char *str;
1389         GSList *list;
1390
1391         DBG("type %d", type);
1392
1393         str = __connman_service_type2string(type);
1394         if (!str)
1395                 return NULL;
1396
1397         technology = technology_find(type);
1398         if (technology) {
1399                 if (type != CONNMAN_SERVICE_TYPE_P2P)
1400                         __sync_fetch_and_add(&technology->refcount, 1);
1401                 return technology;
1402         }
1403
1404         /* First check if we have a driver for this technology type */
1405         for (list = driver_list; list; list = list->next) {
1406                 driver = list->data;
1407
1408                 if (driver->type == type) {
1409                         DBG("technology %p driver %p", technology, driver);
1410                         tech_drivers = g_slist_append(tech_drivers, driver);
1411                 }
1412         }
1413
1414         if (!tech_drivers) {
1415                 DBG("No matching drivers found for %s.",
1416                                 __connman_service_type2string(type));
1417                 return NULL;
1418         }
1419
1420         technology = g_try_new0(struct connman_technology, 1);
1421         if (!technology)
1422                 return NULL;
1423
1424         technology->refcount = 1;
1425         technology->type = type;
1426         technology->tethering_hidden = FALSE;
1427         technology->path = g_strdup_printf("%s/technology/%s",
1428                                                         CONNMAN_PATH, str);
1429
1430         technology_load(technology);
1431         technology_list = g_slist_prepend(technology_list, technology);
1432         technology->driver_list = tech_drivers;
1433
1434         for (list = tech_drivers; list; list = list->next) {
1435                 driver = list->data;
1436
1437                 if (driver->probe && driver->probe(technology) < 0)
1438                         DBG("Driver probe failed for technology %p",
1439                                         technology);
1440         }
1441
1442         if (!technology_dbus_register(technology)) {
1443                 technology_put(technology);
1444                 return NULL;
1445         }
1446
1447         if (type == CONNMAN_SERVICE_TYPE_P2P) {
1448                 struct connman_technology *wifi;
1449                 bool enable;
1450
1451                 enable = technology->enable_persistent;
1452
1453                 wifi = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
1454                 if (enable && wifi)
1455                         enable = wifi->enabled;
1456
1457                 technology_affect_devices(technology, enable);
1458         }
1459
1460         DBG("technology %p %s", technology, get_name(technology->type));
1461
1462         return technology;
1463 }
1464
1465 int connman_technology_driver_register(struct connman_technology_driver *driver)
1466 {
1467         GSList *list;
1468         struct connman_device *device;
1469         enum connman_service_type type;
1470
1471         for (list = driver_list; list; list = list->next) {
1472                 if (list->data == driver)
1473                         goto exist;
1474         }
1475
1476         DBG("Registering %s driver", driver->name);
1477
1478         driver_list = g_slist_insert_sorted(driver_list, driver,
1479                                                         compare_priority);
1480
1481         /*
1482          * Check for technology less devices if this driver
1483          * can service any of them.
1484         */
1485         for (list = techless_device_list; list; list = list->next) {
1486                 device = list->data;
1487
1488                 type = __connman_device_get_service_type(device);
1489                 if (type != driver->type)
1490                         continue;
1491
1492                 techless_device_list = g_slist_remove(techless_device_list,
1493                                                                 device);
1494
1495                 __connman_technology_add_device(device);
1496         }
1497
1498         /* Check for orphaned rfkill switches. */
1499         g_hash_table_foreach(rfkill_list, rfkill_check,
1500                                         GINT_TO_POINTER(driver->type));
1501
1502 exist:
1503         if (driver->type == CONNMAN_SERVICE_TYPE_P2P) {
1504                 if (!technology_get(CONNMAN_SERVICE_TYPE_P2P))
1505                         return -ENOMEM;
1506         }
1507
1508         return 0;
1509 }
1510
1511 void connman_technology_driver_unregister(struct connman_technology_driver *driver)
1512 {
1513         GSList *list, *tech_drivers;
1514         struct connman_technology *technology;
1515         struct connman_technology_driver *current;
1516
1517         DBG("Unregistering driver %p name %s", driver, driver->name);
1518
1519         for (list = technology_list; list; list = list->next) {
1520                 technology = list->data;
1521
1522                 for (tech_drivers = technology->driver_list; tech_drivers;
1523                                 tech_drivers = g_slist_next(tech_drivers)) {
1524                         current = tech_drivers->data;
1525                         if (driver != current)
1526                                 continue;
1527
1528                         if (driver->remove)
1529                                 driver->remove(technology);
1530
1531                         technology->driver_list =
1532                                 g_slist_remove(technology->driver_list,
1533                                                                 driver);
1534                         break;
1535                 }
1536         }
1537
1538         driver_list = g_slist_remove(driver_list, driver);
1539
1540         if (driver->type == CONNMAN_SERVICE_TYPE_P2P) {
1541                 technology = technology_find(CONNMAN_SERVICE_TYPE_P2P);
1542                 if (technology)
1543                         technology_put(technology);
1544         }
1545 }
1546
1547 void __connman_technology_add_interface(enum connman_service_type type,
1548                                 int index, const char *ident)
1549 {
1550         struct connman_technology *technology;
1551         GSList *tech_drivers;
1552         struct connman_technology_driver *driver;
1553         char *name;
1554
1555         switch (type) {
1556         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1557         case CONNMAN_SERVICE_TYPE_SYSTEM:
1558                 return;
1559         case CONNMAN_SERVICE_TYPE_ETHERNET:
1560         case CONNMAN_SERVICE_TYPE_WIFI:
1561         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1562         case CONNMAN_SERVICE_TYPE_CELLULAR:
1563         case CONNMAN_SERVICE_TYPE_GPS:
1564         case CONNMAN_SERVICE_TYPE_VPN:
1565         case CONNMAN_SERVICE_TYPE_GADGET:
1566         case CONNMAN_SERVICE_TYPE_P2P:
1567                 break;
1568         }
1569
1570         name = connman_inet_ifname(index);
1571         connman_info("Adding interface %s [ %s ]", name,
1572                                 __connman_service_type2string(type));
1573
1574         technology = technology_find(type);
1575
1576         if (!technology)
1577                 goto out;
1578
1579         for (tech_drivers = technology->driver_list; tech_drivers;
1580              tech_drivers = g_slist_next(tech_drivers)) {
1581                 driver = tech_drivers->data;
1582
1583                 if (driver->add_interface)
1584                         driver->add_interface(technology, index, name, ident);
1585         }
1586
1587         /*
1588          * At this point we can try to enable tethering automatically as
1589          * now the interfaces are set properly.
1590          */
1591         if (technology->tethering_persistent)
1592                 enable_tethering(technology);
1593
1594 out:
1595         g_free(name);
1596 }
1597
1598 void __connman_technology_remove_interface(enum connman_service_type type,
1599                                 int index, const char *ident)
1600 {
1601         struct connman_technology *technology;
1602         GSList *tech_drivers;
1603         struct connman_technology_driver *driver;
1604         char *name;
1605
1606         switch (type) {
1607         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1608         case CONNMAN_SERVICE_TYPE_SYSTEM:
1609                 return;
1610         case CONNMAN_SERVICE_TYPE_ETHERNET:
1611         case CONNMAN_SERVICE_TYPE_WIFI:
1612         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1613         case CONNMAN_SERVICE_TYPE_CELLULAR:
1614         case CONNMAN_SERVICE_TYPE_GPS:
1615         case CONNMAN_SERVICE_TYPE_VPN:
1616         case CONNMAN_SERVICE_TYPE_GADGET:
1617         case CONNMAN_SERVICE_TYPE_P2P:
1618                 break;
1619         }
1620
1621         name = connman_inet_ifname(index);
1622         connman_info("Remove interface %s [ %s ]", name,
1623                                 __connman_service_type2string(type));
1624         g_free(name);
1625
1626         technology = technology_find(type);
1627
1628         if (!technology)
1629                 return;
1630
1631         for (tech_drivers = technology->driver_list; tech_drivers;
1632              tech_drivers = g_slist_next(tech_drivers)) {
1633                 driver = tech_drivers->data;
1634
1635                 if (driver->remove_interface)
1636                         driver->remove_interface(technology, index);
1637         }
1638 }
1639
1640 int __connman_technology_add_device(struct connman_device *device)
1641 {
1642         struct connman_technology *technology;
1643         enum connman_service_type type;
1644
1645         type = __connman_device_get_service_type(device);
1646
1647         DBG("device %p type %s", device, get_name(type));
1648
1649         technology = technology_get(type);
1650         if (!technology) {
1651                 /*
1652                  * Since no driver can be found for this device at the moment we
1653                  * add it to the techless device list.
1654                 */
1655                 techless_device_list = g_slist_prepend(techless_device_list,
1656                                                                 device);
1657
1658                 return -ENXIO;
1659         }
1660
1661         __sync_synchronize();
1662         if (technology->rfkill_driven) {
1663                 if (technology->enabled)
1664                         __connman_device_enable(device);
1665                 else
1666                         __connman_device_disable(device);
1667
1668                 goto done;
1669         }
1670
1671         if (technology->enable_persistent &&
1672                                         !global_offlinemode) {
1673                 int err = __connman_device_enable(device);
1674                 /*
1675                  * connman_technology_add_device() calls __connman_device_enable()
1676                  * but since the device is already enabled, the calls does not
1677                  * propagate through to connman_technology_enabled via
1678                  * connman_device_set_powered.
1679                  */
1680                 if (err == -EALREADY)
1681                         __connman_technology_enabled(type);
1682         }
1683         /* if technology persistent state is offline */
1684         if (!technology->enable_persistent)
1685                 __connman_device_disable(device);
1686
1687 done:
1688         technology->device_list = g_slist_prepend(technology->device_list,
1689                                                                 device);
1690
1691         return 0;
1692 }
1693
1694 int __connman_technology_remove_device(struct connman_device *device)
1695 {
1696         struct connman_technology *technology;
1697         enum connman_service_type type;
1698
1699         DBG("device %p", device);
1700
1701         type = __connman_device_get_service_type(device);
1702
1703         technology = technology_find(type);
1704         if (!technology) {
1705                 techless_device_list = g_slist_remove(techless_device_list,
1706                                                                 device);
1707                 return -ENXIO;
1708         }
1709
1710         technology->device_list = g_slist_remove(technology->device_list,
1711                                                                 device);
1712
1713         if (technology->tethering)
1714                 set_tethering(technology, false);
1715
1716         technology_put(technology);
1717
1718         return 0;
1719 }
1720
1721 int __connman_technology_enabled(enum connman_service_type type)
1722 {
1723         struct connman_technology *technology;
1724
1725         technology = technology_find(type);
1726         if (!technology)
1727                 return -ENXIO;
1728
1729         DBG("technology %p type %s rfkill %d enabled %d", technology,
1730                 get_name(type), technology->rfkill_driven,
1731                 technology->enabled);
1732 #if !defined TIZEN_EXT
1733         if (technology->rfkill_driven) {
1734                 if (technology->tethering_persistent)
1735                         enable_tethering(technology);
1736                 return 0;
1737         }
1738 #endif
1739
1740         return technology_enabled(technology);
1741 }
1742
1743 int __connman_technology_disabled(enum connman_service_type type)
1744 {
1745         struct connman_technology *technology;
1746         GSList *list;
1747
1748         technology = technology_find(type);
1749         if (!technology)
1750                 return -ENXIO;
1751 #if !defined TIZEN_EXT
1752         if (technology->rfkill_driven)
1753                 return 0;
1754 #endif
1755         for (list = technology->device_list; list; list = list->next) {
1756                 struct connman_device *device = list->data;
1757
1758                 if (connman_device_get_powered(device))
1759                         return 0;
1760         }
1761
1762         return technology_disabled(technology);
1763 }
1764
1765 int __connman_technology_set_offlinemode(bool offlinemode)
1766 {
1767         GSList *list;
1768         int err = -EINVAL, enabled_tech_count = 0;
1769
1770         if (global_offlinemode == offlinemode)
1771                 return 0;
1772
1773         DBG("offlinemode %s", offlinemode ? "On" : "Off");
1774
1775         /*
1776          * This is a bit tricky. When you set offlinemode, there is no
1777          * way to differentiate between attempting offline mode and
1778          * resuming offlinemode from last saved profile. We need that
1779          * information in rfkill_update, otherwise it falls back on the
1780          * technology's persistent state. Hence we set the offline mode here
1781          * but save it & call the notifier only if its successful.
1782          */
1783
1784         global_offlinemode = offlinemode;
1785
1786         /* Traverse technology list, enable/disable each technology. */
1787         for (list = technology_list; list; list = list->next) {
1788                 struct connman_technology *technology = list->data;
1789
1790                 if (offlinemode)
1791                         err = technology_disable(technology);
1792                 else {
1793                         if (technology->hardblocked)
1794                                 continue;
1795
1796                         if (technology->enable_persistent) {
1797                                 err = technology_enable(technology);
1798                                 enabled_tech_count++;
1799                         }
1800                 }
1801         }
1802
1803         if (err == 0 || err == -EINPROGRESS || err == -EALREADY ||
1804                         (err == -EINVAL && enabled_tech_count == 0)) {
1805                 connman_technology_save_offlinemode();
1806                 __connman_notifier_offlinemode(offlinemode);
1807         } else
1808                 global_offlinemode = connman_technology_load_offlinemode();
1809
1810         return err;
1811 }
1812
1813 void __connman_technology_set_connected(enum connman_service_type type,
1814                 bool connected)
1815 {
1816         struct connman_technology *technology;
1817         dbus_bool_t val;
1818
1819         technology = technology_find(type);
1820         if (!technology)
1821                 return;
1822
1823         DBG("technology %p connected %d", technology, connected);
1824
1825         technology->connected = connected;
1826
1827         val = connected;
1828         connman_dbus_property_changed_basic(technology->path,
1829                         CONNMAN_TECHNOLOGY_INTERFACE, "Connected",
1830                         DBUS_TYPE_BOOLEAN, &val);
1831 }
1832
1833 static bool technology_apply_rfkill_change(struct connman_technology *technology,
1834                                                 bool softblock,
1835                                                 bool hardblock,
1836                                                 bool new_rfkill)
1837 {
1838         bool hardblock_changed = false;
1839         bool apply = true;
1840         GList *start, *list;
1841
1842         DBG("technology %p --> %d/%d vs %d/%d",
1843                         technology, softblock, hardblock,
1844                         technology->softblocked, technology->hardblocked);
1845
1846         if (technology->hardblocked == hardblock)
1847                 goto softblock_change;
1848
1849         if (!(new_rfkill && !hardblock)) {
1850                 start = g_hash_table_get_values(rfkill_list);
1851
1852                 for (list = start; list; list = list->next) {
1853                         struct connman_rfkill *rfkill = list->data;
1854
1855                         if (rfkill->type != technology->type)
1856                                 continue;
1857
1858                         if (rfkill->hardblock != hardblock)
1859                                 apply = false;
1860                 }
1861
1862                 g_list_free(start);
1863         }
1864
1865         if (!apply)
1866                 goto softblock_change;
1867
1868         technology->hardblocked = hardblock;
1869         hardblock_changed = true;
1870
1871 softblock_change:
1872         if (!apply && technology->softblocked != softblock)
1873                 apply = true;
1874
1875         if (!apply)
1876                 return technology->hardblocked;
1877
1878         technology->softblocked = softblock;
1879
1880         if (technology->hardblocked ||
1881                                         technology->softblocked) {
1882                 if (technology_disabled(technology) != -EALREADY)
1883                         technology_affect_devices(technology, false);
1884         } else if (!technology->hardblocked &&
1885                                         !technology->softblocked) {
1886                 if (technology_enabled(technology) != -EALREADY)
1887                         technology_affect_devices(technology, true);
1888         }
1889
1890         if (hardblock_changed) {
1891                 if (technology->hardblocked) {
1892                         DBG("%s is switched off.", get_name(technology->type));
1893                         technology_dbus_unregister(technology);
1894                 } else {
1895                         DBG("%s is switched on.", get_name(technology->type));
1896                         technology_dbus_register(technology);
1897
1898                         if (global_offlinemode)
1899                                 __connman_rfkill_block(technology->type, true);
1900                 }
1901         }
1902
1903         return technology->hardblocked;
1904 }
1905
1906 int __connman_technology_add_rfkill(unsigned int index,
1907                                         enum connman_service_type type,
1908                                                 bool softblock,
1909                                                 bool hardblock)
1910 {
1911         struct connman_technology *technology;
1912         struct connman_rfkill *rfkill;
1913
1914         DBG("index %u type %d soft %u hard %u", index, type,
1915                                                         softblock, hardblock);
1916
1917         rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
1918         if (rfkill)
1919                 goto done;
1920
1921         rfkill = g_try_new0(struct connman_rfkill, 1);
1922         if (!rfkill)
1923                 return -ENOMEM;
1924
1925         rfkill->index = index;
1926         rfkill->type = type;
1927         rfkill->softblock = softblock;
1928         rfkill->hardblock = hardblock;
1929
1930         g_hash_table_insert(rfkill_list, GINT_TO_POINTER(index), rfkill);
1931
1932 done:
1933 #if defined TIZEN_EXT
1934         /* Fix Svace Issue [WGID: 1348]. */
1935         g_free(rfkill);
1936 #endif
1937         technology = technology_get(type);
1938         /* If there is no driver for this type, ignore it. */
1939         if (!technology)
1940                 return -ENXIO;
1941
1942         technology->rfkill_driven = true;
1943
1944 #if !defined TIZEN_EXT
1945         /* If hardblocked, there is no need to handle softblocked state */
1946         if (technology_apply_rfkill_change(technology,
1947                                 softblock, hardblock, true))
1948                 return 0;
1949 #endif
1950         if (global_offlinemode)
1951                 return 0;
1952
1953         /*
1954          * Depending on softblocked state we unblock/block according to
1955          * offlinemode and persistente state.
1956          */
1957         if (technology->softblocked &&
1958                                 technology->enable_persistent)
1959                 return __connman_rfkill_block(type, false);
1960         else if (!technology->softblocked &&
1961                                 !technology->enable_persistent)
1962                 return __connman_rfkill_block(type, true);
1963
1964         return 0;
1965 }
1966
1967 int __connman_technology_update_rfkill(unsigned int index,
1968                                         enum connman_service_type type,
1969                                                 bool softblock,
1970                                                 bool hardblock)
1971 {
1972         struct connman_technology *technology;
1973         struct connman_rfkill *rfkill;
1974
1975         DBG("index %u soft %u hard %u", index, softblock, hardblock);
1976
1977         rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
1978         if (!rfkill)
1979                 return -ENXIO;
1980
1981         if (rfkill->softblock == softblock &&
1982                                 rfkill->hardblock == hardblock)
1983                 return 0;
1984
1985         rfkill->softblock = softblock;
1986         rfkill->hardblock = hardblock;
1987
1988         technology = technology_find(type);
1989         /* If there is no driver for this type, ignore it. */
1990         if (!technology)
1991                 return -ENXIO;
1992
1993         technology_apply_rfkill_change(technology, softblock, hardblock,
1994                                                                 false);
1995
1996         if (technology->hardblocked)
1997                 DBG("%s hardblocked", get_name(technology->type));
1998         else
1999                 DBG("%s is%s softblocked", get_name(technology->type),
2000                         technology->softblocked ? "" : " not");
2001
2002         return 0;
2003 }
2004
2005 int __connman_technology_remove_rfkill(unsigned int index,
2006                                         enum connman_service_type type)
2007 {
2008         struct connman_technology *technology;
2009         struct connman_rfkill *rfkill;
2010
2011         DBG("index %u", index);
2012
2013         rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
2014         if (!rfkill)
2015                 return -ENXIO;
2016
2017         g_hash_table_remove(rfkill_list, GINT_TO_POINTER(index));
2018
2019         technology = technology_find(type);
2020         if (!technology)
2021                 return -ENXIO;
2022
2023         technology_apply_rfkill_change(technology,
2024                 technology->softblocked, !technology->hardblocked, false);
2025
2026         technology_put(technology);
2027
2028         return 0;
2029 }
2030
2031 int __connman_technology_init(void)
2032 {
2033         DBG("");
2034
2035         connection = connman_dbus_get_connection();
2036
2037         rfkill_list = g_hash_table_new_full(g_direct_hash, g_direct_equal,
2038                                                         NULL, free_rfkill);
2039
2040         global_offlinemode = connman_technology_load_offlinemode();
2041
2042         /* This will create settings file if it is missing */
2043         connman_technology_save_offlinemode();
2044
2045         return 0;
2046 }
2047
2048 void __connman_technology_cleanup(void)
2049 {
2050         DBG("");
2051
2052         while (technology_list) {
2053                 struct connman_technology *technology = technology_list->data;
2054                 technology_list = g_slist_remove(technology_list, technology);
2055                 technology_put(technology);
2056         }
2057
2058         g_hash_table_destroy(rfkill_list);
2059
2060         dbus_connection_unref(connection);
2061 }