src/service.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2014  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 <stdio.h>
  28 #include <string.h>
  29 #include <netdb.h>
  30 #include <gdbus.h>
  31 #include <ctype.h>
  32 #include <stdint.h>
  33 #include <pwd.h>
  34 #include <utmpx.h>
  35
  36 #include <connman/storage.h>
  37 #include <connman/setting.h>
  38 #include <connman/agent.h>
  39
  40 #include "connman.h"
  41
  42 #define CONNECT_TIMEOUT         120
  43
  44 #define USER_ROOT               0
  45 #define USER_NONE               (uid_t)-1
  46
  47 #if defined TIZEN_EXT
  48 #define WIFI_BSSID_STR_LEN      18
  49 #endif
  50
  51 static DBusConnection *connection = NULL;
  52
  53 static GList *service_list = NULL;
  54 static GHashTable *service_hash = NULL;
  55 static GSList *counter_list = NULL;
  56 static unsigned int autoconnect_timeout = 0;
  57 static unsigned int vpn_autoconnect_timeout = 0;
  58 static struct connman_service *current_default = NULL;
  59 static bool services_dirty = false;
  60
  61 #if defined TIZEN_EXT
  62 static bool auto_connect_mode = TRUE;
  63 #endif
  64
  65 struct connman_stats {
  66         bool valid;
  67         bool enabled;
  68         struct connman_stats_data data_last;
  69         struct connman_stats_data data;
  70         GTimer *timer;
  71 };
  72
  73 struct connman_stats_counter {
  74         bool append_all;
  75         struct connman_stats stats;
  76         struct connman_stats stats_roaming;
  77 };
  78
  79 struct connman_service_user {
  80         uid_t favorite_user;
  81         uid_t current_user;
  82 };
  83
  84 struct connman_service {
  85         int refcount;
  86         char *identifier;
  87         char *path;
  88         enum connman_service_type type;
  89         enum connman_service_security security;
  90         enum connman_service_state state;
  91         enum connman_service_state state_ipv4;
  92         enum connman_service_state state_ipv6;
  93         enum connman_service_error error;
  94         enum connman_service_connect_reason connect_reason;
  95         uint8_t strength;
  96         bool favorite;
  97         bool immutable;
  98         bool hidden;
  99         bool ignore;
 100         bool autoconnect;
 101         GTimeVal modified;
 102         unsigned int order;
 103         char *name;
 104         char *passphrase;
 105         bool roaming;
 106         bool request_passphrase_input;
 107         struct connman_service_user user;
 108         struct connman_ipconfig *ipconfig_ipv4;
 109         struct connman_ipconfig *ipconfig_ipv6;
 110         struct connman_network *network;
 111         struct connman_provider *provider;
 112         char **nameservers;
 113         char **nameservers_config;
 114         char **nameservers_auto;
 115         int nameservers_timeout;
 116         char **domains;
 117         char *hostname;
 118         char *domainname;
 119         char **timeservers;
 120         char **timeservers_config;
 121         /* 802.1x settings from the config files */
 122         char *eap;
 123         char *identity;
 124         char *anonymous_identity;
 125         char *agent_identity;
 126         char *ca_cert_file;
 127         char *subject_match;
 128         char *altsubject_match;
 129         char *domain_suffix_match;
 130         char *domain_match;
 131         char *client_cert_file;
 132         char *private_key_file;
 133         char *private_key_passphrase;
 134         char *phase2;
 135         DBusMessage *pending;
 136         DBusMessage *provider_pending;
 137         guint timeout;
 138         struct connman_stats stats;
 139         struct connman_stats stats_roaming;
 140         GHashTable *counter_table;
 141         enum connman_service_proxy_method proxy;
 142         enum connman_service_proxy_method proxy_config;
 143         char **proxies;
 144         char **excludes;
 145         char *pac;
 146         bool wps;
 147         int online_check_count;
 148         bool do_split_routing;
 149         bool new_service;
 150         bool hidden_service;
 151         char *config_file;
 152         char *config_entry;
 153 #if defined TIZEN_EXT
 154         /*
 155          * Description: TIZEN implements system global connection management.
 156          *              It's only for PDP (cellular) bearer. Wi-Fi is managed
 157          *              by ConnMan automatically. Reference count can help to
 158          *              manage open/close connection requests by each application.
 159          */
 160         int user_pdn_connection_refcount;
 161         bool storage_reload;
 162         /*
 163          * Description: In case of EAP security type,
 164          *                                user can select the keymgmt type for roaming(802.11r).
 165          *                                - FT, CCKM, OKC, ...
 166          */
 167         char *keymgmt_type;
 168         int disconnect_reason;
 169         int assoc_status_code;
 170 #endif
 171 #ifdef TIZEN_EXT
 172         enum connman_dnsconfig_method dns_config_method_ipv4;
 173         enum connman_dnsconfig_method dns_config_method_ipv6;
 174 #endif
 175 };
 176
 177 static bool allow_property_changed(struct connman_service *service);
 178
 179 static struct connman_ipconfig *create_ip4config(struct connman_service *service,
 180                 int index, enum connman_ipconfig_method method);
 181 static struct connman_ipconfig *create_ip6config(struct connman_service *service,
 182                 int index);
 183 static void dns_changed(struct connman_service *service);
 184
 185 struct find_data {
 186         const char *path;
 187         struct connman_service *service;
 188 };
 189
 190 #if defined TIZEN_EXT
 191 /*
 192  * Public APIs to use user_pdn_connection_refcount
 193  */
 194 void connman_service_user_pdn_connection_ref(struct connman_service *service)
 195 {
 196         __sync_fetch_and_add(&service->user_pdn_connection_refcount, 1);
 197
 198         DBG("User made PDN connection referenced: %d",
 199                                 service->user_pdn_connection_refcount);
 200 }
 201
 202 gboolean connman_service_user_pdn_connection_unref_and_test(
 203                                         struct connman_service *service)
 204 {
 205         __sync_synchronize();
 206
 207         DBG("User made PDN connection referenced: %d, which will be decreased",
 208                                 service->user_pdn_connection_refcount);
 209
 210         if (service->user_pdn_connection_refcount < 1)
 211                 return TRUE;
 212
 213         if (__sync_sub_and_fetch(&service->user_pdn_connection_refcount, 1) == 0)
 214                 return TRUE;
 215
 216         return FALSE;
 217 }
 218
 219 gboolean connman_service_is_no_ref_user_pdn_connection(
 220                                         struct connman_service *cellular)
 221 {
 222         if (cellular == NULL)
 223                 return TRUE;
 224
 225         __sync_synchronize();
 226         if (cellular->type == CONNMAN_SERVICE_TYPE_CELLULAR &&
 227                         cellular->user_pdn_connection_refcount == 0)
 228                 return TRUE;
 229
 230         return FALSE;
 231 }
 232 #endif
 233
 234 static void compare_path(gpointer value, gpointer user_data)
 235 {
 236         struct connman_service *service = value;
 237         struct find_data *data = user_data;
 238
 239         if (data->service)
 240                 return;
 241
 242         if (g_strcmp0(service->path, data->path) == 0)
 243                 data->service = service;
 244 }
 245
 246 static struct connman_service *find_service(const char *path)
 247 {
 248         struct find_data data = { .path = path, .service = NULL };
 249
 250         DBG("path %s", path);
 251
 252         g_list_foreach(service_list, compare_path, &data);
 253
 254         return data.service;
 255 }
 256
 257 static const char *reason2string(enum connman_service_connect_reason reason)
 258 {
 259
 260         switch (reason) {
 261         case CONNMAN_SERVICE_CONNECT_REASON_NONE:
 262                 return "none";
 263         case CONNMAN_SERVICE_CONNECT_REASON_USER:
 264                 return "user";
 265         case CONNMAN_SERVICE_CONNECT_REASON_AUTO:
 266                 return "auto";
 267         case CONNMAN_SERVICE_CONNECT_REASON_SESSION:
 268                 return "session";
 269         }
 270
 271         return "unknown";
 272 }
 273
 274 const char *__connman_service_type2string(enum connman_service_type type)
 275 {
 276         switch (type) {
 277         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 278                 break;
 279         case CONNMAN_SERVICE_TYPE_SYSTEM:
 280                 return "system";
 281         case CONNMAN_SERVICE_TYPE_ETHERNET:
 282                 return "ethernet";
 283         case CONNMAN_SERVICE_TYPE_WIFI:
 284                 return "wifi";
 285         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 286                 return "bluetooth";
 287         case CONNMAN_SERVICE_TYPE_CELLULAR:
 288                 return "cellular";
 289         case CONNMAN_SERVICE_TYPE_GPS:
 290                 return "gps";
 291         case CONNMAN_SERVICE_TYPE_VPN:
 292                 return "vpn";
 293         case CONNMAN_SERVICE_TYPE_GADGET:
 294                 return "gadget";
 295         case CONNMAN_SERVICE_TYPE_P2P:
 296                 return "p2p";
 297         }
 298
 299         return NULL;
 300 }
 301
 302 enum connman_service_type __connman_service_string2type(const char *str)
 303 {
 304         if (!str)
 305                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
 306
 307         if (strcmp(str, "ethernet") == 0)
 308                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 309         if (strcmp(str, "gadget") == 0)
 310                 return CONNMAN_SERVICE_TYPE_GADGET;
 311         if (strcmp(str, "wifi") == 0)
 312                 return CONNMAN_SERVICE_TYPE_WIFI;
 313         if (strcmp(str, "cellular") == 0)
 314                 return CONNMAN_SERVICE_TYPE_CELLULAR;
 315         if (strcmp(str, "bluetooth") == 0)
 316                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
 317         if (strcmp(str, "vpn") == 0)
 318                 return CONNMAN_SERVICE_TYPE_VPN;
 319         if (strcmp(str, "gps") == 0)
 320                 return CONNMAN_SERVICE_TYPE_GPS;
 321         if (strcmp(str, "system") == 0)
 322                 return CONNMAN_SERVICE_TYPE_SYSTEM;
 323         if (strcmp(str, "p2p") == 0)
 324                 return CONNMAN_SERVICE_TYPE_P2P;
 325
 326         return CONNMAN_SERVICE_TYPE_UNKNOWN;
 327 }
 328
 329 enum connman_service_security __connman_service_string2security(const char *str)
 330 {
 331         if (!str)
 332                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
 333
 334         if (!strcmp(str, "psk"))
 335                 return CONNMAN_SERVICE_SECURITY_PSK;
 336         if (!strcmp(str, "ieee8021x") || !strcmp(str, "8021x"))
 337                 return CONNMAN_SERVICE_SECURITY_8021X;
 338         if (!strcmp(str, "none") || !strcmp(str, "open"))
 339                 return CONNMAN_SERVICE_SECURITY_NONE;
 340         if (!strcmp(str, "wep"))
 341                 return CONNMAN_SERVICE_SECURITY_WEP;
 342 #if defined TIZEN_EXT
 343         if (!strcmp(str, "rsn"))
 344                 return CONNMAN_SERVICE_SECURITY_RSN;
 345 #endif
 346
 347         return CONNMAN_SERVICE_SECURITY_UNKNOWN;
 348 }
 349
 350 static const char *security2string(enum connman_service_security security)
 351 {
 352         switch (security) {
 353         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 354                 break;
 355         case CONNMAN_SERVICE_SECURITY_NONE:
 356                 return "none";
 357         case CONNMAN_SERVICE_SECURITY_WEP:
 358                 return "wep";
 359         case CONNMAN_SERVICE_SECURITY_PSK:
 360         case CONNMAN_SERVICE_SECURITY_WPA:
 361 #if defined TIZEN_EXT
 362                 return "psk";
 363         case CONNMAN_SERVICE_SECURITY_RSN:
 364                 return "rsn";
 365 #else
 366         case CONNMAN_SERVICE_SECURITY_RSN:
 367                 return "psk";
 368 #endif
 369         case CONNMAN_SERVICE_SECURITY_8021X:
 370                 return "ieee8021x";
 371         }
 372
 373         return NULL;
 374 }
 375
 376 static const char *state2string(enum connman_service_state state)
 377 {
 378         switch (state) {
 379         case CONNMAN_SERVICE_STATE_UNKNOWN:
 380                 break;
 381         case CONNMAN_SERVICE_STATE_IDLE:
 382                 return "idle";
 383         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 384                 return "association";
 385         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 386                 return "configuration";
 387         case CONNMAN_SERVICE_STATE_READY:
 388                 return "ready";
 389         case CONNMAN_SERVICE_STATE_ONLINE:
 390                 return "online";
 391         case CONNMAN_SERVICE_STATE_DISCONNECT:
 392                 return "disconnect";
 393         case CONNMAN_SERVICE_STATE_FAILURE:
 394                 return "failure";
 395         }
 396
 397         return NULL;
 398 }
 399
 400 static const char *error2string(enum connman_service_error error)
 401 {
 402         switch (error) {
 403         case CONNMAN_SERVICE_ERROR_UNKNOWN:
 404                 break;
 405         case CONNMAN_SERVICE_ERROR_OUT_OF_RANGE:
 406                 return "out-of-range";
 407         case CONNMAN_SERVICE_ERROR_PIN_MISSING:
 408                 return "pin-missing";
 409         case CONNMAN_SERVICE_ERROR_DHCP_FAILED:
 410                 return "dhcp-failed";
 411         case CONNMAN_SERVICE_ERROR_CONNECT_FAILED:
 412                 return "connect-failed";
 413         case CONNMAN_SERVICE_ERROR_LOGIN_FAILED:
 414                 return "login-failed";
 415         case CONNMAN_SERVICE_ERROR_AUTH_FAILED:
 416                 return "auth-failed";
 417         case CONNMAN_SERVICE_ERROR_INVALID_KEY:
 418                 return "invalid-key";
 419         case CONNMAN_SERVICE_ERROR_BLOCKED:
 420                 return "blocked";
 421         }
 422
 423         return NULL;
 424 }
 425
 426 static const char *proxymethod2string(enum connman_service_proxy_method method)
 427 {
 428         switch (method) {
 429         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
 430                 return "direct";
 431         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
 432                 return "manual";
 433         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
 434                 return "auto";
 435         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
 436                 break;
 437         }
 438
 439         return NULL;
 440 }
 441
 442 static enum connman_service_proxy_method string2proxymethod(const char *method)
 443 {
 444         if (g_strcmp0(method, "direct") == 0)
 445                 return CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
 446         else if (g_strcmp0(method, "auto") == 0)
 447                 return CONNMAN_SERVICE_PROXY_METHOD_AUTO;
 448         else if (g_strcmp0(method, "manual") == 0)
 449                 return CONNMAN_SERVICE_PROXY_METHOD_MANUAL;
 450         else
 451                 return CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
 452 }
 453
 454 #ifdef TIZEN_EXT
 455 static const char *__connman_dnsconfig_method2string(enum connman_dnsconfig_method method)
 456 {
 457         switch (method) {
 458         case CONNMAN_DNSCONFIG_METHOD_UNKNOWN:
 459                 return "unknown";
 460         case CONNMAN_DNSCONFIG_METHOD_MANUAL:
 461                 return "manual";
 462         case CONNMAN_DNSCONFIG_METHOD_DHCP:
 463                 return "dhcp";
 464         }
 465
 466         return NULL;
 467 }
 468
 469 static enum connman_dnsconfig_method __connman_dnsconfig_string2method(
 470                 const char *method)
 471 {
 472         if (g_strcmp0(method, "manual") == 0)
 473                 return CONNMAN_DNSCONFIG_METHOD_MANUAL;
 474         else if (g_strcmp0(method, "dhcp") == 0)
 475                 return CONNMAN_DNSCONFIG_METHOD_DHCP;
 476         else
 477                 return CONNMAN_DNSCONFIG_METHOD_UNKNOWN;
 478 }
 479 #endif
 480
 481 static bool
 482 connman_service_is_user_allowed(struct connman_service *service, uid_t uid)
 483 {
 484         uid_t favorite_user = service->user.favorite_user;
 485         uid_t current_user = uid;
 486
 487         DBG("Service favorite UID: %d, current UID: %d", favorite_user, current_user);
 488         if (favorite_user == USER_NONE || current_user == USER_ROOT)
 489                 return true;
 490
 491         if (favorite_user != current_user || current_user == USER_NONE) {
 492                 DBG("Current user is not a favorite user to this service!");
 493                 return false;
 494         }
 495
 496         return true;
 497 }
 498
 499 #if !defined TIZEN_EXT
 500 static GList *connman_service_get_login_users()
 501 {
 502         struct utmpx *utmp;
 503         struct passwd *pwd;
 504         GList *user_list = NULL;
 505
 506         setutxent();
 507
 508         while ((utmp = getutxent()) != NULL) {
 509                 DBG("User Name: %s", utmp->ut_user);
 510
 511                 pwd = getpwnam(utmp->ut_user);
 512                 if (pwd) {
 513                         if (!g_list_find(user_list, GUINT_TO_POINTER(pwd->pw_uid)))
 514                                 user_list = g_list_append(user_list,
 515                                                 GUINT_TO_POINTER(pwd->pw_uid));
 516
 517                         DBG("User Name: %s, UID: %d", utmp->ut_user, pwd->pw_uid);
 518                 }
 519         }
 520
 521         endutxent();
 522
 523         return user_list;
 524 }
 525 #endif
 526
 527 static bool is_service_owner_user_login(struct connman_service *service)
 528 {
 529 #if defined TIZEN_EXT
 530         return true;
 531 #else
 532         GList *list, *user_list;
 533         bool ret = false;
 534
 535         /* Here we only care about wifi service */
 536         if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
 537                 return true;
 538
 539         DBG("service favorite user id is: %d", service->user.favorite_user);
 540
 541         user_list = connman_service_get_login_users();
 542         if (user_list == NULL) {
 543                 DBG("Can not get any logged in user info.");
 544                 return true;
 545         }
 546
 547         for (list = user_list; list; list = list->next) {
 548                 uid_t uid = GPOINTER_TO_UINT(list->data);
 549
 550                 DBG("login user id is %d", uid);
 551
 552                 if (service->user.favorite_user == uid) {
 553                         ret = true;
 554                         break;
 555                 }
 556         }
 557
 558         g_list_free(user_list);
 559
 560         return ret;
 561 #endif
 562 }
 563
 564 static void set_split_routing(struct connman_service *service, bool value)
 565 {
 566         if (service->type != CONNMAN_SERVICE_TYPE_VPN)
 567                 return;
 568
 569         service->do_split_routing = value;
 570
 571         if (service->do_split_routing)
 572                 service->order = 0;
 573         else
 574                 service->order = 10;
 575 }
 576
 577 int __connman_service_load_modifiable(struct connman_service *service)
 578 {
 579         GKeyFile *keyfile;
 580         GError *error = NULL;
 581         gchar *str;
 582         bool autoconnect;
 583
 584         DBG("service %p", service);
 585
 586         keyfile = connman_storage_load_service(service->identifier);
 587         if (!keyfile)
 588                 return -EIO;
 589
 590         switch (service->type) {
 591         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 592         case CONNMAN_SERVICE_TYPE_SYSTEM:
 593         case CONNMAN_SERVICE_TYPE_GPS:
 594         case CONNMAN_SERVICE_TYPE_P2P:
 595                 break;
 596         case CONNMAN_SERVICE_TYPE_VPN:
 597                 set_split_routing(service, g_key_file_get_boolean(keyfile,
 598                                                         service->identifier,
 599                                                         "SplitRouting", NULL));
 600
 601                 /* fall through */
 602         case CONNMAN_SERVICE_TYPE_WIFI:
 603         case CONNMAN_SERVICE_TYPE_GADGET:
 604         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 605         case CONNMAN_SERVICE_TYPE_CELLULAR:
 606         case CONNMAN_SERVICE_TYPE_ETHERNET:
 607                 autoconnect = g_key_file_get_boolean(keyfile,
 608                                 service->identifier, "AutoConnect", &error);
 609                 if (!error)
 610                         service->autoconnect = autoconnect;
 611                 g_clear_error(&error);
 612                 break;
 613         }
 614
 615         str = g_key_file_get_string(keyfile,
 616                                 service->identifier, "Modified", NULL);
 617         if (str) {
 618                 g_time_val_from_iso8601(str, &service->modified);
 619                 g_free(str);
 620         }
 621
 622         g_key_file_free(keyfile);
 623
 624         return 0;
 625 }
 626
 627 static int service_load_passphrase(struct connman_service *service)
 628 {
 629         GKeyFile *keyfile;
 630         gchar *str;
 631
 632         keyfile = connman_storage_load_service(service->identifier);
 633         if (!keyfile)
 634                 return -EIO;
 635
 636         str = g_key_file_get_string(keyfile,
 637                                 service->identifier, "Passphrase", NULL);
 638         if (str)
 639                 service->passphrase = str;
 640
 641         g_key_file_free(keyfile);
 642
 643         return 0;
 644 }
 645
 646 static int service_load(struct connman_service *service)
 647 {
 648         GKeyFile *keyfile;
 649         GError *error = NULL;
 650         gsize length;
 651         gchar *str;
 652         bool autoconnect;
 653         unsigned int ssid_len;
 654         int err = 0;
 655
 656         DBG("service %p", service);
 657
 658         keyfile = connman_storage_load_service(service->identifier);
 659         if (!keyfile) {
 660                 service->new_service = true;
 661                 return -EIO;
 662         } else
 663                 service->new_service = false;
 664
 665         switch (service->type) {
 666         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 667         case CONNMAN_SERVICE_TYPE_SYSTEM:
 668         case CONNMAN_SERVICE_TYPE_GPS:
 669         case CONNMAN_SERVICE_TYPE_P2P:
 670                 break;
 671         case CONNMAN_SERVICE_TYPE_VPN:
 672                 set_split_routing(service, g_key_file_get_boolean(keyfile,
 673                                                         service->identifier,
 674                                                         "SplitRouting", NULL));
 675
 676                 autoconnect = g_key_file_get_boolean(keyfile,
 677                                 service->identifier, "AutoConnect", &error);
 678                 if (!error)
 679                         service->autoconnect = autoconnect;
 680                 g_clear_error(&error);
 681                 break;
 682         case CONNMAN_SERVICE_TYPE_WIFI:
 683                 if (!service->name) {
 684                         gchar *name;
 685
 686                         name = g_key_file_get_string(keyfile,
 687                                         service->identifier, "Name", NULL);
 688                         if (name) {
 689                                 g_free(service->name);
 690                                 service->name = name;
 691                         }
 692
 693                         if (service->network)
 694                                 connman_network_set_name(service->network,
 695                                                                         name);
 696                 }
 697
 698                 if (service->network &&
 699                                 !connman_network_get_blob(service->network,
 700                                                 "WiFi.SSID", &ssid_len)) {
 701                         gchar *hex_ssid;
 702
 703                         hex_ssid = g_key_file_get_string(keyfile,
 704                                                         service->identifier,
 705                                                                 "SSID", NULL);
 706
 707                         if (hex_ssid) {
 708                                 gchar *ssid;
 709                                 unsigned int i, j = 0, hex;
 710                                 size_t hex_ssid_len = strlen(hex_ssid);
 711
 712                                 ssid = g_try_malloc0(hex_ssid_len / 2);
 713                                 if (!ssid) {
 714                                         g_free(hex_ssid);
 715                                         err = -ENOMEM;
 716                                         goto done;
 717                                 }
 718
 719                                 for (i = 0; i < hex_ssid_len; i += 2) {
 720                                         sscanf(hex_ssid + i, "%02x", &hex);
 721                                         ssid[j++] = hex;
 722                                 }
 723
 724                                 connman_network_set_blob(service->network,
 725                                         "WiFi.SSID", ssid, hex_ssid_len / 2);
 726
 727                                 g_free(ssid);
 728                         }
 729
 730                         g_free(hex_ssid);
 731                 }
 732                 /* fall through */
 733
 734         case CONNMAN_SERVICE_TYPE_GADGET:
 735         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 736         case CONNMAN_SERVICE_TYPE_CELLULAR:
 737                 service->favorite = g_key_file_get_boolean(keyfile,
 738                                 service->identifier, "Favorite", NULL);
 739
 740                 /* fall through */
 741
 742         case CONNMAN_SERVICE_TYPE_ETHERNET:
 743                 autoconnect = g_key_file_get_boolean(keyfile,
 744                                 service->identifier, "AutoConnect", &error);
 745                 if (!error)
 746                         service->autoconnect = autoconnect;
 747                 g_clear_error(&error);
 748                 break;
 749         }
 750
 751         str = g_key_file_get_string(keyfile,
 752                                 service->identifier, "Modified", NULL);
 753         if (str) {
 754                 g_time_val_from_iso8601(str, &service->modified);
 755                 g_free(str);
 756         }
 757
 758         str = g_key_file_get_string(keyfile,
 759                                 service->identifier, "Passphrase", NULL);
 760         if (str) {
 761                 g_free(service->passphrase);
 762                 service->passphrase = str;
 763         }
 764
 765         if (service->ipconfig_ipv4)
 766                 __connman_ipconfig_load(service->ipconfig_ipv4, keyfile,
 767                                         service->identifier, "IPv4.");
 768
 769         if (service->ipconfig_ipv6)
 770                 __connman_ipconfig_load(service->ipconfig_ipv6, keyfile,
 771                                         service->identifier, "IPv6.");
 772
 773         service->nameservers_config = g_key_file_get_string_list(keyfile,
 774                         service->identifier, "Nameservers", &length, NULL);
 775         if (service->nameservers_config && length == 0) {
 776                 g_strfreev(service->nameservers_config);
 777                 service->nameservers_config = NULL;
 778         }
 779
 780 #ifdef TIZEN_EXT
 781         char *dns_method;
 782
 783         dns_method = g_key_file_get_string(keyfile, service->identifier,
 784                         "Nameservers.IPv4method", NULL);
 785         service->dns_config_method_ipv4 = __connman_dnsconfig_string2method(dns_method);
 786
 787         dns_method = g_key_file_get_string(keyfile, service->identifier,
 788                         "Nameservers.IPv6method", NULL);
 789         service->dns_config_method_ipv6 = __connman_dnsconfig_string2method(dns_method);
 790 #endif
 791
 792         service->timeservers_config = g_key_file_get_string_list(keyfile,
 793                         service->identifier, "Timeservers", &length, NULL);
 794         if (service->timeservers_config && length == 0) {
 795                 g_strfreev(service->timeservers_config);
 796                 service->timeservers_config = NULL;
 797         }
 798
 799         service->domains = g_key_file_get_string_list(keyfile,
 800                         service->identifier, "Domains", &length, NULL);
 801         if (service->domains && length == 0) {
 802                 g_strfreev(service->domains);
 803                 service->domains = NULL;
 804         }
 805
 806         str = g_key_file_get_string(keyfile,
 807                                 service->identifier, "Proxy.Method", NULL);
 808         if (str)
 809                 service->proxy_config = string2proxymethod(str);
 810
 811         g_free(str);
 812
 813         service->proxies = g_key_file_get_string_list(keyfile,
 814                         service->identifier, "Proxy.Servers", &length, NULL);
 815         if (service->proxies && length == 0) {
 816                 g_strfreev(service->proxies);
 817                 service->proxies = NULL;
 818         }
 819
 820         service->excludes = g_key_file_get_string_list(keyfile,
 821                         service->identifier, "Proxy.Excludes", &length, NULL);
 822         if (service->excludes && length == 0) {
 823                 g_strfreev(service->excludes);
 824                 service->excludes = NULL;
 825         }
 826
 827         str = g_key_file_get_string(keyfile,
 828                                 service->identifier, "Proxy.URL", NULL);
 829         if (str) {
 830                 g_free(service->pac);
 831                 service->pac = str;
 832         }
 833
 834         service->hidden_service = g_key_file_get_boolean(keyfile,
 835                                         service->identifier, "Hidden", NULL);
 836
 837 #if defined TIZEN_EXT
 838         if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
 839                         service->security == CONNMAN_SERVICE_SECURITY_8021X) {
 840                 str = g_key_file_get_string(keyfile,
 841                                 service->identifier, "EAP", NULL);
 842                 if (str != NULL) {
 843                         g_free(service->eap);
 844                         service->eap = str;
 845                 }
 846
 847                 str = g_key_file_get_string(keyfile,
 848                                 service->identifier, "Phase2", NULL);
 849                 if (str != NULL) {
 850                         g_free(service->phase2);
 851                         service->phase2 = str;
 852                 }
 853
 854                 str = g_key_file_get_string(keyfile,
 855                                 service->identifier, "Identity", NULL);
 856                 if (str != NULL) {
 857                         g_free(service->identity);
 858                         service->identity = str;
 859                 }
 860
 861                 str = g_key_file_get_string(keyfile,
 862                                 service->identifier, "CACertFile", NULL);
 863                 if (str != NULL) {
 864                         g_free(service->ca_cert_file);
 865                         service->ca_cert_file = str;
 866                 }
 867
 868                 str = g_key_file_get_string(keyfile,
 869                                 service->identifier, "ClientCertFile", NULL);
 870                 if (str != NULL) {
 871                         g_free(service->client_cert_file);
 872                         service->client_cert_file = str;
 873                 }
 874
 875                 str = g_key_file_get_string(keyfile,
 876                                 service->identifier, "PrivateKeyFile", NULL);
 877                 if (str != NULL) {
 878                         g_free(service->private_key_file);
 879                         service->private_key_file = str;
 880                 }
 881
 882                 str = g_key_file_get_string(keyfile,
 883                                 service->identifier, "PrivateKeyPassphrase", NULL);
 884                 if (str != NULL) {
 885                         g_free(service->private_key_passphrase);
 886                         service->private_key_passphrase = str;
 887                 }
 888         }
 889 #endif
 890
 891         if (g_key_file_has_key(keyfile, service->identifier, "UID", NULL))
 892                 service->user.favorite_user = g_key_file_get_integer(keyfile,
 893                                         service->identifier, "UID", NULL);
 894 done:
 895         g_key_file_free(keyfile);
 896
 897         return err;
 898 }
 899
 900 static int service_save(struct connman_service *service)
 901 {
 902         GKeyFile *keyfile;
 903         gchar *str;
 904         guint freq;
 905         const char *cst_str = NULL;
 906         int err = 0;
 907
 908         DBG("service %p new %d", service, service->new_service);
 909
 910         if (service->new_service)
 911                 return -ESRCH;
 912
 913         keyfile = __connman_storage_open_service(service->identifier);
 914         if (!keyfile)
 915                 return -EIO;
 916
 917         if (service->name)
 918                 g_key_file_set_string(keyfile, service->identifier,
 919                                                 "Name", service->name);
 920
 921         switch (service->type) {
 922         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 923         case CONNMAN_SERVICE_TYPE_SYSTEM:
 924         case CONNMAN_SERVICE_TYPE_GPS:
 925         case CONNMAN_SERVICE_TYPE_P2P:
 926                 break;
 927         case CONNMAN_SERVICE_TYPE_VPN:
 928                 g_key_file_set_boolean(keyfile, service->identifier,
 929                                 "SplitRouting", service->do_split_routing);
 930                 if (service->favorite)
 931                         g_key_file_set_boolean(keyfile, service->identifier,
 932                                         "AutoConnect", service->autoconnect);
 933                 break;
 934         case CONNMAN_SERVICE_TYPE_WIFI:
 935                 if (service->network) {
 936                         const unsigned char *ssid;
 937                         unsigned int ssid_len = 0;
 938
 939                         if (service->user.favorite_user == USER_NONE)
 940                                 g_key_file_remove_key(keyfile, service->identifier,
 941                                                         "UID", NULL);
 942                         else
 943                                 g_key_file_set_integer(keyfile, service->identifier,
 944                                                         "UID", service->user.favorite_user);
 945
 946                         ssid = connman_network_get_blob(service->network,
 947                                                         "WiFi.SSID", &ssid_len);
 948
 949                         if (ssid && ssid_len > 0 && ssid[0] != '\0') {
 950                                 char *identifier = service->identifier;
 951                                 GString *ssid_str;
 952                                 unsigned int i;
 953
 954                                 ssid_str = g_string_sized_new(ssid_len * 2);
 955                                 if (!ssid_str) {
 956                                         err = -ENOMEM;
 957                                         goto done;
 958                                 }
 959
 960                                 for (i = 0; i < ssid_len; i++)
 961                                         g_string_append_printf(ssid_str,
 962                                                         "%02x", ssid[i]);
 963
 964                                 g_key_file_set_string(keyfile, identifier,
 965                                                         "SSID", ssid_str->str);
 966
 967                                 g_string_free(ssid_str, TRUE);
 968                         }
 969
 970                         freq = connman_network_get_frequency(service->network);
 971                         g_key_file_set_integer(keyfile, service->identifier,
 972                                                 "Frequency", freq);
 973                 }
 974                 /* fall through */
 975
 976         case CONNMAN_SERVICE_TYPE_GADGET:
 977         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 978         case CONNMAN_SERVICE_TYPE_CELLULAR:
 979                 g_key_file_set_boolean(keyfile, service->identifier,
 980                                         "Favorite", service->favorite);
 981
 982                 g_key_file_remove_key(keyfile, service->identifier,
 983                                 "Failure", NULL);
 984
 985                 /* fall through */
 986
 987         case CONNMAN_SERVICE_TYPE_ETHERNET:
 988                 if (service->favorite)
 989                         g_key_file_set_boolean(keyfile, service->identifier,
 990                                         "AutoConnect", service->autoconnect);
 991                 break;
 992         }
 993
 994         str = g_time_val_to_iso8601(&service->modified);
 995         if (str) {
 996                 g_key_file_set_string(keyfile, service->identifier,
 997                                                         "Modified", str);
 998                 g_free(str);
 999         }
1000
1001         if (service->user.current_user == service->user.favorite_user) {
1002                 if (service->passphrase && strlen(service->passphrase) > 0)
1003                         g_key_file_set_string(keyfile, service->identifier,
1004                                         "Passphrase", service->passphrase);
1005                 else
1006                         g_key_file_remove_key(keyfile, service->identifier,
1007                                         "Passphrase", NULL);
1008         }
1009
1010         if (service->ipconfig_ipv4)
1011                 __connman_ipconfig_save(service->ipconfig_ipv4, keyfile,
1012                                         service->identifier, "IPv4.");
1013
1014         if (service->ipconfig_ipv6)
1015                 __connman_ipconfig_save(service->ipconfig_ipv6, keyfile,
1016                                                 service->identifier, "IPv6.");
1017
1018         if (service->nameservers_config) {
1019                 guint len = g_strv_length(service->nameservers_config);
1020
1021                 g_key_file_set_string_list(keyfile, service->identifier,
1022                                                                 "Nameservers",
1023                                 (const gchar **) service->nameservers_config, len);
1024         } else
1025         g_key_file_remove_key(keyfile, service->identifier,
1026                                                         "Nameservers", NULL);
1027
1028 #if defined TIZEN_EXT
1029         if(service->dns_config_method_ipv4 != 0) {
1030                 const char *method;
1031                 method = __connman_dnsconfig_method2string(
1032                                 service->dns_config_method_ipv4);
1033                 g_key_file_set_string(keyfile, service->identifier,
1034                                 "Nameservers.IPv4method", method);
1035         } else
1036         g_key_file_remove_key(keyfile, service->identifier,
1037                                                 "Nameservers.IPv4method", NULL);
1038
1039         if(service->dns_config_method_ipv6 != 0) {
1040                 const char *method;
1041                 method = __connman_dnsconfig_method2string(
1042                                 service->dns_config_method_ipv6);
1043                 g_key_file_set_string(keyfile, service->identifier,
1044                                 "Nameservers.IPv6method", method);
1045         } else
1046         g_key_file_remove_key(keyfile, service->identifier,
1047                                                         "Nameservers.IPv6method", NULL);
1048 #endif
1049
1050         if (service->timeservers_config) {
1051                 guint len = g_strv_length(service->timeservers_config);
1052
1053                 g_key_file_set_string_list(keyfile, service->identifier,
1054                                                                 "Timeservers",
1055                                 (const gchar **) service->timeservers_config, len);
1056         } else
1057                 g_key_file_remove_key(keyfile, service->identifier,
1058                                                         "Timeservers", NULL);
1059
1060         if (service->domains) {
1061                 guint len = g_strv_length(service->domains);
1062
1063                 g_key_file_set_string_list(keyfile, service->identifier,
1064                                                                 "Domains",
1065                                 (const gchar **) service->domains, len);
1066         } else
1067                 g_key_file_remove_key(keyfile, service->identifier,
1068                                                         "Domains", NULL);
1069
1070         cst_str = proxymethod2string(service->proxy_config);
1071         if (cst_str)
1072                 g_key_file_set_string(keyfile, service->identifier,
1073                                 "Proxy.Method", cst_str);
1074
1075         if (service->proxies) {
1076                 guint len = g_strv_length(service->proxies);
1077
1078                 g_key_file_set_string_list(keyfile, service->identifier,
1079                                 "Proxy.Servers",
1080                                 (const gchar **) service->proxies, len);
1081         } else
1082                 g_key_file_remove_key(keyfile, service->identifier,
1083                                                 "Proxy.Servers", NULL);
1084
1085         if (service->excludes) {
1086                 guint len = g_strv_length(service->excludes);
1087
1088                 g_key_file_set_string_list(keyfile, service->identifier,
1089                                 "Proxy.Excludes",
1090                                 (const gchar **) service->excludes, len);
1091         } else
1092                 g_key_file_remove_key(keyfile, service->identifier,
1093                                                 "Proxy.Excludes", NULL);
1094
1095         if (service->pac && strlen(service->pac) > 0)
1096                 g_key_file_set_string(keyfile, service->identifier,
1097                                         "Proxy.URL", service->pac);
1098         else
1099                 g_key_file_remove_key(keyfile, service->identifier,
1100                                                         "Proxy.URL", NULL);
1101
1102         if (service->hidden_service)
1103                 g_key_file_set_boolean(keyfile, service->identifier, "Hidden",
1104                                                                         TRUE);
1105
1106         if (service->config_file && strlen(service->config_file) > 0)
1107                 g_key_file_set_string(keyfile, service->identifier,
1108                                 "Config.file", service->config_file);
1109
1110         if (service->config_entry &&
1111                                         strlen(service->config_entry) > 0)
1112                 g_key_file_set_string(keyfile, service->identifier,
1113                                 "Config.ident", service->config_entry);
1114
1115 #if defined TIZEN_EXT
1116         if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
1117                         service->security == CONNMAN_SERVICE_SECURITY_8021X) {
1118                 if (service->eap != NULL && strlen(service->eap) > 0)
1119                         g_key_file_set_string(keyfile, service->identifier,
1120                                         "EAP", service->eap);
1121                 else
1122                         g_key_file_remove_key(keyfile, service->identifier,
1123                                         "EAP", NULL);
1124
1125                 if (service->phase2 != NULL && strlen(service->phase2) > 0)
1126                         g_key_file_set_string(keyfile, service->identifier,
1127                                         "Phase2", service->phase2);
1128                 else
1129                         g_key_file_remove_key(keyfile, service->identifier,
1130                                         "Phase2", NULL);
1131
1132                 if (service->identity != NULL && strlen(service->identity) > 0)
1133                         g_key_file_set_string(keyfile, service->identifier,
1134                                         "Identity", service->identity);
1135                 else
1136                         g_key_file_remove_key(keyfile, service->identifier,
1137                                         "Identity", NULL);
1138
1139                 if (service->ca_cert_file != NULL && strlen(service->ca_cert_file) > 0)
1140                         g_key_file_set_string(keyfile, service->identifier,
1141                                         "CACertFile", service->ca_cert_file);
1142                 else
1143                         g_key_file_remove_key(keyfile, service->identifier,
1144                                         "CACertFile", NULL);
1145
1146                 if (service->client_cert_file != NULL && strlen(service->client_cert_file) > 0)
1147                         g_key_file_set_string(keyfile, service->identifier,
1148                                         "ClientCertFile", service->client_cert_file);
1149                 else
1150                         g_key_file_remove_key(keyfile, service->identifier,
1151                                         "ClientCertFile", NULL);
1152
1153                 if (service->private_key_file != NULL && strlen(service->private_key_file) > 0)
1154                         g_key_file_set_string(keyfile, service->identifier,
1155                                         "PrivateKeyFile", service->private_key_file);
1156                 else
1157                         g_key_file_remove_key(keyfile, service->identifier,
1158                                         "PrivateKeyFile", NULL);
1159
1160                 if (service->private_key_passphrase != NULL && strlen(service->private_key_passphrase) > 0)
1161                         g_key_file_set_string(keyfile, service->identifier,
1162                                         "PrivateKeyPassphrase", service->private_key_passphrase);
1163                 else
1164                         g_key_file_remove_key(keyfile, service->identifier,
1165                                         "PrivateKeyPassphrase", NULL);
1166         }
1167 #endif
1168
1169 done:
1170         __connman_storage_save_service(keyfile, service->identifier);
1171
1172         g_key_file_free(keyfile);
1173
1174         return err;
1175 }
1176
1177 void __connman_service_save(struct connman_service *service)
1178 {
1179         if (!service)
1180                 return;
1181
1182         service_save(service);
1183 }
1184
1185 static enum connman_service_state combine_state(
1186                                         enum connman_service_state state_a,
1187                                         enum connman_service_state state_b)
1188 {
1189         enum connman_service_state result;
1190
1191         if (state_a == state_b) {
1192                 result = state_a;
1193                 goto done;
1194         }
1195
1196         if (state_a == CONNMAN_SERVICE_STATE_UNKNOWN) {
1197                 result = state_b;
1198                 goto done;
1199         }
1200
1201         if (state_b == CONNMAN_SERVICE_STATE_UNKNOWN) {
1202                 result = state_a;
1203                 goto done;
1204         }
1205
1206         if (state_a == CONNMAN_SERVICE_STATE_IDLE) {
1207                 result = state_b;
1208                 goto done;
1209         }
1210
1211         if (state_b == CONNMAN_SERVICE_STATE_IDLE) {
1212                 result = state_a;
1213                 goto done;
1214         }
1215
1216         if (state_a == CONNMAN_SERVICE_STATE_ONLINE) {
1217                 result = state_a;
1218                 goto done;
1219         }
1220
1221         if (state_b == CONNMAN_SERVICE_STATE_ONLINE) {
1222                 result = state_b;
1223                 goto done;
1224         }
1225
1226         if (state_a == CONNMAN_SERVICE_STATE_READY) {
1227                 result = state_a;
1228                 goto done;
1229         }
1230
1231         if (state_b == CONNMAN_SERVICE_STATE_READY) {
1232                 result = state_b;
1233                 goto done;
1234         }
1235
1236         if (state_a == CONNMAN_SERVICE_STATE_CONFIGURATION) {
1237                 result = state_a;
1238                 goto done;
1239         }
1240
1241         if (state_b == CONNMAN_SERVICE_STATE_CONFIGURATION) {
1242                 result = state_b;
1243                 goto done;
1244         }
1245
1246         if (state_a == CONNMAN_SERVICE_STATE_ASSOCIATION) {
1247                 result = state_a;
1248                 goto done;
1249         }
1250
1251         if (state_b == CONNMAN_SERVICE_STATE_ASSOCIATION) {
1252                 result = state_b;
1253                 goto done;
1254         }
1255
1256         if (state_a == CONNMAN_SERVICE_STATE_DISCONNECT) {
1257                 result = state_a;
1258                 goto done;
1259         }
1260
1261         if (state_b == CONNMAN_SERVICE_STATE_DISCONNECT) {
1262                 result = state_b;
1263                 goto done;
1264         }
1265
1266         result = CONNMAN_SERVICE_STATE_FAILURE;
1267
1268 done:
1269         return result;
1270 }
1271
1272 static bool is_connecting(enum connman_service_state state)
1273 {
1274         switch (state) {
1275         case CONNMAN_SERVICE_STATE_UNKNOWN:
1276         case CONNMAN_SERVICE_STATE_IDLE:
1277         case CONNMAN_SERVICE_STATE_FAILURE:
1278         case CONNMAN_SERVICE_STATE_DISCONNECT:
1279         case CONNMAN_SERVICE_STATE_READY:
1280         case CONNMAN_SERVICE_STATE_ONLINE:
1281                 break;
1282         case CONNMAN_SERVICE_STATE_ASSOCIATION:
1283         case CONNMAN_SERVICE_STATE_CONFIGURATION:
1284                 return true;
1285         }
1286
1287         return false;
1288 }
1289
1290 static bool is_connected(enum connman_service_state state)
1291 {
1292         switch (state) {
1293         case CONNMAN_SERVICE_STATE_UNKNOWN:
1294         case CONNMAN_SERVICE_STATE_IDLE:
1295         case CONNMAN_SERVICE_STATE_ASSOCIATION:
1296         case CONNMAN_SERVICE_STATE_CONFIGURATION:
1297         case CONNMAN_SERVICE_STATE_DISCONNECT:
1298         case CONNMAN_SERVICE_STATE_FAILURE:
1299                 break;
1300         case CONNMAN_SERVICE_STATE_READY:
1301         case CONNMAN_SERVICE_STATE_ONLINE:
1302                 return true;
1303         }
1304
1305         return false;
1306 }
1307
1308 static bool is_idle(enum connman_service_state state)
1309 {
1310         switch (state) {
1311         case CONNMAN_SERVICE_STATE_IDLE:
1312         case CONNMAN_SERVICE_STATE_DISCONNECT:
1313         case CONNMAN_SERVICE_STATE_FAILURE:
1314                 return true;
1315         case CONNMAN_SERVICE_STATE_UNKNOWN:
1316         case CONNMAN_SERVICE_STATE_ASSOCIATION:
1317         case CONNMAN_SERVICE_STATE_CONFIGURATION:
1318         case CONNMAN_SERVICE_STATE_READY:
1319         case CONNMAN_SERVICE_STATE_ONLINE:
1320                 break;
1321         }
1322
1323         return false;
1324 }
1325
1326 static int nameservers_changed_cb(void *user_data)
1327 {
1328         struct connman_service *service = user_data;
1329
1330         DBG("service %p", service);
1331
1332         service->nameservers_timeout = 0;
1333         if ((is_idle(service->state) && !service->nameservers) ||
1334                         is_connected(service->state))
1335                 dns_changed(service);
1336
1337         return FALSE;
1338 }
1339
1340 static void nameservers_changed(struct connman_service *service)
1341 {
1342         if (!service->nameservers_timeout)
1343                 service->nameservers_timeout = g_idle_add(nameservers_changed_cb,
1344                                                         service);
1345 }
1346
1347 static bool nameserver_available(struct connman_service *service,
1348                                 enum connman_ipconfig_type type,
1349                                 const char *ns)
1350 {
1351         int family;
1352
1353         family = connman_inet_check_ipaddress(ns);
1354
1355         if (family == AF_INET) {
1356                 if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1357                         return false;
1358
1359                 return is_connected(service->state_ipv4);
1360         }
1361
1362         if (family == AF_INET6) {
1363                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1364                         return false;
1365
1366                 return is_connected(service->state_ipv6);
1367         }
1368
1369         return false;
1370 }
1371
1372 static int searchdomain_add_all(struct connman_service *service)
1373 {
1374         int index, i = 0;
1375
1376         if (!is_connected(service->state))
1377                 return -ENOTCONN;
1378
1379         index = __connman_service_get_index(service);
1380         if (index < 0)
1381                 return -ENXIO;
1382
1383         if (service->domains) {
1384                 while (service->domains[i]) {
1385                         connman_resolver_append(index, service->domains[i],
1386                                                 NULL);
1387                         i++;
1388                 }
1389
1390                 return 0;
1391         }
1392
1393         if (service->domainname)
1394                 connman_resolver_append(index, service->domainname, NULL);
1395
1396         return 0;
1397
1398 }
1399
1400 static int searchdomain_remove_all(struct connman_service *service)
1401 {
1402         int index, i = 0;
1403
1404         if (!is_connected(service->state))
1405                 return -ENOTCONN;
1406
1407         index = __connman_service_get_index(service);
1408         if (index < 0)
1409                 return -ENXIO;
1410
1411         while (service->domains && service->domains[i]) {
1412                 connman_resolver_remove(index, service->domains[i], NULL);
1413                 i++;
1414         }
1415
1416         if (service->domainname)
1417                 connman_resolver_remove(index, service->domainname, NULL);
1418
1419         return 0;
1420 }
1421
1422 static int nameserver_add(struct connman_service *service,
1423                         enum connman_ipconfig_type type,
1424                         const char *nameserver)
1425 {
1426         int index, ret;
1427
1428         if (!nameserver_available(service, type, nameserver))
1429                 return 0;
1430
1431         index = __connman_service_get_index(service);
1432         if (index < 0)
1433                 return -ENXIO;
1434
1435 #if defined TIZEN_EXT
1436         DBG("Resolver append nameserver: %s", nameserver);
1437 #endif
1438         ret = connman_resolver_append(index, NULL, nameserver);
1439         if (ret >= 0)
1440                 nameservers_changed(service);
1441
1442         return ret;
1443 }
1444
1445 static int nameserver_add_all(struct connman_service *service,
1446                         enum connman_ipconfig_type type)
1447 {
1448         int i = 0;
1449
1450         if (service->nameservers_config) {
1451                 while (service->nameservers_config[i]) {
1452 #if defined TIZEN_EXT
1453                         DBG("type %d add service->nameservers_config[%d]:%s",type,
1454                             i, service->nameservers_config[i]);
1455                         if(strncmp(service->nameservers_config[i], "::", 2) == 0) {
1456                                 DBG("Invalid nameserver");
1457                                 i++;
1458                                 continue;
1459                         }
1460
1461                         switch(type) {
1462                         case CONNMAN_IPCONFIG_TYPE_IPV4:
1463                                 if (connman_inet_check_ipaddress(
1464                                         service->nameservers_config[i]) == AF_INET &&
1465                                     service->dns_config_method_ipv4 ==
1466                                     CONNMAN_DNSCONFIG_METHOD_MANUAL) {
1467                                         nameserver_add(service, type,
1468                                                        service->nameservers_config[i]);
1469                                 }
1470                                 break;
1471                         case CONNMAN_IPCONFIG_TYPE_IPV6:
1472                                 if (connman_inet_check_ipaddress(
1473                                         service->nameservers_config[i]) == AF_INET6 &&
1474                                     service->dns_config_method_ipv6 ==
1475                                         CONNMAN_DNSCONFIG_METHOD_MANUAL) {
1476                                         nameserver_add(service, type,
1477                                                        service->nameservers_config[i]);
1478                                 }
1479                                 break;
1480                         case CONNMAN_IPCONFIG_TYPE_ALL:
1481                                 if (connman_inet_check_ipaddress(
1482                                         service->nameservers_config[i]) == AF_INET &&
1483                                     service->dns_config_method_ipv4 ==
1484                                         CONNMAN_DNSCONFIG_METHOD_MANUAL) {
1485                                         nameserver_add(service, type,
1486                                                        service->nameservers_config[i]);
1487                                 }
1488                                 if (connman_inet_check_ipaddress(
1489                                         service->nameservers_config[i]) == AF_INET6 &&
1490                                     service->dns_config_method_ipv6 ==
1491                                         CONNMAN_DNSCONFIG_METHOD_MANUAL) {
1492                                         nameserver_add(service, type,
1493                                                        service->nameservers_config[i]);
1494                                 }
1495                                 break;
1496                         case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
1497                                 DBG("CONNMAN_IPCONFIG_TYPE_UNKNOWN do nothing");
1498                                 break;
1499                         default:
1500                                 DBG("default case do nothing");
1501                                 break;
1502                         }
1503 #else
1504                         nameserver_add(service, type,
1505                                 service->nameservers_config[i]);
1506 #endif
1507                         i++;
1508                 }
1509         } else if (service->nameservers) {
1510                 while (service->nameservers[i]) {
1511 #if defined TIZEN_EXT
1512                         DBG("type %d service->nameservers[%d]: %s",type,
1513                             i, service->nameservers[i]);
1514
1515                         switch(type) {
1516                         case CONNMAN_IPCONFIG_TYPE_IPV4:
1517                                 if (connman_inet_check_ipaddress(
1518                                         service->nameservers[i]) == AF_INET &&
1519                                         service->dns_config_method_ipv4 ==
1520                                                 CONNMAN_DNSCONFIG_METHOD_DHCP) {
1521                                         nameserver_add(service, type,
1522                                                        service->nameservers[i]);
1523                                 }
1524                                 break;
1525                         case CONNMAN_IPCONFIG_TYPE_IPV6:
1526                                 if (connman_inet_check_ipaddress(
1527                                         service->nameservers[i]) == AF_INET6 &&
1528                                         service->dns_config_method_ipv6 ==
1529                                                 CONNMAN_DNSCONFIG_METHOD_DHCP) {
1530                                         nameserver_add(service, type,
1531                                                        service->nameservers[i]);
1532                                 }
1533                                 break;
1534                         case CONNMAN_IPCONFIG_TYPE_ALL:
1535                                 if (connman_inet_check_ipaddress(
1536                                         service->nameservers[i]) == AF_INET &&
1537                                         service->dns_config_method_ipv4 ==
1538                                                 CONNMAN_DNSCONFIG_METHOD_DHCP) {
1539                                         nameserver_add(service, type,
1540                                                        service->nameservers[i]);
1541                                 }
1542                                 if (connman_inet_check_ipaddress(
1543                                         service->nameservers[i]) == AF_INET6 &&
1544                                         service->dns_config_method_ipv6 ==
1545                                                 CONNMAN_DNSCONFIG_METHOD_DHCP) {
1546                                         nameserver_add(service, type,
1547                                                        service->nameservers[i]);
1548                                 }
1549                                 break;
1550                         case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
1551                                 DBG("CONNMAN_IPCONFIG_TYPE_UNKNOWN do nothing");
1552                                 break;
1553                         default:
1554                                 DBG("default case do nothing");
1555                                 break;
1556                         }
1557 #else
1558                         nameserver_add(service, type,
1559                                 service->nameservers[i]);
1560 #endif
1561                         i++;
1562                 }
1563         }
1564
1565         if (!i)
1566                 __connman_resolver_append_fallback_nameservers();
1567
1568         searchdomain_add_all(service);
1569
1570         return 0;
1571 }
1572
1573 static int nameserver_remove(struct connman_service *service,
1574                         enum connman_ipconfig_type type,
1575                         const char *nameserver)
1576 {
1577         int index, ret;
1578
1579         if (!nameserver_available(service, type, nameserver))
1580                 return 0;
1581
1582         index = __connman_service_get_index(service);
1583         if (index < 0)
1584                 return -ENXIO;
1585
1586 #if defined TIZEN_EXT
1587         DBG("Resolver remove nameserver: %s", nameserver);
1588 #endif
1589         ret = connman_resolver_remove(index, NULL, nameserver);
1590         if (ret >= 0)
1591                 nameservers_changed(service);
1592
1593         return ret;
1594 }
1595
1596 static int nameserver_remove_all(struct connman_service *service,
1597                                 enum connman_ipconfig_type type)
1598 {
1599 #if defined TIZEN_EXT
1600         /**
1601           * Skip this function if there is any connected profiles
1602           * that use same interface
1603           */
1604         if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR &&
1605                         __connman_service_get_connected_count_of_iface(service) > 0)
1606                 return 0;
1607 #endif
1608         int index, i = 0;
1609
1610         index = __connman_service_get_index(service);
1611         if (index < 0)
1612                 return -ENXIO;
1613
1614         while (service->nameservers_config && service->nameservers_config[i]) {
1615 #if defined TIZEN_EXT
1616                 DBG("type %d Remove service->nameservers_config[%d]: %s",
1617                       type, i, service->nameservers_config[i]);
1618                 switch(type) {
1619                 case CONNMAN_IPCONFIG_TYPE_IPV4:
1620                         if (connman_inet_check_ipaddress(
1621                                 service->nameservers_config[i]) == AF_INET &&
1622                                 (service->dns_config_method_ipv4 ==
1623                                         CONNMAN_DNSCONFIG_METHOD_DHCP ||
1624                                 service->dns_config_method_ipv4 ==
1625                                         CONNMAN_DNSCONFIG_METHOD_MANUAL)) {
1626                                 nameserver_remove(service, type,
1627                                                   service->nameservers_config[i]);
1628                         }
1629                         break;
1630                 case CONNMAN_IPCONFIG_TYPE_IPV6:
1631                         if (connman_inet_check_ipaddress(
1632                                 service->nameservers_config[i]) == AF_INET6 &&
1633                                 (service->dns_config_method_ipv6 ==
1634                                         CONNMAN_DNSCONFIG_METHOD_DHCP ||
1635                                 service->dns_config_method_ipv6 ==
1636                                         CONNMAN_DNSCONFIG_METHOD_MANUAL)) {
1637                                 nameserver_remove(service, type,
1638                                                   service->nameservers_config[i]);
1639                         }
1640                         break;
1641                 case CONNMAN_IPCONFIG_TYPE_ALL:
1642                         if (connman_inet_check_ipaddress(
1643                                 service->nameservers_config[i]) == AF_INET &&
1644                                 (service->dns_config_method_ipv4 ==
1645                                         CONNMAN_DNSCONFIG_METHOD_DHCP ||
1646                                 service->dns_config_method_ipv4 ==
1647                                         CONNMAN_DNSCONFIG_METHOD_MANUAL)) {
1648                                 nameserver_remove(service, type,
1649                                                   service->nameservers_config[i]);
1650                         }
1651                         if (connman_inet_check_ipaddress(
1652                                 service->nameservers_config[i]) == AF_INET6 &&
1653                                 (service->dns_config_method_ipv6 ==
1654                                         CONNMAN_DNSCONFIG_METHOD_DHCP ||
1655                                 service->dns_config_method_ipv6 ==
1656                                         CONNMAN_DNSCONFIG_METHOD_MANUAL)) {
1657                                 nameserver_remove(service, type,
1658                                                   service->nameservers_config[i]);
1659                         }
1660                         break;
1661                 case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
1662                         DBG("CONNMAN_IPCONFIG_TYPE_UNKNOWN do nothing");
1663                         break;
1664                 default:
1665                         DBG("default case do nothing");
1666                         break;
1667                 }
1668 #else
1669                 nameserver_remove(service, type,
1670                                 service->nameservers_config[i]);
1671 #endif
1672                 i++;
1673         }
1674
1675         i = 0;
1676         while (service->nameservers && service->nameservers[i]) {
1677 #if defined TIZEN_EXT
1678                 DBG("type %d Remove service->nameservers[%d]: %s",type, i,
1679                       service->nameservers[i]);
1680                 switch(type) {
1681                         case CONNMAN_IPCONFIG_TYPE_IPV4:
1682                                 if (connman_inet_check_ipaddress(
1683                                         service->nameservers[i]) == AF_INET &&
1684                                         (service->dns_config_method_ipv4 ==
1685                                                 CONNMAN_DNSCONFIG_METHOD_MANUAL ||
1686                                         service->dns_config_method_ipv4 ==
1687                                                 CONNMAN_DNSCONFIG_METHOD_DHCP)) {
1688                                         nameserver_remove(service, type,
1689                                                           service->nameservers[i]);
1690                                 }
1691                                 break;
1692                         case CONNMAN_IPCONFIG_TYPE_IPV6:
1693                                 if (connman_inet_check_ipaddress(
1694                                         service->nameservers[i]) == AF_INET6 &&
1695                                         (service->dns_config_method_ipv6 ==
1696                                                 CONNMAN_DNSCONFIG_METHOD_MANUAL ||
1697                                         service->dns_config_method_ipv6 ==
1698                                                 CONNMAN_DNSCONFIG_METHOD_DHCP)) {
1699                                         nameserver_remove(service, type,
1700                                                           service->nameservers[i]);
1701                                 }
1702                                 break;
1703                         case CONNMAN_IPCONFIG_TYPE_ALL:
1704                                 if (connman_inet_check_ipaddress(
1705                                         service->nameservers[i]) == AF_INET &&
1706                                         (service->dns_config_method_ipv4 ==
1707                                                 CONNMAN_DNSCONFIG_METHOD_MANUAL ||
1708                                         service->dns_config_method_ipv4 ==
1709                                                 CONNMAN_DNSCONFIG_METHOD_DHCP)) {
1710                                         nameserver_remove(service, type,
1711                                                           service->nameservers[i]);
1712                                 }
1713                                 if (connman_inet_check_ipaddress(
1714                                         service->nameservers[i]) == AF_INET6 &&
1715                                         (service->dns_config_method_ipv6 ==
1716                                                 CONNMAN_DNSCONFIG_METHOD_MANUAL ||
1717                                         service->dns_config_method_ipv6 ==
1718                                                 CONNMAN_DNSCONFIG_METHOD_DHCP)) {
1719                                         nameserver_remove(service, type,
1720                                                           service->nameservers[i]);
1721                                 }
1722                                 break;
1723                         case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
1724                                 DBG("CONNMAN_IPCONFIG_TYPE_UNKNOWN do nothing");
1725                                 break;
1726                         default:
1727                                 DBG("default case do nothing");
1728                                 break;
1729                 }
1730 #else
1731                 nameserver_remove(service, type, service->nameservers[i]);
1732 #endif
1733                 i++;
1734         }
1735
1736         searchdomain_remove_all(service);
1737
1738         return 0;
1739 }
1740
1741 /*
1742  * The is_auto variable is set to true when IPv6 autoconf nameservers are
1743  * inserted to resolver via netlink message (see rtnl.c:rtnl_newnduseropt()
1744  * for details) and not through service.c
1745  */
1746 #if defined TIZEN_EXT
1747 int __connman_service_nameserver_append(struct connman_service *service,
1748                                 const char *nameserver, bool is_auto,
1749                                 enum connman_ipconfig_type type)
1750 #else
1751 int __connman_service_nameserver_append(struct connman_service *service,
1752                                 const char *nameserver, bool is_auto)
1753 #endif
1754 {
1755         char **nameservers;
1756         int len, i;
1757
1758         DBG("service %p nameserver %s auto %d", service, nameserver, is_auto);
1759
1760         if (!nameserver)
1761                 return -EINVAL;
1762
1763         if (is_auto)
1764                 nameservers = service->nameservers_auto;
1765         else
1766                 nameservers = service->nameservers;
1767
1768         for (i = 0; nameservers && nameservers[i]; i++)
1769 #if defined TIZEN_EXT
1770         {
1771                 DBG("nameservers[%d] %s, nameserver %s", i, nameservers[i], nameserver);
1772 #endif
1773                 if (g_strcmp0(nameservers[i], nameserver) == 0)
1774                         return -EEXIST;
1775 #if defined TIZEN_EXT
1776         }
1777 #endif
1778
1779         if (nameservers) {
1780                 len = g_strv_length(nameservers);
1781                 nameservers = g_try_renew(char *, nameservers, len + 2);
1782         } else {
1783                 len = 0;
1784                 nameservers = g_try_new0(char *, len + 2);
1785         }
1786
1787         if (!nameservers)
1788                 return -ENOMEM;
1789
1790         nameservers[len] = g_strdup(nameserver);
1791         nameservers[len + 1] = NULL;
1792
1793 #ifdef TIZEN_EXT
1794         if(type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
1795            service->dns_config_method_ipv4 == CONNMAN_DNSCONFIG_METHOD_UNKNOWN)
1796                 service->dns_config_method_ipv4 = CONNMAN_DNSCONFIG_METHOD_DHCP;
1797
1798         if(type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
1799            service->dns_config_method_ipv6 == CONNMAN_DNSCONFIG_METHOD_UNKNOWN)
1800                 service->dns_config_method_ipv6 = CONNMAN_DNSCONFIG_METHOD_DHCP;
1801 #endif
1802
1803         if (is_auto) {
1804                 service->nameservers_auto = nameservers;
1805         } else {
1806                 service->nameservers = nameservers;
1807                 nameserver_add(service, CONNMAN_IPCONFIG_TYPE_ALL, nameserver);
1808         }
1809
1810         nameservers_changed(service);
1811
1812         searchdomain_add_all(service);
1813
1814         return 0;
1815 }
1816
1817 #if defined TIZEN_EXT
1818 int __connman_service_nameserver_remove(struct connman_service *service,
1819                                 const char *nameserver, bool is_auto,
1820                                 enum connman_ipconfig_type type)
1821 #else
1822 int __connman_service_nameserver_remove(struct connman_service *service,
1823                                 const char *nameserver, bool is_auto)
1824 #endif
1825 {
1826         char **servers, **nameservers;
1827         bool found = false;
1828         int len, i, j;
1829
1830         DBG("service %p nameserver %s auto %d", service, nameserver, is_auto);
1831
1832         if (!nameserver)
1833                 return -EINVAL;
1834
1835         if (is_auto)
1836                 nameservers = service->nameservers_auto;
1837         else
1838                 nameservers = service->nameservers;
1839
1840         if (!nameservers)
1841                 return 0;
1842
1843         for (i = 0; nameservers[i]; i++)
1844                 if (g_strcmp0(nameservers[i], nameserver) == 0) {
1845                         found = true;
1846                         break;
1847                 }
1848
1849         if (!found)
1850                 return 0;
1851
1852         len = g_strv_length(nameservers);
1853
1854         if (len == 1) {
1855                 servers = NULL;
1856                 goto set_servers;
1857         }
1858
1859         servers = g_try_new0(char *, len);
1860         if (!servers)
1861                 return -ENOMEM;
1862
1863         for (i = 0, j = 0; i < len; i++) {
1864                 if (g_strcmp0(nameservers[i], nameserver)) {
1865                         servers[j] = nameservers[i];
1866                         j++;
1867                 } else
1868                         g_free(nameservers[i]);
1869
1870                 nameservers[i] = NULL;
1871         }
1872         servers[len - 1] = NULL;
1873
1874 set_servers:
1875         g_strfreev(nameservers);
1876         nameservers = servers;
1877
1878         if (is_auto) {
1879                 service->nameservers_auto = nameservers;
1880         } else {
1881                 service->nameservers = nameservers;
1882 #if defined TIZEN_EXT
1883                 DBG("nameserver remove ip_type: %d", type);
1884                 nameserver_remove(service, type,
1885                                 nameserver);
1886 #else
1887                 nameserver_remove(service, CONNMAN_IPCONFIG_TYPE_ALL,
1888                                 nameserver);
1889 #endif
1890         }
1891
1892         return 0;
1893 }
1894
1895 void __connman_service_nameserver_clear(struct connman_service *service)
1896 {
1897         nameserver_remove_all(service, CONNMAN_IPCONFIG_TYPE_ALL);
1898
1899         g_strfreev(service->nameservers);
1900         service->nameservers = NULL;
1901
1902         nameserver_add_all(service, CONNMAN_IPCONFIG_TYPE_ALL);
1903 }
1904
1905 static void add_nameserver_route(int family, int index, char *nameserver,
1906                                 const char *gw)
1907 {
1908         switch (family) {
1909         case AF_INET:
1910                 if (connman_inet_compare_subnet(index, nameserver))
1911                         break;
1912
1913                 if (connman_inet_add_host_route(index, nameserver, gw) < 0)
1914                         /* For P-t-P link the above route add will fail */
1915                         connman_inet_add_host_route(index, nameserver, NULL);
1916                 break;
1917
1918         case AF_INET6:
1919                 if (connman_inet_add_ipv6_host_route(index, nameserver,
1920                                                                 gw) < 0)
1921                         connman_inet_add_ipv6_host_route(index, nameserver,
1922                                                         NULL);
1923                 break;
1924         }
1925 }
1926
1927 static void nameserver_add_routes(int index, char **nameservers,
1928                                         const char *gw)
1929 {
1930         int i, ns_family, gw_family;
1931
1932         gw_family = connman_inet_check_ipaddress(gw);
1933         if (gw_family < 0)
1934                 return;
1935
1936         for (i = 0; nameservers[i]; i++) {
1937                 ns_family = connman_inet_check_ipaddress(nameservers[i]);
1938                 if (ns_family < 0 || ns_family != gw_family)
1939                         continue;
1940
1941                 add_nameserver_route(ns_family, index, nameservers[i], gw);
1942         }
1943 }
1944
1945 static void nameserver_del_routes(int index, char **nameservers,
1946                                 enum connman_ipconfig_type type)
1947 {
1948         int i, family;
1949
1950         for (i = 0; nameservers[i]; i++) {
1951                 family = connman_inet_check_ipaddress(nameservers[i]);
1952                 if (family < 0)
1953                         continue;
1954
1955                 switch (family) {
1956                 case AF_INET:
1957                         if (type != CONNMAN_IPCONFIG_TYPE_IPV6)
1958                                 connman_inet_del_host_route(index,
1959                                                         nameservers[i]);
1960                         break;
1961                 case AF_INET6:
1962                         if (type != CONNMAN_IPCONFIG_TYPE_IPV4)
1963                                 connman_inet_del_ipv6_host_route(index,
1964                                                         nameservers[i]);
1965                         break;
1966                 }
1967         }
1968 }
1969
1970 void __connman_service_nameserver_add_routes(struct connman_service *service,
1971                                                 const char *gw)
1972 {
1973         int index;
1974
1975         if (!service)
1976                 return;
1977
1978         index = __connman_service_get_index(service);
1979
1980         if (service->nameservers_config) {
1981                 /*
1982                  * Configured nameserver takes preference over the
1983                  * discoverd nameserver gathered from DHCP, VPN, etc.
1984                  */
1985                 nameserver_add_routes(index, service->nameservers_config, gw);
1986         } else if (service->nameservers) {
1987                 /*
1988                  * We add nameservers host routes for nameservers that
1989                  * are not on our subnet. For those who are, the subnet
1990                  * route will be installed by the time the dns proxy code
1991                  * tries to reach them. The subnet route is installed
1992                  * when setting the interface IP address.
1993                  */
1994                 nameserver_add_routes(index, service->nameservers, gw);
1995         }
1996 }
1997
1998 void __connman_service_nameserver_del_routes(struct connman_service *service,
1999                                         enum connman_ipconfig_type type)
2000 {
2001         int index;
2002
2003         if (!service)
2004                 return;
2005
2006         index = __connman_service_get_index(service);
2007
2008         if (service->nameservers_config)
2009                 nameserver_del_routes(index, service->nameservers_config,
2010                                         type);
2011         else if (service->nameservers)
2012                 nameserver_del_routes(index, service->nameservers, type);
2013 }
2014
2015 static void address_updated(struct connman_service *service,
2016                         enum connman_ipconfig_type type)
2017 {
2018         if (is_connected(service->state) &&
2019                         service == __connman_service_get_default()) {
2020                 nameserver_remove_all(service, type);
2021                 nameserver_add_all(service, type);
2022
2023                 __connman_timeserver_sync(service);
2024         }
2025 }
2026
2027 static struct connman_stats *stats_get(struct connman_service *service)
2028 {
2029         if (service->roaming)
2030                 return &service->stats_roaming;
2031         else
2032                 return &service->stats;
2033 }
2034
2035 static bool stats_enabled(struct connman_service *service)
2036 {
2037         struct connman_stats *stats = stats_get(service);
2038
2039         return stats->enabled;
2040 }
2041
2042 static void stats_start(struct connman_service *service)
2043 {
2044         struct connman_stats *stats = stats_get(service);
2045
2046         DBG("service %p", service);
2047
2048         if (!stats->timer)
2049                 return;
2050
2051         stats->enabled = true;
2052         stats->data_last.time = stats->data.time;
2053
2054         g_timer_start(stats->timer);
2055 }
2056
2057 static void stats_stop(struct connman_service *service)
2058 {
2059         struct connman_stats *stats = stats_get(service);
2060         unsigned int seconds;
2061
2062         DBG("service %p", service);
2063
2064         if (!stats->timer)
2065                 return;
2066
2067         if (!stats->enabled)
2068                 return;
2069
2070         g_timer_stop(stats->timer);
2071
2072         seconds = g_timer_elapsed(stats->timer, NULL);
2073         stats->data.time = stats->data_last.time + seconds;
2074
2075         stats->enabled = false;
2076 }
2077
2078 static void reset_stats(struct connman_service *service)
2079 {
2080         DBG("service %p", service);
2081
2082         /* home */
2083         service->stats.valid = false;
2084
2085         service->stats.data.rx_packets = 0;
2086         service->stats.data.tx_packets = 0;
2087         service->stats.data.rx_bytes = 0;
2088         service->stats.data.tx_bytes = 0;
2089         service->stats.data.rx_errors = 0;
2090         service->stats.data.tx_errors = 0;
2091         service->stats.data.rx_dropped = 0;
2092         service->stats.data.tx_dropped = 0;
2093         service->stats.data.time = 0;
2094         service->stats.data_last.time = 0;
2095
2096         g_timer_reset(service->stats.timer);
2097
2098         /* roaming */
2099         service->stats_roaming.valid = false;
2100
2101         service->stats_roaming.data.rx_packets = 0;
2102         service->stats_roaming.data.tx_packets = 0;
2103         service->stats_roaming.data.rx_bytes = 0;
2104         service->stats_roaming.data.tx_bytes = 0;
2105         service->stats_roaming.data.rx_errors = 0;
2106         service->stats_roaming.data.tx_errors = 0;
2107         service->stats_roaming.data.rx_dropped = 0;
2108         service->stats_roaming.data.tx_dropped = 0;
2109         service->stats_roaming.data.time = 0;
2110         service->stats_roaming.data_last.time = 0;
2111
2112         g_timer_reset(service->stats_roaming.timer);
2113 }
2114
2115 #if defined TIZEN_EXT
2116 static gboolean __connman_service_is_internet_profile(
2117                 struct connman_service *cellular)
2118 {
2119         const char internet_suffix[] = "_1";
2120
2121         DBG("Service path: %s", cellular->path);
2122
2123         if (g_str_has_suffix(cellular->path, internet_suffix) == TRUE)
2124                 return TRUE;
2125
2126         return FALSE;
2127 }
2128
2129 static gboolean __connman_service_is_tethering_profile(
2130                 struct connman_service *cellular)
2131 {
2132         const char tethering_suffix[] = "_5";
2133
2134         DBG("Service path: %s", cellular->path);
2135
2136         if (g_str_has_suffix(cellular->path, tethering_suffix) == TRUE)
2137                 return TRUE;
2138
2139         return FALSE;
2140 }
2141
2142 struct connman_service *connman_service_get_default_connection(void)
2143 {
2144         GList *list;
2145         struct connman_service *service;
2146         struct connman_service *default_service = NULL;
2147
2148         for (list = service_list; list; list = list->next) {
2149                 service = list->data;
2150
2151                 DBG("service: %p %s %s %s", service, service->name,
2152                                 state2string(service->state),
2153                                 __connman_service_type2string(service->type));
2154
2155                 if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
2156                                 is_connected(service->state) == TRUE) {
2157                         return service;
2158                 } else if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR &&
2159                                 __connman_service_is_internet_profile(service) == TRUE) {
2160                         if (default_service == NULL)
2161                                 default_service = service;
2162                         else if (is_connected(service->state) == TRUE &&
2163                                         is_connected(default_service->state) == FALSE)
2164                                 default_service = service;
2165                 } else if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET &&
2166                                 is_connected(service->state) == TRUE) {
2167                         if (default_service == NULL)
2168                                 default_service = service;
2169                 } else if (service->type == CONNMAN_SERVICE_TYPE_BLUETOOTH &&
2170                                 is_connected(service->state) == TRUE) {
2171                         if (default_service == NULL)
2172                                 default_service = service;
2173                 }
2174         }
2175
2176         return default_service;
2177 }
2178 #endif
2179
2180 struct connman_service *__connman_service_get_default(void)
2181 {
2182         struct connman_service *service;
2183
2184         if (!service_list)
2185                 return NULL;
2186
2187         service = service_list->data;
2188
2189         if (!is_connected(service->state))
2190                 return NULL;
2191
2192         return service;
2193 }
2194
2195 bool __connman_service_index_is_default(int index)
2196 {
2197         struct connman_service *service;
2198
2199         if (index < 0)
2200                 return false;
2201
2202         service = __connman_service_get_default();
2203
2204         return __connman_service_get_index(service) == index;
2205 }
2206
2207 static void default_changed(void)
2208 {
2209         struct connman_service *service = __connman_service_get_default();
2210
2211         if (service == current_default)
2212                 return;
2213
2214         DBG("current default %p %s", current_default,
2215                 current_default ? current_default->identifier : "");
2216         DBG("new default %p %s", service, service ? service->identifier : "");
2217
2218 #if defined TIZEN_EXT
2219         current_default = service;
2220
2221         __connman_service_timeserver_changed(service, NULL);
2222 #else
2223         __connman_service_timeserver_changed(current_default, NULL);
2224
2225         current_default = service;
2226 #endif
2227
2228         if (service) {
2229                 if (service->hostname &&
2230                                 connman_setting_get_bool("AllowHostnameUpdates"))
2231                         __connman_utsname_set_hostname(service->hostname);
2232
2233                 if (service->domainname)
2234                         __connman_utsname_set_domainname(service->domainname);
2235         }
2236
2237         __connman_notifier_default_changed(service);
2238 }
2239
2240 static void state_changed(struct connman_service *service)
2241 {
2242         const char *str;
2243
2244         __connman_notifier_service_state_changed(service, service->state);
2245
2246         str = state2string(service->state);
2247         if (!str)
2248                 return;
2249
2250 #if !defined TIZEN_EXT
2251         if (!allow_property_changed(service))
2252                 return;
2253 #endif
2254 #if defined TIZEN_EXT
2255         DBG(" %s, %s", str, service->path);
2256 #endif
2257         connman_dbus_property_changed_basic(service->path,
2258                                 CONNMAN_SERVICE_INTERFACE, "State",
2259                                                 DBUS_TYPE_STRING, &str);
2260 }
2261
2262 static void strength_changed(struct connman_service *service)
2263 {
2264         if (service->strength == 0)
2265                 return;
2266
2267         if (!allow_property_changed(service))
2268                 return;
2269
2270         connman_dbus_property_changed_basic(service->path,
2271                                 CONNMAN_SERVICE_INTERFACE, "Strength",
2272                                         DBUS_TYPE_BYTE, &service->strength);
2273 }
2274
2275 static void favorite_changed(struct connman_service *service)
2276 {
2277         dbus_bool_t favorite;
2278
2279         if (!service->path)
2280                 return;
2281
2282         if (!allow_property_changed(service))
2283                 return;
2284
2285         favorite = service->favorite;
2286         connman_dbus_property_changed_basic(service->path,
2287                                 CONNMAN_SERVICE_INTERFACE, "Favorite",
2288                                         DBUS_TYPE_BOOLEAN, &favorite);
2289 }
2290
2291 static void immutable_changed(struct connman_service *service)
2292 {
2293         dbus_bool_t immutable;
2294
2295         if (!service->path)
2296                 return;
2297
2298         if (!allow_property_changed(service))
2299                 return;
2300
2301         immutable = service->immutable;
2302         connman_dbus_property_changed_basic(service->path,
2303                                 CONNMAN_SERVICE_INTERFACE, "Immutable",
2304                                         DBUS_TYPE_BOOLEAN, &immutable);
2305 }
2306
2307 static void roaming_changed(struct connman_service *service)
2308 {
2309         dbus_bool_t roaming;
2310
2311         if (!service->path)
2312                 return;
2313
2314         if (!allow_property_changed(service))
2315                 return;
2316
2317         roaming = service->roaming;
2318         connman_dbus_property_changed_basic(service->path,
2319                                 CONNMAN_SERVICE_INTERFACE, "Roaming",
2320                                         DBUS_TYPE_BOOLEAN, &roaming);
2321 }
2322
2323 static void autoconnect_changed(struct connman_service *service)
2324 {
2325         dbus_bool_t autoconnect;
2326
2327         if (!service->path)
2328                 return;
2329
2330         if (!allow_property_changed(service))
2331                 return;
2332
2333         autoconnect = service->autoconnect;
2334         connman_dbus_property_changed_basic(service->path,
2335                                 CONNMAN_SERVICE_INTERFACE, "AutoConnect",
2336                                 DBUS_TYPE_BOOLEAN, &autoconnect);
2337 }
2338
2339 static void append_security(DBusMessageIter *iter, void *user_data)
2340 {
2341         struct connman_service *service = user_data;
2342         const char *str;
2343
2344         str = security2string(service->security);
2345         if (str)
2346                 dbus_message_iter_append_basic(iter,
2347                                 DBUS_TYPE_STRING, &str);
2348
2349         /*
2350          * Some access points incorrectly advertise WPS even when they
2351          * are configured as open or no security, so filter
2352          * appropriately.
2353          */
2354         if (service->wps) {
2355                 switch (service->security) {
2356                 case CONNMAN_SERVICE_SECURITY_PSK:
2357                 case CONNMAN_SERVICE_SECURITY_WPA:
2358                 case CONNMAN_SERVICE_SECURITY_RSN:
2359                         str = "wps";
2360                         dbus_message_iter_append_basic(iter,
2361                                                 DBUS_TYPE_STRING, &str);
2362                         break;
2363                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
2364                 case CONNMAN_SERVICE_SECURITY_NONE:
2365                 case CONNMAN_SERVICE_SECURITY_WEP:
2366                 case CONNMAN_SERVICE_SECURITY_8021X:
2367                         break;
2368                 }
2369         }
2370 }
2371
2372 static void append_ethernet(DBusMessageIter *iter, void *user_data)
2373 {
2374         struct connman_service *service = user_data;
2375
2376         if (service->ipconfig_ipv4)
2377                 __connman_ipconfig_append_ethernet(service->ipconfig_ipv4,
2378                                                                         iter);
2379         else if (service->ipconfig_ipv6)
2380                 __connman_ipconfig_append_ethernet(service->ipconfig_ipv6,
2381                                                                         iter);
2382 }
2383
2384 static void append_ipv4(DBusMessageIter *iter, void *user_data)
2385 {
2386         struct connman_service *service = user_data;
2387
2388         if (!is_connected(service->state_ipv4))
2389                 return;
2390
2391         if (service->ipconfig_ipv4)
2392                 __connman_ipconfig_append_ipv4(service->ipconfig_ipv4, iter);
2393 }
2394
2395 static void append_ipv6(DBusMessageIter *iter, void *user_data)
2396 {
2397         struct connman_service *service = user_data;
2398
2399         if (!is_connected(service->state_ipv6))
2400                 return;
2401
2402         if (service->ipconfig_ipv6)
2403                 __connman_ipconfig_append_ipv6(service->ipconfig_ipv6, iter,
2404                                                 service->ipconfig_ipv4);
2405 }
2406
2407 static void append_ipv4config(DBusMessageIter *iter, void *user_data)
2408 {
2409         struct connman_service *service = user_data;
2410
2411         if (service->ipconfig_ipv4)
2412                 __connman_ipconfig_append_ipv4config(service->ipconfig_ipv4,
2413                                                         iter);
2414 }
2415
2416 static void append_ipv6config(DBusMessageIter *iter, void *user_data)
2417 {
2418         struct connman_service *service = user_data;
2419
2420         if (service->ipconfig_ipv6)
2421                 __connman_ipconfig_append_ipv6config(service->ipconfig_ipv6,
2422                                                         iter);
2423 }
2424
2425 static void append_nameservers(DBusMessageIter *iter,
2426                 struct connman_service *service, char **servers)
2427 {
2428         int i;
2429         bool available = true;
2430
2431         for (i = 0; servers[i]; i++) {
2432                 if (service)
2433                         available = nameserver_available(service,
2434                                                 CONNMAN_IPCONFIG_TYPE_ALL,
2435                                                 servers[i]);
2436
2437                 if (available)
2438                         dbus_message_iter_append_basic(iter,
2439                                         DBUS_TYPE_STRING, &servers[i]);
2440         }
2441 }
2442
2443 #if defined TIZEN_EXT
2444 static void append_nameserver_manual(DBusMessageIter *iter,
2445                 struct connman_service *service, const char *server)
2446 {
2447         bool available = true;
2448
2449         if (service)
2450                 available = nameserver_available(service,
2451                                 CONNMAN_IPCONFIG_TYPE_ALL, server);
2452
2453         if (available)
2454                 dbus_message_iter_append_basic(iter,
2455                                 DBUS_TYPE_STRING, &server);
2456 }
2457
2458 static void append_nameserver_dhcp(DBusMessageIter *iter,
2459                 struct connman_service *service, const char *server)
2460 {
2461         bool available = true;
2462
2463         if (service)
2464                 available = nameserver_available(service,
2465                                 CONNMAN_IPCONFIG_TYPE_ALL, server);
2466
2467         if (available)
2468                 dbus_message_iter_append_basic(iter,
2469                                 DBUS_TYPE_STRING, &server);
2470 }
2471 #endif
2472
2473 static void append_dns(DBusMessageIter *iter, void *user_data)
2474 {
2475         struct connman_service *service = user_data;
2476 #if defined TIZEN_EXT
2477         int i;
2478 #endif
2479
2480         if (!is_connected(service->state))
2481                 return;
2482
2483 #ifdef TIZEN_EXT
2484         const char *str;
2485
2486         str = __connman_dnsconfig_method2string(service->dns_config_method_ipv4);
2487         if(str != NULL) {
2488                 char *str1 = g_strdup_printf("ipv4.%s", str);
2489                 dbus_message_iter_append_basic(iter,
2490                         DBUS_TYPE_STRING, &str1);
2491                 g_free(str1);
2492         }
2493
2494         str = __connman_dnsconfig_method2string(service->dns_config_method_ipv6);
2495         if(str != NULL) {
2496                 char *str1 = g_strdup_printf("ipv6.%s", str);
2497                 dbus_message_iter_append_basic(iter,
2498                         DBUS_TYPE_STRING, &str1);
2499                 g_free(str1);
2500         }
2501 #endif
2502
2503         if (service->nameservers_config) {
2504 #if defined TIZEN_EXT
2505                 i = 0;
2506                 while (service->nameservers_config[i]) {
2507                         if (connman_inet_check_ipaddress(
2508                                 service->nameservers_config[i]) == AF_INET &&
2509                                 service->dns_config_method_ipv4 ==
2510                                         CONNMAN_DNSCONFIG_METHOD_MANUAL) {
2511                                 append_nameserver_manual(iter, service,
2512                                                 service->nameservers_config[i]);
2513                         }
2514
2515                         if (connman_inet_check_ipaddress(
2516                                 service->nameservers_config[i]) == AF_INET6 &&
2517                                 service->dns_config_method_ipv6 ==
2518                                         CONNMAN_DNSCONFIG_METHOD_MANUAL) {
2519                                 append_nameserver_manual(iter, service,
2520                                                 service->nameservers_config[i]);
2521                         }
2522                         i++;
2523                 }
2524                 /* In case of mixed DNS Config Type one of IPv4/IPv6 can be
2525                  * dynamic while other is static so try to append the DNS
2526                  * Address which is dynamic also */
2527                 if (service->nameservers != NULL) {
2528                         i = 0;
2529                         while (service->nameservers[i]) {
2530                                 if (connman_inet_check_ipaddress(
2531                                         service->nameservers[i]) == AF_INET &&
2532                                         service->dns_config_method_ipv4 ==
2533                                                 CONNMAN_DNSCONFIG_METHOD_DHCP) {
2534                                         append_nameserver_dhcp(iter, service,
2535                                                         service->nameservers[i]);
2536                                 }
2537
2538                                 if (connman_inet_check_ipaddress(
2539                                         service->nameservers[i]) == AF_INET6 &&
2540                                         service->dns_config_method_ipv6 ==
2541                                                 CONNMAN_DNSCONFIG_METHOD_DHCP) {
2542                                         append_nameserver_dhcp(iter, service,
2543                                                         service->nameservers[i]);
2544                                 }
2545                                 i++;
2546                         }
2547                 }
2548 #else
2549                 append_nameservers(iter, service, service->nameservers_config);
2550 #endif
2551                 return;
2552         } else {
2553                 if (service->nameservers)
2554 #if defined TIZEN_EXT
2555                 {
2556                         i = 0;
2557                         while (service->nameservers[i]) {
2558                                 if (connman_inet_check_ipaddress(
2559                                         service->nameservers[i]) == AF_INET &&
2560                                         service->dns_config_method_ipv4 ==
2561                                                 CONNMAN_DNSCONFIG_METHOD_DHCP) {
2562                                         append_nameserver_dhcp(iter, service,
2563                                                         service->nameservers[i]);
2564                                 }
2565
2566                                 if (connman_inet_check_ipaddress(
2567                                         service->nameservers[i]) == AF_INET6 &&
2568                                         service->dns_config_method_ipv6 ==
2569                                                 CONNMAN_DNSCONFIG_METHOD_DHCP) {
2570                                         append_nameserver_dhcp(iter, service,
2571                                                         service->nameservers[i]);
2572                                 }
2573                                 i++;
2574                         }
2575                 }
2576 #else
2577                         append_nameservers(iter, service,
2578                                         service->nameservers);
2579 #endif
2580
2581                 if (service->nameservers_auto)
2582                         append_nameservers(iter, service,
2583                                         service->nameservers_auto);
2584
2585                 if (!service->nameservers && !service->nameservers_auto) {
2586                         char **ns;
2587
2588                         DBG("append fallback nameservers");
2589
2590                         ns = connman_setting_get_string_list("FallbackNameservers");
2591                         if (ns)
2592                                 append_nameservers(iter, service, ns);
2593                 }
2594         }
2595 }
2596
2597 static void append_dnsconfig(DBusMessageIter *iter, void *user_data)
2598 {
2599         struct connman_service *service = user_data;
2600
2601 #ifdef TIZEN_EXT
2602         /* Append DNS Config Type */
2603         const char *str;
2604         str = __connman_dnsconfig_method2string(service->dns_config_method_ipv4);
2605         if(str != NULL) {
2606                 char *str1 = g_strdup_printf("ipv4.%s", str);
2607                 dbus_message_iter_append_basic(iter,
2608                         DBUS_TYPE_STRING, &str1);
2609                 g_free(str1);
2610         }
2611
2612         str = __connman_dnsconfig_method2string(service->dns_config_method_ipv6);
2613         if(str != NULL) {
2614                 char *str1 = g_strdup_printf("ipv6.%s", str);
2615                 dbus_message_iter_append_basic(iter,
2616                         DBUS_TYPE_STRING, &str1);
2617                 g_free(str1);
2618         }
2619 #endif
2620
2621         if (!service->nameservers_config)
2622                 return;
2623
2624 #if defined TIZEN_EXT
2625         int i = 0;
2626         while (service->nameservers_config[i]) {
2627                 if (connman_inet_check_ipaddress(service->nameservers_config[i]) == AF_INET &&
2628                                 service->dns_config_method_ipv4 == CONNMAN_DNSCONFIG_METHOD_MANUAL) {
2629                         append_nameserver_manual(iter, NULL, service->nameservers_config[i]);
2630                 }
2631
2632                 if (connman_inet_check_ipaddress(service->nameservers_config[i]) == AF_INET6 &&
2633                                 service->dns_config_method_ipv6 == CONNMAN_DNSCONFIG_METHOD_MANUAL) {
2634                         append_nameserver_manual(iter, NULL, service->nameservers_config[i]);
2635                 }
2636                 i++;
2637         }
2638 #else
2639         append_nameservers(iter, NULL, service->nameservers_config);
2640 #endif
2641 }
2642
2643 static void append_ts(DBusMessageIter *iter, void *user_data)
2644 {
2645         GSList *list = user_data;
2646
2647         while (list) {
2648                 char *timeserver = list->data;
2649
2650                 if (timeserver)
2651                         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
2652                                         &timeserver);
2653
2654                 list = g_slist_next(list);
2655         }
2656 }
2657
2658 static void append_tsconfig(DBusMessageIter *iter, void *user_data)
2659 {
2660         struct connman_service *service = user_data;
2661         int i;
2662
2663         if (!service->timeservers_config)
2664                 return;
2665
2666         for (i = 0; service->timeservers_config[i]; i++) {
2667                 dbus_message_iter_append_basic(iter,
2668                                 DBUS_TYPE_STRING,
2669                                 &service->timeservers_config[i]);
2670         }
2671 }
2672
2673 static void append_domainconfig(DBusMessageIter *iter, void *user_data)
2674 {
2675         struct connman_service *service = user_data;
2676         int i;
2677
2678         if (!service->domains)
2679                 return;
2680
2681         for (i = 0; service->domains[i]; i++)
2682                 dbus_message_iter_append_basic(iter,
2683                                 DBUS_TYPE_STRING, &service->domains[i]);
2684 }
2685
2686 static void append_domain(DBusMessageIter *iter, void *user_data)
2687 {
2688         struct connman_service *service = user_data;
2689
2690         if (!is_connected(service->state) &&
2691                                 !is_connecting(service->state))
2692                 return;
2693
2694         if (service->domains)
2695                 append_domainconfig(iter, user_data);
2696         else if (service->domainname)
2697                 dbus_message_iter_append_basic(iter,
2698                                 DBUS_TYPE_STRING, &service->domainname);
2699 }
2700
2701 static void append_proxies(DBusMessageIter *iter, void *user_data)
2702 {
2703         struct connman_service *service = user_data;
2704         int i;
2705
2706         if (!service->proxies)
2707                 return;
2708
2709         for (i = 0; service->proxies[i]; i++)
2710                 dbus_message_iter_append_basic(iter,
2711                                 DBUS_TYPE_STRING, &service->proxies[i]);
2712 }
2713
2714 static void append_excludes(DBusMessageIter *iter, void *user_data)
2715 {
2716         struct connman_service *service = user_data;
2717         int i;
2718
2719         if (!service->excludes)
2720                 return;
2721
2722         for (i = 0; service->excludes[i]; i++)
2723                 dbus_message_iter_append_basic(iter,
2724                                 DBUS_TYPE_STRING, &service->excludes[i]);
2725 }
2726
2727 static void append_proxy(DBusMessageIter *iter, void *user_data)
2728 {
2729         struct connman_service *service = user_data;
2730         enum connman_service_proxy_method proxy;
2731         const char *pac = NULL;
2732         const char *method = proxymethod2string(
2733                 CONNMAN_SERVICE_PROXY_METHOD_DIRECT);
2734
2735         if (!is_connected(service->state))
2736                 return;
2737
2738         proxy = connman_service_get_proxy_method(service);
2739
2740         switch (proxy) {
2741         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
2742                 return;
2743         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
2744                 goto done;
2745         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
2746                 connman_dbus_dict_append_array(iter, "Servers",
2747                                         DBUS_TYPE_STRING, append_proxies,
2748                                         service);
2749
2750                 connman_dbus_dict_append_array(iter, "Excludes",
2751                                         DBUS_TYPE_STRING, append_excludes,
2752                                         service);
2753                 break;
2754         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
2755                 /* Maybe DHCP, or WPAD,  has provided an url for a pac file */
2756                 if (service->ipconfig_ipv4)
2757                         pac = __connman_ipconfig_get_proxy_autoconfig(
2758                                 service->ipconfig_ipv4);
2759                 else if (service->ipconfig_ipv6)
2760                         pac = __connman_ipconfig_get_proxy_autoconfig(
2761                                 service->ipconfig_ipv6);
2762
2763                 if (!service->pac && !pac)
2764                         goto done;
2765
2766                 if (service->pac)
2767                         pac = service->pac;
2768
2769                 connman_dbus_dict_append_basic(iter, "URL",
2770                                         DBUS_TYPE_STRING, &pac);
2771                 break;
2772         }
2773
2774         method = proxymethod2string(proxy);
2775
2776 done:
2777         connman_dbus_dict_append_basic(iter, "Method",
2778                                         DBUS_TYPE_STRING, &method);
2779 }
2780
2781 static void append_proxyconfig(DBusMessageIter *iter, void *user_data)
2782 {
2783         struct connman_service *service = user_data;
2784         const char *method;
2785
2786         if (service->proxy_config == CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN)
2787                 return;
2788
2789         switch (service->proxy_config) {
2790         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
2791                 return;
2792         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
2793                 break;
2794         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
2795                 if (service->proxies)
2796                         connman_dbus_dict_append_array(iter, "Servers",
2797                                                 DBUS_TYPE_STRING,
2798                                                 append_proxies, service);
2799
2800                 if (service->excludes)
2801                         connman_dbus_dict_append_array(iter, "Excludes",
2802                                                 DBUS_TYPE_STRING,
2803                                                 append_excludes, service);
2804                 break;
2805         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
2806                 if (service->pac)
2807                         connman_dbus_dict_append_basic(iter, "URL",
2808                                         DBUS_TYPE_STRING, &service->pac);
2809                 break;
2810         }
2811
2812         method = proxymethod2string(service->proxy_config);
2813
2814         connman_dbus_dict_append_basic(iter, "Method",
2815                                 DBUS_TYPE_STRING, &method);
2816 }
2817
2818 static void append_provider(DBusMessageIter *iter, void *user_data)
2819 {
2820         struct connman_service *service = user_data;
2821
2822         if (!is_connected(service->state))
2823                 return;
2824
2825         if (service->provider)
2826                 __connman_provider_append_properties(service->provider, iter);
2827 }
2828
2829
2830 static void settings_changed(struct connman_service *service,
2831                                 struct connman_ipconfig *ipconfig)
2832 {
2833         enum connman_ipconfig_type type;
2834
2835         type = __connman_ipconfig_get_config_type(ipconfig);
2836
2837         __connman_notifier_ipconfig_changed(service, ipconfig);
2838
2839         if (!allow_property_changed(service))
2840                 return;
2841
2842         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
2843                 connman_dbus_property_changed_dict(service->path,
2844                                         CONNMAN_SERVICE_INTERFACE, "IPv4",
2845                                         append_ipv4, service);
2846         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
2847                 connman_dbus_property_changed_dict(service->path,
2848                                         CONNMAN_SERVICE_INTERFACE, "IPv6",
2849                                         append_ipv6, service);
2850 }
2851
2852 static void ipv4_configuration_changed(struct connman_service *service)
2853 {
2854         if (!allow_property_changed(service))
2855                 return;
2856
2857         connman_dbus_property_changed_dict(service->path,
2858                                         CONNMAN_SERVICE_INTERFACE,
2859                                                         "IPv4.Configuration",
2860                                                         append_ipv4config,
2861                                                         service);
2862 }
2863
2864 void __connman_service_notify_ipv4_configuration(
2865                                         struct connman_service *service)
2866 {
2867         if (!service)
2868                 return;
2869
2870         ipv4_configuration_changed(service);
2871 }
2872
2873 static void ipv6_configuration_changed(struct connman_service *service)
2874 {
2875         if (!allow_property_changed(service))
2876                 return;
2877
2878         connman_dbus_property_changed_dict(service->path,
2879                                         CONNMAN_SERVICE_INTERFACE,
2880                                                         "IPv6.Configuration",
2881                                                         append_ipv6config,
2882                                                         service);
2883 }
2884
2885 static void dns_changed(struct connman_service *service)
2886 {
2887         if (!allow_property_changed(service))
2888                 return;
2889
2890         connman_dbus_property_changed_array(service->path,
2891                                 CONNMAN_SERVICE_INTERFACE, "Nameservers",
2892                                         DBUS_TYPE_STRING, append_dns, service);
2893 }
2894
2895 static void dns_configuration_changed(struct connman_service *service)
2896 {
2897         if (!allow_property_changed(service))
2898                 return;
2899
2900         connman_dbus_property_changed_array(service->path,
2901                                 CONNMAN_SERVICE_INTERFACE,
2902                                 "Nameservers.Configuration",
2903                                 DBUS_TYPE_STRING, append_dnsconfig, service);
2904
2905         dns_changed(service);
2906 }
2907
2908 static void domain_changed(struct connman_service *service)
2909 {
2910         if (!allow_property_changed(service))
2911                 return;
2912
2913         connman_dbus_property_changed_array(service->path,
2914                                 CONNMAN_SERVICE_INTERFACE, "Domains",
2915                                 DBUS_TYPE_STRING, append_domain, service);
2916 }
2917
2918 static void domain_configuration_changed(struct connman_service *service)
2919 {
2920         if (!allow_property_changed(service))
2921                 return;
2922
2923         connman_dbus_property_changed_array(service->path,
2924                                 CONNMAN_SERVICE_INTERFACE,
2925                                 "Domains.Configuration",
2926                                 DBUS_TYPE_STRING, append_domainconfig, service);
2927 }
2928
2929 static void proxy_changed(struct connman_service *service)
2930 {
2931         if (!allow_property_changed(service))
2932                 return;
2933
2934         connman_dbus_property_changed_dict(service->path,
2935                                         CONNMAN_SERVICE_INTERFACE, "Proxy",
2936                                                         append_proxy, service);
2937 }
2938
2939 static void proxy_configuration_changed(struct connman_service *service)
2940 {
2941         if (!allow_property_changed(service))
2942                 return;
2943
2944         connman_dbus_property_changed_dict(service->path,
2945                         CONNMAN_SERVICE_INTERFACE, "Proxy.Configuration",
2946                                                 append_proxyconfig, service);
2947
2948         proxy_changed(service);
2949 }
2950
2951 static void timeservers_configuration_changed(struct connman_service *service)
2952 {
2953         if (!allow_property_changed(service))
2954                 return;
2955
2956         connman_dbus_property_changed_array(service->path,
2957                         CONNMAN_SERVICE_INTERFACE,
2958                         "Timeservers.Configuration",
2959                         DBUS_TYPE_STRING,
2960                         append_tsconfig, service);
2961 }
2962
2963 static void link_changed(struct connman_service *service)
2964 {
2965         if (!allow_property_changed(service))
2966                 return;
2967
2968         connman_dbus_property_changed_dict(service->path,
2969                                         CONNMAN_SERVICE_INTERFACE, "Ethernet",
2970                                                 append_ethernet, service);
2971 }
2972
2973 static void stats_append_counters(DBusMessageIter *dict,
2974                         struct connman_stats_data *stats,
2975                         struct connman_stats_data *counters,
2976                         bool append_all)
2977 {
2978         if (counters->rx_packets != stats->rx_packets || append_all) {
2979                 counters->rx_packets = stats->rx_packets;
2980                 connman_dbus_dict_append_basic(dict, "RX.Packets",
2981                                         DBUS_TYPE_UINT32, &stats->rx_packets);
2982         }
2983
2984         if (counters->tx_packets != stats->tx_packets || append_all) {
2985                 counters->tx_packets = stats->tx_packets;
2986                 connman_dbus_dict_append_basic(dict, "TX.Packets",
2987                                         DBUS_TYPE_UINT32, &stats->tx_packets);
2988         }
2989
2990         if (counters->rx_bytes != stats->rx_bytes || append_all) {
2991                 counters->rx_bytes = stats->rx_bytes;
2992                 connman_dbus_dict_append_basic(dict, "RX.Bytes",
2993                                         DBUS_TYPE_UINT32, &stats->rx_bytes);
2994         }
2995
2996         if (counters->tx_bytes != stats->tx_bytes || append_all) {
2997                 counters->tx_bytes = stats->tx_bytes;
2998                 connman_dbus_dict_append_basic(dict, "TX.Bytes",
2999                                         DBUS_TYPE_UINT32, &stats->tx_bytes);
3000         }
3001
3002         if (counters->rx_errors != stats->rx_errors || append_all) {
3003                 counters->rx_errors = stats->rx_errors;
3004                 connman_dbus_dict_append_basic(dict, "RX.Errors",
3005                                         DBUS_TYPE_UINT32, &stats->rx_errors);
3006         }
3007
3008         if (counters->tx_errors != stats->tx_errors || append_all) {
3009                 counters->tx_errors = stats->tx_errors;
3010                 connman_dbus_dict_append_basic(dict, "TX.Errors",
3011                                         DBUS_TYPE_UINT32, &stats->tx_errors);
3012         }
3013
3014         if (counters->rx_dropped != stats->rx_dropped || append_all) {
3015                 counters->rx_dropped = stats->rx_dropped;
3016                 connman_dbus_dict_append_basic(dict, "RX.Dropped",
3017                                         DBUS_TYPE_UINT32, &stats->rx_dropped);
3018         }
3019
3020         if (counters->tx_dropped != stats->tx_dropped || append_all) {
3021                 counters->tx_dropped = stats->tx_dropped;
3022                 connman_dbus_dict_append_basic(dict, "TX.Dropped",
3023                                         DBUS_TYPE_UINT32, &stats->tx_dropped);
3024         }
3025
3026         if (counters->time != stats->time || append_all) {
3027                 counters->time = stats->time;
3028                 connman_dbus_dict_append_basic(dict, "Time",
3029                                         DBUS_TYPE_UINT32, &stats->time);
3030         }
3031 }
3032
3033 static void stats_append(struct connman_service *service,
3034                                 const char *counter,
3035                                 struct connman_stats_counter *counters,
3036                                 bool append_all)
3037 {
3038         DBusMessageIter array, dict;
3039         DBusMessage *msg;
3040
3041         DBG("service %p counter %s", service, counter);
3042
3043         msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
3044         if (!msg)
3045                 return;
3046
3047         dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH,
3048                                 &service->path, DBUS_TYPE_INVALID);
3049
3050         dbus_message_iter_init_append(msg, &array);
3051
3052         /* home counter */
3053         connman_dbus_dict_open(&array, &dict);
3054
3055         stats_append_counters(&dict, &service->stats.data,
3056                                 &counters->stats.data, append_all);
3057
3058         connman_dbus_dict_close(&array, &dict);
3059
3060         /* roaming counter */
3061         connman_dbus_dict_open(&array, &dict);
3062
3063         stats_append_counters(&dict, &service->stats_roaming.data,
3064                                 &counters->stats_roaming.data, append_all);
3065
3066         connman_dbus_dict_close(&array, &dict);
3067
3068         __connman_counter_send_usage(counter, msg);
3069 }
3070
3071 static void stats_update(struct connman_service *service,
3072                                 unsigned int rx_packets, unsigned int tx_packets,
3073                                 unsigned int rx_bytes, unsigned int tx_bytes,
3074                                 unsigned int rx_errors, unsigned int tx_errors,
3075                                 unsigned int rx_dropped, unsigned int tx_dropped)
3076 {
3077         struct connman_stats *stats = stats_get(service);
3078         struct connman_stats_data *data_last = &stats->data_last;
3079         struct connman_stats_data *data = &stats->data;
3080         unsigned int seconds;
3081
3082         DBG("service %p", service);
3083
3084         if (stats->valid) {
3085                 data->rx_packets +=
3086                         rx_packets - data_last->rx_packets;
3087                 data->tx_packets +=
3088                         tx_packets - data_last->tx_packets;
3089                 data->rx_bytes +=
3090                         rx_bytes - data_last->rx_bytes;
3091                 data->tx_bytes +=
3092                         tx_bytes - data_last->tx_bytes;
3093                 data->rx_errors +=
3094                         rx_errors - data_last->rx_errors;
3095                 data->tx_errors +=
3096                         tx_errors - data_last->tx_errors;
3097                 data->rx_dropped +=
3098                         rx_dropped - data_last->rx_dropped;
3099                 data->tx_dropped +=
3100                         tx_dropped - data_last->tx_dropped;
3101         } else {
3102                 stats->valid = true;
3103         }
3104
3105         data_last->rx_packets = rx_packets;
3106         data_last->tx_packets = tx_packets;
3107         data_last->rx_bytes = rx_bytes;
3108         data_last->tx_bytes = tx_bytes;
3109         data_last->rx_errors = rx_errors;
3110         data_last->tx_errors = tx_errors;
3111         data_last->rx_dropped = rx_dropped;
3112         data_last->tx_dropped = tx_dropped;
3113
3114         seconds = g_timer_elapsed(stats->timer, NULL);
3115         stats->data.time = stats->data_last.time + seconds;
3116 }
3117
3118 void __connman_service_notify(struct connman_service *service,
3119                         unsigned int rx_packets, unsigned int tx_packets,
3120                         unsigned int rx_bytes, unsigned int tx_bytes,
3121                         unsigned int rx_errors, unsigned int tx_errors,
3122                         unsigned int rx_dropped, unsigned int tx_dropped)
3123 {
3124         GHashTableIter iter;
3125         gpointer key, value;
3126         const char *counter;
3127         struct connman_stats_counter *counters;
3128         struct connman_stats_data *data;
3129         int err;
3130
3131         if (!service)
3132                 return;
3133
3134         if (!is_connected(service->state))
3135                 return;
3136
3137         stats_update(service,
3138                 rx_packets, tx_packets,
3139                 rx_bytes, tx_bytes,
3140                 rx_errors, tx_errors,
3141                 rx_dropped, tx_dropped);
3142
3143         data = &stats_get(service)->data;
3144         err = __connman_stats_update(service, service->roaming, data);
3145         if (err < 0)
3146                 connman_error("Failed to store statistics for %s",
3147                                 service->identifier);
3148
3149         g_hash_table_iter_init(&iter, service->counter_table);
3150         while (g_hash_table_iter_next(&iter, &key, &value)) {
3151                 counter = key;
3152                 counters = value;
3153
3154                 stats_append(service, counter, counters, counters->append_all);
3155                 counters->append_all = false;
3156         }
3157 }
3158
3159 int __connman_service_counter_register(const char *counter)
3160 {
3161         struct connman_service *service;
3162         GList *list;
3163         struct connman_stats_counter *counters;
3164
3165         DBG("counter %s", counter);
3166
3167         counter_list = g_slist_prepend(counter_list, (gpointer)counter);
3168
3169         for (list = service_list; list; list = list->next) {
3170                 service = list->data;
3171
3172                 counters = g_try_new0(struct connman_stats_counter, 1);
3173                 if (!counters)
3174                         return -ENOMEM;
3175
3176                 counters->append_all = true;
3177
3178                 g_hash_table_replace(service->counter_table, (gpointer)counter,
3179                                         counters);
3180         }
3181
3182         return 0;
3183 }
3184
3185 void __connman_service_counter_unregister(const char *counter)
3186 {
3187         struct connman_service *service;
3188         GList *list;
3189
3190         DBG("counter %s", counter);
3191
3192         for (list = service_list; list; list = list->next) {
3193                 service = list->data;
3194
3195                 g_hash_table_remove(service->counter_table, counter);
3196         }
3197
3198         counter_list = g_slist_remove(counter_list, counter);
3199 }
3200
3201 int __connman_service_iterate_services(service_iterate_cb cb, void *user_data)
3202 {
3203         GList *list;
3204
3205         for (list = service_list; list; list = list->next) {
3206                 struct connman_service *service = list->data;
3207
3208                 cb(service, user_data);
3209         }
3210
3211         return 0;
3212 }
3213
3214 #if defined TIZEN_EXT
3215 static void append_wifi_ext_info(DBusMessageIter *dict,
3216                                         struct connman_network *network)
3217 {
3218         char bssid_buff[WIFI_BSSID_STR_LEN] = {0,};
3219         char *bssid_str = bssid_buff;
3220         const void *ssid;
3221         unsigned int ssid_len;
3222         unsigned char *bssid;
3223         unsigned int maxrate;
3224         unsigned int keymgmt;
3225         uint16_t frequency;
3226         const char *enc_mode;
3227         const char *str;
3228         gboolean passpoint;
3229
3230         ssid = connman_network_get_blob(network, "WiFi.SSID", &ssid_len);
3231         bssid = connman_network_get_bssid(network);
3232         maxrate = connman_network_get_maxrate(network);
3233         frequency = connman_network_get_frequency(network);
3234         enc_mode = connman_network_get_enc_mode(network);
3235         passpoint = connman_network_get_bool(network, "WiFi.HS20AP");
3236         keymgmt = connman_network_get_keymgmt(network);
3237
3238         snprintf(bssid_str, WIFI_BSSID_STR_LEN, "%02x:%02x:%02x:%02x:%02x:%02x",
3239                                 bssid[0], bssid[1], bssid[2],
3240                                 bssid[3], bssid[4], bssid[5]);
3241
3242         connman_dbus_dict_append_fixed_array(dict, "SSID",
3243                                         DBUS_TYPE_BYTE, &ssid, ssid_len);
3244         connman_dbus_dict_append_basic(dict, "BSSID",
3245                                         DBUS_TYPE_STRING, &bssid_str);
3246         connman_dbus_dict_append_basic(dict, "MaxRate",
3247                                         DBUS_TYPE_UINT32, &maxrate);
3248         connman_dbus_dict_append_basic(dict, "Frequency",
3249                                         DBUS_TYPE_UINT16, &frequency);
3250         connman_dbus_dict_append_basic(dict, "EncryptionMode",
3251                                         DBUS_TYPE_STRING, &enc_mode);
3252         connman_dbus_dict_append_basic(dict, "Passpoint",
3253                                         DBUS_TYPE_BOOLEAN, &passpoint);
3254         connman_dbus_dict_append_basic(dict, "Keymgmt",
3255                                         DBUS_TYPE_UINT32, &keymgmt);
3256
3257         str = connman_network_get_string(network, "WiFi.Security");
3258         if (str != NULL && g_str_equal(str, "ieee8021x") == TRUE) {
3259                 str = connman_network_get_string(network, "WiFi.EAP");
3260                 if (str != NULL)
3261                         connman_dbus_dict_append_basic(dict, "EAP",
3262                                         DBUS_TYPE_STRING, &str);
3263
3264                 str = connman_network_get_string(network, "WiFi.Phase2");
3265                 if (str != NULL)
3266                         connman_dbus_dict_append_basic(dict, "Phase2",
3267                                         DBUS_TYPE_STRING, &str);
3268
3269                 str = connman_network_get_string(network, "WiFi.Identity");
3270                 if (str != NULL)
3271                         connman_dbus_dict_append_basic(dict, "Identity",
3272                                         DBUS_TYPE_STRING, &str);
3273
3274                 str = connman_network_get_string(network, "WiFi.CACertFile");
3275                 if (str != NULL)
3276                         connman_dbus_dict_append_basic(dict, "CACertFile",
3277                                         DBUS_TYPE_STRING, &str);
3278
3279                 str = connman_network_get_string(network,
3280                                 "WiFi.ClientCertFile");
3281                 if (str != NULL)
3282                         connman_dbus_dict_append_basic(dict, "ClientCertFile",
3283                                         DBUS_TYPE_STRING, &str);
3284
3285                 str = connman_network_get_string(network,
3286                                 "WiFi.PrivateKeyFile");
3287                 if (str != NULL)
3288                         connman_dbus_dict_append_basic(dict, "PrivateKeyFile",
3289                                         DBUS_TYPE_STRING, &str);
3290         }
3291 }
3292 #endif
3293
3294 static void append_properties(DBusMessageIter *dict, dbus_bool_t limited,
3295                                         struct connman_service *service)
3296 {
3297         dbus_bool_t val;
3298         const char *str;
3299         GSList *list;
3300
3301 #if defined TIZEN_EXT
3302         unsigned int frequency = 0U;
3303         if (service && service->network) {
3304                 frequency = connman_network_get_frequency(service->network);
3305                 connman_dbus_dict_append_basic(dict, "Frequency",
3306                                 DBUS_TYPE_UINT16, &frequency);
3307         }
3308
3309         unsigned char *wifi_vsie;
3310         unsigned int wifi_vsie_len;
3311         GSList *vsie_list = NULL;
3312
3313         if (service->network)
3314                 vsie_list = (GSList *)connman_network_get_vsie_list(service->network);
3315
3316         if (vsie_list) {
3317                 DBG("ConnMan, service->path=%s No.of elements in list: %d", service->path, g_slist_length(vsie_list));
3318                 GSList *list;
3319                 for (list = vsie_list; list; list = list->next) {
3320                         wifi_vsie = (unsigned char *)list->data;
3321                         wifi_vsie_len = wifi_vsie[1] + 2;
3322
3323                         connman_dbus_dict_append_fixed_array(dict, "Vsie", DBUS_TYPE_BYTE,
3324                                         &wifi_vsie, wifi_vsie_len);
3325                 }
3326         }
3327 #endif
3328
3329         str = __connman_service_type2string(service->type);
3330         if (str)
3331                 connman_dbus_dict_append_basic(dict, "Type",
3332                                                 DBUS_TYPE_STRING, &str);
3333
3334         connman_dbus_dict_append_array(dict, "Security",
3335                                 DBUS_TYPE_STRING, append_security, service);
3336
3337         str = state2string(service->state);
3338         if (str)
3339                 connman_dbus_dict_append_basic(dict, "State",
3340                                                 DBUS_TYPE_STRING, &str);
3341
3342 #ifdef TIZEN_EXT
3343         str = state2string(service->state_ipv6);
3344         if (str != NULL)
3345                 connman_dbus_dict_append_basic(dict, "StateIPv6",
3346                                 DBUS_TYPE_STRING, &str);
3347 #endif
3348
3349         str = error2string(service->error);
3350         if (str)
3351                 connman_dbus_dict_append_basic(dict, "Error",
3352                                                 DBUS_TYPE_STRING, &str);
3353
3354         if (service->strength > 0)
3355                 connman_dbus_dict_append_basic(dict, "Strength",
3356                                         DBUS_TYPE_BYTE, &service->strength);
3357
3358         val = service->favorite;
3359         connman_dbus_dict_append_basic(dict, "Favorite",
3360                                         DBUS_TYPE_BOOLEAN, &val);
3361
3362         val = service->immutable;
3363         connman_dbus_dict_append_basic(dict, "Immutable",
3364                                         DBUS_TYPE_BOOLEAN, &val);
3365
3366         if (service->favorite)
3367                 val = service->autoconnect;
3368         else
3369                 val = service->favorite;
3370
3371         connman_dbus_dict_append_basic(dict, "AutoConnect",
3372                                 DBUS_TYPE_BOOLEAN, &val);
3373
3374         if (service->name)
3375                 connman_dbus_dict_append_basic(dict, "Name",
3376                                         DBUS_TYPE_STRING, &service->name);
3377
3378         switch (service->type) {
3379         case CONNMAN_SERVICE_TYPE_UNKNOWN:
3380         case CONNMAN_SERVICE_TYPE_SYSTEM:
3381         case CONNMAN_SERVICE_TYPE_GPS:
3382         case CONNMAN_SERVICE_TYPE_VPN:
3383         case CONNMAN_SERVICE_TYPE_P2P:
3384                 break;
3385         case CONNMAN_SERVICE_TYPE_CELLULAR:
3386                 val = service->roaming;
3387                 connman_dbus_dict_append_basic(dict, "Roaming",
3388                                         DBUS_TYPE_BOOLEAN, &val);
3389
3390                 connman_dbus_dict_append_dict(dict, "Ethernet",
3391                                                 append_ethernet, service);
3392                 break;
3393         case CONNMAN_SERVICE_TYPE_WIFI:
3394 #if defined TIZEN_EXT
3395                 if (service->network != NULL)
3396                         append_wifi_ext_info(dict, service->network);
3397
3398                 connman_dbus_dict_append_dict(dict, "Ethernet",
3399                                                 append_ethernet, service);
3400
3401                 connman_dbus_dict_append_basic(dict, "DisconnectReason",
3402                                 DBUS_TYPE_INT32, &service->disconnect_reason);
3403
3404                 connman_dbus_dict_append_basic(dict, "AssocStatusCode",
3405                                 DBUS_TYPE_INT32, &service->assoc_status_code);
3406
3407                 break;
3408 #endif
3409         case CONNMAN_SERVICE_TYPE_ETHERNET:
3410         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
3411         case CONNMAN_SERVICE_TYPE_GADGET:
3412                 connman_dbus_dict_append_dict(dict, "Ethernet",
3413                                                 append_ethernet, service);
3414                 break;
3415         }
3416
3417         connman_dbus_dict_append_dict(dict, "IPv4", append_ipv4, service);
3418
3419         connman_dbus_dict_append_dict(dict, "IPv4.Configuration",
3420                                                 append_ipv4config, service);
3421
3422         connman_dbus_dict_append_dict(dict, "IPv6", append_ipv6, service);
3423
3424         connman_dbus_dict_append_dict(dict, "IPv6.Configuration",
3425                                                 append_ipv6config, service);
3426
3427         connman_dbus_dict_append_array(dict, "Nameservers",
3428                                 DBUS_TYPE_STRING, append_dns, service);
3429
3430         connman_dbus_dict_append_array(dict, "Nameservers.Configuration",
3431                                 DBUS_TYPE_STRING, append_dnsconfig, service);
3432
3433         if (service->state == CONNMAN_SERVICE_STATE_READY ||
3434                         service->state == CONNMAN_SERVICE_STATE_ONLINE)
3435                 list = __connman_timeserver_get_all(service);
3436         else
3437                 list = NULL;
3438
3439         connman_dbus_dict_append_array(dict, "Timeservers",
3440                                 DBUS_TYPE_STRING, append_ts, list);
3441
3442         g_slist_free_full(list, g_free);
3443
3444         connman_dbus_dict_append_array(dict, "Timeservers.Configuration",
3445                                 DBUS_TYPE_STRING, append_tsconfig, service);
3446
3447         connman_dbus_dict_append_array(dict, "Domains",
3448                                 DBUS_TYPE_STRING, append_domain, service);
3449
3450         connman_dbus_dict_append_array(dict, "Domains.Configuration",
3451                                 DBUS_TYPE_STRING, append_domainconfig, service);
3452
3453         connman_dbus_dict_append_dict(dict, "Proxy", append_proxy, service);
3454
3455         connman_dbus_dict_append_dict(dict, "Proxy.Configuration",
3456                                                 append_proxyconfig, service);
3457
3458         connman_dbus_dict_append_dict(dict, "Provider",
3459                                                 append_provider, service);
3460 }
3461
3462 static void append_struct_service(DBusMessageIter *iter,
3463                 connman_dbus_append_cb_t function,
3464                 struct connman_service *service)
3465 {
3466         DBusMessageIter entry, dict;
3467
3468         dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &entry);
3469
3470         dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
3471                                                         &service->path);
3472
3473         connman_dbus_dict_open(&entry, &dict);
3474         if (function)
3475                 function(&dict, service);
3476         connman_dbus_dict_close(&entry, &dict);
3477
3478         dbus_message_iter_close_container(iter, &entry);
3479 }
3480
3481 static void append_dict_properties(DBusMessageIter *dict, void *user_data)
3482 {
3483         struct connman_service *service = user_data;
3484
3485         append_properties(dict, TRUE, service);
3486 }
3487
3488 static void append_struct(gpointer value, gpointer user_data)
3489 {
3490         struct connman_service *service = value;
3491         DBusMessageIter *iter = user_data;
3492
3493         if (!service->path)
3494                 return;
3495
3496         append_struct_service(iter, append_dict_properties, service);
3497 }
3498
3499 void __connman_service_list_struct(DBusMessageIter *iter)
3500 {
3501         g_list_foreach(service_list, append_struct, iter);
3502 }
3503
3504 bool __connman_service_is_hidden(struct connman_service *service)
3505 {
3506         return service->hidden;
3507 }
3508
3509 bool
3510 __connman_service_is_split_routing(struct connman_service *service)
3511 {
3512         return service->do_split_routing;
3513 }
3514
3515 bool __connman_service_index_is_split_routing(int index)
3516 {
3517         struct connman_service *service;
3518
3519         if (index < 0)
3520                 return false;
3521
3522         service = __connman_service_lookup_from_index(index);
3523         if (!service)
3524                 return false;
3525
3526         return __connman_service_is_split_routing(service);
3527 }
3528
3529 int __connman_service_get_index(struct connman_service *service)
3530 {
3531         if (!service)
3532                 return -1;
3533
3534         if (service->network)
3535                 return connman_network_get_index(service->network);
3536         else if (service->provider)
3537                 return connman_provider_get_index(service->provider);
3538
3539         return -1;
3540 }
3541
3542 void __connman_service_set_hidden(struct connman_service *service)
3543 {
3544         if (!service || service->hidden)
3545                 return;
3546
3547         service->hidden_service = true;
3548 }
3549
3550 void __connman_service_set_hostname(struct connman_service *service,
3551                                                 const char *hostname)
3552 {
3553         if (!service || service->hidden)
3554                 return;
3555
3556         g_free(service->hostname);
3557         service->hostname = g_strdup(hostname);
3558 }
3559
3560 const char *__connman_service_get_hostname(struct connman_service *service)
3561 {
3562         if (!service)
3563                 return NULL;
3564
3565         return service->hostname;
3566 }
3567
3568 void __connman_service_set_domainname(struct connman_service *service,
3569                                                 const char *domainname)
3570 {
3571         if (!service || service->hidden)
3572                 return;
3573
3574         g_free(service->domainname);
3575         service->domainname = g_strdup(domainname);
3576
3577         domain_changed(service);
3578 }
3579
3580 const char *connman_service_get_domainname(struct connman_service *service)
3581 {
3582         if (!service)
3583                 return NULL;
3584
3585         if (service->domains)
3586                 return service->domains[0];
3587         else
3588                 return service->domainname;
3589 }
3590
3591 char **connman_service_get_nameservers(struct connman_service *service)
3592 {
3593         if (!service)
3594                 return NULL;
3595
3596         if (service->nameservers_config)
3597                 return g_strdupv(service->nameservers_config);
3598         else if (service->nameservers ||
3599                                         service->nameservers_auto) {
3600                 int len = 0, len_auto = 0, i;
3601                 char **nameservers;
3602
3603                 if (service->nameservers)
3604                         len = g_strv_length(service->nameservers);
3605                 if (service->nameservers_auto)
3606                         len_auto = g_strv_length(service->nameservers_auto);
3607
3608                 nameservers = g_try_new0(char *, len + len_auto + 1);
3609                 if (!nameservers)
3610                         return NULL;
3611
3612                 for (i = 0; i < len; i++)
3613                         nameservers[i] = g_strdup(service->nameservers[i]);
3614
3615                 for (i = 0; i < len_auto; i++)
3616                         nameservers[i + len] =
3617                                 g_strdup(service->nameservers_auto[i]);
3618
3619                 return nameservers;
3620         }
3621
3622         return g_strdupv(connman_setting_get_string_list("FallbackNameservers"));
3623 }
3624
3625 char **connman_service_get_timeservers_config(struct connman_service *service)
3626 {
3627         if (!service)
3628                 return NULL;
3629
3630         return service->timeservers_config;
3631 }
3632
3633 char **connman_service_get_timeservers(struct connman_service *service)
3634 {
3635         if (!service)
3636                 return NULL;
3637
3638         return service->timeservers;
3639 }
3640
3641 #if defined TIZEN_EXT
3642 /*
3643  * Description: Telephony plug-in requires manual PROXY setting function
3644  */
3645 int connman_service_set_proxy(struct connman_service *service,
3646                                         const char *proxy, gboolean active)
3647 {
3648         char **proxies_array = NULL;
3649
3650         if (service == NULL)
3651                 return -EINVAL;
3652
3653         switch (service->type) {
3654         case CONNMAN_SERVICE_TYPE_CELLULAR:
3655         case CONNMAN_SERVICE_TYPE_ETHERNET:
3656         case CONNMAN_SERVICE_TYPE_WIFI:
3657                 break;
3658
3659         default:
3660                 return -EINVAL;
3661         }
3662
3663         g_strfreev(service->proxies);
3664         service->proxies = NULL;
3665
3666         if (proxy != NULL)
3667                 proxies_array = g_strsplit(proxy, " ", 0);
3668
3669         service->proxies = proxies_array;
3670
3671         if (proxy == NULL) {
3672                 service->proxy_config = CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
3673                 DBG("proxy changed (%d)", active);
3674         } else {
3675                 service->proxy_config = CONNMAN_SERVICE_PROXY_METHOD_MANUAL;
3676                 DBG("proxy chagned %s (%d)", proxy, active);
3677         }
3678
3679         if (active == TRUE) {
3680                 proxy_changed(service);
3681
3682                 __connman_notifier_proxy_changed(service);
3683         }
3684
3685         return 0;
3686 }
3687 #endif
3688
3689 void connman_service_set_proxy_method(struct connman_service *service,
3690                                         enum connman_service_proxy_method method)
3691 {
3692         if (!service || service->hidden)
3693                 return;
3694
3695         service->proxy = method;
3696
3697         proxy_changed(service);
3698
3699         if (method != CONNMAN_SERVICE_PROXY_METHOD_AUTO)
3700                 __connman_notifier_proxy_changed(service);
3701 }
3702
3703 enum connman_service_proxy_method connman_service_get_proxy_method(
3704                                         struct connman_service *service)
3705 {
3706         if (!service)
3707                 return CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
3708
3709         if (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN) {
3710                 if (service->proxy_config == CONNMAN_SERVICE_PROXY_METHOD_AUTO &&
3711                                 !service->pac)
3712                         return service->proxy;
3713
3714                 return service->proxy_config;
3715         }
3716
3717         return service->proxy;
3718 }
3719
3720 char **connman_service_get_proxy_servers(struct connman_service *service)
3721 {
3722         return g_strdupv(service->proxies);
3723 }
3724
3725 char **connman_service_get_proxy_excludes(struct connman_service *service)
3726 {
3727         return g_strdupv(service->excludes);
3728 }
3729
3730 const char *connman_service_get_proxy_url(struct connman_service *service)
3731 {
3732         if (!service)
3733                 return NULL;
3734
3735         return service->pac;
3736 }
3737
3738 void __connman_service_set_proxy_autoconfig(struct connman_service *service,
3739                                                         const char *url)
3740 {
3741         if (!service || service->hidden)
3742                 return;
3743
3744         service->proxy = CONNMAN_SERVICE_PROXY_METHOD_AUTO;
3745
3746         if (service->ipconfig_ipv4) {
3747                 if (__connman_ipconfig_set_proxy_autoconfig(
3748                             service->ipconfig_ipv4, url) < 0)
3749                         return;
3750         } else if (service->ipconfig_ipv6) {
3751                 if (__connman_ipconfig_set_proxy_autoconfig(
3752                             service->ipconfig_ipv6, url) < 0)
3753                         return;
3754         } else
3755                 return;
3756
3757         proxy_changed(service);
3758
3759         __connman_notifier_proxy_changed(service);
3760 }
3761
3762 const char *connman_service_get_proxy_autoconfig(struct connman_service *service)
3763 {
3764         if (!service)
3765                 return NULL;
3766
3767         if (service->ipconfig_ipv4)
3768                 return __connman_ipconfig_get_proxy_autoconfig(
3769                                                 service->ipconfig_ipv4);
3770         else if (service->ipconfig_ipv6)
3771                 return __connman_ipconfig_get_proxy_autoconfig(
3772                                                 service->ipconfig_ipv6);
3773         return NULL;
3774 }
3775
3776 #if defined TIZEN_EXT
3777 int connman_service_get_ipv6_dns_method(struct connman_service *service)
3778 {
3779         if (!service) {
3780                 DBG("Service is NULL");
3781                 return -1;
3782         }
3783
3784         return service->dns_config_method_ipv6;
3785 }
3786 #endif
3787
3788 void __connman_service_set_timeservers(struct connman_service *service,
3789                                 char **timeservers)
3790 {
3791         int i;
3792
3793         if (!service)
3794                 return;
3795
3796         g_strfreev(service->timeservers);
3797         service->timeservers = NULL;
3798
3799         for (i = 0; timeservers && timeservers[i]; i++)
3800                 __connman_service_timeserver_append(service, timeservers[i]);
3801 }
3802
3803 int __connman_service_timeserver_append(struct connman_service *service,
3804                                                 const char *timeserver)
3805 {
3806         int len;
3807
3808         DBG("service %p timeserver %s", service, timeserver);
3809
3810         if (!timeserver)
3811                 return -EINVAL;
3812
3813         if (service->timeservers) {
3814                 int i;
3815
3816                 for (i = 0; service->timeservers[i]; i++)
3817                         if (g_strcmp0(service->timeservers[i], timeserver) == 0)
3818                                 return -EEXIST;
3819
3820                 len = g_strv_length(service->timeservers);
3821                 service->timeservers = g_try_renew(char *, service->timeservers,
3822                                                         len + 2);
3823         } else {
3824                 len = 0;
3825                 service->timeservers = g_try_new0(char *, len + 2);
3826         }
3827
3828         if (!service->timeservers)
3829                 return -ENOMEM;
3830
3831         service->timeservers[len] = g_strdup(timeserver);
3832         service->timeservers[len + 1] = NULL;
3833
3834         return 0;
3835 }
3836
3837 int __connman_service_timeserver_remove(struct connman_service *service,
3838                                                 const char *timeserver)
3839 {
3840         char **servers;
3841         int len, i, j, found = 0;
3842
3843         DBG("service %p timeserver %s", service, timeserver);
3844
3845         if (!timeserver)
3846                 return -EINVAL;
3847
3848         if (!service->timeservers)
3849                 return 0;
3850
3851         for (i = 0; service->timeservers &&
3852                                         service->timeservers[i]; i++)
3853                 if (g_strcmp0(service->timeservers[i], timeserver) == 0) {
3854                         found = 1;
3855                         break;
3856                 }
3857
3858         if (found == 0)
3859                 return 0;
3860
3861         len = g_strv_length(service->timeservers);
3862
3863         if (len == 1) {
3864                 g_strfreev(service->timeservers);
3865                 service->timeservers = NULL;
3866
3867                 return 0;
3868         }
3869
3870         servers = g_try_new0(char *, len);
3871         if (!servers)
3872                 return -ENOMEM;
3873
3874         for (i = 0, j = 0; i < len; i++) {
3875                 if (g_strcmp0(service->timeservers[i], timeserver) != 0) {
3876                         servers[j] = g_strdup(service->timeservers[i]);
3877                         if (!servers[j])
3878                                 return -ENOMEM;
3879                         j++;
3880                 }
3881         }
3882         servers[len - 1] = NULL;
3883
3884         g_strfreev(service->timeservers);
3885         service->timeservers = servers;
3886
3887         return 0;
3888 }
3889
3890 void __connman_service_timeserver_changed(struct connman_service *service,
3891                 GSList *ts_list)
3892 {
3893         if (!service)
3894                 return;
3895
3896         if (!allow_property_changed(service))
3897                 return;
3898
3899         connman_dbus_property_changed_array(service->path,
3900                         CONNMAN_SERVICE_INTERFACE, "Timeservers",
3901                         DBUS_TYPE_STRING, append_ts, ts_list);
3902 }
3903
3904 void __connman_service_set_pac(struct connman_service *service,
3905                                         const char *pac)
3906 {
3907         if (service->hidden)
3908                 return;
3909         g_free(service->pac);
3910         service->pac = g_strdup(pac);
3911
3912         proxy_changed(service);
3913 }
3914
3915 #if defined TIZEN_EXT
3916 void __connman_service_set_proxy(struct connman_service *service,
3917                                        const char *proxies)
3918 {
3919        char **proxies_array = NULL;
3920
3921        g_strfreev(service->proxies);
3922        service->proxies = NULL;
3923
3924        if (proxies != NULL)
3925                proxies_array = g_strsplit(proxies, " ", 0);
3926
3927        service->proxies = proxies_array;
3928 }
3929 #endif
3930
3931 void __connman_service_set_identity(struct connman_service *service,
3932                                         const char *identity)
3933 {
3934         if (service->immutable || service->hidden)
3935                 return;
3936
3937         g_free(service->identity);
3938         service->identity = g_strdup(identity);
3939
3940         if (service->network)
3941                 connman_network_set_string(service->network,
3942                                         "WiFi.Identity",
3943                                         service->identity);
3944 }
3945
3946 void __connman_service_set_anonymous_identity(struct connman_service *service,
3947                                                 const char *anonymous_identity)
3948 {
3949         if (service->immutable || service->hidden)
3950                 return;
3951
3952         g_free(service->anonymous_identity);
3953         service->anonymous_identity = g_strdup(anonymous_identity);
3954
3955         if (service->network)
3956                 connman_network_set_string(service->network,
3957                                         "WiFi.AnonymousIdentity",
3958                                         service->anonymous_identity);
3959 }
3960
3961 void __connman_service_set_subject_match(struct connman_service *service,
3962                                                 const char *subject_match)
3963 {
3964         if (service->immutable || service->hidden)
3965                 return;
3966
3967         g_free(service->subject_match);
3968         service->subject_match = g_strdup(subject_match);
3969
3970         if (service->network)
3971                 connman_network_set_string(service->network,
3972                                         "WiFi.SubjectMatch",
3973                                         service->subject_match);
3974 }
3975
3976 void __connman_service_set_altsubject_match(struct connman_service *service,
3977                                                 const char *altsubject_match)
3978 {
3979         if (service->immutable || service->hidden)
3980                 return;
3981
3982         g_free(service->altsubject_match);
3983         service->altsubject_match = g_strdup(altsubject_match);
3984
3985         if (service->network)
3986                 connman_network_set_string(service->network,
3987                                         "WiFi.AltSubjectMatch",
3988                                         service->altsubject_match);
3989 }
3990
3991 void __connman_service_set_domain_suffix_match(struct connman_service *service,
3992                                                 const char *domain_suffix_match)
3993 {
3994         if (service->immutable || service->hidden)
3995                 return;
3996
3997         g_free(service->domain_suffix_match);
3998         service->domain_suffix_match = g_strdup(domain_suffix_match);
3999
4000         if (service->network)
4001                 connman_network_set_string(service->network,
4002                                         "WiFi.DomainSuffixMatch",
4003                                         service->domain_suffix_match);
4004 }
4005
4006 void __connman_service_set_domain_match(struct connman_service *service,
4007                                                 const char *domain_match)
4008 {
4009         if (service->immutable || service->hidden)
4010                 return;
4011
4012         g_free(service->domain_match);
4013         service->domain_match = g_strdup(domain_match);
4014
4015         if (service->network)
4016                 connman_network_set_string(service->network,
4017                                         "WiFi.DomainMatch",
4018                                         service->domain_match);
4019 }
4020
4021 void __connman_service_set_agent_identity(struct connman_service *service,
4022                                                 const char *agent_identity)
4023 {
4024         if (service->hidden)
4025                 return;
4026         g_free(service->agent_identity);
4027         service->agent_identity = g_strdup(agent_identity);
4028
4029         if (service->network)
4030                 connman_network_set_string(service->network,
4031                                         "WiFi.AgentIdentity",
4032                                         service->agent_identity);
4033 }
4034
4035 int __connman_service_check_passphrase(enum connman_service_security security,
4036                 const char *passphrase)
4037 {
4038         guint i;
4039         gsize length;
4040
4041         if (!passphrase)
4042                 return 0;
4043
4044         length = strlen(passphrase);
4045
4046         switch (security) {
4047         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
4048         case CONNMAN_SERVICE_SECURITY_NONE:
4049         case CONNMAN_SERVICE_SECURITY_WPA:
4050 #if !defined TIZEN_EXT
4051         case CONNMAN_SERVICE_SECURITY_RSN:
4052 #endif
4053
4054                 DBG("service security '%s' (%d) not handled",
4055                                 security2string(security), security);
4056
4057                 return -EOPNOTSUPP;
4058
4059         case CONNMAN_SERVICE_SECURITY_PSK:
4060 #if defined TIZEN_EXT
4061         case CONNMAN_SERVICE_SECURITY_RSN:
4062 #endif
4063                 /* A raw key is always 64 bytes length,
4064                  * its content is in hex representation.
4065                  * A PSK key must be between [8..63].
4066                  */
4067                 if (length == 64) {
4068                         for (i = 0; i < 64; i++)
4069                                 if (!isxdigit((unsigned char)
4070                                               passphrase[i]))
4071                                         return -ENOKEY;
4072                 } else if (length < 8 || length > 63)
4073                         return -ENOKEY;
4074                 break;
4075         case CONNMAN_SERVICE_SECURITY_WEP:
4076                 /* length of WEP key is 10 or 26
4077                  * length of WEP passphrase is 5 or 13
4078                  */
4079                 if (length == 10 || length == 26) {
4080                         for (i = 0; i < length; i++)
4081                                 if (!isxdigit((unsigned char)
4082                                               passphrase[i]))
4083                                         return -ENOKEY;
4084                 } else if (length != 5 && length != 13)
4085                         return -ENOKEY;
4086                 break;
4087
4088         case CONNMAN_SERVICE_SECURITY_8021X:
4089                 break;
4090         }
4091
4092         return 0;
4093 }
4094
4095 int __connman_service_set_passphrase(struct connman_service *service,
4096                                         const char *passphrase)
4097 {
4098         int err;
4099
4100         if (service->hidden)
4101                 return -EINVAL;
4102
4103         if (service->immutable &&
4104                         service->security != CONNMAN_SERVICE_SECURITY_8021X)
4105                 return -EINVAL;
4106 #if defined TIZEN_EXT
4107         /* The encrypted passphrase is used here
4108          * and validation is done by net-config before being encrypted.
4109          */
4110         err = 0;
4111         if (service->security != CONNMAN_SERVICE_SECURITY_PSK &&
4112                         service->security != CONNMAN_SERVICE_SECURITY_RSN &&
4113                         service->security != CONNMAN_SERVICE_SECURITY_WEP)
4114 #endif
4115         err = __connman_service_check_passphrase(service->security, passphrase);
4116
4117         if (err < 0)
4118                 return err;
4119
4120         g_free(service->passphrase);
4121         service->passphrase = g_strdup(passphrase);
4122
4123         if (service->network)
4124                 connman_network_set_string(service->network, "WiFi.Passphrase",
4125                                 service->passphrase);
4126
4127         return 0;
4128 }
4129
4130 const char *__connman_service_get_passphrase(struct connman_service *service)
4131 {
4132         if (!service)
4133                 return NULL;
4134
4135         return service->passphrase;
4136 }
4137
4138 static DBusMessage *get_properties(DBusConnection *conn,
4139                                         DBusMessage *msg, void *user_data)
4140 {
4141         struct connman_service *service = user_data;
4142         DBusMessage *reply;
4143         DBusMessageIter array, dict;
4144
4145         reply = dbus_message_new_method_return(msg);
4146         if (!reply)
4147                 return NULL;
4148
4149         dbus_message_iter_init_append(reply, &array);
4150
4151         connman_dbus_dict_open(&array, &dict);
4152         append_properties(&dict, FALSE, service);
4153         connman_dbus_dict_close(&array, &dict);
4154
4155         return reply;
4156 }
4157
4158 static char **remove_empty_strings(char **strv)
4159 {
4160         int index = 0;
4161         char **iter = strv;
4162
4163         while (*iter) {
4164                 if (**iter)
4165                         strv[index++] = *iter;
4166                 else
4167                         g_free(*iter);
4168                 iter++;
4169         }
4170
4171         strv[index] = NULL;
4172         return strv;
4173 }
4174
4175 static int update_proxy_configuration(struct connman_service *service,
4176                                 DBusMessageIter *array)
4177 {
4178         DBusMessageIter dict;
4179         enum connman_service_proxy_method method;
4180         GString *servers_str = NULL;
4181         GString *excludes_str = NULL;
4182         const char *url = NULL;
4183
4184         method = CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
4185
4186         dbus_message_iter_recurse(array, &dict);
4187
4188         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
4189                 DBusMessageIter entry, variant;
4190                 const char *key;
4191                 int type;
4192
4193                 dbus_message_iter_recurse(&dict, &entry);
4194
4195                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
4196                         goto error;
4197
4198                 dbus_message_iter_get_basic(&entry, &key);
4199                 dbus_message_iter_next(&entry);
4200
4201                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
4202                         goto error;
4203
4204                 dbus_message_iter_recurse(&entry, &variant);
4205
4206                 type = dbus_message_iter_get_arg_type(&variant);
4207
4208                 if (g_str_equal(key, "Method")) {
4209                         const char *val;
4210
4211                         if (type != DBUS_TYPE_STRING)
4212                                 goto error;
4213
4214                         dbus_message_iter_get_basic(&variant, &val);
4215                         method = string2proxymethod(val);
4216                 } else if (g_str_equal(key, "URL")) {
4217                         if (type != DBUS_TYPE_STRING)
4218                                 goto error;
4219
4220                         dbus_message_iter_get_basic(&variant, &url);
4221                 } else if (g_str_equal(key, "Servers")) {
4222                         DBusMessageIter str_array;
4223
4224                         if (type != DBUS_TYPE_ARRAY)
4225                                 goto error;
4226
4227                         servers_str = g_string_new(NULL);
4228                         if (!servers_str)
4229                                 goto error;
4230
4231                         dbus_message_iter_recurse(&variant, &str_array);
4232
4233                         while (dbus_message_iter_get_arg_type(&str_array) ==
4234                                                         DBUS_TYPE_STRING) {
4235                                 char *val = NULL;
4236
4237                                 dbus_message_iter_get_basic(&str_array, &val);
4238
4239                                 if (servers_str->len > 0)
4240                                         g_string_append_printf(servers_str,
4241                                                         " %s", val);
4242                                 else
4243                                         g_string_append(servers_str, val);
4244
4245                                 dbus_message_iter_next(&str_array);
4246                         }
4247                 } else if (g_str_equal(key, "Excludes")) {
4248                         DBusMessageIter str_array;
4249
4250                         if (type != DBUS_TYPE_ARRAY)
4251                                 goto error;
4252
4253                         excludes_str = g_string_new(NULL);
4254                         if (!excludes_str)
4255                                 goto error;
4256
4257                         dbus_message_iter_recurse(&variant, &str_array);
4258
4259                         while (dbus_message_iter_get_arg_type(&str_array) ==
4260                                                         DBUS_TYPE_STRING) {
4261                                 char *val = NULL;
4262
4263                                 dbus_message_iter_get_basic(&str_array, &val);
4264
4265                                 if (excludes_str->len > 0)
4266                                         g_string_append_printf(excludes_str,
4267                                                         " %s", val);
4268                                 else
4269                                         g_string_append(excludes_str, val);
4270
4271                                 dbus_message_iter_next(&str_array);
4272                         }
4273                 }
4274
4275                 dbus_message_iter_next(&dict);
4276         }
4277
4278         switch (method) {
4279         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
4280                 break;
4281         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
4282                 if (!servers_str && !service->proxies)
4283                         goto error;
4284
4285                 if (servers_str) {
4286                         g_strfreev(service->proxies);
4287
4288                         if (servers_str->len > 0) {
4289                                 char **proxies = g_strsplit_set(
4290                                         servers_str->str, " ", 0);
4291                                 proxies = remove_empty_strings(proxies);
4292                                 service->proxies = proxies;
4293                         } else
4294                                 service->proxies = NULL;
4295                 }
4296
4297                 if (excludes_str) {
4298                         g_strfreev(service->excludes);
4299
4300                         if (excludes_str->len > 0) {
4301                                 char **excludes = g_strsplit_set(
4302                                         excludes_str->str, " ", 0);
4303                                 excludes = remove_empty_strings(excludes);
4304                                 service->excludes = excludes;
4305                         } else
4306                                 service->excludes = NULL;
4307                 }
4308
4309                 if (!service->proxies)
4310                         method = CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
4311
4312                 break;
4313         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
4314                 g_free(service->pac);
4315
4316                 if (url && strlen(url) > 0)
4317                         service->pac = g_strstrip(g_strdup(url));
4318                 else
4319                         service->pac = NULL;
4320
4321                 /* if we are connected:
4322                    - if service->pac == NULL
4323                    - if __connman_ipconfig_get_proxy_autoconfig(
4324                    service->ipconfig) == NULL
4325                    --> We should start WPAD */
4326
4327                 break;
4328         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
4329                 goto error;
4330         }
4331
4332         if (servers_str)
4333                 g_string_free(servers_str, TRUE);
4334
4335         if (excludes_str)
4336                 g_string_free(excludes_str, TRUE);
4337
4338         service->proxy_config = method;
4339
4340         return 0;
4341
4342 error:
4343         if (servers_str)
4344                 g_string_free(servers_str, TRUE);
4345
4346         if (excludes_str)
4347                 g_string_free(excludes_str, TRUE);
4348
4349         return -EINVAL;
4350 }
4351
4352 int __connman_service_reset_ipconfig(struct connman_service *service,
4353                 enum connman_ipconfig_type type, DBusMessageIter *array,
4354                 enum connman_service_state *new_state)
4355 {
4356         struct connman_ipconfig *ipconfig, *new_ipconfig;
4357         enum connman_ipconfig_method old_method, new_method;
4358         enum connman_service_state state;
4359         int err = 0, index;
4360
4361         if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
4362                 ipconfig = service->ipconfig_ipv4;
4363                 state = service->state_ipv4;
4364                 new_method = CONNMAN_IPCONFIG_METHOD_DHCP;
4365         } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
4366                 ipconfig = service->ipconfig_ipv6;
4367                 state = service->state_ipv6;
4368                 new_method = CONNMAN_IPCONFIG_METHOD_AUTO;
4369         } else
4370                 return -EINVAL;
4371
4372         if (!ipconfig)
4373                 return -ENXIO;
4374
4375         old_method = __connman_ipconfig_get_method(ipconfig);
4376         index = __connman_ipconfig_get_index(ipconfig);
4377
4378         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
4379                 new_ipconfig = create_ip4config(service, index,
4380                                 CONNMAN_IPCONFIG_METHOD_UNKNOWN);
4381         else
4382                 new_ipconfig = create_ip6config(service, index);
4383
4384         if (array) {
4385                 err = __connman_ipconfig_set_config(new_ipconfig, array);
4386                 if (err < 0) {
4387                         __connman_ipconfig_unref(new_ipconfig);
4388                         return err;
4389                 }
4390
4391                 new_method = __connman_ipconfig_get_method(new_ipconfig);
4392         }
4393
4394         if (is_connecting(state) || is_connected(state))
4395                 __connman_network_clear_ipconfig(service->network, ipconfig);
4396
4397         __connman_ipconfig_unref(ipconfig);
4398
4399         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
4400                 service->ipconfig_ipv4 = new_ipconfig;
4401         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
4402                 service->ipconfig_ipv6 = new_ipconfig;
4403
4404         if (is_connecting(state) || is_connected(state))
4405                 __connman_ipconfig_enable(new_ipconfig);
4406
4407         if (new_state && new_method != old_method) {
4408                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
4409                         *new_state = service->state_ipv4;
4410                 else
4411                         *new_state = service->state_ipv6;
4412
4413                 settings_changed(service, new_ipconfig);
4414                 address_updated(service, new_method);
4415
4416                 __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
4417         }
4418
4419         DBG("err %d ipconfig %p type %d method %d state %s", err,
4420                 new_ipconfig, type, new_method,
4421                 !new_state  ? "-" : state2string(*new_state));
4422
4423         return err;
4424 }
4425
4426 static DBusMessage *set_property(DBusConnection *conn,
4427                                         DBusMessage *msg, void *user_data)
4428 {
4429         struct connman_service *service = user_data;
4430         DBusMessageIter iter, value;
4431         const char *name;
4432         int type;
4433
4434         DBG("service %p", service);
4435
4436         if (!dbus_message_iter_init(msg, &iter))
4437                 return __connman_error_invalid_arguments(msg);
4438
4439         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
4440                 return __connman_error_invalid_arguments(msg);
4441
4442         if (service->type == CONNMAN_SERVICE_TYPE_WIFI && is_connected(service->state)) {
4443                 uid_t uid;
4444                 if (connman_dbus_get_connection_unix_user_sync(conn,
4445                                                 dbus_message_get_sender(msg),
4446                                                 &uid) < 0) {
4447                         DBG("Can not get unix user id!");
4448                         return __connman_error_permission_denied(msg);
4449                 }
4450
4451                 if (!connman_service_is_user_allowed(service, uid)) {
4452                         DBG("Not allow this user to operate this wifi service now!");
4453                         return __connman_error_permission_denied(msg);
4454                 }
4455         }
4456
4457         dbus_message_iter_get_basic(&iter, &name);
4458         dbus_message_iter_next(&iter);
4459
4460         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
4461                 return __connman_error_invalid_arguments(msg);
4462
4463         dbus_message_iter_recurse(&iter, &value);
4464
4465         type = dbus_message_iter_get_arg_type(&value);
4466
4467         if (g_str_equal(name, "AutoConnect")) {
4468                 dbus_bool_t autoconnect;
4469
4470                 if (type != DBUS_TYPE_BOOLEAN)
4471                         return __connman_error_invalid_arguments(msg);
4472
4473                 if (!service->favorite)
4474                         return __connman_error_invalid_service(msg);
4475
4476                 dbus_message_iter_get_basic(&value, &autoconnect);
4477
4478                 if (service->autoconnect == autoconnect)
4479                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
4480
4481                 service->autoconnect = autoconnect;
4482
4483                 autoconnect_changed(service);
4484
4485                 if (autoconnect)
4486                         __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
4487
4488                 service_save(service);
4489         } else if (g_str_equal(name, "Nameservers.Configuration")) {
4490                 DBusMessageIter entry;
4491                 GString *str;
4492                 int index;
4493                 const char *gw;
4494 #if defined TIZEN_EXT
4495                 enum connman_ipconfig_type ip_type = CONNMAN_IPCONFIG_TYPE_ALL;
4496                 DBG("%s", name);
4497 #endif
4498
4499                 if (__connman_provider_is_immutable(service->provider) ||
4500                                 service->immutable)
4501                         return __connman_error_not_supported(msg);
4502
4503                 if (type != DBUS_TYPE_ARRAY)
4504                         return __connman_error_invalid_arguments(msg);
4505
4506                 str = g_string_new(NULL);
4507                 if (!str)
4508                         return __connman_error_invalid_arguments(msg);
4509
4510                 index = __connman_service_get_index(service);
4511                 gw = __connman_ipconfig_get_gateway_from_index(index,
4512                         CONNMAN_IPCONFIG_TYPE_ALL);
4513
4514 #if !defined TIZEN_EXT
4515                 if (gw && strlen(gw))
4516                         __connman_service_nameserver_del_routes(service,
4517                                                 CONNMAN_IPCONFIG_TYPE_ALL);
4518 #endif
4519                 dbus_message_iter_recurse(&value, &entry);
4520
4521 #if defined TIZEN_EXT
4522                 /* IPv4/IPv6 Last DNS config method */
4523                 int last_dns_ipv4 = service->dns_config_method_ipv4;
4524                 int last_dns_ipv6 = service->dns_config_method_ipv6;
4525                 DBG("Last DNS Config Method IPv4: %d IPv6: %d", last_dns_ipv4, last_dns_ipv6);
4526 #endif
4527
4528                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
4529                         const char *val;
4530                         dbus_message_iter_get_basic(&entry, &val);
4531                         dbus_message_iter_next(&entry);
4532 #ifdef TIZEN_EXT
4533                         /* First unpack the DNS Config Method */
4534                         DBG("DNS Config Method: %s", val);
4535                         if((g_strcmp0(val, "ipv4.manual") == 0)) {
4536                                 service->dns_config_method_ipv4 =
4537                                         CONNMAN_DNSCONFIG_METHOD_MANUAL;
4538
4539                                 if(last_dns_ipv4 != CONNMAN_DNSCONFIG_METHOD_MANUAL) {
4540                                         if(ip_type == CONNMAN_IPCONFIG_TYPE_UNKNOWN)
4541                                                 ip_type = CONNMAN_IPCONFIG_TYPE_IPV4;
4542                                         else
4543                                                 ip_type = CONNMAN_IPCONFIG_TYPE_ALL;
4544                                 }
4545                                 continue;
4546                         } else if(g_strcmp0(val, "ipv4.dhcp") == 0) {
4547                                 service->dns_config_method_ipv4 =
4548                                         CONNMAN_DNSCONFIG_METHOD_DHCP;
4549                                 if(last_dns_ipv4 == CONNMAN_DNSCONFIG_METHOD_MANUAL)
4550                                         ip_type = CONNMAN_IPCONFIG_TYPE_IPV4;
4551
4552                                 continue;
4553                         } else if(g_strcmp0(val, "ipv6.manual") == 0) {
4554                                 service->dns_config_method_ipv6 =
4555                                         CONNMAN_DNSCONFIG_METHOD_MANUAL;
4556                                 if(last_dns_ipv6 != CONNMAN_DNSCONFIG_METHOD_MANUAL) {
4557                                         if(ip_type == CONNMAN_IPCONFIG_TYPE_UNKNOWN)
4558                                                 ip_type = CONNMAN_IPCONFIG_TYPE_IPV6;
4559                                         else
4560                                                 ip_type = CONNMAN_IPCONFIG_TYPE_ALL;
4561                                 }
4562                                 continue;
4563                         } else if(g_strcmp0(val, "ipv6.dhcp") == 0) {
4564                                 service->dns_config_method_ipv6 =
4565                                         CONNMAN_DNSCONFIG_METHOD_DHCP;
4566                                 if(last_dns_ipv6 == CONNMAN_DNSCONFIG_METHOD_MANUAL)
4567                                         ip_type = CONNMAN_IPCONFIG_TYPE_IPV6;
4568
4569                                 continue;
4570                         }
4571 #endif
4572                         if (!val[0])
4573                                 continue;
4574
4575                         if (str->len > 0)
4576                                 g_string_append_printf(str, " %s", val);
4577                         else
4578                                 g_string_append(str, val);
4579                 }
4580
4581 #if defined TIZEN_EXT
4582                 if (service->dns_config_method_ipv4 == CONNMAN_DNSCONFIG_METHOD_DHCP &&
4583                         service->dns_config_method_ipv6 == CONNMAN_DNSCONFIG_METHOD_DHCP) {
4584                                         DBG("Both IPv4 and IPv6 DNS Method DHCP");
4585                                         ip_type = CONNMAN_IPCONFIG_TYPE_ALL;
4586                 }
4587                 if (gw && strlen(gw))
4588                         __connman_service_nameserver_del_routes(service,
4589                                                 ip_type);
4590
4591                 DBG("%s ip_type: %d nameserver remove all", name, ip_type);
4592                 nameserver_remove_all(service, ip_type);
4593 #else
4594                 nameserver_remove_all(service, CONNMAN_IPCONFIG_TYPE_ALL);
4595 #endif
4596                 g_strfreev(service->nameservers_config);
4597
4598                 if (str->len > 0) {
4599                         char **nameservers, **iter;
4600
4601                         nameservers = g_strsplit_set(str->str, " ", 0);
4602
4603                         for (iter = nameservers; *iter; iter++)
4604                                 if (connman_inet_check_ipaddress(*iter) <= 0)
4605                                         *iter[0] = '\0';
4606
4607                         nameservers = remove_empty_strings(nameservers);
4608                         service->nameservers_config = nameservers;
4609                 } else {
4610                         service->nameservers_config = NULL;
4611                 }
4612
4613                 g_string_free(str, TRUE);
4614
4615                 if (gw && strlen(gw))
4616                         __connman_service_nameserver_add_routes(service, gw);
4617
4618 #if defined TIZEN_EXT
4619                 DBG("%s ip_type: %d nameserver add all", name, ip_type);
4620                 nameserver_add_all(service, ip_type);
4621 #else
4622                 nameserver_add_all(service, CONNMAN_IPCONFIG_TYPE_ALL);
4623 #endif
4624                 dns_configuration_changed(service);
4625
4626                 if (__connman_service_is_connected_state(service,
4627                                                 CONNMAN_IPCONFIG_TYPE_IPV4))
4628                         __connman_wispr_start(service,
4629                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
4630
4631                 if (__connman_service_is_connected_state(service,
4632                                                 CONNMAN_IPCONFIG_TYPE_IPV6))
4633                         __connman_wispr_start(service,
4634                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
4635
4636                 service_save(service);
4637         } else if (g_str_equal(name, "Timeservers.Configuration")) {
4638                 DBusMessageIter entry;
4639                 GString *str;
4640
4641                 if (service->immutable)
4642                         return __connman_error_not_supported(msg);
4643
4644                 if (type != DBUS_TYPE_ARRAY)
4645                         return __connman_error_invalid_arguments(msg);
4646
4647                 str = g_string_new(NULL);
4648                 if (!str)
4649                         return __connman_error_invalid_arguments(msg);
4650
4651                 dbus_message_iter_recurse(&value, &entry);
4652
4653                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
4654                         const char *val;
4655                         dbus_message_iter_get_basic(&entry, &val);
4656                         dbus_message_iter_next(&entry);
4657
4658                         if (!val[0])
4659                                 continue;
4660
4661                         if (str->len > 0)
4662                                 g_string_append_printf(str, " %s", val);
4663                         else
4664                                 g_string_append(str, val);
4665                 }
4666
4667                 g_strfreev(service->timeservers_config);
4668                 service->timeservers_config = NULL;
4669
4670                 if (str->len > 0) {
4671                         char **timeservers = g_strsplit_set(str->str, " ", 0);
4672                         timeservers = remove_empty_strings(timeservers);
4673                         service->timeservers_config = timeservers;
4674                 } else
4675                         service->timeservers = NULL;
4676
4677                 g_string_free(str, TRUE);
4678
4679                 service_save(service);
4680                 timeservers_configuration_changed(service);
4681
4682                 if (service == __connman_service_get_default())
4683                         __connman_timeserver_sync(service);
4684
4685         } else if (g_str_equal(name, "Domains.Configuration")) {
4686                 DBusMessageIter entry;
4687                 GString *str;
4688
4689                 if (service->immutable)
4690                         return __connman_error_not_supported(msg);
4691
4692                 if (type != DBUS_TYPE_ARRAY)
4693                         return __connman_error_invalid_arguments(msg);
4694
4695                 str = g_string_new(NULL);
4696                 if (!str)
4697                         return __connman_error_invalid_arguments(msg);
4698
4699                 dbus_message_iter_recurse(&value, &entry);
4700
4701                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
4702                         const char *val;
4703                         dbus_message_iter_get_basic(&entry, &val);
4704                         dbus_message_iter_next(&entry);
4705
4706                         if (!val[0])
4707                                 continue;
4708
4709                         if (str->len > 0)
4710                                 g_string_append_printf(str, " %s", val);
4711                         else
4712                                 g_string_append(str, val);
4713                 }
4714
4715                 searchdomain_remove_all(service);
4716                 g_strfreev(service->domains);
4717
4718                 if (str->len > 0) {
4719                         char **domains = g_strsplit_set(str->str, " ", 0);
4720                         domains = remove_empty_strings(domains);
4721                         service->domains = domains;
4722                 } else
4723                         service->domains = NULL;
4724
4725                 g_string_free(str, TRUE);
4726
4727                 searchdomain_add_all(service);
4728                 domain_configuration_changed(service);
4729                 domain_changed(service);
4730
4731                 service_save(service);
4732         } else if (g_str_equal(name, "Proxy.Configuration")) {
4733                 int err;
4734
4735                 if (service->immutable)
4736                         return __connman_error_not_supported(msg);
4737
4738                 if (type != DBUS_TYPE_ARRAY)
4739                         return __connman_error_invalid_arguments(msg);
4740
4741                 err = update_proxy_configuration(service, &value);
4742
4743                 if (err < 0)
4744                         return __connman_error_failed(msg, -err);
4745
4746                 proxy_configuration_changed(service);
4747
4748                 __connman_notifier_proxy_changed(service);
4749
4750                 service_save(service);
4751         } else if (g_str_equal(name, "IPv4.Configuration") ||
4752                         g_str_equal(name, "IPv6.Configuration")) {
4753
4754                 enum connman_service_state state =
4755                                                 CONNMAN_SERVICE_STATE_UNKNOWN;
4756                 enum connman_ipconfig_type type =
4757                         CONNMAN_IPCONFIG_TYPE_UNKNOWN;
4758                 int err = 0;
4759
4760                 if (service->type == CONNMAN_SERVICE_TYPE_VPN ||
4761                                 service->immutable)
4762                         return __connman_error_not_supported(msg);
4763
4764                 DBG("%s", name);
4765
4766                 if (!service->ipconfig_ipv4 &&
4767                                         !service->ipconfig_ipv6)
4768                         return __connman_error_invalid_property(msg);
4769
4770                 if (g_str_equal(name, "IPv4.Configuration"))
4771                         type = CONNMAN_IPCONFIG_TYPE_IPV4;
4772                 else
4773                         type = CONNMAN_IPCONFIG_TYPE_IPV6;
4774
4775                 err = __connman_service_reset_ipconfig(service, type, &value,
4776                                                                 &state);
4777
4778                 if (err < 0) {
4779                         if (is_connected(state) || is_connecting(state)) {
4780                                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
4781                                         __connman_network_enable_ipconfig(service->network,
4782                                                         service->ipconfig_ipv4);
4783                                 else
4784                                         __connman_network_enable_ipconfig(service->network,
4785                                                         service->ipconfig_ipv6);
4786                         }
4787
4788                         return __connman_error_failed(msg, -err);
4789                 }
4790
4791                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
4792                         ipv4_configuration_changed(service);
4793                 else
4794                         ipv6_configuration_changed(service);
4795
4796                 if (is_connecting(service->state) ||
4797                                 is_connected(service->state)) {
4798                         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
4799                                 __connman_network_enable_ipconfig(service->network,
4800                                                                 service->ipconfig_ipv4);
4801                         else
4802                                 __connman_network_enable_ipconfig(service->network,
4803                                                                 service->ipconfig_ipv6);
4804                 }
4805
4806                 service_save(service);
4807         } else
4808                 return __connman_error_invalid_property(msg);
4809
4810         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
4811 }
4812
4813 static void set_error(struct connman_service *service,
4814                                         enum connman_service_error error)
4815 {
4816         const char *str;
4817
4818         if (service->error == error)
4819                 return;
4820
4821         service->error = error;
4822
4823         if (!service->path)
4824                 return;
4825
4826 #if !defined TIZEN_EXT
4827         if (!allow_property_changed(service))
4828                 return;
4829 #endif
4830
4831         str = error2string(service->error);
4832
4833         if (!str)
4834                 str = "";
4835
4836         connman_dbus_property_changed_basic(service->path,
4837                                 CONNMAN_SERVICE_INTERFACE, "Error",
4838                                 DBUS_TYPE_STRING, &str);
4839 }
4840
4841 static void remove_timeout(struct connman_service *service)
4842 {
4843         if (service->timeout > 0) {
4844                 g_source_remove(service->timeout);
4845                 service->timeout = 0;
4846         }
4847 }
4848
4849 static void reply_pending(struct connman_service *service, int error)
4850 {
4851         remove_timeout(service);
4852
4853         if (service->pending) {
4854                 connman_dbus_reply_pending(service->pending, error, NULL);
4855                 service->pending = NULL;
4856         }
4857
4858         if (service->provider_pending) {
4859                 connman_dbus_reply_pending(service->provider_pending,
4860                                 error, service->path);
4861                 service->provider_pending = NULL;
4862         }
4863 }
4864
4865 static void service_complete(struct connman_service *service)
4866 {
4867         reply_pending(service, EIO);
4868
4869         if (service->connect_reason != CONNMAN_SERVICE_CONNECT_REASON_USER)
4870                 __connman_service_auto_connect(service->connect_reason);
4871
4872         g_get_current_time(&service->modified);
4873         service_save(service);
4874 }
4875
4876 static void set_idle(struct connman_service *service)
4877 {
4878         service->state = service->state_ipv4 = service->state_ipv6 =
4879                                                 CONNMAN_SERVICE_STATE_IDLE;
4880         set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
4881         state_changed(service);
4882 }
4883
4884 static DBusMessage *clear_property(DBusConnection *conn,
4885                                         DBusMessage *msg, void *user_data)
4886 {
4887         struct connman_service *service = user_data;
4888         const char *name;
4889
4890         DBG("service %p", service);
4891
4892         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
4893                                                         DBUS_TYPE_INVALID);
4894
4895         if (g_str_equal(name, "Error")) {
4896                 set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
4897
4898                 __connman_service_clear_error(service);
4899                 service_complete(service);
4900         } else
4901                 return __connman_error_invalid_property(msg);
4902
4903         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
4904 }
4905
4906 static bool is_ipconfig_usable(struct connman_service *service)
4907 {
4908         if (!__connman_ipconfig_is_usable(service->ipconfig_ipv4) &&
4909                         !__connman_ipconfig_is_usable(service->ipconfig_ipv6))
4910                 return false;
4911
4912         return true;
4913 }
4914
4915 static bool is_ignore(struct connman_service *service)
4916 {
4917         if (!service->autoconnect)
4918                 return true;
4919
4920         if (service->roaming)
4921                 return true;
4922
4923         if (service->ignore)
4924                 return true;
4925
4926         if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
4927                 return true;
4928
4929         if (!is_ipconfig_usable(service))
4930                 return true;
4931
4932         return false;
4933 }
4934
4935 static void disconnect_on_last_session(enum connman_service_type type)
4936 {
4937         GList *list;
4938
4939         for (list = service_list; list; list = list->next) {
4940                 struct connman_service *service = list->data;
4941
4942                 if (service->type != type)
4943                         continue;
4944
4945                 if (service->connect_reason != CONNMAN_SERVICE_CONNECT_REASON_SESSION)
4946                          continue;
4947
4948                 __connman_service_disconnect(service);
4949                 return;
4950         }
4951 }
4952
4953 static int active_sessions[MAX_CONNMAN_SERVICE_TYPES] = {};
4954 static int always_connect[MAX_CONNMAN_SERVICE_TYPES] = {};
4955 static int active_count = 0;
4956
4957 void __connman_service_set_active_session(bool enable, GSList *list)
4958 {
4959         if (!list)
4960                 return;
4961
4962         if (enable)
4963                 active_count++;
4964         else
4965                 active_count--;
4966
4967         while (list) {
4968                 enum connman_service_type type = GPOINTER_TO_INT(list->data);
4969
4970                 switch (type) {
4971                 case CONNMAN_SERVICE_TYPE_ETHERNET:
4972                 case CONNMAN_SERVICE_TYPE_WIFI:
4973                 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
4974                 case CONNMAN_SERVICE_TYPE_CELLULAR:
4975                 case CONNMAN_SERVICE_TYPE_GADGET:
4976                         if (enable)
4977                                 active_sessions[type]++;
4978                         else
4979                                 active_sessions[type]--;
4980                         break;
4981
4982                 case CONNMAN_SERVICE_TYPE_UNKNOWN:
4983                 case CONNMAN_SERVICE_TYPE_SYSTEM:
4984                 case CONNMAN_SERVICE_TYPE_GPS:
4985                 case CONNMAN_SERVICE_TYPE_VPN:
4986                 case CONNMAN_SERVICE_TYPE_P2P:
4987                         break;
4988                 }
4989
4990                 if (active_sessions[type] == 0)
4991                         disconnect_on_last_session(type);
4992
4993                 list = g_slist_next(list);
4994         }
4995
4996         DBG("eth %d wifi %d bt %d cellular %d gadget %d sessions %d",
4997                         active_sessions[CONNMAN_SERVICE_TYPE_ETHERNET],
4998                         active_sessions[CONNMAN_SERVICE_TYPE_WIFI],
4999                         active_sessions[CONNMAN_SERVICE_TYPE_BLUETOOTH],
5000                         active_sessions[CONNMAN_SERVICE_TYPE_CELLULAR],
5001                         active_sessions[CONNMAN_SERVICE_TYPE_GADGET],
5002                         active_count);
5003 }
5004
5005 struct preferred_tech_data {
5006         GList *preferred_list;
5007         enum connman_service_type type;
5008 };
5009
5010 static void preferred_tech_add_by_type(gpointer data, gpointer user_data)
5011 {
5012         struct connman_service *service = data;
5013         struct preferred_tech_data *tech_data = user_data;
5014
5015         if (service->type == tech_data->type) {
5016                 tech_data->preferred_list =
5017                         g_list_append(tech_data->preferred_list, service);
5018
5019                 DBG("type %d service %p %s", tech_data->type, service,
5020                                 service->name);
5021         }
5022 }
5023
5024 static GList *preferred_tech_list_get(void)
5025 {
5026         unsigned int *tech_array;
5027         struct preferred_tech_data tech_data = { 0, };
5028         int i;
5029
5030         tech_array = connman_setting_get_uint_list("PreferredTechnologies");
5031         if (!tech_array)
5032                 return NULL;
5033
5034         if (connman_setting_get_bool("SingleConnectedTechnology")) {
5035                 GList *list;
5036                 for (list = service_list; list; list = list->next) {
5037                         struct connman_service *service = list->data;
5038
5039                         if (!is_connected(service->state))
5040                                 break;
5041
5042                         if (service->connect_reason ==
5043                                         CONNMAN_SERVICE_CONNECT_REASON_USER) {
5044                                 DBG("service %p name %s is user connected",
5045                                                 service, service->name);
5046 #if defined TIZEN_EXT
5047                                 /* We can connect to a favorite service like
5048                                  * wifi even we have a userconnect for cellular
5049                                  * because we have refount for cellular service
5050                                  */
5051                                 if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR)
5052                                         break;
5053
5054                                 if (service->type == CONNMAN_SERVICE_TYPE_BLUETOOTH)
5055                                         break;
5056 #endif
5057                                 return NULL;
5058                         }
5059                 }
5060         }
5061
5062         for (i = 0; tech_array[i] != 0; i += 1) {
5063                 tech_data.type = tech_array[i];
5064                 g_list_foreach(service_list, preferred_tech_add_by_type,
5065                                 &tech_data);
5066         }
5067
5068         return tech_data.preferred_list;
5069 }
5070
5071 static void set_always_connecting_technologies()
5072 {
5073         unsigned int *always_connected_techs =
5074                 connman_setting_get_uint_list("AlwaysConnectedTechnologies");
5075         int i;
5076         for (i = 0; always_connected_techs && always_connected_techs[i]; i++)
5077                 always_connect[always_connected_techs[i]] = 1;
5078 }
5079
5080 static bool autoconnect_no_session_active(struct connman_service *service)
5081 {
5082         /*
5083          * Test active_count to see if there are no sessions set up and
5084          * stop autoconnecting, but continue connecting if the service
5085          * belongs to a technology which should always autoconnect.
5086          */
5087         if (!active_count && !always_connect[service->type])
5088                 return true;
5089
5090         return false;
5091 }
5092
5093 static bool autoconnect_already_connecting(struct connman_service *service,
5094                                            bool autoconnecting)
5095 {
5096         /*
5097          * If another service is already connecting and this service type has
5098          * not been marked as always connecting, stop the connecting procedure.
5099          */
5100         if (autoconnecting &&
5101                         !active_sessions[service->type] &&
5102                         !always_connect[service->type])
5103                 return true;
5104
5105         return false;
5106 }
5107
5108 static bool auto_connect_service(GList *services,
5109                                 enum connman_service_connect_reason reason,
5110                                 bool preferred)
5111 {
5112         struct connman_service *service = NULL;
5113         bool ignore[MAX_CONNMAN_SERVICE_TYPES] = { };
5114         bool autoconnecting = false;
5115         GList *list;
5116
5117         DBG("preferred %d sessions %d reason %s", preferred, active_count,
5118                 reason2string(reason));
5119
5120         ignore[CONNMAN_SERVICE_TYPE_VPN] = true;
5121
5122         for (list = services; list; list = list->next) {
5123                 service = list->data;
5124
5125                 if (ignore[service->type]) {
5126                         DBG("service %p type %s ignore", service,
5127                                 __connman_service_type2string(service->type));
5128                         continue;
5129                 }
5130
5131 #if defined TIZEN_EXT
5132                 DBG("service %p %s %s %s, favorite(%d), ignore(%d), hidden(%d, %d)",
5133                                 service, service->name,
5134                                 state2string(service->state),
5135                                 __connman_service_type2string(service->type),
5136                                 service->favorite, is_ignore(service),
5137                                 service->hidden, service->hidden_service);
5138
5139                 /* Tizen takes Wi-Fi as the highest priority into consideration. */
5140                 if (service->type != CONNMAN_SERVICE_TYPE_WIFI)
5141                         if (is_connecting(service->state) == TRUE || is_connected(service->state) == TRUE)
5142                                 continue;
5143 #endif
5144
5145                 if (service->pending ||
5146                                 is_connecting(service->state) ||
5147                                 is_connected(service->state)) {
5148                         if (autoconnect_no_session_active(service))
5149                                         return true;
5150
5151                         ignore[service->type] = true;
5152                         autoconnecting = true;
5153
5154                         DBG("service %p type %s busy", service,
5155                                 __connman_service_type2string(service->type));
5156
5157                         continue;
5158                 }
5159
5160                 if (!service->favorite) {
5161                         if (preferred)
5162                                continue;
5163
5164 #if defined TIZEN_EXT
5165                         DBG("Service is not favorite, autoconnecting %d",
5166                                         autoconnecting);
5167 #endif
5168                         return autoconnecting;
5169                 }
5170
5171 #if defined TIZEN_EXT
5172                 DBG("service %p identifier %s roaming %d ignore %d "
5173                                 "ipconfig_usable %d autoconnect %d state %d",
5174                                 service,
5175                                 service->identifier, service->roaming,
5176                                 service->ignore, is_ipconfig_usable(service),
5177                                 service->autoconnect, service->state);
5178 #endif
5179                 if (is_ignore(service) || service->state !=
5180                                 CONNMAN_SERVICE_STATE_IDLE)
5181                         continue;
5182
5183                 if (autoconnect_already_connecting(service, autoconnecting)) {
5184                         DBG("service %p type %s has no users", service,
5185                                 __connman_service_type2string(service->type));
5186                         continue;
5187                 }
5188
5189                 if (!is_service_owner_user_login(service)) {
5190                         DBG("favorite user not login, wifi auto connect denied");
5191                         continue;
5192                 }
5193
5194                 DBG("service %p %s %s", service, service->name,
5195                         (preferred) ? "preferred" : reason2string(reason));
5196
5197                 __connman_service_connect(service, reason);
5198
5199                 if (autoconnect_no_session_active(service))
5200                         return true;
5201
5202                 ignore[service->type] = true;
5203         }
5204
5205         return autoconnecting;
5206 }
5207
5208 static gboolean run_auto_connect(gpointer data)
5209 {
5210         enum connman_service_connect_reason reason = GPOINTER_TO_UINT(data);
5211         bool autoconnecting = false;
5212         GList *preferred_tech;
5213
5214         autoconnect_timeout = 0;
5215
5216         DBG("");
5217
5218         preferred_tech = preferred_tech_list_get();
5219         if (preferred_tech) {
5220                 autoconnecting = auto_connect_service(preferred_tech, reason,
5221                                                         true);
5222                 g_list_free(preferred_tech);
5223         }
5224
5225         if (!autoconnecting || active_count)
5226                 auto_connect_service(service_list, reason, false);
5227
5228         return FALSE;
5229 }
5230
5231 #if defined TIZEN_EXT
5232 bool __connman_service_get_auto_connect_mode(void)
5233 {
5234         return auto_connect_mode;
5235 }
5236
5237 void __connman_service_set_auto_connect_mode(bool enable)
5238 {
5239         DBG("set auto_connect_mode = %d", enable);
5240
5241         if (auto_connect_mode != enable)
5242                 auto_connect_mode = enable;
5243 }
5244 #endif
5245
5246 void __connman_service_auto_connect(enum connman_service_connect_reason reason)
5247 {
5248         DBG("");
5249
5250         if (autoconnect_timeout != 0)
5251                 return;
5252
5253 #if defined TIZEN_EXT
5254         if (auto_connect_mode == FALSE) {
5255                 DBG("Currently, not auto connection mode");
5256                 return;
5257         }
5258 #endif
5259
5260         if (!__connman_session_policy_autoconnect(reason))
5261                 return;
5262
5263 #if defined TIZEN_EXT
5264         /* Adding Timeout of 500ms before trying to auto connect.
5265          * This is done because of below scenario
5266          * 1. Device is connected to AP1
5267          * 2. WPS Connection request is initiated for AP2
5268          * 3. Immediately WPS Connection is Cancelled
5269          * When WPS Connection Connection is initiated for AP2 then
5270          * sometimes there is a scenario where connman gets in ASSOCIATED
5271          * state with AP1 due to autoconnect and subsequently the connection
5272          * initiated by AP1 fails and connman service for AP1 comes in
5273          * FAILURE state due to this when connection with AP2 is cancelled
5274          * then autoconnect with AP1 doesn't works because its autoconnection
5275          * is ignored as its last state was FAILURE rather than IDLE */
5276         autoconnect_timeout = g_timeout_add(500, run_auto_connect,
5277 #else
5278         autoconnect_timeout = g_idle_add(run_auto_connect,
5279 #endif
5280                                                 GUINT_TO_POINTER(reason));
5281 }
5282
5283 static gboolean run_vpn_auto_connect(gpointer data) {
5284         GList *list;
5285         bool need_split = false;
5286
5287         vpn_autoconnect_timeout = 0;
5288
5289         for (list = service_list; list; list = list->next) {
5290                 struct connman_service *service = list->data;
5291                 int res;
5292
5293                 if (service->type != CONNMAN_SERVICE_TYPE_VPN)
5294                         continue;
5295
5296                 if (is_connected(service->state) ||
5297                                 is_connecting(service->state)) {
5298                         if (!service->do_split_routing)
5299                                 need_split = true;
5300                         continue;
5301                 }
5302
5303                 if (is_ignore(service) || !service->favorite)
5304                         continue;
5305
5306                 if (need_split && !service->do_split_routing) {
5307                         DBG("service %p no split routing", service);
5308                         continue;
5309                 }
5310
5311                 DBG("service %p %s %s", service, service->name,
5312                                 service->do_split_routing ?
5313                                 "split routing" : "");
5314
5315                 res = __connman_service_connect(service,
5316                                 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
5317                 if (res < 0 && res != -EINPROGRESS)
5318                         continue;
5319
5320                 if (!service->do_split_routing)
5321                         need_split = true;
5322         }
5323
5324         return FALSE;
5325 }
5326
5327 static void vpn_auto_connect(void)
5328 {
5329         if (vpn_autoconnect_timeout)
5330                 return;
5331
5332         vpn_autoconnect_timeout =
5333                 g_idle_add(run_vpn_auto_connect, NULL);
5334 }
5335
5336 bool
5337 __connman_service_is_provider_pending(struct connman_service *service)
5338 {
5339         if (!service)
5340                 return false;
5341
5342         if (service->provider_pending)
5343                 return true;
5344
5345         return false;
5346 }
5347
5348 void __connman_service_set_provider_pending(struct connman_service *service,
5349                                                         DBusMessage *msg)
5350 {
5351         if (service->provider_pending) {
5352                 DBG("service %p provider pending msg %p already exists",
5353                         service, service->provider_pending);
5354                 return;
5355         }
5356
5357         service->provider_pending = msg;
5358         return;
5359 }
5360
5361 static void check_pending_msg(struct connman_service *service)
5362 {
5363         if (!service->pending)
5364                 return;
5365
5366         DBG("service %p pending msg %p already exists", service,
5367                                                 service->pending);
5368         dbus_message_unref(service->pending);
5369 }
5370
5371 void __connman_service_set_hidden_data(struct connman_service *service,
5372                                                         gpointer user_data)
5373 {
5374         DBusMessage *pending = user_data;
5375
5376         DBG("service %p pending %p", service, pending);
5377
5378         if (!pending)
5379                 return;
5380
5381         check_pending_msg(service);
5382
5383         service->pending = pending;
5384 }
5385
5386 void __connman_service_return_error(struct connman_service *service,
5387                                 int error, gpointer user_data)
5388 {
5389         DBG("service %p error %d user_data %p", service, error, user_data);
5390
5391         __connman_service_set_hidden_data(service, user_data);
5392
5393         reply_pending(service, error);
5394 }
5395
5396 static gboolean connect_timeout(gpointer user_data)
5397 {
5398         struct connman_service *service = user_data;
5399         bool autoconnect = false;
5400
5401         DBG("service %p", service);
5402
5403         service->timeout = 0;
5404
5405         if (service->network)
5406                 __connman_network_disconnect(service->network);
5407         else if (service->provider)
5408                 connman_provider_disconnect(service->provider);
5409
5410         __connman_stats_service_unregister(service);
5411
5412         if (service->pending) {
5413                 DBusMessage *reply;
5414
5415                 reply = __connman_error_operation_timeout(service->pending);
5416                 if (reply)
5417                         g_dbus_send_message(connection, reply);
5418
5419                 dbus_message_unref(service->pending);
5420                 service->pending = NULL;
5421         } else
5422                 autoconnect = true;
5423
5424         __connman_service_ipconfig_indicate_state(service,
5425                                         CONNMAN_SERVICE_STATE_FAILURE,
5426                                         CONNMAN_IPCONFIG_TYPE_IPV4);
5427         __connman_service_ipconfig_indicate_state(service,
5428                                         CONNMAN_SERVICE_STATE_FAILURE,
5429                                         CONNMAN_IPCONFIG_TYPE_IPV6);
5430
5431         if (autoconnect &&
5432                         service->connect_reason !=
5433                                 CONNMAN_SERVICE_CONNECT_REASON_USER)
5434                 __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
5435
5436         return FALSE;
5437 }
5438
5439 static DBusMessage *connect_service(DBusConnection *conn,
5440                                         DBusMessage *msg, void *user_data)
5441 {
5442         struct connman_service *service = user_data;
5443 #if defined TIZEN_EXT
5444         int err = 0;
5445 #else
5446         int index, err = 0;
5447         GList *list;
5448 #endif
5449
5450         DBG("service %p", service);
5451
5452 #if defined TIZEN_EXT
5453         /*
5454          * Description: TIZEN implements system global connection management.
5455          */
5456         if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR)
5457                 connman_service_user_pdn_connection_ref(service);
5458
5459         /*Reset the Disconnect Reason while issue connect request*/
5460         service->disconnect_reason = 0;
5461
5462         /*Reset the association status code while issue connect request*/
5463         service->assoc_status_code = 0;
5464 #endif
5465
5466         if (service->pending)
5467                 return __connman_error_in_progress(msg);
5468
5469         if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
5470                 uid_t uid;
5471                 if (connman_dbus_get_connection_unix_user_sync(conn,
5472                                                 dbus_message_get_sender(msg),
5473                                                 &uid) < 0) {
5474                         DBG("Can not get unix user id!");
5475                         return __connman_error_permission_denied(msg);
5476                 }
5477
5478                 if (!__connman_service_is_user_allowed(CONNMAN_SERVICE_TYPE_WIFI, uid)) {
5479                         DBG("Not allow this user to connect this wifi service now!");
5480                         return __connman_error_permission_denied(msg);
5481                 }
5482
5483                 if (uid != USER_ROOT && uid != service->user.favorite_user)
5484                         service->request_passphrase_input = true;
5485
5486                 service->user.current_user = uid;
5487
5488                 if (!service->passphrase && uid == service->user.favorite_user) {
5489                         DBG("Now load this favorite user's passphrase.");
5490                         service_load_passphrase(service);
5491                 }
5492         }
5493
5494 #if !defined TIZEN_EXT
5495         index = __connman_service_get_index(service);
5496
5497         for (list = service_list; list; list = list->next) {
5498                 struct connman_service *temp = list->data;
5499
5500 #if defined TIZEN_EXT
5501                 if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR)
5502                         break;
5503 #endif
5504                 if (!is_connecting(temp->state) && !is_connected(temp->state))
5505                         break;
5506
5507                 if (service == temp)
5508                         continue;
5509
5510                 if (service->type != temp->type)
5511                         continue;
5512
5513                 if (__connman_service_get_index(temp) == index &&
5514                                 __connman_service_disconnect(temp) == -EINPROGRESS)
5515                         err = -EINPROGRESS;
5516
5517         }
5518         if (err == -EINPROGRESS)
5519                 return __connman_error_operation_timeout(msg);
5520 #endif
5521
5522         service->ignore = false;
5523
5524         service->pending = dbus_message_ref(msg);
5525
5526         err = __connman_service_connect(service,
5527                         CONNMAN_SERVICE_CONNECT_REASON_USER);
5528
5529         if (err == -EINPROGRESS)
5530                 return NULL;
5531
5532         if (service->pending) {
5533                 dbus_message_unref(service->pending);
5534                 service->pending = NULL;
5535         }
5536
5537         if (err < 0)
5538                 return __connman_error_failed(msg, -err);
5539
5540         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
5541 }
5542
5543 static DBusMessage *disconnect_service(DBusConnection *conn,
5544                                         DBusMessage *msg, void *user_data)
5545 {
5546         struct connman_service *service = user_data;
5547         int err;
5548
5549         DBG("service %p", service);
5550
5551 #if defined TIZEN_EXT
5552         /*
5553          * Description: TIZEN implements system global connection management.
5554          */
5555         if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR) {
5556                 if (connman_service_user_pdn_connection_unref_and_test(service) != TRUE)
5557                         return __connman_error_failed(msg, EISCONN);
5558
5559                 if (is_connected(service->state) == TRUE &&
5560                                 service == connman_service_get_default_connection())
5561                         return __connman_error_failed(msg, EISCONN);
5562         }
5563 #endif
5564
5565         if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
5566                 uid_t uid;
5567                 if (connman_dbus_get_connection_unix_user_sync(conn,
5568                                                 dbus_message_get_sender(msg),
5569                                                 &uid) < 0) {
5570                         DBG("Can not get unix user id!");
5571                         return __connman_error_permission_denied(msg);
5572                 }
5573
5574                 if (!connman_service_is_user_allowed(service, uid)) {
5575                         DBG("Not allow this user to disconnect this wifi service now!");
5576                         return __connman_error_permission_denied(msg);
5577                 }
5578         }
5579
5580         service->ignore = true;
5581
5582         err = __connman_service_disconnect(service);
5583         if (err < 0 && err != -EINPROGRESS)
5584                 return __connman_error_failed(msg, -err);
5585
5586         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
5587 }
5588
5589 #if defined TIZEN_EXT
5590 static void __connman_service_cleanup_network_8021x(struct connman_service *service)
5591 {
5592         if (service == NULL)
5593                 return;
5594
5595         DBG("service %p ", service);
5596
5597         connman_network_set_string(service->network, "WiFi.EAP", NULL);
5598         connman_network_set_string(service->network, "WiFi.Identity", NULL);
5599         connman_network_set_string(service->network, "WiFi.CACertFile", NULL);
5600         connman_network_set_string(service->network, "WiFi.ClientCertFile", NULL);
5601         connman_network_set_string(service->network, "WiFi.PrivateKeyFile", NULL);
5602         connman_network_set_string(service->network, "WiFi.PrivateKeyPassphrase", NULL);
5603         connman_network_set_string(service->network, "WiFi.Phase2", NULL);
5604 }
5605 #endif
5606
5607 bool __connman_service_remove(struct connman_service *service)
5608 {
5609         if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET ||
5610                         service->type == CONNMAN_SERVICE_TYPE_GADGET)
5611                 return false;
5612
5613         if (service->immutable || service->hidden ||
5614                         __connman_provider_is_immutable(service->provider))
5615                 return false;
5616
5617 #if !defined TIZEN_EXT
5618         if (!service->favorite && !is_idle(service->state))
5619                 return false;
5620 #endif
5621
5622         __connman_service_disconnect(service);
5623
5624         g_free(service->passphrase);
5625         service->passphrase = NULL;
5626
5627         g_free(service->identity);
5628         service->identity = NULL;
5629
5630         g_free(service->anonymous_identity);
5631         service->anonymous_identity = NULL;
5632
5633         g_free(service->subject_match);
5634         service->subject_match = NULL;
5635
5636         g_free(service->altsubject_match);
5637         service->altsubject_match = NULL;
5638
5639         g_free(service->domain_suffix_match);
5640         service->domain_suffix_match = NULL;
5641
5642         g_free(service->domain_match);
5643         service->domain_match = NULL;
5644
5645         g_free(service->agent_identity);
5646         service->agent_identity = NULL;
5647
5648         g_free(service->eap);
5649         service->eap = NULL;
5650
5651 #if defined TIZEN_EXT
5652         g_free(service->ca_cert_file);
5653         service->ca_cert_file = NULL;
5654
5655         g_free(service->client_cert_file);
5656         service->client_cert_file = NULL;
5657
5658         g_free(service->private_key_file);
5659         service->private_key_file = NULL;
5660
5661         g_free(service->private_key_passphrase);
5662         service->private_key_passphrase = NULL;
5663
5664         g_free(service->phase2);
5665         service->phase2 = NULL;
5666
5667         __connman_service_cleanup_network_8021x(service);
5668
5669         __connman_ipconfig_set_method(service->ipconfig_ipv4, CONNMAN_IPCONFIG_METHOD_DHCP);
5670         __connman_ipconfig_set_method(service->ipconfig_ipv6, CONNMAN_IPCONFIG_METHOD_AUTO);
5671         connman_service_set_proxy(service, NULL, false);
5672
5673         __connman_service_nameserver_clear(service);
5674
5675         g_strfreev(service->nameservers_config);
5676         service->nameservers_config = NULL;
5677
5678 #endif
5679
5680 #if defined TIZEN_EXT
5681         if (service->security != CONNMAN_SERVICE_SECURITY_8021X)
5682 #endif
5683         set_idle(service);
5684
5685         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
5686
5687         service->user.favorite_user = USER_NONE;
5688
5689         __connman_service_set_favorite(service, false);
5690
5691         __connman_ipconfig_ipv6_reset_privacy(service->ipconfig_ipv6);
5692
5693 #if defined TIZEN_EXT
5694         /* Reset IP Method and DNS Method to DHCP */
5695         __connman_ipconfig_set_method(service->ipconfig_ipv4,
5696                         CONNMAN_IPCONFIG_METHOD_DHCP);
5697         service->dns_config_method_ipv4 = CONNMAN_DNSCONFIG_METHOD_DHCP;
5698         g_strfreev(service->nameservers_config);
5699         service->nameservers_config = NULL;
5700 #endif
5701
5702 #if defined TIZEN_EXT
5703         __connman_storage_remove_service(service->identifier);
5704 #else
5705         service_save(service);
5706 #endif
5707
5708         return true;
5709 }
5710
5711 static DBusMessage *remove_service(DBusConnection *conn,
5712                                         DBusMessage *msg, void *user_data)
5713 {
5714         struct connman_service *service = user_data;
5715
5716         DBG("service %p", service);
5717
5718         if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
5719                 uid_t uid;
5720                 if (connman_dbus_get_connection_unix_user_sync(conn,
5721                                                 dbus_message_get_sender(msg),
5722                                                 &uid) < 0) {
5723                         DBG("Can not get unix user id!");
5724                         return __connman_error_permission_denied(msg);
5725                 }
5726
5727 #if !defined TIZEN_EXT
5728                 if (!connman_service_is_user_allowed(service, uid)) {
5729                         DBG("Not allow this user to remove this wifi service now!");
5730                         return __connman_error_permission_denied(msg);
5731                 }
5732 #endif
5733         }
5734
5735         if (!__connman_service_remove(service))
5736                 return __connman_error_not_supported(msg);
5737
5738         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
5739 }
5740
5741 static bool check_suitable_state(enum connman_service_state a,
5742                                         enum connman_service_state b)
5743 {
5744         /*
5745          * Special check so that "ready" service can be moved before
5746          * "online" one.
5747          */
5748         if ((a == CONNMAN_SERVICE_STATE_ONLINE &&
5749                         b == CONNMAN_SERVICE_STATE_READY) ||
5750                 (b == CONNMAN_SERVICE_STATE_ONLINE &&
5751                         a == CONNMAN_SERVICE_STATE_READY))
5752                 return true;
5753
5754         return a == b;
5755 }
5756
5757 static void downgrade_state(struct connman_service *service)
5758 {
5759         if (!service)
5760                 return;
5761
5762         DBG("service %p state4 %d state6 %d", service, service->state_ipv4,
5763                                                 service->state_ipv6);
5764
5765         if (service->state_ipv4 == CONNMAN_SERVICE_STATE_ONLINE)
5766                 __connman_service_ipconfig_indicate_state(service,
5767                                                 CONNMAN_SERVICE_STATE_READY,
5768                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
5769
5770         if (service->state_ipv6 == CONNMAN_SERVICE_STATE_ONLINE)
5771                 __connman_service_ipconfig_indicate_state(service,
5772                                                 CONNMAN_SERVICE_STATE_READY,
5773                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
5774 }
5775
5776 static void apply_relevant_default_downgrade(struct connman_service *service)
5777 {
5778         struct connman_service *def_service;
5779
5780         def_service = __connman_service_get_default();
5781         if (!def_service)
5782                 return;
5783
5784         if (def_service == service &&
5785                         def_service->state == CONNMAN_SERVICE_STATE_ONLINE) {
5786                 def_service->state = CONNMAN_SERVICE_STATE_READY;
5787                 __connman_notifier_leave_online(def_service->type);
5788                 state_changed(def_service);
5789         }
5790 }
5791
5792 static void switch_default_service(struct connman_service *default_service,
5793                 struct connman_service *downgrade_service)
5794 {
5795         struct connman_service *service;
5796         GList *src, *dst;
5797
5798         apply_relevant_default_downgrade(default_service);
5799         src = g_list_find(service_list, downgrade_service);
5800         dst = g_list_find(service_list, default_service);
5801
5802         /* Nothing to do */
5803         if (src == dst || src->next == dst)
5804                 return;
5805
5806         service = src->data;
5807         service_list = g_list_delete_link(service_list, src);
5808         service_list = g_list_insert_before(service_list, dst, service);
5809
5810         downgrade_state(downgrade_service);
5811 }
5812
5813 static DBusMessage *move_service(DBusConnection *conn,
5814                                         DBusMessage *msg, void *user_data,
5815                                                                 bool before)
5816 {
5817         struct connman_service *service = user_data;
5818         struct connman_service *target;
5819         const char *path;
5820         enum connman_ipconfig_method target4, target6;
5821         enum connman_ipconfig_method service4, service6;
5822
5823         DBG("service %p", service);
5824
5825         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
5826                                                         DBUS_TYPE_INVALID);
5827
5828         if (!service->favorite)
5829                 return __connman_error_not_supported(msg);
5830
5831         target = find_service(path);
5832         if (!target || !target->favorite || target == service)
5833                 return __connman_error_invalid_service(msg);
5834
5835         if (target->type == CONNMAN_SERVICE_TYPE_VPN) {
5836                 /*
5837                  * We only allow VPN route splitting if there are
5838                  * routes defined for a given VPN.
5839                  */
5840                 if (!__connman_provider_check_routes(target->provider)) {
5841                         connman_info("Cannot move service. "
5842                                 "No routes defined for provider %s",
5843                                 __connman_provider_get_ident(target->provider));
5844                         return __connman_error_invalid_service(msg);
5845                 }
5846
5847                 set_split_routing(target, true);
5848         } else
5849                 set_split_routing(target, false);
5850
5851         set_split_routing(service, false);
5852
5853         target4 = __connman_ipconfig_get_method(target->ipconfig_ipv4);
5854         target6 = __connman_ipconfig_get_method(target->ipconfig_ipv6);
5855         service4 = __connman_ipconfig_get_method(service->ipconfig_ipv4);
5856         service6 = __connman_ipconfig_get_method(service->ipconfig_ipv6);
5857
5858         DBG("target %s method %d/%d state %d/%d split %d", target->identifier,
5859                 target4, target6, target->state_ipv4, target->state_ipv6,
5860                 target->do_split_routing);
5861
5862         DBG("service %s method %d/%d state %d/%d", service->identifier,
5863                                 service4, service6,
5864                                 service->state_ipv4, service->state_ipv6);
5865
5866         /*
5867          * If method is OFF, then we do not need to check the corresponding
5868          * ipconfig state.
5869          */
5870         if (target4 == CONNMAN_IPCONFIG_METHOD_OFF) {
5871                 if (service6 != CONNMAN_IPCONFIG_METHOD_OFF) {
5872                         if (!check_suitable_state(target->state_ipv6,
5873                                                         service->state_ipv6))
5874                                 return __connman_error_invalid_service(msg);
5875                 }
5876         }
5877
5878         if (target6 == CONNMAN_IPCONFIG_METHOD_OFF) {
5879                 if (service4 != CONNMAN_IPCONFIG_METHOD_OFF) {
5880                         if (!check_suitable_state(target->state_ipv4,
5881                                                         service->state_ipv4))
5882                                 return __connman_error_invalid_service(msg);
5883                 }
5884         }
5885
5886         if (service4 == CONNMAN_IPCONFIG_METHOD_OFF) {
5887                 if (target6 != CONNMAN_IPCONFIG_METHOD_OFF) {
5888                         if (!check_suitable_state(target->state_ipv6,
5889                                                         service->state_ipv6))
5890                                 return __connman_error_invalid_service(msg);
5891                 }
5892         }
5893
5894         if (service6 == CONNMAN_IPCONFIG_METHOD_OFF) {
5895                 if (target4 != CONNMAN_IPCONFIG_METHOD_OFF) {
5896                         if (!check_suitable_state(target->state_ipv4,
5897                                                         service->state_ipv4))
5898                                 return __connman_error_invalid_service(msg);
5899                 }
5900         }
5901
5902         g_get_current_time(&service->modified);
5903         service_save(service);
5904         service_save(target);
5905
5906         /*
5907          * If the service which goes down is the default service and is
5908          * online, we downgrade directly its state to ready so:
5909          * the service which goes up, needs to recompute its state which
5910          * is triggered via downgrading it - if relevant - to state ready.
5911          */
5912         if (before)
5913                 switch_default_service(target, service);
5914         else
5915                 switch_default_service(service, target);
5916
5917         __connman_connection_update_gateway();
5918
5919         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
5920 }
5921
5922 static DBusMessage *move_before(DBusConnection *conn,
5923                                         DBusMessage *msg, void *user_data)
5924 {
5925         return move_service(conn, msg, user_data, true);
5926 }
5927
5928 static DBusMessage *move_after(DBusConnection *conn,
5929                                         DBusMessage *msg, void *user_data)
5930 {
5931         return move_service(conn, msg, user_data, false);
5932 }
5933
5934 static DBusMessage *reset_counters(DBusConnection *conn,
5935                                         DBusMessage *msg, void *user_data)
5936 {
5937         struct connman_service *service = user_data;
5938
5939         reset_stats(service);
5940
5941         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
5942 }
5943
5944 static DBusMessage *get_user_favorite(DBusConnection *conn,
5945                                         DBusMessage *msg, void *user_data)
5946 {
5947         DBusMessage *reply;
5948         uid_t uid = USER_NONE;
5949         dbus_bool_t user_favorite = false;
5950         struct connman_service *service = user_data;
5951
5952         connman_dbus_get_connection_unix_user_sync(conn,
5953                                         dbus_message_get_sender(msg),
5954                                         &uid);
5955         if (uid == USER_ROOT)
5956                 user_favorite = service->favorite;
5957         else if (uid != USER_NONE && uid == service->user.favorite_user) {
5958                 DBG("The service is favorite to this user!");
5959                 user_favorite = true;
5960         }
5961
5962         reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
5963         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN,
5964                                 &user_favorite, DBUS_TYPE_INVALID);
5965         return reply;
5966 }
5967
5968 static struct _services_notify {
5969         int id;
5970         GHashTable *add;
5971         GHashTable *remove;
5972 } *services_notify;
5973
5974 static void service_append_added_foreach(gpointer data, gpointer user_data)
5975 {
5976         struct connman_service *service = data;
5977         DBusMessageIter *iter = user_data;
5978
5979         if (!service || !service->path) {
5980 #if !defined TIZEN_EXT
5981                 DBG("service %p or path is NULL", service);
5982 #endif
5983                 return;
5984         }
5985
5986         if (g_hash_table_lookup(services_notify->add, service->path)) {
5987 #if !defined TIZEN_EXT
5988                 DBG("new %s", service->path);
5989 #endif
5990
5991                 append_struct(service, iter);
5992                 g_hash_table_remove(services_notify->add, service->path);
5993         } else {
5994 #if !defined TIZEN_EXT
5995                 DBG("changed %s", service->path);
5996 #endif
5997
5998                 append_struct_service(iter, NULL, service);
5999         }
6000 }
6001
6002 static void service_append_ordered(DBusMessageIter *iter, void *user_data)
6003 {
6004         g_list_foreach(service_list, service_append_added_foreach, iter);
6005 }
6006
6007 static void append_removed(gpointer key, gpointer value, gpointer user_data)
6008 {
6009         char *objpath = key;
6010         DBusMessageIter *iter = user_data;
6011
6012         DBG("removed %s", objpath);
6013         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &objpath);
6014 }
6015
6016 static void service_append_removed(DBusMessageIter *iter, void *user_data)
6017 {
6018         g_hash_table_foreach(services_notify->remove, append_removed, iter);
6019 }
6020
6021 static gboolean service_send_changed(gpointer data)
6022 {
6023         DBusMessage *signal;
6024
6025         DBG("");
6026
6027         services_notify->id = 0;
6028
6029         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
6030                         CONNMAN_MANAGER_INTERFACE, "ServicesChanged");
6031         if (!signal)
6032                 return FALSE;
6033
6034         __connman_dbus_append_objpath_dict_array(signal,
6035                                         service_append_ordered, NULL);
6036         __connman_dbus_append_objpath_array(signal,
6037                                         service_append_removed, NULL);
6038
6039         dbus_connection_send(connection, signal, NULL);
6040         dbus_message_unref(signal);
6041
6042         g_hash_table_remove_all(services_notify->remove);
6043         g_hash_table_remove_all(services_notify->add);
6044
6045         return FALSE;
6046 }
6047
6048 static void service_schedule_changed(void)
6049 {
6050         if (services_notify->id != 0)
6051                 return;
6052
6053         services_notify->id = g_timeout_add(100, service_send_changed, NULL);
6054 }
6055
6056 static void service_schedule_added(struct connman_service *service)
6057 {
6058         DBG("service %p", service);
6059
6060         g_hash_table_remove(services_notify->remove, service->path);
6061         g_hash_table_replace(services_notify->add, service->path, service);
6062
6063         service_schedule_changed();
6064 }
6065
6066 static void service_schedule_removed(struct connman_service *service)
6067 {
6068         if (!service || !service->path) {
6069                 DBG("service %p or path is NULL", service);
6070                 return;
6071         }
6072
6073         DBG("service %p %s", service, service->path);
6074
6075         g_hash_table_remove(services_notify->add, service->path);
6076         g_hash_table_replace(services_notify->remove, g_strdup(service->path),
6077                         NULL);
6078
6079         service_schedule_changed();
6080 }
6081
6082 static bool allow_property_changed(struct connman_service *service)
6083 {
6084 #if defined TIZEN_EXT
6085         if (service->path == NULL)
6086                 return FALSE;
6087 #endif
6088         if (g_hash_table_lookup_extended(services_notify->add, service->path,
6089                                         NULL, NULL))
6090                 return false;
6091
6092         return true;
6093 }
6094
6095 static const GDBusMethodTable service_methods[] = {
6096         { GDBUS_DEPRECATED_METHOD("GetProperties",
6097                         NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
6098                         get_properties) },
6099         { GDBUS_METHOD("SetProperty",
6100                         GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
6101                         NULL, set_property) },
6102         { GDBUS_METHOD("ClearProperty",
6103                         GDBUS_ARGS({ "name", "s" }), NULL,
6104                         clear_property) },
6105         { GDBUS_ASYNC_METHOD("Connect", NULL, NULL,
6106                               connect_service) },
6107         { GDBUS_METHOD("Disconnect", NULL, NULL,
6108                         disconnect_service) },
6109         { GDBUS_METHOD("Remove", NULL, NULL, remove_service) },
6110         { GDBUS_METHOD("MoveBefore",
6111                         GDBUS_ARGS({ "service", "o" }), NULL,
6112                         move_before) },
6113         { GDBUS_METHOD("MoveAfter",
6114                         GDBUS_ARGS({ "service", "o" }), NULL,
6115                         move_after) },
6116         { GDBUS_METHOD("ResetCounters", NULL, NULL, reset_counters) },
6117         { GDBUS_METHOD("GetUserFavorite",
6118                         NULL, GDBUS_ARGS({ "value", "v" }),
6119                         get_user_favorite) },
6120         { },
6121 };
6122
6123 static const GDBusSignalTable service_signals[] = {
6124         { GDBUS_SIGNAL("PropertyChanged",
6125                         GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
6126         { },
6127 };
6128
6129 static void service_free(gpointer user_data)
6130 {
6131         struct connman_service *service = user_data;
6132         char *path = service->path;
6133
6134         DBG("service %p", service);
6135
6136         reply_pending(service, ENOENT);
6137
6138         if (service->nameservers_timeout) {
6139                 g_source_remove(service->nameservers_timeout);
6140                 dns_changed(service);
6141         }
6142
6143         __connman_notifier_service_remove(service);
6144         service_schedule_removed(service);
6145
6146         __connman_wispr_stop(service);
6147         stats_stop(service);
6148
6149         service->path = NULL;
6150
6151         if (path) {
6152                 __connman_connection_update_gateway();
6153
6154                 g_dbus_unregister_interface(connection, path,
6155                                                 CONNMAN_SERVICE_INTERFACE);
6156                 g_free(path);
6157         }
6158
6159         g_hash_table_destroy(service->counter_table);
6160
6161         if (service->network) {
6162                 __connman_network_disconnect(service->network);
6163                 connman_network_unref(service->network);
6164                 service->network = NULL;
6165         }
6166
6167         if (service->provider)
6168                 connman_provider_unref(service->provider);
6169
6170         if (service->ipconfig_ipv4) {
6171                 __connman_ipconfig_set_ops(service->ipconfig_ipv4, NULL);
6172                 __connman_ipconfig_set_data(service->ipconfig_ipv4, NULL);
6173                 __connman_ipconfig_unref(service->ipconfig_ipv4);
6174                 service->ipconfig_ipv4 = NULL;
6175         }
6176
6177         if (service->ipconfig_ipv6) {
6178                 __connman_ipconfig_set_ops(service->ipconfig_ipv6, NULL);
6179                 __connman_ipconfig_set_data(service->ipconfig_ipv6, NULL);
6180                 __connman_ipconfig_unref(service->ipconfig_ipv6);
6181                 service->ipconfig_ipv6 = NULL;
6182         }
6183
6184         g_strfreev(service->timeservers);
6185         g_strfreev(service->timeservers_config);
6186         g_strfreev(service->nameservers);
6187         g_strfreev(service->nameservers_config);
6188         g_strfreev(service->nameservers_auto);
6189         g_strfreev(service->domains);
6190         g_strfreev(service->proxies);
6191         g_strfreev(service->excludes);
6192
6193         g_free(service->hostname);
6194         g_free(service->domainname);
6195         g_free(service->pac);
6196         g_free(service->name);
6197         g_free(service->passphrase);
6198         g_free(service->identifier);
6199         g_free(service->eap);
6200         g_free(service->identity);
6201         g_free(service->anonymous_identity);
6202         g_free(service->agent_identity);
6203         g_free(service->ca_cert_file);
6204         g_free(service->subject_match);
6205         g_free(service->altsubject_match);
6206         g_free(service->domain_suffix_match);
6207         g_free(service->domain_match);
6208         g_free(service->client_cert_file);
6209         g_free(service->private_key_file);
6210         g_free(service->private_key_passphrase);
6211         g_free(service->phase2);
6212         g_free(service->config_file);
6213         g_free(service->config_entry);
6214
6215         if (service->stats.timer)
6216                 g_timer_destroy(service->stats.timer);
6217         if (service->stats_roaming.timer)
6218                 g_timer_destroy(service->stats_roaming.timer);
6219
6220         if (current_default == service)
6221                 current_default = NULL;
6222
6223         g_free(service);
6224 }
6225
6226 static void stats_init(struct connman_service *service)
6227 {
6228         /* home */
6229         service->stats.valid = false;
6230         service->stats.enabled = false;
6231         service->stats.timer = g_timer_new();
6232
6233         /* roaming */
6234         service->stats_roaming.valid = false;
6235         service->stats_roaming.enabled = false;
6236         service->stats_roaming.timer = g_timer_new();
6237 }
6238
6239 static void service_initialize(struct connman_service *service)
6240 {
6241         DBG("service %p", service);
6242
6243         service->refcount = 1;
6244
6245         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
6246
6247         service->type     = CONNMAN_SERVICE_TYPE_UNKNOWN;
6248         service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
6249
6250         service->state = CONNMAN_SERVICE_STATE_UNKNOWN;
6251         service->state_ipv4 = CONNMAN_SERVICE_STATE_UNKNOWN;
6252         service->state_ipv6 = CONNMAN_SERVICE_STATE_UNKNOWN;
6253
6254         service->favorite  = false;
6255         service->immutable = false;
6256         service->hidden = false;
6257
6258         service->ignore = false;
6259
6260         service->user.favorite_user = USER_NONE;
6261         service->user.current_user = USER_NONE;
6262
6263         service->request_passphrase_input = false;
6264
6265         service->connect_reason = CONNMAN_SERVICE_CONNECT_REASON_NONE;
6266
6267         service->order = 0;
6268
6269         stats_init(service);
6270
6271         service->provider = NULL;
6272
6273         service->wps = false;
6274 #if defined TIZEN_EXT
6275         service->storage_reload = false;
6276         /*
6277          * Description: TIZEN implements system global connection management.
6278          */
6279         service->user_pdn_connection_refcount = 0;
6280         __sync_synchronize();
6281 #endif
6282 }
6283
6284 /**
6285  * connman_service_create:
6286  *
6287  * Allocate a new service.
6288  *
6289  * Returns: a newly-allocated #connman_service structure
6290  */
6291 struct connman_service *connman_service_create(void)
6292 {
6293         GSList *list;
6294         struct connman_stats_counter *counters;
6295         const char *counter;
6296
6297         struct connman_service *service;
6298
6299         service = g_try_new0(struct connman_service, 1);
6300         if (!service)
6301                 return NULL;
6302
6303         DBG("service %p", service);
6304
6305         service->counter_table = g_hash_table_new_full(g_str_hash,
6306                                                 g_str_equal, NULL, g_free);
6307
6308         for (list = counter_list; list; list = list->next) {
6309                 counter = list->data;
6310
6311                 counters = g_try_new0(struct connman_stats_counter, 1);
6312                 if (!counters) {
6313                         g_hash_table_destroy(service->counter_table);
6314                         g_free(service);
6315                         return NULL;
6316                 }
6317
6318                 counters->append_all = true;
6319
6320                 g_hash_table_replace(service->counter_table, (gpointer)counter,
6321                                 counters);
6322         }
6323
6324         service_initialize(service);
6325
6326         return service;
6327 }
6328
6329 /**
6330  * connman_service_ref:
6331  * @service: service structure
6332  *
6333  * Increase reference counter of service
6334  */
6335 struct connman_service *
6336 connman_service_ref_debug(struct connman_service *service,
6337                         const char *file, int line, const char *caller)
6338 {
6339         DBG("%p ref %d by %s:%d:%s()", service, service->refcount + 1,
6340                 file, line, caller);
6341
6342         __sync_fetch_and_add(&service->refcount, 1);
6343
6344         return service;
6345 }
6346
6347 /**
6348  * connman_service_unref:
6349  * @service: service structure
6350  *
6351  * Decrease reference counter of service and release service if no
6352  * longer needed.
6353  */
6354 void connman_service_unref_debug(struct connman_service *service,
6355                         const char *file, int line, const char *caller)
6356 {
6357         DBG("%p ref %d by %s:%d:%s()", service, service->refcount - 1,
6358                 file, line, caller);
6359
6360         if (__sync_fetch_and_sub(&service->refcount, 1) != 1)
6361                 return;
6362
6363         service_list = g_list_remove(service_list, service);
6364
6365         __connman_service_disconnect(service);
6366
6367         g_hash_table_remove(service_hash, service->identifier);
6368 }
6369
6370 static gint service_compare(gconstpointer a, gconstpointer b)
6371 {
6372         struct connman_service *service_a = (void *) a;
6373         struct connman_service *service_b = (void *) b;
6374         enum connman_service_state state_a, state_b;
6375         bool a_connected, b_connected;
6376         gint strength;
6377
6378         state_a = service_a->state;
6379         state_b = service_b->state;
6380         a_connected = is_connected(state_a);
6381         b_connected = is_connected(state_b);
6382
6383         if (a_connected && b_connected) {
6384                 if (service_a->order > service_b->order)
6385                         return -1;
6386
6387                 if (service_a->order < service_b->order)
6388                         return 1;
6389         }
6390
6391         if (state_a != state_b) {
6392                 if (a_connected && b_connected) {
6393                         /* We prefer online over ready state */
6394                         if (state_a == CONNMAN_SERVICE_STATE_ONLINE)
6395                                 return -1;
6396
6397                         if (state_b == CONNMAN_SERVICE_STATE_ONLINE)
6398                                 return 1;
6399                 }
6400
6401                 if (a_connected)
6402                         return -1;
6403                 if (b_connected)
6404                         return 1;
6405
6406                 if (is_connecting(state_a))
6407                         return -1;
6408                 if (is_connecting(state_b))
6409                         return 1;
6410         }
6411
6412         if (service_a->favorite && !service_b->favorite)
6413                 return -1;
6414
6415         if (!service_a->favorite && service_b->favorite)
6416                 return 1;
6417
6418         if (service_a->type != service_b->type) {
6419                 unsigned int *tech_array;
6420                 int i;
6421
6422                 tech_array = connman_setting_get_uint_list(
6423                                                 "PreferredTechnologies");
6424                 if (tech_array) {
6425                         for (i = 0; tech_array[i]; i++) {
6426                                 if (tech_array[i] == service_a->type)
6427                                         return -1;
6428
6429                                 if (tech_array[i] == service_b->type)
6430                                         return 1;
6431                         }
6432                 }
6433
6434                 if (service_a->type == CONNMAN_SERVICE_TYPE_ETHERNET)
6435                         return -1;
6436                 if (service_b->type == CONNMAN_SERVICE_TYPE_ETHERNET)
6437                         return 1;
6438
6439                 if (service_a->type == CONNMAN_SERVICE_TYPE_WIFI)
6440                         return -1;
6441                 if (service_b->type == CONNMAN_SERVICE_TYPE_WIFI)
6442                         return 1;
6443
6444                 if (service_a->type == CONNMAN_SERVICE_TYPE_CELLULAR)
6445                         return -1;
6446                 if (service_b->type == CONNMAN_SERVICE_TYPE_CELLULAR)
6447                         return 1;
6448
6449                 if (service_a->type == CONNMAN_SERVICE_TYPE_BLUETOOTH)
6450                         return -1;
6451                 if (service_b->type == CONNMAN_SERVICE_TYPE_BLUETOOTH)
6452                         return 1;
6453
6454                 if (service_a->type == CONNMAN_SERVICE_TYPE_VPN)
6455                         return -1;
6456                 if (service_b->type == CONNMAN_SERVICE_TYPE_VPN)
6457                         return 1;
6458
6459                 if (service_a->type == CONNMAN_SERVICE_TYPE_GADGET)
6460                         return -1;
6461                 if (service_b->type == CONNMAN_SERVICE_TYPE_GADGET)
6462                         return 1;
6463         }
6464
6465         strength = (gint) service_b->strength - (gint) service_a->strength;
6466         if (strength)
6467                 return strength;
6468
6469         return g_strcmp0(service_a->name, service_b->name);
6470 }
6471
6472 static void service_list_sort(void)
6473 {
6474         if (service_list && service_list->next) {
6475                 service_list = g_list_sort(service_list, service_compare);
6476                 service_schedule_changed();
6477         }
6478 }
6479
6480 int __connman_service_compare(const struct connman_service *a,
6481                                         const struct connman_service *b)
6482 {
6483         return service_compare(a, b);
6484 }
6485
6486 /**
6487  * connman_service_get_type:
6488  * @service: service structure
6489  *
6490  * Get the type of service
6491  */
6492 enum connman_service_type connman_service_get_type(struct connman_service *service)
6493 {
6494         if (!service)
6495                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
6496
6497         return service->type;
6498 }
6499
6500 /**
6501  * connman_service_get_interface:
6502  * @service: service structure
6503  *
6504  * Get network interface of service
6505  */
6506 char *connman_service_get_interface(struct connman_service *service)
6507 {
6508         int index;
6509
6510         if (!service)
6511                 return NULL;
6512
6513         index = __connman_service_get_index(service);
6514
6515         return connman_inet_ifname(index);
6516 }
6517
6518 /**
6519  * __connman_service_is_user_allowed:
6520  * @type: service type
6521  * @uid: user id
6522  *
6523  * Check a user is allowed to operate a type of service
6524  */
6525 bool __connman_service_is_user_allowed(enum connman_service_type type,
6526                                         uid_t uid)
6527 {
6528         GList *list;
6529         uid_t owner_user = USER_NONE;
6530
6531         for (list = service_list; list; list = list->next) {
6532                 struct connman_service *service = list->data;
6533
6534                 if (service->type != type)
6535                         continue;
6536
6537                 if (is_connected(service->state)) {
6538                         owner_user = service->user.favorite_user;
6539                         break;
6540                 }
6541         }
6542
6543         if (uid == USER_NONE ||
6544                         (uid != USER_ROOT &&
6545                         owner_user != USER_NONE &&
6546                         owner_user != uid))
6547                 return false;
6548
6549         return true;
6550 }
6551
6552 /**
6553  * connman_service_get_network:
6554  * @service: service structure
6555  *
6556  * Get the service network
6557  */
6558 struct connman_network *
6559 __connman_service_get_network(struct connman_service *service)
6560 {
6561         if (!service)
6562                 return NULL;
6563
6564         return service->network;
6565 }
6566
6567 struct connman_ipconfig *
6568 __connman_service_get_ip4config(struct connman_service *service)
6569 {
6570         if (!service)
6571                 return NULL;
6572
6573         return service->ipconfig_ipv4;
6574 }
6575
6576 struct connman_ipconfig *
6577 __connman_service_get_ip6config(struct connman_service *service)
6578 {
6579         if (!service)
6580                 return NULL;
6581
6582         return service->ipconfig_ipv6;
6583 }
6584
6585 struct connman_ipconfig *
6586 __connman_service_get_ipconfig(struct connman_service *service, int family)
6587 {
6588         if (family == AF_INET)
6589                 return __connman_service_get_ip4config(service);
6590         else if (family == AF_INET6)
6591                 return __connman_service_get_ip6config(service);
6592         else
6593                 return NULL;
6594
6595 }
6596
6597 bool __connman_service_is_connected_state(struct connman_service *service,
6598                                         enum connman_ipconfig_type type)
6599 {
6600         if (!service)
6601                 return false;
6602
6603         switch (type) {
6604         case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
6605                 break;
6606         case CONNMAN_IPCONFIG_TYPE_IPV4:
6607                 return is_connected(service->state_ipv4);
6608         case CONNMAN_IPCONFIG_TYPE_IPV6:
6609                 return is_connected(service->state_ipv6);
6610         case CONNMAN_IPCONFIG_TYPE_ALL:
6611                 return is_connected(service->state_ipv4) &&
6612                         is_connected(service->state_ipv6);
6613         }
6614
6615         return false;
6616 }
6617 enum connman_service_security __connman_service_get_security(
6618                                 struct connman_service *service)
6619 {
6620         if (!service)
6621                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
6622
6623         return service->security;
6624 }
6625
6626 const char *__connman_service_get_phase2(struct connman_service *service)
6627 {
6628         if (!service)
6629                 return NULL;
6630
6631         return service->phase2;
6632 }
6633
6634 bool __connman_service_wps_enabled(struct connman_service *service)
6635 {
6636         if (!service)
6637                 return false;
6638
6639         return service->wps;
6640 }
6641
6642 void __connman_service_mark_dirty(void)
6643 {
6644         services_dirty = true;
6645 }
6646
6647 #if defined TIZEN_EXT
6648 /**
6649   * Returns profile count if there is any connected profiles
6650   * that use same interface
6651   */
6652 int __connman_service_get_connected_count_of_iface(
6653                                         struct connman_service *service)
6654 {
6655         GList *list;
6656         int count = 0;
6657         int index1 = 0;
6658         int index2 = 0;
6659
6660         DBG("");
6661
6662         index1 = __connman_service_get_index(service);
6663
6664         if (index1 <= 0)
6665                 return 0;
6666
6667         for (list = service_list; list; list = list->next) {
6668                 struct connman_service *service2 = list->data;
6669
6670                 if (service == service2)
6671                         continue;
6672
6673                 index2 = __connman_service_get_index(service2);
6674
6675                 if (is_connected(service2->state) && index2 > 0 && index1 == index2)
6676                         count++;
6677
6678                 index2 = 0;
6679         }
6680
6681         DBG("Interface index %d, count %d", index1, count);
6682
6683         return count;
6684 }
6685
6686 void __connman_service_set_storage_reload(struct connman_service *service,
6687                                         bool storage_reload)
6688 {
6689         if (service != NULL)
6690                 service->storage_reload = storage_reload;
6691 }
6692 #endif
6693
6694 /**
6695  * __connman_service_set_favorite_delayed:
6696  * @service: service structure
6697  * @favorite: favorite value
6698  * @delay_ordering: do not order service sequence
6699  *
6700  * Change the favorite setting of service
6701  */
6702 int __connman_service_set_favorite_delayed(struct connman_service *service,
6703                                         bool favorite,
6704                                         bool delay_ordering)
6705 {
6706 #if defined TIZEN_EXT
6707         if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR)
6708                 return -EIO;
6709 #endif
6710         if (service->hidden)
6711                 return -EOPNOTSUPP;
6712
6713         if (service->favorite == favorite)
6714                 return -EALREADY;
6715
6716         service->favorite = favorite;
6717
6718         if (!delay_ordering)
6719                 __connman_service_get_order(service);
6720
6721         favorite_changed(service);
6722
6723         if (!delay_ordering) {
6724
6725                 service_list_sort();
6726
6727                 __connman_connection_update_gateway();
6728         }
6729
6730         return 0;
6731 }
6732
6733 /**
6734  * __connman_service_set_favorite:
6735  * @service: service structure
6736  * @favorite: favorite value
6737  *
6738  * Change the favorite setting of service
6739  */
6740 int __connman_service_set_favorite(struct connman_service *service,
6741                                                 bool favorite)
6742 {
6743         return __connman_service_set_favorite_delayed(service, favorite,
6744                                                         false);
6745 }
6746
6747 bool connman_service_get_favorite(struct connman_service *service)
6748 {
6749         return service->favorite;
6750 }
6751
6752 bool connman_service_get_autoconnect(struct connman_service *service)
6753 {
6754         return service->autoconnect;
6755 }
6756
6757 int __connman_service_set_immutable(struct connman_service *service,
6758                                                 bool immutable)
6759 {
6760         if (service->hidden)
6761                 return -EOPNOTSUPP;
6762
6763         if (service->immutable == immutable)
6764                 return 0;
6765
6766         service->immutable = immutable;
6767
6768         immutable_changed(service);
6769
6770         return 0;
6771 }
6772
6773 int __connman_service_set_ignore(struct connman_service *service,
6774                                                 bool ignore)
6775 {
6776         if (!service)
6777                 return -EINVAL;
6778
6779         service->ignore = ignore;
6780
6781         return 0;
6782 }
6783
6784 void __connman_service_set_string(struct connman_service *service,
6785                                   const char *key, const char *value)
6786 {
6787         if (service->hidden)
6788                 return;
6789         if (g_str_equal(key, "EAP")) {
6790                 g_free(service->eap);
6791                 service->eap = g_strdup(value);
6792         } else if (g_str_equal(key, "Identity")) {
6793                 g_free(service->identity);
6794                 service->identity = g_strdup(value);
6795         } else if (g_str_equal(key, "AnonymousIdentity")) {
6796                 g_free(service->anonymous_identity);
6797                 service->anonymous_identity = g_strdup(value);
6798         } else if (g_str_equal(key, "CACertFile")) {
6799                 g_free(service->ca_cert_file);
6800                 service->ca_cert_file = g_strdup(value);
6801         } else if (g_str_equal(key, "SubjectMatch")) {
6802                 g_free(service->subject_match);
6803                 service->subject_match = g_strdup(value);
6804         } else if (g_str_equal(key, "AltSubjectMatch")) {
6805                 g_free(service->altsubject_match);
6806                 service->altsubject_match = g_strdup(value);
6807         } else if (g_str_equal(key, "DomainSuffixMatch")) {
6808                 g_free(service->domain_suffix_match);
6809                 service->domain_suffix_match = g_strdup(value);
6810         } else if (g_str_equal(key, "DomainMatch")) {
6811                 g_free(service->domain_match);
6812                 service->domain_match = g_strdup(value);
6813         } else if (g_str_equal(key, "ClientCertFile")) {
6814                 g_free(service->client_cert_file);
6815                 service->client_cert_file = g_strdup(value);
6816         } else if (g_str_equal(key, "PrivateKeyFile")) {
6817                 g_free(service->private_key_file);
6818                 service->private_key_file = g_strdup(value);
6819         } else if (g_str_equal(key, "PrivateKeyPassphrase")) {
6820                 g_free(service->private_key_passphrase);
6821                 service->private_key_passphrase = g_strdup(value);
6822         } else if (g_str_equal(key, "Phase2")) {
6823                 g_free(service->phase2);
6824                 service->phase2 = g_strdup(value);
6825         } else if (g_str_equal(key, "Passphrase"))
6826                 __connman_service_set_passphrase(service, value);
6827 }
6828
6829 void __connman_service_set_search_domains(struct connman_service *service,
6830                                         char **domains)
6831 {
6832         searchdomain_remove_all(service);
6833
6834         if (service->domains)
6835                 g_strfreev(service->domains);
6836
6837         service->domains = g_strdupv(domains);
6838
6839         searchdomain_add_all(service);
6840 }
6841
6842 static void report_error_cb(void *user_context, bool retry,
6843                                                         void *user_data)
6844 {
6845         struct connman_service *service = user_context;
6846
6847         if (retry)
6848                 __connman_service_connect(service,
6849                                         CONNMAN_SERVICE_CONNECT_REASON_USER);
6850         else {
6851                 /* It is not relevant to stay on Failure state
6852                  * when failing is due to wrong user input */
6853                 __connman_service_clear_error(service);
6854 #if defined TIZEN_EXT
6855                 /* Reseting the state back in case of failure state */
6856                 service->state_ipv4 = service->state_ipv6 =
6857                                 CONNMAN_SERVICE_STATE_IDLE;
6858
6859                 if (service->error != CONNMAN_SERVICE_ERROR_AUTH_FAILED)
6860                         set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
6861 #endif
6862                 service_complete(service);
6863                 __connman_connection_update_gateway();
6864         }
6865 }
6866
6867 static int check_wpspin(struct connman_service *service, const char *wpspin)
6868 {
6869         int length;
6870         guint i;
6871
6872         if (!wpspin)
6873                 return 0;
6874
6875         length = strlen(wpspin);
6876
6877         /* If 0, it will mean user wants to use PBC method */
6878         if (length == 0) {
6879                 connman_network_set_string(service->network,
6880                                                         "WiFi.PinWPS", NULL);
6881                 return 0;
6882         }
6883
6884         /* A WPS PIN is always 8 chars length,
6885          * its content is in digit representation.
6886          */
6887         if (length != 8)
6888                 return -ENOKEY;
6889
6890         for (i = 0; i < 8; i++)
6891                 if (!isdigit((unsigned char) wpspin[i]))
6892                         return -ENOKEY;
6893
6894         connman_network_set_string(service->network, "WiFi.PinWPS", wpspin);
6895
6896         return 0;
6897 }
6898
6899 static void request_input_cb(struct connman_service *service,
6900                         bool values_received,
6901                         const char *name, int name_len,
6902                         const char *identity, const char *passphrase,
6903                         bool wps, const char *wpspin,
6904                         const char *error, void *user_data)
6905 {
6906         struct connman_device *device;
6907         const char *security;
6908         int err = 0;
6909
6910         DBG("RequestInput return, %p", service);
6911
6912         if (error) {
6913                 DBG("error: %s", error);
6914
6915                 if (g_strcmp0(error,
6916                                 "net.connman.Agent.Error.Canceled") == 0) {
6917                         err = -EINVAL;
6918
6919                         if (service->hidden)
6920                                 __connman_service_return_error(service,
6921                                                         ECONNABORTED,
6922                                                         user_data);
6923                         goto done;
6924                 } else {
6925                         if (service->hidden)
6926                                 __connman_service_return_error(service,
6927                                                         ETIMEDOUT, user_data);
6928                 }
6929         }
6930
6931         if (service->hidden && name_len > 0 && name_len <= 32) {
6932                 device = connman_network_get_device(service->network);
6933                 security = connman_network_get_string(service->network,
6934                                                         "WiFi.Security");
6935                 err = __connman_device_request_hidden_scan(device,
6936                                                 name, name_len,
6937                                                 identity, passphrase,
6938                                                 security, user_data);
6939                 if (err < 0)
6940                         __connman_service_return_error(service, -err,
6941                                                         user_data);
6942         }
6943
6944         if (!values_received || service->hidden) {
6945                 err = -EINVAL;
6946                 goto done;
6947         }
6948
6949         if (wps && service->network) {
6950                 err = check_wpspin(service, wpspin);
6951                 if (err < 0)
6952                         goto done;
6953
6954                 connman_network_set_bool(service->network, "WiFi.UseWPS", wps);
6955         }
6956
6957         if (identity)
6958                 __connman_service_set_agent_identity(service, identity);
6959
6960         if (passphrase)
6961                 err = __connman_service_set_passphrase(service, passphrase);
6962
6963  done:
6964         if (err >= 0) {
6965                 /* We forget any previous error. */
6966                 set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
6967
6968                 __connman_service_connect(service,
6969                                         CONNMAN_SERVICE_CONNECT_REASON_USER);
6970
6971         } else if (err == -ENOKEY) {
6972                 __connman_service_indicate_error(service,
6973                                         CONNMAN_SERVICE_ERROR_INVALID_KEY);
6974         } else {
6975                 /* It is not relevant to stay on Failure state
6976                  * when failing is due to wrong user input */
6977                 service->state = CONNMAN_SERVICE_STATE_IDLE;
6978
6979                 if (!service->hidden) {
6980                         /*
6981                          * If there was a real error when requesting
6982                          * hidden scan, then that error is returned already
6983                          * to the user somewhere above so do not try to
6984                          * do this again.
6985                          */
6986                         __connman_service_return_error(service, -err,
6987                                                         user_data);
6988                 }
6989
6990                 service_complete(service);
6991                 __connman_connection_update_gateway();
6992         }
6993 }
6994
6995 static void downgrade_connected_services(void)
6996 {
6997         struct connman_service *up_service;
6998         GList *list;
6999
7000         for (list = service_list; list; list = list->next) {
7001                 up_service = list->data;
7002
7003                 if (!is_connected(up_service->state))
7004                         continue;
7005
7006                 if (up_service->state == CONNMAN_SERVICE_STATE_ONLINE)
7007                         return;
7008
7009                 downgrade_state(up_service);
7010         }
7011 }
7012
7013 static int service_update_preferred_order(struct connman_service *default_service,
7014                 struct connman_service *new_service,
7015                 enum connman_service_state new_state)
7016 {
7017         unsigned int *tech_array;
7018         int i;
7019
7020         if (!default_service || default_service == new_service ||
7021                         default_service->state != new_state)
7022                 return 0;
7023
7024         tech_array = connman_setting_get_uint_list("PreferredTechnologies");
7025         if (tech_array) {
7026
7027                 for (i = 0; tech_array[i] != 0; i += 1) {
7028                         if (default_service->type == tech_array[i])
7029                                 return -EALREADY;
7030
7031                         if (new_service->type == tech_array[i]) {
7032                                 switch_default_service(default_service,
7033                                                 new_service);
7034                                 __connman_connection_update_gateway();
7035                                 return 0;
7036                         }
7037                 }
7038         }
7039
7040         return -EALREADY;
7041 }
7042
7043 #if defined TIZEN_EXT
7044 static gboolean __connman_service_can_drop(struct connman_service *service)
7045 {
7046         if (is_connected(service->state) == TRUE || is_connecting(service->state) == TRUE) {
7047                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
7048                         return TRUE;
7049                 else if (connman_service_is_no_ref_user_pdn_connection(service) == TRUE)
7050                         return TRUE;
7051         }
7052         return FALSE;
7053 }
7054
7055 static struct connman_device *default_connecting_device = NULL;
7056
7057 static void __connman_service_disconnect_default(struct connman_service *service)
7058 {
7059         struct connman_device *default_device = NULL;
7060
7061         if (default_connecting_device == NULL)
7062                 return;
7063
7064         default_device = connman_network_get_device(
7065                         __connman_service_get_network(service));
7066
7067         DBG("Disconnecting service %p %s", service, service->path);
7068         DBG("Disconnecting device %p %p %s",
7069                         default_connecting_device,
7070                         default_device,
7071                         connman_device_get_string(default_device, "Name"));
7072
7073         if (default_connecting_device == default_device)
7074                 default_connecting_device = NULL;
7075 }
7076
7077 static void __connman_service_connect_default(struct connman_service *current)
7078 {
7079         int err;
7080         GList *list;
7081         bool default_internet;
7082         struct connman_service *service;
7083         struct connman_service *default_service = NULL;
7084         struct connman_device *default_device = NULL;
7085
7086         if (current->type == CONNMAN_SERVICE_TYPE_CELLULAR) {
7087                 switch (current->state) {
7088                 case CONNMAN_SERVICE_STATE_UNKNOWN:
7089                 case CONNMAN_SERVICE_STATE_ASSOCIATION:
7090                 case CONNMAN_SERVICE_STATE_CONFIGURATION:
7091                         return;
7092                 default:
7093                         break;
7094                 }
7095
7096                 if (default_connecting_device &&
7097                                 __connman_service_is_internet_profile(current) == TRUE) {
7098                         if (current->network == NULL)
7099                                 return;
7100
7101                         default_device = connman_network_get_device(current->network);
7102                         if (default_connecting_device == default_device) {
7103                                 DBG("Cellular service[%s]  %p %s",
7104                                                 state2string(current->state), current, current->path);
7105                                 DBG("Cellular device %p %p %s",
7106                                                 default_connecting_device, default_device,
7107                                                 connman_device_get_string(default_device, "Name"));
7108
7109                                 default_connecting_device = NULL;
7110                         }
7111                 }
7112
7113                 return;
7114         } else if (is_connected(current->state) == TRUE || is_connecting(current->state) == TRUE)
7115                 return;
7116
7117         /* Always-on: keep default cellular connection as possible */
7118         for (list = service_list; list; list = list->next) {
7119                 service = list->data;
7120
7121                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR ||
7122                                 __connman_service_is_internet_profile(service) != TRUE ||
7123                                 service->network == NULL) {
7124                         continue;
7125                 }
7126
7127                 default_internet =
7128                                 connman_network_get_bool(service->network, "DefaultInternet");
7129
7130                 DBG("service: %p %s %s %s (default: %d)", service, service->name,
7131                                 __connman_service_type2string(service->type),
7132                                 state2string(service->state), default_internet);
7133
7134                 if (default_internet) {
7135                         default_service = service;
7136                         if (is_connected(default_service->state) == TRUE ||
7137                                         is_connecting(default_service->state) == TRUE)
7138                                 return;
7139
7140                         default_device = connman_network_get_device(default_service->network);
7141                         if (default_connecting_device == default_device) {
7142                                 DBG("Device is connecting (%p)", default_connecting_device);
7143                                 return;
7144                         }
7145
7146                         default_connecting_device = default_device;
7147                         default_service->connect_reason = CONNMAN_SERVICE_CONNECT_REASON_USER;
7148
7149                         err = __connman_network_connect(default_service->network);
7150                         DBG("Connecting default service %p %s [%d]",
7151                                         default_service, default_service->path, err);
7152                         DBG("Connecting device %p %s", default_connecting_device,
7153                                         connman_device_get_string(default_connecting_device, "Name"));
7154                         if (err < 0 && err != -EINPROGRESS) {
7155                                 default_connecting_device = NULL;
7156                         } else
7157                                 break;
7158                 }
7159         }
7160 }
7161 #endif
7162
7163 static void single_connected_tech(struct connman_service *allowed)
7164 {
7165         struct connman_service *service;
7166         GSList *services = NULL, *list;
7167         GList *iter;
7168
7169         DBG("keeping %p %s", allowed, allowed->path);
7170
7171 #if defined TIZEN_EXT
7172         if (!allowed || allowed->type == CONNMAN_SERVICE_TYPE_CELLULAR)
7173                 return;
7174 #endif
7175
7176         for (iter = service_list; iter; iter = iter->next) {
7177                 service = iter->data;
7178
7179 #if defined TIZEN_EXT
7180                 if (service != allowed && service->type != allowed->type &&
7181                                 __connman_service_can_drop(service) == TRUE)
7182 #else
7183                 if (!is_connected(service->state))
7184                         break;
7185
7186                 if (service == allowed)
7187                         continue;
7188 #endif
7189                 services = g_slist_prepend(services, service);
7190         }
7191
7192         for (list = services; list; list = list->next) {
7193                 service = list->data;
7194
7195                 DBG("disconnecting %p %s", service, service->path);
7196 #if defined TIZEN_EXT
7197                 __connman_service_disconnect_default(service);
7198 #endif
7199                 __connman_service_disconnect(service);
7200         }
7201
7202         g_slist_free(services);
7203 }
7204
7205 #if defined TIZEN_EXT
7206 static void set_priority_connected_service(void)
7207 {
7208         struct connman_service *service;
7209         GList *list;
7210
7211         for (list = service_list; list; list = list->next) {
7212                 service = list->data;
7213
7214                 if (is_connected(service->state) == FALSE)
7215                         service->order = 5;
7216                 else
7217                         service->order = 6;
7218         }
7219 }
7220 #endif
7221
7222 static const char *get_dbus_sender(struct connman_service *service)
7223 {
7224         if (!service->pending)
7225                 return NULL;
7226
7227         return dbus_message_get_sender(service->pending);
7228 }
7229
7230 static int service_indicate_state(struct connman_service *service)
7231 {
7232         enum connman_service_state old_state, new_state;
7233         struct connman_service *def_service;
7234         enum connman_ipconfig_method method;
7235         int result;
7236
7237         if (!service)
7238                 return -EINVAL;
7239
7240         old_state = service->state;
7241         new_state = combine_state(service->state_ipv4, service->state_ipv6);
7242
7243         DBG("service %p old %s - new %s/%s => %s",
7244                                         service,
7245                                         state2string(old_state),
7246                                         state2string(service->state_ipv4),
7247                                         state2string(service->state_ipv6),
7248                                         state2string(new_state));
7249
7250         if (old_state == new_state)
7251                 return -EALREADY;
7252
7253         def_service = __connman_service_get_default();
7254
7255         if (new_state == CONNMAN_SERVICE_STATE_ONLINE) {
7256                 result = service_update_preferred_order(def_service,
7257                                 service, new_state);
7258                 if (result == -EALREADY)
7259                         return result;
7260         }
7261
7262         if (old_state == CONNMAN_SERVICE_STATE_ONLINE)
7263                 __connman_notifier_leave_online(service->type);
7264
7265         if (is_connected(old_state) && !is_connected(new_state))
7266                 searchdomain_remove_all(service);
7267
7268         service->state = new_state;
7269         state_changed(service);
7270
7271         if (!is_connected(old_state) && is_connected(new_state))
7272                 searchdomain_add_all(service);
7273
7274         switch(new_state) {
7275         case CONNMAN_SERVICE_STATE_UNKNOWN:
7276
7277                 break;
7278
7279         case CONNMAN_SERVICE_STATE_IDLE:
7280                 if (old_state != CONNMAN_SERVICE_STATE_DISCONNECT)
7281                         __connman_service_disconnect(service);
7282
7283                 break;
7284
7285         case CONNMAN_SERVICE_STATE_ASSOCIATION:
7286
7287                 break;
7288
7289         case CONNMAN_SERVICE_STATE_CONFIGURATION:
7290                 if (!service->new_service &&
7291                                 __connman_stats_service_register(service) == 0) {
7292                         /*
7293                          * For new services the statistics are updated after
7294                          * we have successfully connected.
7295                          */
7296                         __connman_stats_get(service, false,
7297                                                 &service->stats.data);
7298                         __connman_stats_get(service, true,
7299                                                 &service->stats_roaming.data);
7300                 }
7301
7302                 break;
7303
7304         case CONNMAN_SERVICE_STATE_READY:
7305                 set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
7306
7307                 if (service->new_service &&
7308                                 __connman_stats_service_register(service) == 0) {
7309                         /*
7310                          * This is normally done after configuring state
7311                          * but for new service do this after we have connected
7312                          * successfully.
7313                          */
7314                         __connman_stats_get(service, false,
7315                                                 &service->stats.data);
7316                         __connman_stats_get(service, true,
7317                                                 &service->stats_roaming.data);
7318                 }
7319
7320                 service->new_service = false;
7321
7322                 default_changed();
7323
7324                 def_service = __connman_service_get_default();
7325
7326                 service_update_preferred_order(def_service, service, new_state);
7327
7328                 __connman_service_set_favorite(service, true);
7329
7330                 reply_pending(service, 0);
7331
7332                 if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
7333                         connman_network_get_bool(service->network,
7334                                                 "WiFi.UseWPS")) {
7335                         const char *pass;
7336
7337                         pass = connman_network_get_string(service->network,
7338                                                         "WiFi.Passphrase");
7339
7340                         __connman_service_set_passphrase(service, pass);
7341
7342                         connman_network_set_bool(service->network,
7343                                                         "WiFi.UseWPS", false);
7344                 }
7345
7346                 g_get_current_time(&service->modified);
7347                 service_save(service);
7348
7349                 domain_changed(service);
7350                 proxy_changed(service);
7351
7352                 if (old_state != CONNMAN_SERVICE_STATE_ONLINE)
7353                         __connman_notifier_connect(service->type);
7354
7355                 method = __connman_ipconfig_get_method(service->ipconfig_ipv6);
7356                 if (method == CONNMAN_IPCONFIG_METHOD_OFF)
7357                         __connman_ipconfig_disable_ipv6(
7358                                                 service->ipconfig_ipv6);
7359
7360                 if (connman_setting_get_bool("SingleConnectedTechnology"))
7361                         single_connected_tech(service);
7362                 else if (service->type != CONNMAN_SERVICE_TYPE_VPN)
7363                         vpn_auto_connect();
7364
7365 #if defined TIZEN_EXT
7366                 if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
7367                         set_priority_connected_service();
7368 #endif
7369
7370                 break;
7371
7372         case CONNMAN_SERVICE_STATE_ONLINE:
7373
7374                 break;
7375
7376         case CONNMAN_SERVICE_STATE_DISCONNECT:
7377                 set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
7378
7379                 reply_pending(service, ECONNABORTED);
7380
7381                 def_service = __connman_service_get_default();
7382                 service->disconnect_reason = connman_network_get_disconnect_reason(service->network);
7383                 service->assoc_status_code = connman_network_get_assoc_status_code(service->network);
7384
7385                 if (!__connman_notifier_is_connected() &&
7386                         def_service &&
7387                                 def_service->provider)
7388                         connman_provider_disconnect(def_service->provider);
7389
7390                 default_changed();
7391
7392                 __connman_wispr_stop(service);
7393
7394                 __connman_wpad_stop(service);
7395
7396 #if defined TIZEN_EXT
7397                 /**
7398                   * Skip the functions if there is any connected profiles
7399                   * that use same interface
7400                   */
7401                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR ||
7402                         __connman_service_get_connected_count_of_iface(
7403                                                         service) <= 0) {
7404 #endif
7405                 domain_changed(service);
7406                 proxy_changed(service);
7407 #if defined TIZEN_EXT
7408                 }
7409 #endif
7410
7411                 /*
7412                  * Previous services which are connected and which states
7413                  * are set to online should reset relevantly ipconfig_state
7414                  * to ready so wispr/portal will be rerun on those
7415                  */
7416                 downgrade_connected_services();
7417
7418                 __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
7419                 break;
7420
7421         case CONNMAN_SERVICE_STATE_FAILURE:
7422 #if defined TIZEN_EXT
7423                 if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
7424                         service->order = 5;
7425                 __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
7426 #endif
7427                 if (service->connect_reason == CONNMAN_SERVICE_CONNECT_REASON_USER &&
7428                         connman_agent_report_error(service, service->path,
7429                                         error2string(service->error),
7430                                         report_error_cb,
7431                                         get_dbus_sender(service),
7432                                         NULL) == -EINPROGRESS)
7433                         return 0;
7434                 service_complete(service);
7435
7436                 break;
7437         }
7438
7439         service_list_sort();
7440
7441 #if defined TIZEN_EXT
7442         __connman_service_connect_default(service);
7443 #endif
7444
7445         __connman_connection_update_gateway();
7446
7447         if ((old_state == CONNMAN_SERVICE_STATE_ONLINE &&
7448                         new_state != CONNMAN_SERVICE_STATE_READY) ||
7449                 (old_state == CONNMAN_SERVICE_STATE_READY &&
7450                         new_state != CONNMAN_SERVICE_STATE_ONLINE)) {
7451                 __connman_notifier_disconnect(service->type);
7452         }
7453
7454         if (new_state == CONNMAN_SERVICE_STATE_ONLINE) {
7455                 __connman_notifier_enter_online(service->type);
7456                 default_changed();
7457         }
7458
7459         if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
7460                 service->connect_reason == CONNMAN_SERVICE_CONNECT_REASON_USER &&
7461                 (new_state == CONNMAN_SERVICE_STATE_READY ||
7462                 new_state == CONNMAN_SERVICE_STATE_ONLINE)) {
7463                 if (service->user.favorite_user != service->user.current_user) {
7464                         DBG("Now set service favorite user id from %d to %d",
7465                         service->user.favorite_user, service->user.current_user);
7466
7467                         service->user.favorite_user = service->user.current_user;
7468
7469                         service_save(service);
7470                 }
7471         }
7472
7473         return 0;
7474 }
7475
7476 int __connman_service_indicate_error(struct connman_service *service,
7477                                         enum connman_service_error error)
7478 {
7479         DBG("service %p error %d", service, error);
7480
7481         if (!service)
7482                 return -EINVAL;
7483
7484         if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
7485                 return -EALREADY;
7486
7487         set_error(service, error);
7488
7489 /* default internet service: fix not cleared if pdp activation*/
7490 #if defined TIZEN_EXT
7491                 /*
7492                  * If connection failed for default service(DefaultInternet),
7493                  * default_connecting_device should be cleared.
7494                  */
7495                 if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR &&
7496                                 service->error == CONNMAN_SERVICE_ERROR_CONNECT_FAILED)
7497                         __connman_service_disconnect_default(service);
7498
7499                 if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
7500                                 service->error == CONNMAN_SERVICE_ERROR_INVALID_KEY) {
7501                         g_free(service->passphrase);
7502                         service->passphrase = NULL;
7503                 }
7504 #endif
7505
7506         __connman_service_ipconfig_indicate_state(service,
7507                                                 CONNMAN_SERVICE_STATE_FAILURE,
7508                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
7509         __connman_service_ipconfig_indicate_state(service,
7510                                                 CONNMAN_SERVICE_STATE_FAILURE,
7511                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
7512         return 0;
7513 }
7514
7515 int __connman_service_clear_error(struct connman_service *service)
7516 {
7517         DBusMessage *pending, *provider_pending;
7518
7519         DBG("service %p", service);
7520
7521         if (!service)
7522                 return -EINVAL;
7523
7524         if (service->state != CONNMAN_SERVICE_STATE_FAILURE)
7525                 return -EINVAL;
7526
7527         pending = service->pending;
7528         service->pending = NULL;
7529         provider_pending = service->provider_pending;
7530         service->provider_pending = NULL;
7531
7532         __connman_service_ipconfig_indicate_state(service,
7533                                                 CONNMAN_SERVICE_STATE_IDLE,
7534                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
7535
7536         __connman_service_ipconfig_indicate_state(service,
7537                                                 CONNMAN_SERVICE_STATE_IDLE,
7538                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
7539
7540         service->pending = pending;
7541         service->provider_pending = provider_pending;
7542
7543         return 0;
7544 }
7545
7546 int __connman_service_indicate_default(struct connman_service *service)
7547 {
7548         DBG("service %p state %s", service, state2string(service->state));
7549
7550         if (!is_connected(service->state)) {
7551                 /*
7552                  * If service is not yet fully connected, then we must not
7553                  * change the default yet. The default gw will be changed
7554                  * after the service state is in ready.
7555                  */
7556                 return -EINPROGRESS;
7557         }
7558
7559         default_changed();
7560
7561         return 0;
7562 }
7563
7564 enum connman_service_state __connman_service_ipconfig_get_state(
7565                                         struct connman_service *service,
7566                                         enum connman_ipconfig_type type)
7567 {
7568         if (!service)
7569                 return CONNMAN_SERVICE_STATE_UNKNOWN;
7570
7571         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
7572                 return service->state_ipv4;
7573
7574         if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
7575                 return service->state_ipv6;
7576
7577         return CONNMAN_SERVICE_STATE_UNKNOWN;
7578 }
7579
7580 static void check_proxy_setup(struct connman_service *service)
7581 {
7582         /*
7583          * We start WPAD if we haven't got a PAC URL from DHCP and
7584          * if our proxy manual configuration is either empty or set
7585          * to AUTO with an empty URL.
7586          */
7587
7588         if (service->proxy != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN)
7589                 goto done;
7590
7591         if (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN &&
7592                 (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_AUTO ||
7593                         service->pac))
7594                 goto done;
7595
7596         if (__connman_wpad_start(service) < 0) {
7597                 service->proxy = CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
7598                 __connman_notifier_proxy_changed(service);
7599                 goto done;
7600         }
7601
7602         return;
7603
7604 done:
7605         __connman_wispr_start(service, CONNMAN_IPCONFIG_TYPE_IPV4);
7606 }
7607
7608 #if defined TIZEN_EXT
7609 void connman_check_proxy_setup_and_wispr_start(struct connman_service *service){
7610
7611         DBG("check the proxy and start wispr");
7612         check_proxy_setup(service);
7613         return;
7614 }
7615 #endif
7616
7617 /*
7618  * How many networks are connected at the same time. If more than 1,
7619  * then set the rp_filter setting properly (loose mode routing) so that network
7620  * connectivity works ok. This is only done for IPv4 networks as IPv6
7621  * does not have rp_filter knob.
7622  */
7623 static int connected_networks_count;
7624 static int original_rp_filter;
7625
7626 static void service_rp_filter(struct connman_service *service,
7627                                 bool connected)
7628 {
7629         enum connman_ipconfig_method method;
7630
7631         method = __connman_ipconfig_get_method(service->ipconfig_ipv4);
7632
7633         switch (method) {
7634         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
7635         case CONNMAN_IPCONFIG_METHOD_OFF:
7636         case CONNMAN_IPCONFIG_METHOD_AUTO:
7637                 return;
7638         case CONNMAN_IPCONFIG_METHOD_FIXED:
7639         case CONNMAN_IPCONFIG_METHOD_MANUAL:
7640         case CONNMAN_IPCONFIG_METHOD_DHCP:
7641                 break;
7642         }
7643
7644         if (connected) {
7645                 if (connected_networks_count == 1) {
7646                         int filter_value;
7647                         filter_value = __connman_ipconfig_set_rp_filter();
7648                         if (filter_value < 0)
7649                                 return;
7650
7651                         original_rp_filter = filter_value;
7652                 }
7653                 connected_networks_count++;
7654
7655         } else {
7656                 if (connected_networks_count == 2)
7657                         __connman_ipconfig_unset_rp_filter(original_rp_filter);
7658
7659                 connected_networks_count--;
7660                 if (connected_networks_count < 0)
7661                         connected_networks_count = 0;
7662         }
7663
7664         DBG("%s %s ipconfig %p method %d count %d filter %d",
7665                 connected ? "connected" : "disconnected", service->identifier,
7666                 service->ipconfig_ipv4, method,
7667                 connected_networks_count, original_rp_filter);
7668 }
7669
7670 static gboolean redo_wispr(gpointer user_data)
7671 {
7672         struct connman_service *service = user_data;
7673         int refcount = service->refcount - 1;
7674
7675         connman_service_unref(service);
7676         if (refcount == 0) {
7677                 DBG("Service %p already removed", service);
7678                 return FALSE;
7679         }
7680
7681         __connman_wispr_start(service, CONNMAN_IPCONFIG_TYPE_IPV6);
7682
7683         return FALSE;
7684 }
7685
7686 int __connman_service_online_check_failed(struct connman_service *service,
7687                                         enum connman_ipconfig_type type)
7688 {
7689         DBG("service %p type %d count %d", service, type,
7690                                                 service->online_check_count);
7691
7692         /* currently we only retry IPv6 stuff */
7693         if (type == CONNMAN_IPCONFIG_TYPE_IPV4 ||
7694                         service->online_check_count != 1) {
7695                 connman_warn("Online check failed for %p %s", service,
7696                         service->name);
7697                 return 0;
7698         }
7699
7700         service->online_check_count = 0;
7701
7702         /*
7703          * We set the timeout to 1 sec so that we have a chance to get
7704          * necessary IPv6 router advertisement messages that might have
7705          * DNS data etc.
7706          */
7707         g_timeout_add_seconds(1, redo_wispr, connman_service_ref(service));
7708
7709         return EAGAIN;
7710 }
7711
7712 int __connman_service_ipconfig_indicate_state(struct connman_service *service,
7713                                         enum connman_service_state new_state,
7714                                         enum connman_ipconfig_type type)
7715 {
7716         struct connman_ipconfig *ipconfig = NULL;
7717         enum connman_service_state old_state;
7718         enum connman_ipconfig_method method;
7719
7720         if (!service)
7721                 return -EINVAL;
7722
7723         switch (type) {
7724         case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
7725         case CONNMAN_IPCONFIG_TYPE_ALL:
7726                 return -EINVAL;
7727
7728         case CONNMAN_IPCONFIG_TYPE_IPV4:
7729                 old_state = service->state_ipv4;
7730                 ipconfig = service->ipconfig_ipv4;
7731
7732                 break;
7733
7734         case CONNMAN_IPCONFIG_TYPE_IPV6:
7735                 old_state = service->state_ipv6;
7736                 ipconfig = service->ipconfig_ipv6;
7737
7738                 break;
7739         }
7740
7741         if (!ipconfig)
7742                 return -EINVAL;
7743
7744         method = __connman_ipconfig_get_method(ipconfig);
7745
7746         switch (method) {
7747         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
7748         case CONNMAN_IPCONFIG_METHOD_OFF:
7749                 if (new_state != CONNMAN_SERVICE_STATE_IDLE)
7750                         connman_warn("ipconfig state %d ipconfig method %d",
7751                                 new_state, method);
7752
7753                 new_state = CONNMAN_SERVICE_STATE_IDLE;
7754                 break;
7755
7756         case CONNMAN_IPCONFIG_METHOD_FIXED:
7757         case CONNMAN_IPCONFIG_METHOD_MANUAL:
7758         case CONNMAN_IPCONFIG_METHOD_DHCP:
7759         case CONNMAN_IPCONFIG_METHOD_AUTO:
7760                 break;
7761
7762         }
7763
7764         /* Any change? */
7765         if (old_state == new_state)
7766                 return -EALREADY;
7767
7768 #if defined TIZEN_EXT
7769         __sync_synchronize();
7770         if (service->user_pdn_connection_refcount > 0 &&
7771                         service->type == CONNMAN_SERVICE_TYPE_CELLULAR)
7772                 if (new_state == CONNMAN_SERVICE_STATE_FAILURE ||
7773                                 new_state == CONNMAN_SERVICE_STATE_DISCONNECT ||
7774                                 new_state == CONNMAN_SERVICE_STATE_IDLE) {
7775                         service->user_pdn_connection_refcount = 0;
7776                         __sync_synchronize();
7777                 }
7778 #endif
7779
7780         DBG("service %p (%s) old state %d (%s) new state %d (%s) type %d (%s)",
7781                 service, service ? service->identifier : NULL,
7782                 old_state, state2string(old_state),
7783                 new_state, state2string(new_state),
7784                 type, __connman_ipconfig_type2string(type));
7785
7786         switch (new_state) {
7787         case CONNMAN_SERVICE_STATE_UNKNOWN:
7788         case CONNMAN_SERVICE_STATE_ASSOCIATION:
7789                 break;
7790         case CONNMAN_SERVICE_STATE_CONFIGURATION:
7791                 break;
7792         case CONNMAN_SERVICE_STATE_READY:
7793 #if defined TIZEN_EXT
7794                 if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR &&
7795                                 __connman_service_is_internet_profile(service) != TRUE) {
7796                         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
7797                                 service_rp_filter(service, TRUE);
7798
7799                         break;
7800                 }
7801 #endif
7802                 if (connman_setting_get_bool("EnableOnlineCheck")) {
7803                         if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
7804 #if !defined TIZEN_EXT
7805                                 check_proxy_setup(service);
7806 #endif
7807                         } else {
7808                                 service->online_check_count = 1;
7809                                 __connman_wispr_start(service, type);
7810                         }
7811                 } else
7812                         connman_info("Online check disabled. "
7813                                 "Default service remains in READY state.");
7814                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
7815                         service_rp_filter(service, true);
7816                 break;
7817         case CONNMAN_SERVICE_STATE_ONLINE:
7818                 break;
7819         case CONNMAN_SERVICE_STATE_DISCONNECT:
7820                 if (service->state == CONNMAN_SERVICE_STATE_IDLE)
7821                         return -EINVAL;
7822
7823                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
7824                         service_rp_filter(service, false);
7825
7826                 break;
7827
7828         case CONNMAN_SERVICE_STATE_IDLE:
7829         case CONNMAN_SERVICE_STATE_FAILURE:
7830                 __connman_ipconfig_disable(ipconfig);
7831
7832                 break;
7833         }
7834
7835         if (is_connected(old_state) && !is_connected(new_state))
7836                 nameserver_remove_all(service, type);
7837
7838         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
7839                 service->state_ipv4 = new_state;
7840         else
7841                 service->state_ipv6 = new_state;
7842
7843         if (!is_connected(old_state) && is_connected(new_state))
7844                 nameserver_add_all(service, type);
7845
7846         __connman_timeserver_sync(service);
7847
7848 #if defined TIZEN_EXT
7849         int ret = service_indicate_state(service);
7850         /*Sent the Ready changed signal again in case IPv4 IP set
7851           after IPv6 IP set*/
7852
7853         if(ret == -EALREADY && type == CONNMAN_IPCONFIG_TYPE_IPV4
7854                         && new_state == CONNMAN_SERVICE_STATE_READY) {
7855                 DBG("Notify IPv4 state new/old %d/%d", new_state,old_state);
7856                 state_changed(service);
7857         }
7858
7859         return ret;
7860 #endif
7861         return service_indicate_state(service);
7862 }
7863
7864 static bool prepare_network(struct connman_service *service)
7865 {
7866         enum connman_network_type type;
7867         unsigned int ssid_len;
7868
7869         type = connman_network_get_type(service->network);
7870
7871         switch (type) {
7872         case CONNMAN_NETWORK_TYPE_UNKNOWN:
7873         case CONNMAN_NETWORK_TYPE_VENDOR:
7874                 return false;
7875         case CONNMAN_NETWORK_TYPE_WIFI:
7876                 if (!connman_network_get_blob(service->network, "WiFi.SSID",
7877                                                 &ssid_len))
7878                         return false;
7879
7880                 if (service->passphrase)
7881                         connman_network_set_string(service->network,
7882                                 "WiFi.Passphrase", service->passphrase);
7883                 break;
7884         case CONNMAN_NETWORK_TYPE_ETHERNET:
7885         case CONNMAN_NETWORK_TYPE_GADGET:
7886         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
7887         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
7888         case CONNMAN_NETWORK_TYPE_CELLULAR:
7889                 break;
7890         }
7891
7892         return true;
7893 }
7894
7895 static void prepare_8021x(struct connman_service *service)
7896 {
7897         if (service->eap)
7898                 connman_network_set_string(service->network, "WiFi.EAP",
7899                                                                 service->eap);
7900
7901         if (service->identity)
7902                 connman_network_set_string(service->network, "WiFi.Identity",
7903                                                         service->identity);
7904
7905         if (service->anonymous_identity)
7906                 connman_network_set_string(service->network,
7907                                                 "WiFi.AnonymousIdentity",
7908                                                 service->anonymous_identity);
7909
7910         if (service->ca_cert_file)
7911                 connman_network_set_string(service->network, "WiFi.CACertFile",
7912                                                         service->ca_cert_file);
7913
7914         if (service->subject_match)
7915                 connman_network_set_string(service->network, "WiFi.SubjectMatch",
7916                                                         service->subject_match);
7917
7918         if (service->altsubject_match)
7919                 connman_network_set_string(service->network, "WiFi.AltSubjectMatch",
7920                                                         service->altsubject_match);
7921
7922         if (service->domain_suffix_match)
7923                 connman_network_set_string(service->network, "WiFi.DomainSuffixMatch",
7924                                                         service->domain_suffix_match);
7925
7926         if (service->domain_match)
7927                 connman_network_set_string(service->network, "WiFi.DomainMatch",
7928                                                         service->domain_match);
7929
7930         if (service->client_cert_file)
7931                 connman_network_set_string(service->network,
7932                                                 "WiFi.ClientCertFile",
7933                                                 service->client_cert_file);
7934
7935         if (service->private_key_file)
7936                 connman_network_set_string(service->network,
7937                                                 "WiFi.PrivateKeyFile",
7938                                                 service->private_key_file);
7939
7940         if (service->private_key_passphrase)
7941                 connman_network_set_string(service->network,
7942                                         "WiFi.PrivateKeyPassphrase",
7943                                         service->private_key_passphrase);
7944
7945         if (service->phase2)
7946                 connman_network_set_string(service->network, "WiFi.Phase2",
7947                                                         service->phase2);
7948 }
7949
7950 static int service_connect(struct connman_service *service)
7951 {
7952         int err;
7953
7954         if (service->hidden)
7955                 return -EPERM;
7956
7957 #if defined TIZEN_EXT
7958         GList *list;
7959         int index;
7960
7961         index = __connman_service_get_index(service);
7962
7963         for (list = service_list; list; list = list->next) {
7964                 struct connman_service *temp = list->data;
7965
7966                 if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR)
7967                         break;
7968
7969                 if (!is_connecting(temp->state) && !is_connected(temp->state))
7970                         break;
7971
7972                 if (service == temp)
7973                         continue;
7974
7975                 if (service->type != temp->type)
7976                         continue;
7977
7978                 if (__connman_service_get_index(temp) == index &&
7979                                 __connman_service_disconnect(temp) == -EINPROGRESS)
7980                         return -EINPROGRESS;
7981         }
7982 #endif
7983
7984         switch (service->type) {
7985         case CONNMAN_SERVICE_TYPE_UNKNOWN:
7986         case CONNMAN_SERVICE_TYPE_SYSTEM:
7987         case CONNMAN_SERVICE_TYPE_GPS:
7988         case CONNMAN_SERVICE_TYPE_P2P:
7989                 return -EINVAL;
7990         case CONNMAN_SERVICE_TYPE_ETHERNET:
7991         case CONNMAN_SERVICE_TYPE_GADGET:
7992         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
7993         case CONNMAN_SERVICE_TYPE_CELLULAR:
7994         case CONNMAN_SERVICE_TYPE_VPN:
7995                 break;
7996         case CONNMAN_SERVICE_TYPE_WIFI:
7997                 switch (service->security) {
7998                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
7999                 case CONNMAN_SERVICE_SECURITY_NONE:
8000                         break;
8001                 case CONNMAN_SERVICE_SECURITY_WEP:
8002                 case CONNMAN_SERVICE_SECURITY_PSK:
8003                 case CONNMAN_SERVICE_SECURITY_WPA:
8004                 case CONNMAN_SERVICE_SECURITY_RSN:
8005                         if (service->error == CONNMAN_SERVICE_ERROR_INVALID_KEY)
8006                                 return -ENOKEY;
8007
8008                         if (service->request_passphrase_input) {
8009                                 DBG("Now try to connect other user's favorite service");
8010                                 service->request_passphrase_input = false;
8011                                 return -ENOKEY;
8012                         } else if (!service->passphrase) {
8013                                 if (!service->network)
8014                                         return -EOPNOTSUPP;
8015
8016                                 if (!service->wps ||
8017                                         !connman_network_get_bool(service->network, "WiFi.UseWPS"))
8018                                         return -ENOKEY;
8019                         }
8020                         break;
8021
8022                 case CONNMAN_SERVICE_SECURITY_8021X:
8023                         if (!service->eap)
8024                                 return -EINVAL;
8025
8026 #if defined TIZEN_EXT
8027                         /*
8028                          * never request credentials if using EAP-TLS, EAP-SIM
8029                          * or EAP-AKA (EAP-TLS, EAP-SIM and EAP-AKA networks
8030                          * need to be fully provisioned)
8031                          */
8032                         DBG("service eap: %s", service->eap);
8033                         if (g_str_equal(service->eap, "tls") ||
8034                                 g_str_equal(service->eap, "sim") ||
8035                                 g_str_equal(service->eap, "aka"))
8036                                 break;
8037 #else
8038                         /*
8039                          * never request credentials if using EAP-TLS
8040                          * (EAP-TLS networks need to be fully provisioned)
8041                          */
8042                         if (g_str_equal(service->eap, "tls"))
8043                                 break;
8044 #endif
8045                         /*
8046                          * Return -ENOKEY if either identity or passphrase is
8047                          * missing. Agent provided credentials can be used as
8048                          * fallback if needed.
8049                          */
8050                         if (((!service->identity &&
8051                                         !service->agent_identity) ||
8052                                         !service->passphrase) ||
8053                                         service->error == CONNMAN_SERVICE_ERROR_INVALID_KEY)
8054                                 return -ENOKEY;
8055
8056                         break;
8057                 }
8058                 break;
8059         }
8060
8061         if (service->network) {
8062                 if (!prepare_network(service))
8063                         return -EINVAL;
8064
8065                 switch (service->security) {
8066                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
8067                 case CONNMAN_SERVICE_SECURITY_NONE:
8068                 case CONNMAN_SERVICE_SECURITY_WEP:
8069                 case CONNMAN_SERVICE_SECURITY_PSK:
8070                 case CONNMAN_SERVICE_SECURITY_WPA:
8071                 case CONNMAN_SERVICE_SECURITY_RSN:
8072                         break;
8073                 case CONNMAN_SERVICE_SECURITY_8021X:
8074                         prepare_8021x(service);
8075                         break;
8076                 }
8077
8078                 if (__connman_stats_service_register(service) == 0) {
8079                         __connman_stats_get(service, false,
8080                                                 &service->stats.data);
8081                         __connman_stats_get(service, true,
8082                                                 &service->stats_roaming.data);
8083                 }
8084
8085                 err = __connman_network_connect(service->network);
8086         } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
8087                                         service->provider)
8088                 err = __connman_provider_connect(service->provider,
8089                                                 get_dbus_sender(service));
8090         else
8091                 return -EOPNOTSUPP;
8092
8093         if (err < 0) {
8094                 if (err != -EINPROGRESS) {
8095                         __connman_service_ipconfig_indicate_state(service,
8096                                                 CONNMAN_SERVICE_STATE_FAILURE,
8097                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
8098                         __connman_service_ipconfig_indicate_state(service,
8099                                                 CONNMAN_SERVICE_STATE_FAILURE,
8100                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
8101                         __connman_stats_service_unregister(service);
8102                 }
8103         }
8104
8105         return err;
8106 }
8107
8108 int __connman_service_connect(struct connman_service *service,
8109                         enum connman_service_connect_reason reason)
8110 {
8111         int err;
8112
8113         DBG("service %p state %s connect reason %s -> %s",
8114                 service, state2string(service->state),
8115                 reason2string(service->connect_reason),
8116                 reason2string(reason));
8117
8118         if (is_connected(service->state))
8119                 return -EISCONN;
8120
8121         if (is_connecting(service->state))
8122                 return -EALREADY;
8123
8124         switch (service->type) {
8125         case CONNMAN_SERVICE_TYPE_UNKNOWN:
8126         case CONNMAN_SERVICE_TYPE_SYSTEM:
8127         case CONNMAN_SERVICE_TYPE_GPS:
8128         case CONNMAN_SERVICE_TYPE_P2P:
8129                 return -EINVAL;
8130
8131         case CONNMAN_SERVICE_TYPE_ETHERNET:
8132         case CONNMAN_SERVICE_TYPE_GADGET:
8133         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
8134         case CONNMAN_SERVICE_TYPE_CELLULAR:
8135         case CONNMAN_SERVICE_TYPE_VPN:
8136         case CONNMAN_SERVICE_TYPE_WIFI:
8137                 break;
8138         }
8139
8140         if (!is_ipconfig_usable(service))
8141                 return -ENOLINK;
8142
8143         __connman_service_clear_error(service);
8144
8145         err = service_connect(service);
8146
8147         DBG("service %p err %d", service, err);
8148
8149         service->connect_reason = reason;
8150         if (err >= 0)
8151                 return 0;
8152
8153         if (err == -EINPROGRESS) {
8154                 if (service->timeout == 0)
8155                         service->timeout = g_timeout_add_seconds(
8156                                 CONNECT_TIMEOUT, connect_timeout, service);
8157
8158                 return -EINPROGRESS;
8159         }
8160
8161         if (service->network)
8162                 __connman_network_disconnect(service->network);
8163         else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
8164                                 service->provider)
8165                         connman_provider_disconnect(service->provider);
8166
8167         if (service->connect_reason == CONNMAN_SERVICE_CONNECT_REASON_USER) {
8168                 if (err == -ENOKEY || err == -EPERM) {
8169                         DBusMessage *pending = NULL;
8170                         const char *dbus_sender = get_dbus_sender(service);
8171
8172                         /*
8173                          * We steal the reply here. The idea is that the
8174                          * connecting client will see the connection status
8175                          * after the real hidden network is connected or
8176                          * connection failed.
8177                          */
8178                         if (service->hidden) {
8179                                 pending = service->pending;
8180                                 service->pending = NULL;
8181                         }
8182
8183                         err = __connman_agent_request_passphrase_input(service,
8184                                         request_input_cb,
8185                                         dbus_sender,
8186                                         pending);
8187                         if (service->hidden && err != -EINPROGRESS)
8188                                 service->pending = pending;
8189
8190                         return err;
8191                 }
8192                 reply_pending(service, -err);
8193         }
8194
8195         return err;
8196 }
8197
8198 int __connman_service_disconnect(struct connman_service *service)
8199 {
8200         int err;
8201
8202         DBG("service %p", service);
8203
8204         service->connect_reason = CONNMAN_SERVICE_CONNECT_REASON_NONE;
8205         service->proxy = CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
8206
8207         connman_agent_cancel(service);
8208
8209         reply_pending(service, ECONNABORTED);
8210
8211         if (service->network) {
8212                 err = __connman_network_disconnect(service->network);
8213         } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
8214                                         service->provider)
8215                 err = connman_provider_disconnect(service->provider);
8216         else
8217                 return -EOPNOTSUPP;
8218
8219         if (err < 0 && err != -EINPROGRESS)
8220                 return err;
8221
8222         __connman_6to4_remove(service->ipconfig_ipv4);
8223
8224         if (service->ipconfig_ipv4)
8225                 __connman_ipconfig_set_proxy_autoconfig(service->ipconfig_ipv4,
8226                                                         NULL);
8227         else
8228                 __connman_ipconfig_set_proxy_autoconfig(service->ipconfig_ipv6,
8229                                                         NULL);
8230
8231 #if defined TIZEN_EXT
8232         /**
8233           * Skip the functions If there is any connected profiles
8234           * that use same interface
8235           */
8236         if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR ||
8237                 __connman_service_get_connected_count_of_iface(service) <= 0) {
8238 #endif
8239         __connman_ipconfig_address_remove(service->ipconfig_ipv4);
8240         settings_changed(service, service->ipconfig_ipv4);
8241
8242         __connman_ipconfig_address_remove(service->ipconfig_ipv6);
8243         settings_changed(service, service->ipconfig_ipv6);
8244
8245         __connman_ipconfig_disable(service->ipconfig_ipv4);
8246         __connman_ipconfig_disable(service->ipconfig_ipv6);
8247 #if defined TIZEN_EXT
8248         }
8249 #endif
8250
8251         __connman_stats_service_unregister(service);
8252
8253         return err;
8254 }
8255
8256 int __connman_service_disconnect_all(void)
8257 {
8258         struct connman_service *service;
8259         GSList *services = NULL, *list;
8260         GList *iter;
8261
8262         DBG("");
8263
8264         for (iter = service_list; iter; iter = iter->next) {
8265                 service = iter->data;
8266
8267                 if (!is_connected(service->state))
8268                         break;
8269
8270                 services = g_slist_prepend(services, service);
8271         }
8272
8273         for (list = services; list; list = list->next) {
8274                 struct connman_service *service = list->data;
8275
8276                 service->ignore = true;
8277
8278                 __connman_service_disconnect(service);
8279         }
8280
8281         g_slist_free(services);
8282
8283         return 0;
8284 }
8285
8286 /**
8287  * lookup_by_identifier:
8288  * @identifier: service identifier
8289  *
8290  * Look up a service by identifier (reference count will not be increased)
8291  */
8292 static struct connman_service *lookup_by_identifier(const char *identifier)
8293 {
8294         return g_hash_table_lookup(service_hash, identifier);
8295 }
8296
8297 struct connman_service *connman_service_lookup_from_identifier(const char* identifier)
8298 {
8299         return lookup_by_identifier(identifier);
8300 }
8301
8302 struct provision_user_data {
8303         const char *ident;
8304         int ret;
8305 };
8306
8307 static void provision_changed(gpointer value, gpointer user_data)
8308 {
8309         struct connman_service *service = value;
8310         struct provision_user_data *data = user_data;
8311         const char *path = data->ident;
8312         int ret;
8313
8314         ret = __connman_config_provision_service_ident(service, path,
8315                         service->config_file, service->config_entry);
8316         if (ret > 0)
8317                 data->ret = ret;
8318 }
8319
8320 int __connman_service_provision_changed(const char *ident)
8321 {
8322         struct provision_user_data data = {
8323                 .ident = ident,
8324                 .ret = 0
8325         };
8326
8327         g_list_foreach(service_list, provision_changed, (void *)&data);
8328
8329         /*
8330          * Because the provision_changed() might have set some services
8331          * as favorite, we must sort the sequence now.
8332          */
8333         if (services_dirty) {
8334                 services_dirty = false;
8335
8336                 service_list_sort();
8337
8338                 __connman_connection_update_gateway();
8339         }
8340
8341         return data.ret;
8342 }
8343
8344 void __connman_service_set_config(struct connman_service *service,
8345                                 const char *file_id, const char *entry)
8346 {
8347         if (!service)
8348                 return;
8349
8350         g_free(service->config_file);
8351         service->config_file = g_strdup(file_id);
8352
8353         g_free(service->config_entry);
8354         service->config_entry = g_strdup(entry);
8355 }
8356
8357 /**
8358  * __connman_service_get:
8359  * @identifier: service identifier
8360  *
8361  * Look up a service by identifier or create a new one if not found
8362  */
8363 static struct connman_service *service_get(const char *identifier)
8364 {
8365         struct connman_service *service;
8366
8367         service = g_hash_table_lookup(service_hash, identifier);
8368         if (service) {
8369                 connman_service_ref(service);
8370                 return service;
8371         }
8372
8373         service = connman_service_create();
8374         if (!service)
8375                 return NULL;
8376
8377         DBG("service %p", service);
8378
8379         service->identifier = g_strdup(identifier);
8380
8381         service_list = g_list_insert_sorted(service_list, service,
8382                                                 service_compare);
8383
8384         g_hash_table_insert(service_hash, service->identifier, service);
8385
8386         return service;
8387 }
8388
8389 static int service_register(struct connman_service *service)
8390 {
8391         DBG("service %p", service);
8392
8393         if (service->path)
8394                 return -EALREADY;
8395
8396         service->path = g_strdup_printf("%s/service/%s", CONNMAN_PATH,
8397                                                 service->identifier);
8398
8399         DBG("path %s", service->path);
8400
8401         if (__connman_config_provision_service(service) < 0)
8402                 service_load(service);
8403
8404         g_dbus_register_interface(connection, service->path,
8405                                         CONNMAN_SERVICE_INTERFACE,
8406                                         service_methods, service_signals,
8407                                                         NULL, service, NULL);
8408
8409         service_list_sort();
8410
8411         __connman_connection_update_gateway();
8412
8413         return 0;
8414 }
8415
8416 static void service_up(struct connman_ipconfig *ipconfig,
8417                 const char *ifname)
8418 {
8419         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
8420
8421         DBG("%s up", ifname);
8422
8423         link_changed(service);
8424
8425         service->stats.valid = false;
8426         service->stats_roaming.valid = false;
8427 }
8428
8429 static void service_down(struct connman_ipconfig *ipconfig,
8430                         const char *ifname)
8431 {
8432         DBG("%s down", ifname);
8433 }
8434
8435 static void service_lower_up(struct connman_ipconfig *ipconfig,
8436                         const char *ifname)
8437 {
8438         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
8439
8440         DBG("%s lower up", ifname);
8441
8442         stats_start(service);
8443 }
8444
8445 static void service_lower_down(struct connman_ipconfig *ipconfig,
8446                         const char *ifname)
8447 {
8448         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
8449
8450         DBG("%s lower down", ifname);
8451
8452         stats_stop(service);
8453         service_save(service);
8454 }
8455
8456 static void service_ip_bound(struct connman_ipconfig *ipconfig,
8457                         const char *ifname)
8458 {
8459         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
8460         enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
8461         enum connman_ipconfig_type type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
8462 #if defined TIZEN_EXT
8463         int err;
8464 #endif
8465
8466         DBG("%s ip bound", ifname);
8467
8468         type = __connman_ipconfig_get_config_type(ipconfig);
8469         method = __connman_ipconfig_get_method(ipconfig);
8470
8471         DBG("service %p ipconfig %p type %d method %d", service, ipconfig,
8472                                                         type, method);
8473
8474         if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
8475                         method == CONNMAN_IPCONFIG_METHOD_AUTO)
8476 #if defined TIZEN_EXT
8477         {
8478                 err = __connman_ipconfig_gateway_add(ipconfig, service);
8479
8480                 if(err < 0)
8481                         DBG("Failed to add gateway");
8482         }
8483 #else
8484                 __connman_service_ipconfig_indicate_state(service,
8485                                                 CONNMAN_SERVICE_STATE_READY,
8486                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
8487 #endif
8488
8489         settings_changed(service, ipconfig);
8490         address_updated(service, type);
8491 }
8492
8493 static void service_ip_release(struct connman_ipconfig *ipconfig,
8494                         const char *ifname)
8495 {
8496         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
8497         enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
8498         enum connman_ipconfig_type type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
8499
8500         DBG("%s ip release", ifname);
8501
8502         type = __connman_ipconfig_get_config_type(ipconfig);
8503         method = __connman_ipconfig_get_method(ipconfig);
8504
8505         DBG("service %p ipconfig %p type %d method %d", service, ipconfig,
8506                                                         type, method);
8507
8508         if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
8509                         method == CONNMAN_IPCONFIG_METHOD_OFF)
8510                 __connman_service_ipconfig_indicate_state(service,
8511                                         CONNMAN_SERVICE_STATE_DISCONNECT,
8512                                         CONNMAN_IPCONFIG_TYPE_IPV6);
8513
8514         if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
8515                         method == CONNMAN_IPCONFIG_METHOD_OFF)
8516                 __connman_service_ipconfig_indicate_state(service,
8517                                         CONNMAN_SERVICE_STATE_DISCONNECT,
8518                                         CONNMAN_IPCONFIG_TYPE_IPV4);
8519
8520         settings_changed(service, ipconfig);
8521 }
8522
8523 static void service_route_changed(struct connman_ipconfig *ipconfig,
8524                                 const char *ifname)
8525 {
8526         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
8527
8528         DBG("%s route changed", ifname);
8529
8530         settings_changed(service, ipconfig);
8531 }
8532
8533 static const struct connman_ipconfig_ops service_ops = {
8534         .up             = service_up,
8535         .down           = service_down,
8536         .lower_up       = service_lower_up,
8537         .lower_down     = service_lower_down,
8538         .ip_bound       = service_ip_bound,
8539         .ip_release     = service_ip_release,
8540         .route_set      = service_route_changed,
8541         .route_unset    = service_route_changed,
8542 };
8543
8544 static struct connman_ipconfig *create_ip4config(struct connman_service *service,
8545                 int index, enum connman_ipconfig_method method)
8546 {
8547         struct connman_ipconfig *ipconfig_ipv4;
8548
8549         ipconfig_ipv4 = __connman_ipconfig_create(index,
8550                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
8551         if (!ipconfig_ipv4)
8552                 return NULL;
8553
8554         __connman_ipconfig_set_method(ipconfig_ipv4, method);
8555
8556         __connman_ipconfig_set_data(ipconfig_ipv4, service);
8557
8558         __connman_ipconfig_set_ops(ipconfig_ipv4, &service_ops);
8559
8560         return ipconfig_ipv4;
8561 }
8562
8563 static struct connman_ipconfig *create_ip6config(struct connman_service *service,
8564                 int index)
8565 {
8566         struct connman_ipconfig *ipconfig_ipv6;
8567
8568         ipconfig_ipv6 = __connman_ipconfig_create(index,
8569                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
8570         if (!ipconfig_ipv6)
8571                 return NULL;
8572
8573         __connman_ipconfig_set_data(ipconfig_ipv6, service);
8574
8575         __connman_ipconfig_set_ops(ipconfig_ipv6, &service_ops);
8576
8577         return ipconfig_ipv6;
8578 }
8579
8580 void __connman_service_read_ip4config(struct connman_service *service)
8581 {
8582         GKeyFile *keyfile;
8583
8584         if (!service->ipconfig_ipv4)
8585                 return;
8586
8587         keyfile = connman_storage_load_service(service->identifier);
8588         if (!keyfile)
8589                 return;
8590
8591         __connman_ipconfig_load(service->ipconfig_ipv4, keyfile,
8592                                 service->identifier, "IPv4.");
8593
8594         g_key_file_free(keyfile);
8595 }
8596
8597 void connman_service_create_ip4config(struct connman_service *service,
8598                                         int index)
8599 {
8600         DBG("ipv4 %p", service->ipconfig_ipv4);
8601
8602         if (service->ipconfig_ipv4)
8603                 return;
8604
8605         service->ipconfig_ipv4 = create_ip4config(service, index,
8606                         CONNMAN_IPCONFIG_METHOD_DHCP);
8607         __connman_service_read_ip4config(service);
8608 }
8609
8610 void __connman_service_read_ip6config(struct connman_service *service)
8611 {
8612         GKeyFile *keyfile;
8613
8614         if (!service->ipconfig_ipv6)
8615                 return;
8616
8617         keyfile = connman_storage_load_service(service->identifier);
8618         if (!keyfile)
8619                 return;
8620
8621         __connman_ipconfig_load(service->ipconfig_ipv6, keyfile,
8622                                 service->identifier, "IPv6.");
8623
8624         g_key_file_free(keyfile);
8625 }
8626
8627 void connman_service_create_ip6config(struct connman_service *service,
8628                                                                 int index)
8629 {
8630         DBG("ipv6 %p", service->ipconfig_ipv6);
8631
8632         if (service->ipconfig_ipv6)
8633                 return;
8634
8635         service->ipconfig_ipv6 = create_ip6config(service, index);
8636
8637         __connman_service_read_ip6config(service);
8638 }
8639
8640 /**
8641  * connman_service_lookup_from_network:
8642  * @network: network structure
8643  *
8644  * Look up a service by network (reference count will not be increased)
8645  */
8646 struct connman_service *connman_service_lookup_from_network(struct connman_network *network)
8647 {
8648         struct connman_service *service;
8649         const char *ident, *group;
8650         char *name;
8651
8652         if (!network)
8653                 return NULL;
8654
8655         ident = __connman_network_get_ident(network);
8656         if (!ident)
8657                 return NULL;
8658
8659         group = connman_network_get_group(network);
8660         if (!group)
8661                 return NULL;
8662
8663         name = g_strdup_printf("%s_%s_%s",
8664                         __connman_network_get_type(network), ident, group);
8665         service = lookup_by_identifier(name);
8666         g_free(name);
8667
8668         return service;
8669 }
8670
8671 struct connman_service *__connman_service_lookup_from_index(int index)
8672 {
8673         struct connman_service *service;
8674         GList *list;
8675
8676         for (list = service_list; list; list = list->next) {
8677                 service = list->data;
8678
8679                 if (__connman_ipconfig_get_index(service->ipconfig_ipv4)
8680                                                         == index)
8681                         return service;
8682
8683                 if (__connman_ipconfig_get_index(service->ipconfig_ipv6)
8684                                                         == index)
8685                         return service;
8686         }
8687
8688         return NULL;
8689 }
8690
8691 struct connman_service *__connman_service_lookup_from_ident(const char *identifier)
8692 {
8693         return lookup_by_identifier(identifier);
8694 }
8695
8696 const char *__connman_service_get_ident(struct connman_service *service)
8697 {
8698         return service->identifier;
8699 }
8700
8701 const char *__connman_service_get_path(struct connman_service *service)
8702 {
8703         return service->path;
8704 }
8705
8706 const char *__connman_service_get_name(struct connman_service *service)
8707 {
8708         return service->name;
8709 }
8710
8711 enum connman_service_state __connman_service_get_state(struct connman_service *service)
8712 {
8713         return service->state;
8714 }
8715
8716 unsigned int __connman_service_get_order(struct connman_service *service)
8717 {
8718         unsigned int order = 0;
8719
8720         if (!service)
8721                 return 0;
8722
8723         service->order = 0;
8724
8725         if (!service->favorite)
8726                 return 0;
8727
8728 #if defined TIZEN_EXT
8729         if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
8730                         service->do_split_routing == FALSE)
8731                 order = 10;
8732         else if (service->type == CONNMAN_SERVICE_TYPE_WIFI) {
8733                 if (service->order < 5)
8734                         order = 5;
8735         } else if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
8736                 order = 4;
8737         else if (service->type == CONNMAN_SERVICE_TYPE_BLUETOOTH)
8738                 order = 3;
8739         else if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR &&
8740                         __connman_service_is_internet_profile(service) == TRUE)
8741                 order = 1;
8742         else if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR &&
8743                         __connman_service_is_tethering_profile(service) == TRUE)
8744                 order = 0;
8745         else if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR)
8746                 order = 0;
8747         else
8748                 order = 2;
8749 #else
8750         if (service == service_list->data)
8751                 order = 1;
8752
8753         if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
8754                         !service->do_split_routing) {
8755                 service->order = 10;
8756                 order = 10;
8757         }
8758 #endif
8759         DBG("service %p name %s order %d split %d", service, service->name,
8760                 order, service->do_split_routing);
8761
8762         return order;
8763 }
8764
8765 static enum connman_service_type convert_network_type(struct connman_network *network)
8766 {
8767         enum connman_network_type type = connman_network_get_type(network);
8768
8769         switch (type) {
8770         case CONNMAN_NETWORK_TYPE_UNKNOWN:
8771         case CONNMAN_NETWORK_TYPE_VENDOR:
8772                 break;
8773         case CONNMAN_NETWORK_TYPE_ETHERNET:
8774                 return CONNMAN_SERVICE_TYPE_ETHERNET;
8775         case CONNMAN_NETWORK_TYPE_WIFI:
8776                 return CONNMAN_SERVICE_TYPE_WIFI;
8777         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
8778         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
8779                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
8780         case CONNMAN_NETWORK_TYPE_CELLULAR:
8781                 return CONNMAN_SERVICE_TYPE_CELLULAR;
8782         case CONNMAN_NETWORK_TYPE_GADGET:
8783                 return CONNMAN_SERVICE_TYPE_GADGET;
8784         }
8785
8786         return CONNMAN_SERVICE_TYPE_UNKNOWN;
8787 }
8788
8789 static enum connman_service_security convert_wifi_security(const char *security)
8790 {
8791         if (!security)
8792                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
8793         else if (g_str_equal(security, "none"))
8794                 return CONNMAN_SERVICE_SECURITY_NONE;
8795         else if (g_str_equal(security, "wep"))
8796                 return CONNMAN_SERVICE_SECURITY_WEP;
8797         else if (g_str_equal(security, "psk"))
8798                 return CONNMAN_SERVICE_SECURITY_PSK;
8799         else if (g_str_equal(security, "ieee8021x"))
8800                 return CONNMAN_SERVICE_SECURITY_8021X;
8801         else if (g_str_equal(security, "wpa"))
8802                 return CONNMAN_SERVICE_SECURITY_WPA;
8803         else if (g_str_equal(security, "rsn"))
8804                 return CONNMAN_SERVICE_SECURITY_RSN;
8805 #if defined TIZEN_EXT
8806         else if (g_str_equal(security, "ft_psk") == TRUE)
8807                 return CONNMAN_SERVICE_SECURITY_PSK;
8808         else if (g_str_equal(security, "ft_ieee8021x") == TRUE)
8809                 return CONNMAN_SERVICE_SECURITY_8021X;
8810 #endif
8811         else
8812                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
8813 }
8814
8815 #if defined TIZEN_EXT
8816 int check_passphrase_ext(struct connman_network *network,
8817                                         const char *passphrase)
8818 {
8819         const char *str;
8820         enum connman_service_security security;
8821
8822         str = connman_network_get_string(network, "WiFi.Security");
8823         security = convert_wifi_security(str);
8824
8825         return __connman_service_check_passphrase(security, passphrase);
8826 }
8827 #endif
8828
8829 static void update_from_network(struct connman_service *service,
8830                                         struct connman_network *network)
8831 {
8832         uint8_t strength = service->strength;
8833         const char *str;
8834
8835         DBG("service %p network %p", service, network);
8836
8837         if (is_connected(service->state))
8838                 return;
8839
8840         if (is_connecting(service->state))
8841                 return;
8842
8843         str = connman_network_get_string(network, "Name");
8844         if (str) {
8845                 g_free(service->name);
8846                 service->name = g_strdup(str);
8847                 service->hidden = false;
8848         } else {
8849                 g_free(service->name);
8850                 service->name = NULL;
8851                 service->hidden = true;
8852         }
8853
8854         service->strength = connman_network_get_strength(network);
8855         service->roaming = connman_network_get_bool(network, "Roaming");
8856
8857         if (service->strength == 0) {
8858                 /*
8859                  * Filter out 0-values; it's unclear what they mean
8860                  * and they cause anomalous sorting of the priority list.
8861                  */
8862                 service->strength = strength;
8863         }
8864
8865         str = connman_network_get_string(network, "WiFi.Security");
8866         service->security = convert_wifi_security(str);
8867
8868         if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
8869                 service->wps = connman_network_get_bool(network, "WiFi.WPS");
8870
8871         if (service->strength > strength && service->network) {
8872                 connman_network_unref(service->network);
8873                 service->network = connman_network_ref(network);
8874
8875                 strength_changed(service);
8876         }
8877
8878         if (!service->network)
8879                 service->network = connman_network_ref(network);
8880
8881         service_list_sort();
8882 }
8883
8884 /**
8885  * __connman_service_create_from_network:
8886  * @network: network structure
8887  *
8888  * Look up service by network and if not found, create one
8889  */
8890 struct connman_service * __connman_service_create_from_network(struct connman_network *network)
8891 {
8892         struct connman_service *service;
8893         struct connman_device *device;
8894         const char *ident, *group;
8895         char *name;
8896         unsigned int *auto_connect_types;
8897         int i, index;
8898
8899         DBG("network %p", network);
8900
8901         if (!network)
8902                 return NULL;
8903
8904         ident = __connman_network_get_ident(network);
8905         if (!ident)
8906                 return NULL;
8907
8908         group = connman_network_get_group(network);
8909         if (!group)
8910                 return NULL;
8911
8912         name = g_strdup_printf("%s_%s_%s",
8913                         __connman_network_get_type(network), ident, group);
8914         service = service_get(name);
8915         g_free(name);
8916
8917         if (!service)
8918                 return NULL;
8919
8920         if (__connman_network_get_weakness(network))
8921                 return service;
8922
8923         if (service->path) {
8924                 update_from_network(service, network);
8925                 __connman_connection_update_gateway();
8926                 return service;
8927         }
8928
8929         service->type = convert_network_type(network);
8930
8931         auto_connect_types = connman_setting_get_uint_list("DefaultAutoConnectTechnologies");
8932         service->autoconnect = false;
8933         for (i = 0; auto_connect_types &&
8934                      auto_connect_types[i] != 0; i++) {
8935                 if (service->type == auto_connect_types[i]) {
8936                         service->autoconnect = true;
8937                         break;
8938                 }
8939         }
8940
8941         switch (service->type) {
8942         case CONNMAN_SERVICE_TYPE_UNKNOWN:
8943         case CONNMAN_SERVICE_TYPE_SYSTEM:
8944         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
8945         case CONNMAN_SERVICE_TYPE_GPS:
8946         case CONNMAN_SERVICE_TYPE_VPN:
8947         case CONNMAN_SERVICE_TYPE_GADGET:
8948         case CONNMAN_SERVICE_TYPE_WIFI:
8949         case CONNMAN_SERVICE_TYPE_CELLULAR:
8950         case CONNMAN_SERVICE_TYPE_P2P:
8951                 break;
8952         case CONNMAN_SERVICE_TYPE_ETHERNET:
8953                 service->favorite = true;
8954                 break;
8955         }
8956
8957         service->state_ipv4 = service->state_ipv6 = CONNMAN_SERVICE_STATE_IDLE;
8958         service->state = combine_state(service->state_ipv4, service->state_ipv6);
8959
8960         update_from_network(service, network);
8961
8962         index = connman_network_get_index(network);
8963
8964         if (!service->ipconfig_ipv4)
8965                 service->ipconfig_ipv4 = create_ip4config(service, index,
8966                                 CONNMAN_IPCONFIG_METHOD_DHCP);
8967
8968         if (!service->ipconfig_ipv6)
8969                 service->ipconfig_ipv6 = create_ip6config(service, index);
8970
8971         service_register(service);
8972         service_schedule_added(service);
8973
8974         if (service->favorite) {
8975                 device = connman_network_get_device(service->network);
8976                 if (device && !connman_device_get_scanning(device)) {
8977
8978                         switch (service->type) {
8979                         case CONNMAN_SERVICE_TYPE_UNKNOWN:
8980                         case CONNMAN_SERVICE_TYPE_SYSTEM:
8981                         case CONNMAN_SERVICE_TYPE_P2P:
8982                                 break;
8983
8984                         case CONNMAN_SERVICE_TYPE_GADGET:
8985                         case CONNMAN_SERVICE_TYPE_ETHERNET:
8986                                 if (service->autoconnect) {
8987                                         __connman_service_connect(service,
8988                                                 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
8989                                         break;
8990                                 }
8991
8992                                 /* fall through */
8993                         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
8994                         case CONNMAN_SERVICE_TYPE_GPS:
8995                         case CONNMAN_SERVICE_TYPE_VPN:
8996                         case CONNMAN_SERVICE_TYPE_WIFI:
8997                         case CONNMAN_SERVICE_TYPE_CELLULAR:
8998                                 __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
8999                                 break;
9000                         }
9001                 }
9002
9003 #if defined TIZEN_EXT
9004                 /* TIZEN synchronizes below information when the service creates */
9005                 if (service->eap != NULL)
9006                         connman_network_set_string(service->network, "WiFi.EAP",
9007                                                                 service->eap);
9008                 if (service->identity != NULL)
9009                         connman_network_set_string(service->network, "WiFi.Identity",
9010                                                                 service->identity);
9011                 if (service->phase2 != NULL)
9012                         connman_network_set_string(service->network, "WiFi.Phase2",
9013                                                                 service->phase2);
9014 #endif
9015         }
9016
9017         __connman_notifier_service_add(service, service->name);
9018
9019         return service;
9020 }
9021
9022 void __connman_service_update_from_network(struct connman_network *network)
9023 {
9024         bool need_sort = false;
9025         struct connman_service *service;
9026         uint8_t strength;
9027         bool roaming;
9028         const char *name;
9029         bool stats_enable;
9030
9031         service = connman_service_lookup_from_network(network);
9032         if (!service)
9033                 return;
9034
9035         if (!service->network)
9036                 return;
9037
9038 #if defined TIZEN_EXT
9039         if (service->storage_reload) {
9040                 service_load(service);
9041                 __connman_service_set_storage_reload(service, false);
9042         }
9043 #endif
9044
9045         name = connman_network_get_string(service->network, "Name");
9046         if (g_strcmp0(service->name, name) != 0) {
9047                 g_free(service->name);
9048                 service->name = g_strdup(name);
9049
9050                 if (allow_property_changed(service))
9051                         connman_dbus_property_changed_basic(service->path,
9052                                         CONNMAN_SERVICE_INTERFACE, "Name",
9053                                         DBUS_TYPE_STRING, &service->name);
9054         }
9055
9056         if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
9057                 service->wps = connman_network_get_bool(network, "WiFi.WPS");
9058
9059         strength = connman_network_get_strength(service->network);
9060         if (strength == service->strength)
9061                 goto roaming;
9062
9063         service->strength = strength;
9064         need_sort = true;
9065
9066         strength_changed(service);
9067
9068 roaming:
9069         roaming = connman_network_get_bool(service->network, "Roaming");
9070         if (roaming == service->roaming)
9071                 goto sorting;
9072
9073         stats_enable = stats_enabled(service);
9074         if (stats_enable)
9075                 stats_stop(service);
9076
9077         service->roaming = roaming;
9078         need_sort = true;
9079
9080         if (stats_enable)
9081                 stats_start(service);
9082
9083         roaming_changed(service);
9084
9085 sorting:
9086         if (need_sort) {
9087                 service_list_sort();
9088         }
9089 }
9090
9091 void __connman_service_remove_from_network(struct connman_network *network)
9092 {
9093         struct connman_service *service;
9094
9095         service = connman_service_lookup_from_network(network);
9096
9097         DBG("network %p service %p", network, service);
9098
9099         if (!service)
9100                 return;
9101
9102         service->ignore = true;
9103
9104         __connman_connection_gateway_remove(service,
9105                                         CONNMAN_IPCONFIG_TYPE_ALL);
9106
9107         connman_service_unref(service);
9108 }
9109
9110 /**
9111  * __connman_service_create_from_provider:
9112  * @provider: provider structure
9113  *
9114  * Look up service by provider and if not found, create one
9115  */
9116 struct connman_service *
9117 __connman_service_create_from_provider(struct connman_provider *provider)
9118 {
9119         struct connman_service *service;
9120         const char *ident, *str;
9121         char *name;
9122         int index = connman_provider_get_index(provider);
9123
9124         DBG("provider %p", provider);
9125
9126         ident = __connman_provider_get_ident(provider);
9127         if (!ident)
9128                 return NULL;
9129
9130         name = g_strdup_printf("vpn_%s", ident);
9131         service = service_get(name);
9132         g_free(name);
9133
9134         if (!service)
9135                 return NULL;
9136
9137         service->type = CONNMAN_SERVICE_TYPE_VPN;
9138         service->provider = connman_provider_ref(provider);
9139         service->autoconnect = false;
9140         service->favorite = true;
9141
9142         service->state_ipv4 = service->state_ipv6 = CONNMAN_SERVICE_STATE_IDLE;
9143         service->state = combine_state(service->state_ipv4, service->state_ipv6);
9144
9145         str = connman_provider_get_string(provider, "Name");
9146         if (str) {
9147                 g_free(service->name);
9148                 service->name = g_strdup(str);
9149                 service->hidden = false;
9150         } else {
9151                 g_free(service->name);
9152                 service->name = NULL;
9153                 service->hidden = true;
9154         }
9155
9156         service->strength = 0;
9157
9158         if (!service->ipconfig_ipv4)
9159                 service->ipconfig_ipv4 = create_ip4config(service, index,
9160                                 CONNMAN_IPCONFIG_METHOD_MANUAL);
9161
9162         if (!service->ipconfig_ipv6)
9163                 service->ipconfig_ipv6 = create_ip6config(service, index);
9164
9165         service_register(service);
9166
9167         __connman_notifier_service_add(service, service->name);
9168         service_schedule_added(service);
9169
9170         return service;
9171 }
9172
9173 static void remove_unprovisioned_services(void)
9174 {
9175         gchar **services;
9176         GKeyFile *keyfile, *configkeyfile;
9177         char *file, *section;
9178         int i = 0;
9179
9180         services = connman_storage_get_services();
9181         if (!services)
9182                 return;
9183
9184         for (; services[i]; i++) {
9185                 file = section = NULL;
9186                 keyfile = configkeyfile = NULL;
9187
9188                 keyfile = connman_storage_load_service(services[i]);
9189                 if (!keyfile)
9190                         continue;
9191
9192                 file = g_key_file_get_string(keyfile, services[i],
9193                                         "Config.file", NULL);
9194                 if (!file)
9195                         goto next;
9196
9197                 section = g_key_file_get_string(keyfile, services[i],
9198                                         "Config.ident", NULL);
9199                 if (!section)
9200                         goto next;
9201
9202                 configkeyfile = __connman_storage_load_config(file);
9203                 if (!configkeyfile) {
9204                         /*
9205                          * Config file is missing, remove the provisioned
9206                          * service.
9207                          */
9208                         __connman_storage_remove_service(services[i]);
9209                         goto next;
9210                 }
9211
9212                 if (!g_key_file_has_group(configkeyfile, section))
9213                         /*
9214                          * Config section is missing, remove the provisioned
9215                          * service.
9216                          */
9217                         __connman_storage_remove_service(services[i]);
9218
9219         next:
9220                 if (keyfile)
9221                         g_key_file_free(keyfile);
9222
9223                 if (configkeyfile)
9224                         g_key_file_free(configkeyfile);
9225
9226                 g_free(section);
9227                 g_free(file);
9228         }
9229
9230         g_strfreev(services);
9231 }
9232
9233 static int agent_probe(struct connman_agent *agent)
9234 {
9235         DBG("agent %p", agent);
9236         return 0;
9237 }
9238
9239 static void agent_remove(struct connman_agent *agent)
9240 {
9241         DBG("agent %p", agent);
9242 }
9243
9244 static void *agent_context_ref(void *context)
9245 {
9246         struct connman_service *service = context;
9247
9248         return (void *)connman_service_ref(service);
9249 }
9250
9251 static void agent_context_unref(void *context)
9252 {
9253         struct connman_service *service = context;
9254
9255         connman_service_unref(service);
9256 }
9257
9258 static struct connman_agent_driver agent_driver = {
9259         .name           = "service",
9260         .interface      = CONNMAN_AGENT_INTERFACE,
9261         .probe          = agent_probe,
9262         .remove         = agent_remove,
9263         .context_ref    = agent_context_ref,
9264         .context_unref  = agent_context_unref,
9265 };
9266
9267 int __connman_service_init(void)
9268 {
9269         int err;
9270
9271         DBG("");
9272
9273         err = connman_agent_driver_register(&agent_driver);
9274         if (err < 0) {
9275                 connman_error("Cannot register agent driver for %s",
9276                                                 agent_driver.name);
9277                 return err;
9278         }
9279
9280         set_always_connecting_technologies();
9281
9282         connection = connman_dbus_get_connection();
9283
9284         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
9285                                                         NULL, service_free);
9286
9287         services_notify = g_new0(struct _services_notify, 1);
9288         services_notify->remove = g_hash_table_new_full(g_str_hash,
9289                         g_str_equal, g_free, NULL);
9290         services_notify->add = g_hash_table_new(g_str_hash, g_str_equal);
9291
9292         remove_unprovisioned_services();
9293
9294         return 0;
9295 }
9296
9297 void __connman_service_cleanup(void)
9298 {
9299         DBG("");
9300
9301         if (vpn_autoconnect_timeout) {
9302                 g_source_remove(vpn_autoconnect_timeout);
9303                 vpn_autoconnect_timeout = 0;
9304         }
9305
9306         if (autoconnect_timeout != 0) {
9307                 g_source_remove(autoconnect_timeout);
9308                 autoconnect_timeout = 0;
9309         }
9310
9311         connman_agent_driver_unregister(&agent_driver);
9312
9313         g_list_free(service_list);
9314         service_list = NULL;
9315
9316         g_hash_table_destroy(service_hash);
9317         service_hash = NULL;
9318
9319         g_slist_free(counter_list);
9320         counter_list = NULL;
9321
9322         if (services_notify->id != 0) {
9323                 g_source_remove(services_notify->id);
9324                 service_send_changed(NULL);
9325         }
9326
9327         g_hash_table_destroy(services_notify->remove);
9328         g_hash_table_destroy(services_notify->add);
9329         g_free(services_notify);
9330
9331         dbus_connection_unref(connection);
9332 }