src/service.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <netdb.h>
  30 #include <gdbus.h>
  31 #include <ctype.h>
  32
  33 #include <connman/storage.h>
  34 #include <connman/setting.h>
  35
  36 #include "connman.h"
  37
  38 #define CONNECT_TIMEOUT         120
  39
  40 static DBusConnection *connection = NULL;
  41
  42 static GSequence *service_list = NULL;
  43 static GHashTable *service_hash = NULL;
  44 static GSList *counter_list = NULL;
  45 static unsigned int autoconnect_timeout = 0;
  46 static struct connman_service *current_default = NULL;
  47
  48 struct connman_stats {
  49         connman_bool_t valid;
  50         connman_bool_t enabled;
  51         struct connman_stats_data data_last;
  52         struct connman_stats_data data;
  53         GTimer *timer;
  54 };
  55
  56 struct connman_stats_counter {
  57         connman_bool_t append_all;
  58         struct connman_stats stats;
  59         struct connman_stats stats_roaming;
  60 };
  61
  62 struct connman_service {
  63         int refcount;
  64         int session_usage_count;
  65         char *identifier;
  66         char *path;
  67         enum connman_service_type type;
  68         enum connman_service_security security;
  69         enum connman_service_state state;
  70         enum connman_service_state state_ipv4;
  71         enum connman_service_state state_ipv6;
  72         enum connman_service_error error;
  73         connman_uint8_t strength;
  74         connman_bool_t favorite;
  75         connman_bool_t immutable;
  76         connman_bool_t hidden;
  77         connman_bool_t ignore;
  78         connman_bool_t autoconnect;
  79         connman_bool_t userconnect;
  80         GTimeVal modified;
  81         unsigned int order;
  82         char *name;
  83         char *passphrase;
  84         char *agent_passphrase;
  85         connman_bool_t roaming;
  86         struct connman_ipconfig *ipconfig_ipv4;
  87         struct connman_ipconfig *ipconfig_ipv6;
  88         struct connman_network *network;
  89         struct connman_provider *provider;
  90         char **nameservers;
  91         char **nameservers_config;
  92         char **nameservers_auto;
  93         char **domains;
  94         char *domainname;
  95         char **timeservers;
  96         char **timeservers_config;
  97         /* 802.1x settings from the config files */
  98         char *eap;
  99         char *identity;
 100         char *agent_identity;
 101         char *ca_cert_file;
 102         char *client_cert_file;
 103         char *private_key_file;
 104         char *private_key_passphrase;
 105         char *phase2;
 106         DBusMessage *pending;
 107         guint timeout;
 108         struct connman_stats stats;
 109         struct connman_stats stats_roaming;
 110         GHashTable *counter_table;
 111         enum connman_service_proxy_method proxy;
 112         enum connman_service_proxy_method proxy_config;
 113         char **proxies;
 114         char **excludes;
 115         char *pac;
 116         connman_bool_t wps;
 117         int online_check_count;
 118         connman_bool_t do_split_routing;
 119         connman_bool_t new_service;
 120         connman_bool_t hidden_service;
 121 };
 122
 123 struct find_data {
 124         const char *path;
 125         struct connman_service *service;
 126 };
 127
 128 static void compare_path(gpointer value, gpointer user_data)
 129 {
 130         struct connman_service *service = value;
 131         struct find_data *data = user_data;
 132
 133         if (data->service != NULL)
 134                 return;
 135
 136         if (g_strcmp0(service->path, data->path) == 0)
 137                 data->service = service;
 138 }
 139
 140 static struct connman_service *find_service(const char *path)
 141 {
 142         struct find_data data = { .path = path, .service = NULL };
 143
 144         DBG("path %s", path);
 145
 146         g_sequence_foreach(service_list, compare_path, &data);
 147
 148         return data.service;
 149 }
 150
 151 const char *__connman_service_type2string(enum connman_service_type type)
 152 {
 153         switch (type) {
 154         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 155                 break;
 156         case CONNMAN_SERVICE_TYPE_SYSTEM:
 157                 return "system";
 158         case CONNMAN_SERVICE_TYPE_ETHERNET:
 159                 return "ethernet";
 160         case CONNMAN_SERVICE_TYPE_WIFI:
 161                 return "wifi";
 162         case CONNMAN_SERVICE_TYPE_WIMAX:
 163                 return "wimax";
 164         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 165                 return "bluetooth";
 166         case CONNMAN_SERVICE_TYPE_CELLULAR:
 167                 return "cellular";
 168         case CONNMAN_SERVICE_TYPE_GPS:
 169                 return "gps";
 170         case CONNMAN_SERVICE_TYPE_VPN:
 171                 return "vpn";
 172         case CONNMAN_SERVICE_TYPE_GADGET:
 173                 return "gadget";
 174         }
 175
 176         return NULL;
 177 }
 178
 179 enum connman_service_type __connman_service_string2type(const char *str)
 180 {
 181         if (str == NULL)
 182                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
 183
 184         if (strcmp(str, "ethernet") == 0)
 185                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 186         if (strcmp(str, "gadget") == 0)
 187                 return CONNMAN_SERVICE_TYPE_GADGET;
 188         if (strcmp(str, "wifi") == 0)
 189                 return CONNMAN_SERVICE_TYPE_WIFI;
 190         if (strcmp(str, "cellular") == 0)
 191                 return CONNMAN_SERVICE_TYPE_CELLULAR;
 192         if (strcmp(str, "bluetooth") == 0)
 193                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
 194         if (strcmp(str, "wimax") == 0)
 195                 return CONNMAN_SERVICE_TYPE_WIMAX;
 196         if (strcmp(str, "vpn") == 0)
 197                 return CONNMAN_SERVICE_TYPE_VPN;
 198         if (strcmp(str, "gps") == 0)
 199                 return CONNMAN_SERVICE_TYPE_GPS;
 200         if (strcmp(str, "system") == 0)
 201                 return CONNMAN_SERVICE_TYPE_SYSTEM;
 202
 203         return CONNMAN_SERVICE_TYPE_UNKNOWN;
 204 }
 205
 206 static const char *security2string(enum connman_service_security security)
 207 {
 208         switch (security) {
 209         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 210                 break;
 211         case CONNMAN_SERVICE_SECURITY_NONE:
 212                 return "none";
 213         case CONNMAN_SERVICE_SECURITY_WEP:
 214                 return "wep";
 215         case CONNMAN_SERVICE_SECURITY_PSK:
 216         case CONNMAN_SERVICE_SECURITY_WPA:
 217         case CONNMAN_SERVICE_SECURITY_RSN:
 218                 return "psk";
 219         case CONNMAN_SERVICE_SECURITY_8021X:
 220                 return "ieee8021x";
 221         }
 222
 223         return NULL;
 224 }
 225
 226 static const char *state2string(enum connman_service_state state)
 227 {
 228         switch (state) {
 229         case CONNMAN_SERVICE_STATE_UNKNOWN:
 230                 break;
 231         case CONNMAN_SERVICE_STATE_IDLE:
 232                 return "idle";
 233         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 234                 return "association";
 235         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 236                 return "configuration";
 237         case CONNMAN_SERVICE_STATE_READY:
 238                 return "ready";
 239         case CONNMAN_SERVICE_STATE_ONLINE:
 240                 return "online";
 241         case CONNMAN_SERVICE_STATE_DISCONNECT:
 242                 return "disconnect";
 243         case CONNMAN_SERVICE_STATE_FAILURE:
 244                 return "failure";
 245         }
 246
 247         return NULL;
 248 }
 249
 250 static const char *error2string(enum connman_service_error error)
 251 {
 252         switch (error) {
 253         case CONNMAN_SERVICE_ERROR_UNKNOWN:
 254                 break;
 255         case CONNMAN_SERVICE_ERROR_OUT_OF_RANGE:
 256                 return "out-of-range";
 257         case CONNMAN_SERVICE_ERROR_PIN_MISSING:
 258                 return "pin-missing";
 259         case CONNMAN_SERVICE_ERROR_DHCP_FAILED:
 260                 return "dhcp-failed";
 261         case CONNMAN_SERVICE_ERROR_CONNECT_FAILED:
 262                 return "connect-failed";
 263         case CONNMAN_SERVICE_ERROR_LOGIN_FAILED:
 264                 return "login-failed";
 265         case CONNMAN_SERVICE_ERROR_AUTH_FAILED:
 266                 return "auth-failed";
 267         case CONNMAN_SERVICE_ERROR_INVALID_KEY:
 268                 return "invalid-key";
 269         }
 270
 271         return NULL;
 272 }
 273
 274 static enum connman_service_error string2error(const char *error)
 275 {
 276         if (g_strcmp0(error, "dhcp-failed") == 0)
 277                 return CONNMAN_SERVICE_ERROR_DHCP_FAILED;
 278         else if (g_strcmp0(error, "pin-missing") == 0)
 279                 return CONNMAN_SERVICE_ERROR_PIN_MISSING;
 280         else if (g_strcmp0(error, "invalid-key") == 0)
 281                 return CONNMAN_SERVICE_ERROR_INVALID_KEY;
 282
 283         return CONNMAN_SERVICE_ERROR_UNKNOWN;
 284 }
 285
 286 static const char *proxymethod2string(enum connman_service_proxy_method method)
 287 {
 288         switch (method) {
 289         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
 290                 return "direct";
 291         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
 292                 return "manual";
 293         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
 294                 return "auto";
 295         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
 296                 break;
 297         }
 298
 299         return NULL;
 300 }
 301
 302 static enum connman_service_proxy_method string2proxymethod(const char *method)
 303 {
 304         if (g_strcmp0(method, "direct") == 0)
 305                 return CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
 306         else if (g_strcmp0(method, "auto") == 0)
 307                 return CONNMAN_SERVICE_PROXY_METHOD_AUTO;
 308         else if (g_strcmp0(method, "manual") == 0)
 309                 return CONNMAN_SERVICE_PROXY_METHOD_MANUAL;
 310         else
 311                 return CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
 312 }
 313
 314 static int service_load(struct connman_service *service)
 315 {
 316         GKeyFile *keyfile;
 317         GError *error = NULL;
 318         gsize length;
 319         gchar *str;
 320         connman_bool_t autoconnect;
 321         unsigned int ssid_len;
 322         int err = 0;
 323
 324         DBG("service %p", service);
 325
 326         keyfile = connman_storage_load_service(service->identifier);
 327         if (keyfile == NULL) {
 328                 service->new_service = TRUE;
 329                 return -EIO;
 330         } else
 331                 service->new_service = FALSE;
 332
 333         switch (service->type) {
 334         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 335         case CONNMAN_SERVICE_TYPE_SYSTEM:
 336         case CONNMAN_SERVICE_TYPE_GPS:
 337         case CONNMAN_SERVICE_TYPE_GADGET:
 338                 break;
 339         case CONNMAN_SERVICE_TYPE_VPN:
 340                 service->do_split_routing = g_key_file_get_boolean(keyfile,
 341                                 service->identifier, "SplitRouting", NULL);
 342                 break;
 343         case CONNMAN_SERVICE_TYPE_WIFI:
 344                 if (service->name == NULL) {
 345                         gchar *name;
 346
 347                         name = g_key_file_get_string(keyfile,
 348                                         service->identifier, "Name", NULL);
 349                         if (name != NULL) {
 350                                 g_free(service->name);
 351                                 service->name = name;
 352                         }
 353
 354                         if (service->network != NULL)
 355                                 connman_network_set_name(service->network,
 356                                                                         name);
 357                 }
 358
 359                 if (service->network &&
 360                                 connman_network_get_blob(service->network,
 361                                         "WiFi.SSID", &ssid_len) == NULL) {
 362                         gchar *hex_ssid;
 363
 364                         hex_ssid = g_key_file_get_string(keyfile,
 365                                                         service->identifier,
 366                                                                 "SSID", NULL);
 367
 368                         if (hex_ssid != NULL) {
 369                                 gchar *ssid;
 370                                 unsigned int i, j = 0, hex;
 371                                 size_t hex_ssid_len = strlen(hex_ssid);
 372
 373                                 ssid = g_try_malloc0(hex_ssid_len / 2);
 374                                 if (ssid == NULL) {
 375                                         g_free(hex_ssid);
 376                                         err = -ENOMEM;
 377                                         goto done;
 378                                 }
 379
 380                                 for (i = 0; i < hex_ssid_len; i += 2) {
 381                                         sscanf(hex_ssid + i, "%02x", &hex);
 382                                         ssid[j++] = hex;
 383                                 }
 384
 385                                 connman_network_set_blob(service->network,
 386                                         "WiFi.SSID", ssid, hex_ssid_len / 2);
 387                         }
 388
 389                         g_free(hex_ssid);
 390                 }
 391                 /* fall through */
 392
 393         case CONNMAN_SERVICE_TYPE_WIMAX:
 394         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 395         case CONNMAN_SERVICE_TYPE_CELLULAR:
 396                 service->favorite = g_key_file_get_boolean(keyfile,
 397                                 service->identifier, "Favorite", NULL);
 398
 399                 str = g_key_file_get_string(keyfile,
 400                                 service->identifier, "Failure", NULL);
 401                 if (str != NULL) {
 402                         if (service->favorite == FALSE)
 403                                 service->state_ipv4 = service->state_ipv6 =
 404                                         CONNMAN_SERVICE_STATE_FAILURE;
 405                         service->error = string2error(str);
 406                         g_free(str);
 407                 }
 408                 /* fall through */
 409
 410         case CONNMAN_SERVICE_TYPE_ETHERNET:
 411                 autoconnect = g_key_file_get_boolean(keyfile,
 412                                 service->identifier, "AutoConnect", &error);
 413                 if (error == NULL)
 414                         service->autoconnect = autoconnect;
 415                 g_clear_error(&error);
 416                 break;
 417         }
 418
 419         str = g_key_file_get_string(keyfile,
 420                                 service->identifier, "Modified", NULL);
 421         if (str != NULL) {
 422                 g_time_val_from_iso8601(str, &service->modified);
 423                 g_free(str);
 424         }
 425
 426         str = g_key_file_get_string(keyfile,
 427                                 service->identifier, "Passphrase", NULL);
 428         if (str != NULL) {
 429                 g_free(service->passphrase);
 430                 service->passphrase = str;
 431         }
 432
 433         if (service->ipconfig_ipv4 != NULL)
 434                 __connman_ipconfig_load(service->ipconfig_ipv4, keyfile,
 435                                         service->identifier, "IPv4.");
 436
 437         if (service->ipconfig_ipv6 != NULL)
 438                 __connman_ipconfig_load(service->ipconfig_ipv6, keyfile,
 439                                         service->identifier, "IPv6.");
 440
 441         service->nameservers_config = g_key_file_get_string_list(keyfile,
 442                         service->identifier, "Nameservers", &length, NULL);
 443         if (service->nameservers_config != NULL && length == 0) {
 444                 g_strfreev(service->nameservers_config);
 445                 service->nameservers_config = NULL;
 446         }
 447
 448         service->timeservers_config = g_key_file_get_string_list(keyfile,
 449                         service->identifier, "Timeservers", &length, NULL);
 450         if (service->timeservers_config != NULL && length == 0) {
 451                 g_strfreev(service->timeservers_config);
 452                 service->timeservers_config = NULL;
 453         }
 454
 455         service->domains = g_key_file_get_string_list(keyfile,
 456                         service->identifier, "Domains", &length, NULL);
 457         if (service->domains != NULL && length == 0) {
 458                 g_strfreev(service->domains);
 459                 service->domains = NULL;
 460         }
 461
 462         str = g_key_file_get_string(keyfile,
 463                                 service->identifier, "Proxy.Method", NULL);
 464         if (str != NULL)
 465                 service->proxy_config = string2proxymethod(str);
 466
 467         g_free(str);
 468
 469         service->proxies = g_key_file_get_string_list(keyfile,
 470                         service->identifier, "Proxy.Servers", &length, NULL);
 471         if (service->proxies != NULL && length == 0) {
 472                 g_strfreev(service->proxies);
 473                 service->proxies = NULL;
 474         }
 475
 476         service->excludes = g_key_file_get_string_list(keyfile,
 477                         service->identifier, "Proxy.Excludes", &length, NULL);
 478         if (service->excludes != NULL && length == 0) {
 479                 g_strfreev(service->excludes);
 480                 service->excludes = NULL;
 481         }
 482
 483         str = g_key_file_get_string(keyfile,
 484                                 service->identifier, "Proxy.URL", NULL);
 485         if (str != NULL) {
 486                 g_free(service->pac);
 487                 service->pac = str;
 488         }
 489
 490         service->hidden_service = g_key_file_get_boolean(keyfile,
 491                                         service->identifier, "Hidden", NULL);
 492
 493 done:
 494         g_key_file_free(keyfile);
 495
 496         return err;
 497 }
 498
 499 static int service_save(struct connman_service *service)
 500 {
 501         GKeyFile *keyfile;
 502         gchar *str;
 503         guint freq;
 504         const char *cst_str = NULL;
 505         int err = 0;
 506
 507         DBG("service %p new %d", service, service->new_service);
 508
 509         if (service->new_service == TRUE)
 510                 return -ESRCH;
 511
 512         keyfile = __connman_storage_open_service(service->identifier);
 513         if (keyfile == NULL)
 514                 return -EIO;
 515
 516         if (service->name != NULL)
 517                 g_key_file_set_string(keyfile, service->identifier,
 518                                                 "Name", service->name);
 519
 520         switch (service->type) {
 521         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 522         case CONNMAN_SERVICE_TYPE_SYSTEM:
 523         case CONNMAN_SERVICE_TYPE_GPS:
 524         case CONNMAN_SERVICE_TYPE_GADGET:
 525                 break;
 526         case CONNMAN_SERVICE_TYPE_VPN:
 527                 g_key_file_set_boolean(keyfile, service->identifier,
 528                                 "SplitRouting", service->do_split_routing);
 529                 break;
 530         case CONNMAN_SERVICE_TYPE_WIFI:
 531                 if (service->network) {
 532                         const unsigned char *ssid;
 533                         unsigned int ssid_len = 0;
 534
 535                         ssid = connman_network_get_blob(service->network,
 536                                                         "WiFi.SSID", &ssid_len);
 537
 538                         if (ssid != NULL && ssid_len > 0 && ssid[0] != '\0') {
 539                                 char *identifier = service->identifier;
 540                                 GString *str;
 541                                 unsigned int i;
 542
 543                                 str = g_string_sized_new(ssid_len * 2);
 544                                 if (str == NULL) {
 545                                         err = -ENOMEM;
 546                                         goto done;
 547                                 }
 548
 549                                 for (i = 0; i < ssid_len; i++)
 550                                         g_string_append_printf(str,
 551                                                         "%02x", ssid[i]);
 552
 553                                 g_key_file_set_string(keyfile, identifier,
 554                                                         "SSID", str->str);
 555
 556                                 g_string_free(str, TRUE);
 557                         }
 558
 559                         freq = connman_network_get_frequency(service->network);
 560                         g_key_file_set_integer(keyfile, service->identifier,
 561                                                 "Frequency", freq);
 562                 }
 563                 /* fall through */
 564
 565         case CONNMAN_SERVICE_TYPE_WIMAX:
 566         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 567         case CONNMAN_SERVICE_TYPE_CELLULAR:
 568                 g_key_file_set_boolean(keyfile, service->identifier,
 569                                         "Favorite", service->favorite);
 570
 571                 if (service->state_ipv4 == CONNMAN_SERVICE_STATE_FAILURE ||
 572                         service->state_ipv6 == CONNMAN_SERVICE_STATE_FAILURE) {
 573                         const char *failure = error2string(service->error);
 574                         if (failure != NULL)
 575                                 g_key_file_set_string(keyfile,
 576                                                         service->identifier,
 577                                                         "Failure", failure);
 578                 } else {
 579                         g_key_file_remove_key(keyfile, service->identifier,
 580                                                         "Failure", NULL);
 581                 }
 582                 /* fall through */
 583
 584         case CONNMAN_SERVICE_TYPE_ETHERNET:
 585                 if (service->favorite == TRUE)
 586                         g_key_file_set_boolean(keyfile, service->identifier,
 587                                         "AutoConnect", service->autoconnect);
 588                 break;
 589         }
 590
 591         str = g_time_val_to_iso8601(&service->modified);
 592         if (str != NULL) {
 593                 g_key_file_set_string(keyfile, service->identifier,
 594                                                         "Modified", str);
 595                 g_free(str);
 596         }
 597
 598         if (service->passphrase != NULL && strlen(service->passphrase) > 0)
 599                 g_key_file_set_string(keyfile, service->identifier,
 600                                         "Passphrase", service->passphrase);
 601         else
 602                 g_key_file_remove_key(keyfile, service->identifier,
 603                                                         "Passphrase", NULL);
 604
 605         if (service->ipconfig_ipv4 != NULL)
 606                 __connman_ipconfig_save(service->ipconfig_ipv4, keyfile,
 607                                         service->identifier, "IPv4.");
 608
 609         if (service->ipconfig_ipv6 != NULL)
 610                 __connman_ipconfig_save(service->ipconfig_ipv6, keyfile,
 611                                                 service->identifier, "IPv6.");
 612
 613         if (service->nameservers_config != NULL) {
 614                 guint len = g_strv_length(service->nameservers_config);
 615
 616                 g_key_file_set_string_list(keyfile, service->identifier,
 617                                                                 "Nameservers",
 618                                 (const gchar **) service->nameservers_config, len);
 619         } else
 620         g_key_file_remove_key(keyfile, service->identifier,
 621                                                         "Nameservers", NULL);
 622
 623         if (service->timeservers_config != NULL) {
 624                 guint len = g_strv_length(service->timeservers_config);
 625
 626                 g_key_file_set_string_list(keyfile, service->identifier,
 627                                                                 "Timeservers",
 628                                 (const gchar **) service->timeservers_config, len);
 629         } else
 630                 g_key_file_remove_key(keyfile, service->identifier,
 631                                                         "Timeservers", NULL);
 632
 633         if (service->domains != NULL) {
 634                 guint len = g_strv_length(service->domains);
 635
 636                 g_key_file_set_string_list(keyfile, service->identifier,
 637                                                                 "Domains",
 638                                 (const gchar **) service->domains, len);
 639         } else
 640                 g_key_file_remove_key(keyfile, service->identifier,
 641                                                         "Domains", NULL);
 642
 643         cst_str = proxymethod2string(service->proxy_config);
 644         if (cst_str != NULL)
 645                 g_key_file_set_string(keyfile, service->identifier,
 646                                 "Proxy.Method", cst_str);
 647
 648         if (service->proxies != NULL) {
 649                 guint len = g_strv_length(service->proxies);
 650
 651                 g_key_file_set_string_list(keyfile, service->identifier,
 652                                 "Proxy.Servers",
 653                                 (const gchar **) service->proxies, len);
 654         } else
 655                 g_key_file_remove_key(keyfile, service->identifier,
 656                                                 "Proxy.Servers", NULL);
 657
 658         if (service->excludes != NULL) {
 659                 guint len = g_strv_length(service->excludes);
 660
 661                 g_key_file_set_string_list(keyfile, service->identifier,
 662                                 "Proxy.Excludes",
 663                                 (const gchar **) service->excludes, len);
 664         } else
 665                 g_key_file_remove_key(keyfile, service->identifier,
 666                                                 "Proxy.Excludes", NULL);
 667
 668         if (service->pac != NULL && strlen(service->pac) > 0)
 669                 g_key_file_set_string(keyfile, service->identifier,
 670                                         "Proxy.URL", service->pac);
 671         else
 672                 g_key_file_remove_key(keyfile, service->identifier,
 673                                                         "Proxy.URL", NULL);
 674
 675         if (service->hidden_service == TRUE)
 676                 g_key_file_set_boolean(keyfile, service->identifier, "Hidden",
 677                                                                         TRUE);
 678
 679 done:
 680         __connman_storage_save_service(keyfile, service->identifier);
 681
 682         g_key_file_free(keyfile);
 683
 684         return err;
 685 }
 686
 687 static enum connman_service_state combine_state(
 688                                         enum connman_service_state state_a,
 689                                         enum connman_service_state state_b)
 690 {
 691         enum connman_service_state result;
 692
 693         if (state_a == state_b) {
 694                 result = state_a;
 695                 goto done;
 696         }
 697
 698         if (state_a == CONNMAN_SERVICE_STATE_UNKNOWN) {
 699                 result = state_b;
 700                 goto done;
 701         }
 702
 703         if (state_b == CONNMAN_SERVICE_STATE_UNKNOWN) {
 704                 result = state_a;
 705                 goto done;
 706         }
 707
 708         if (state_a == CONNMAN_SERVICE_STATE_IDLE) {
 709                 result = state_b;
 710                 goto done;
 711         }
 712
 713         if (state_b == CONNMAN_SERVICE_STATE_IDLE) {
 714                 result = state_a;
 715                 goto done;
 716         }
 717
 718         if (state_a == CONNMAN_SERVICE_STATE_ONLINE) {
 719                 result = state_a;
 720                 goto done;
 721         }
 722
 723         if (state_b == CONNMAN_SERVICE_STATE_ONLINE) {
 724                 result = state_b;
 725                 goto done;
 726         }
 727
 728         if (state_a == CONNMAN_SERVICE_STATE_READY) {
 729                 result = state_a;
 730                 goto done;
 731         }
 732
 733         if (state_b == CONNMAN_SERVICE_STATE_READY) {
 734                 result = state_b;
 735                 goto done;
 736         }
 737
 738         if (state_a == CONNMAN_SERVICE_STATE_CONFIGURATION) {
 739                 result = state_a;
 740                 goto done;
 741         }
 742
 743         if (state_b == CONNMAN_SERVICE_STATE_CONFIGURATION) {
 744                 result = state_b;
 745                 goto done;
 746         }
 747
 748         if (state_a == CONNMAN_SERVICE_STATE_ASSOCIATION) {
 749                 result = state_a;
 750                 goto done;
 751         }
 752
 753         if (state_b == CONNMAN_SERVICE_STATE_ASSOCIATION) {
 754                 result = state_b;
 755                 goto done;
 756         }
 757
 758         if (state_a == CONNMAN_SERVICE_STATE_DISCONNECT) {
 759                 result = state_a;
 760                 goto done;
 761         }
 762
 763         if (state_b == CONNMAN_SERVICE_STATE_DISCONNECT) {
 764                 result = state_b;
 765                 goto done;
 766         }
 767
 768         result = CONNMAN_SERVICE_STATE_FAILURE;
 769
 770 done:
 771         return result;
 772 }
 773
 774 static connman_bool_t is_connecting_state(struct connman_service *service,
 775                                         enum connman_service_state state)
 776 {
 777         switch (state) {
 778         case CONNMAN_SERVICE_STATE_UNKNOWN:
 779         case CONNMAN_SERVICE_STATE_IDLE:
 780         case CONNMAN_SERVICE_STATE_FAILURE:
 781                 if (service->network != NULL)
 782                         return connman_network_get_connecting(service->network);
 783         case CONNMAN_SERVICE_STATE_DISCONNECT:
 784         case CONNMAN_SERVICE_STATE_READY:
 785         case CONNMAN_SERVICE_STATE_ONLINE:
 786                 break;
 787         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 788         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 789                 return TRUE;
 790         }
 791
 792         return FALSE;
 793 }
 794
 795 static connman_bool_t is_connected_state(const struct connman_service *service,
 796                                         enum connman_service_state state)
 797 {
 798         switch (state) {
 799         case CONNMAN_SERVICE_STATE_UNKNOWN:
 800         case CONNMAN_SERVICE_STATE_IDLE:
 801         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 802         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 803         case CONNMAN_SERVICE_STATE_DISCONNECT:
 804         case CONNMAN_SERVICE_STATE_FAILURE:
 805                 break;
 806         case CONNMAN_SERVICE_STATE_READY:
 807         case CONNMAN_SERVICE_STATE_ONLINE:
 808                 return TRUE;
 809         }
 810
 811         return FALSE;
 812 }
 813
 814 static connman_bool_t is_idle_state(const struct connman_service *service,
 815                                 enum connman_service_state state)
 816 {
 817         switch (state) {
 818         case CONNMAN_SERVICE_STATE_UNKNOWN:
 819         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 820         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 821         case CONNMAN_SERVICE_STATE_READY:
 822         case CONNMAN_SERVICE_STATE_ONLINE:
 823         case CONNMAN_SERVICE_STATE_DISCONNECT:
 824         case CONNMAN_SERVICE_STATE_FAILURE:
 825                 break;
 826         case CONNMAN_SERVICE_STATE_IDLE:
 827                 return TRUE;
 828         }
 829
 830         return FALSE;
 831 }
 832
 833 static connman_bool_t is_connecting(struct connman_service *service)
 834 {
 835         return is_connecting_state(service, service->state);
 836 }
 837
 838 static connman_bool_t is_connected(struct connman_service *service)
 839 {
 840         return is_connected_state(service, service->state);
 841 }
 842
 843 static const char *nameserver_get_ifname(struct connman_service *service)
 844 {
 845         const char *ifname;
 846
 847         if (service->ipconfig_ipv4)
 848                 ifname = __connman_ipconfig_get_ifname(service->ipconfig_ipv4);
 849         else if (service->ipconfig_ipv6)
 850                 ifname = __connman_ipconfig_get_ifname(service->ipconfig_ipv6);
 851         else
 852                 ifname = NULL;
 853
 854         if (ifname == NULL)
 855                 return NULL;
 856
 857         switch (combine_state(service->state_ipv4, service->state_ipv6)) {
 858         case CONNMAN_SERVICE_STATE_UNKNOWN:
 859         case CONNMAN_SERVICE_STATE_IDLE:
 860         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 861         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 862         case CONNMAN_SERVICE_STATE_FAILURE:
 863         case CONNMAN_SERVICE_STATE_DISCONNECT:
 864                 return NULL;
 865         case CONNMAN_SERVICE_STATE_READY:
 866         case CONNMAN_SERVICE_STATE_ONLINE:
 867                 break;
 868         }
 869
 870         return ifname;
 871 }
 872
 873 static void remove_nameservers(struct connman_service *service,
 874                 const char* interface, char **ns)
 875 {
 876         const char *ifname = interface;
 877         int i;
 878
 879         if (ns == NULL)
 880                 return;
 881
 882         if (interface == NULL)
 883                 ifname = nameserver_get_ifname(service);
 884
 885         if (ifname == NULL)
 886                         return;
 887
 888         for (i = 0; ns[i] != NULL; i++)
 889                 connman_resolver_remove(ifname, NULL, ns[i]);
 890 }
 891
 892 static void remove_searchdomains(struct connman_service *service,
 893                 const char *interface, char **sd)
 894 {
 895         const char *ifname = interface;
 896         int i;
 897
 898         if (sd == NULL)
 899                 return;
 900
 901         if (interface == NULL)
 902                 ifname = nameserver_get_ifname(service);
 903
 904         if (ifname == NULL)
 905                 return;
 906
 907         for (i = 0; sd[i] != NULL; i++)
 908                 connman_resolver_remove(ifname, sd[i], NULL);
 909 }
 910
 911 static void update_nameservers(struct connman_service *service)
 912 {
 913         const char *ifname;
 914
 915         if (service->ipconfig_ipv4)
 916                 ifname = __connman_ipconfig_get_ifname(service->ipconfig_ipv4);
 917         else if (service->ipconfig_ipv6)
 918                 ifname = __connman_ipconfig_get_ifname(service->ipconfig_ipv6);
 919         else
 920                 ifname = NULL;
 921
 922         if (ifname == NULL)
 923                 return;
 924
 925         switch (combine_state(service->state_ipv4, service->state_ipv6)) {
 926         case CONNMAN_SERVICE_STATE_UNKNOWN:
 927         case CONNMAN_SERVICE_STATE_IDLE:
 928         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 929         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 930                 return;
 931         case CONNMAN_SERVICE_STATE_FAILURE:
 932         case CONNMAN_SERVICE_STATE_DISCONNECT:
 933                 connman_resolver_remove_all(ifname);
 934                 return;
 935         case CONNMAN_SERVICE_STATE_READY:
 936         case CONNMAN_SERVICE_STATE_ONLINE:
 937                 break;
 938         }
 939
 940         if (service->nameservers_config != NULL) {
 941                 int i;
 942
 943                 remove_nameservers(service, ifname, service->nameservers);
 944
 945                 i = g_strv_length(service->nameservers_config);
 946                 while (i != 0) {
 947                         i--;
 948                         connman_resolver_append(ifname, NULL,
 949                                         service->nameservers_config[i]);
 950                 }
 951         } else if (service->nameservers != NULL) {
 952                 int i;
 953
 954                 i = g_strv_length(service->nameservers);
 955                 while (i != 0) {
 956                         i--;
 957                         connman_resolver_append(ifname, NULL,
 958                                         service->nameservers[i]);
 959                 }
 960         }
 961
 962         if (service->domains != NULL) {
 963                 char *searchdomains[2] = {NULL, NULL};
 964                 int i;
 965
 966                 searchdomains[0] = service->domainname;
 967                 remove_searchdomains(service, ifname, searchdomains);
 968
 969                 i = g_strv_length(service->domains);
 970                 while (i != 0) {
 971                         i--;
 972                         connman_resolver_append(ifname, service->domains[i],
 973                                                 NULL);
 974                 }
 975         } else if (service->domainname != NULL)
 976                 connman_resolver_append(ifname, service->domainname, NULL);
 977
 978         connman_resolver_flush();
 979 }
 980
 981 /*
 982  * The is_auto variable is set to true when IPv6 autoconf nameservers are
 983  * inserted to resolver via netlink message (see rtnl.c:rtnl_newnduseropt()
 984  * for details) and not through service.c
 985  */
 986 int __connman_service_nameserver_append(struct connman_service *service,
 987                                 const char *nameserver, gboolean is_auto)
 988 {
 989         char **nameservers;
 990         int len, i;
 991
 992         DBG("service %p nameserver %s auto %d", service, nameserver, is_auto);
 993
 994         if (nameserver == NULL)
 995                 return -EINVAL;
 996
 997         if (is_auto == TRUE)
 998                 nameservers = service->nameservers_auto;
 999         else
1000                 nameservers = service->nameservers;
1001
1002         for (i = 0; nameservers != NULL && nameservers[i] != NULL; i++)
1003                 if (g_strcmp0(nameservers[i], nameserver) == 0)
1004                         return -EEXIST;
1005
1006         if (nameservers != NULL) {
1007                 len = g_strv_length(nameservers);
1008                 nameservers = g_try_renew(char *, nameservers, len + 2);
1009         } else {
1010                 len = 0;
1011                 nameservers = g_try_new0(char *, len + 2);
1012         }
1013
1014         if (nameservers == NULL)
1015                 return -ENOMEM;
1016
1017         nameservers[len] = g_strdup(nameserver);
1018         if (nameservers[len] == NULL)
1019                 return -ENOMEM;
1020
1021         nameservers[len + 1] = NULL;
1022
1023         if (is_auto == TRUE) {
1024                 service->nameservers_auto = nameservers;
1025         } else {
1026                 service->nameservers = nameservers;
1027                 update_nameservers(service);
1028         }
1029
1030         return 0;
1031 }
1032
1033 int __connman_service_nameserver_remove(struct connman_service *service,
1034                                 const char *nameserver, gboolean is_auto)
1035 {
1036         char **servers, **nameservers;
1037         gboolean found = FALSE;
1038         int len, i, j;
1039
1040         DBG("service %p nameserver %s auto %d", service, nameserver, is_auto);
1041
1042         if (nameserver == NULL)
1043                 return -EINVAL;
1044
1045         if (is_auto == TRUE)
1046                 nameservers = service->nameservers_auto;
1047         else
1048                 nameservers = service->nameservers;
1049
1050         if (nameservers == NULL)
1051                 return 0;
1052
1053         for (i = 0; nameservers != NULL && nameservers[i] != NULL; i++)
1054                 if (g_strcmp0(nameservers[i], nameserver) == 0) {
1055                         found = TRUE;
1056                         break;
1057                 }
1058
1059         if (found == FALSE)
1060                 return 0;
1061
1062         len = g_strv_length(nameservers);
1063
1064         if (len == 1) {
1065                 g_strfreev(nameservers);
1066                 if (is_auto == TRUE)
1067                         service->nameservers_auto = NULL;
1068                 else
1069                         service->nameservers = NULL;
1070
1071                 return 0;
1072         }
1073
1074         servers = g_try_new0(char *, len);
1075         if (servers == NULL)
1076                 return -ENOMEM;
1077
1078         for (i = 0, j = 0; i < len; i++) {
1079                 if (g_strcmp0(nameservers[i], nameserver) != 0) {
1080                         servers[j] = g_strdup(nameservers[i]);
1081                         if (servers[j] == NULL)
1082                                 return -ENOMEM;
1083                         j++;
1084                 }
1085         }
1086         servers[len - 1] = NULL;
1087
1088         g_strfreev(nameservers);
1089         nameservers = servers;
1090
1091         if (is_auto == TRUE) {
1092                 service->nameservers_auto = nameservers;
1093         } else {
1094                 service->nameservers = nameservers;
1095                 update_nameservers(service);
1096         }
1097
1098         return 0;
1099 }
1100
1101 void __connman_service_nameserver_clear(struct connman_service *service)
1102 {
1103         g_strfreev(service->nameservers);
1104         service->nameservers = NULL;
1105
1106         update_nameservers(service);
1107 }
1108
1109 static void add_nameserver_route(int family, int index, char *nameserver,
1110                                 const char *gw)
1111 {
1112         switch (family) {
1113         case AF_INET:
1114                 if (connman_inet_compare_subnet(index, nameserver) == TRUE)
1115                         break;
1116
1117                 if (connman_inet_add_host_route(index, nameserver, gw) < 0)
1118                         /* For P-t-P link the above route add will fail */
1119                         connman_inet_add_host_route(index, nameserver, NULL);
1120                 break;
1121
1122         case AF_INET6:
1123                 if (connman_inet_add_ipv6_host_route(index, nameserver,
1124                                                                 gw) < 0)
1125                         connman_inet_add_ipv6_host_route(index, nameserver,
1126                                                         NULL);
1127                 break;
1128         }
1129 }
1130
1131 static void nameserver_add_routes(int index, char **nameservers,
1132                                         const char *gw)
1133 {
1134         int i, ret, family;
1135         struct addrinfo hints;
1136         struct addrinfo *addr;
1137
1138         for (i = 0; nameservers[i] != NULL; i++) {
1139                 memset(&hints, 0, sizeof(struct addrinfo));
1140                 hints.ai_flags = AI_NUMERICHOST;
1141                 addr = NULL;
1142
1143                 ret = getaddrinfo(nameservers[i], NULL, &hints, &addr);
1144                 if (ret == EAI_NONAME)
1145                         family = AF_INET; /* use the IPv4 as a default */
1146                 else if (ret != 0)
1147                         continue;
1148                 else
1149                         family = addr->ai_family;
1150
1151                 add_nameserver_route(family, index, nameservers[i], gw);
1152
1153                 freeaddrinfo(addr);
1154         }
1155 }
1156
1157 static void nameserver_del_routes(int index, char **nameservers,
1158                                 enum connman_ipconfig_type type)
1159 {
1160         int i, ret, family;
1161         struct addrinfo hints;
1162         struct addrinfo *addr;
1163
1164         for (i = 0; nameservers[i] != NULL; i++) {
1165                 memset(&hints, 0, sizeof(struct addrinfo));
1166                 hints.ai_flags = AI_NUMERICHOST;
1167                 addr = NULL;
1168
1169                 ret = getaddrinfo(nameservers[i], NULL, &hints, &addr);
1170                 if (ret == EAI_NONAME)
1171                         family = AF_INET; /* use the IPv4 as a default */
1172                 else if (ret != 0)
1173                         continue;
1174                 else
1175                         family = addr->ai_family;
1176
1177                 switch (family) {
1178                 case AF_INET:
1179                         if (type != CONNMAN_IPCONFIG_TYPE_IPV6)
1180                                 connman_inet_del_host_route(index,
1181                                                         nameservers[i]);
1182                         break;
1183                 case AF_INET6:
1184                         if (type != CONNMAN_IPCONFIG_TYPE_IPV4)
1185                                 connman_inet_del_ipv6_host_route(index,
1186                                                         nameservers[i]);
1187                         break;
1188                 }
1189
1190                 freeaddrinfo(addr);
1191         }
1192 }
1193
1194 void __connman_service_nameserver_add_routes(struct connman_service *service,
1195                                                 const char *gw)
1196 {
1197         int index = -1;
1198
1199         if (service == NULL)
1200                 return;
1201
1202         if (service->network != NULL)
1203                 index = connman_network_get_index(service->network);
1204         else if (service->provider != NULL)
1205                 index = connman_provider_get_index(service->provider);
1206
1207         if (service->nameservers_config != NULL) {
1208                 /*
1209                  * Configured nameserver takes preference over the
1210                  * discoverd nameserver gathered from DHCP, VPN, etc.
1211                  */
1212                 nameserver_add_routes(index, service->nameservers_config, gw);
1213         } else if (service->nameservers != NULL) {
1214                 /*
1215                  * We add nameservers host routes for nameservers that
1216                  * are not on our subnet. For those who are, the subnet
1217                  * route will be installed by the time the dns proxy code
1218                  * tries to reach them. The subnet route is installed
1219                  * when setting the interface IP address.
1220                  */
1221                 nameserver_add_routes(index, service->nameservers, gw);
1222         }
1223 }
1224
1225 void __connman_service_nameserver_del_routes(struct connman_service *service,
1226                                         enum connman_ipconfig_type type)
1227 {
1228         int index = -1;
1229
1230         if (service == NULL)
1231                 return;
1232
1233         if (service->network != NULL)
1234                 index = connman_network_get_index(service->network);
1235         else if (service->provider != NULL)
1236                 index = connman_provider_get_index(service->provider);
1237
1238         if (service->nameservers_config != NULL)
1239                 nameserver_del_routes(index, service->nameservers_config,
1240                                         type);
1241         else if (service->nameservers != NULL)
1242                 nameserver_del_routes(index, service->nameservers, type);
1243 }
1244
1245 static struct connman_stats *stats_get(struct connman_service *service)
1246 {
1247         if (service->roaming == TRUE)
1248                 return &service->stats_roaming;
1249         else
1250                 return &service->stats;
1251 }
1252
1253 static connman_bool_t stats_enabled(struct connman_service *service)
1254 {
1255         struct connman_stats *stats = stats_get(service);
1256
1257         return stats->enabled;
1258 }
1259
1260 static void stats_start(struct connman_service *service)
1261 {
1262         struct connman_stats *stats = stats_get(service);
1263
1264         DBG("service %p", service);
1265
1266         if (stats->timer == NULL)
1267                 return;
1268
1269         stats->enabled = TRUE;
1270         stats->data_last.time = stats->data.time;
1271
1272         g_timer_start(stats->timer);
1273 }
1274
1275 static void stats_stop(struct connman_service *service)
1276 {
1277         struct connman_stats *stats = stats_get(service);
1278         unsigned int seconds;
1279
1280         DBG("service %p", service);
1281
1282         if (stats->timer == NULL)
1283                 return;
1284
1285         if (stats->enabled == FALSE)
1286                 return;
1287
1288         g_timer_stop(stats->timer);
1289
1290         seconds = g_timer_elapsed(stats->timer, NULL);
1291         stats->data.time = stats->data_last.time + seconds;
1292
1293         stats->enabled = FALSE;
1294 }
1295
1296 static void reset_stats(struct connman_service *service)
1297 {
1298         DBG("service %p", service);
1299
1300         /* home */
1301         service->stats.valid = FALSE;
1302
1303         service->stats.data.rx_packets = 0;
1304         service->stats.data.tx_packets = 0;
1305         service->stats.data.rx_bytes = 0;
1306         service->stats.data.tx_bytes = 0;
1307         service->stats.data.rx_errors = 0;
1308         service->stats.data.tx_errors = 0;
1309         service->stats.data.rx_dropped = 0;
1310         service->stats.data.tx_dropped = 0;
1311         service->stats.data.time = 0;
1312         service->stats.data_last.time = 0;
1313
1314         g_timer_reset(service->stats.timer);
1315
1316         /* roaming */
1317         service->stats_roaming.valid = FALSE;
1318
1319         service->stats_roaming.data.rx_packets = 0;
1320         service->stats_roaming.data.tx_packets = 0;
1321         service->stats_roaming.data.rx_bytes = 0;
1322         service->stats_roaming.data.tx_bytes = 0;
1323         service->stats_roaming.data.rx_errors = 0;
1324         service->stats_roaming.data.tx_errors = 0;
1325         service->stats_roaming.data.rx_dropped = 0;
1326         service->stats_roaming.data.tx_dropped = 0;
1327         service->stats_roaming.data.time = 0;
1328         service->stats_roaming.data_last.time = 0;
1329
1330         g_timer_reset(service->stats_roaming.timer);
1331 }
1332
1333 struct connman_service *__connman_service_get_default(void)
1334 {
1335         struct connman_service *service;
1336         GSequenceIter *iter;
1337
1338         iter = g_sequence_get_begin_iter(service_list);
1339
1340         if (g_sequence_iter_is_end(iter) == TRUE)
1341                 return NULL;
1342
1343         service = g_sequence_get(iter);
1344
1345         if (is_connected(service) == FALSE)
1346                 return NULL;
1347
1348         return service;
1349 }
1350
1351 static void default_changed(void)
1352 {
1353         struct connman_service *service = __connman_service_get_default();
1354
1355         if (service == current_default)
1356                 return;
1357
1358         __connman_service_timeserver_changed(current_default, NULL);
1359
1360         current_default = service;
1361
1362         __connman_notifier_default_changed(service);
1363 }
1364
1365 static void state_changed(struct connman_service *service)
1366 {
1367         const char *str;
1368
1369         __connman_notifier_service_state_changed(service, service->state);
1370
1371         str = state2string(service->state);
1372         if (str == NULL)
1373                 return;
1374
1375         connman_dbus_property_changed_basic(service->path,
1376                                 CONNMAN_SERVICE_INTERFACE, "State",
1377                                                 DBUS_TYPE_STRING, &str);
1378 }
1379
1380 static void strength_changed(struct connman_service *service)
1381 {
1382         if (service->strength == 0)
1383                 return;
1384
1385         connman_dbus_property_changed_basic(service->path,
1386                                 CONNMAN_SERVICE_INTERFACE, "Strength",
1387                                         DBUS_TYPE_BYTE, &service->strength);
1388 }
1389
1390 static void favorite_changed(struct connman_service *service)
1391 {
1392         if (service->path == NULL)
1393                 return;
1394
1395         connman_dbus_property_changed_basic(service->path,
1396                                 CONNMAN_SERVICE_INTERFACE, "Favorite",
1397                                         DBUS_TYPE_BOOLEAN, &service->favorite);
1398 }
1399
1400 static void immutable_changed(struct connman_service *service)
1401 {
1402         if (service->path == NULL)
1403                 return;
1404
1405         connman_dbus_property_changed_basic(service->path,
1406                                 CONNMAN_SERVICE_INTERFACE, "Immutable",
1407                                         DBUS_TYPE_BOOLEAN, &service->immutable);
1408 }
1409
1410 static void roaming_changed(struct connman_service *service)
1411 {
1412         if (service->path == NULL)
1413                 return;
1414
1415         connman_dbus_property_changed_basic(service->path,
1416                                 CONNMAN_SERVICE_INTERFACE, "Roaming",
1417                                         DBUS_TYPE_BOOLEAN, &service->roaming);
1418 }
1419
1420 static void autoconnect_changed(struct connman_service *service)
1421 {
1422         if (service->path == NULL)
1423                 return;
1424
1425         connman_dbus_property_changed_basic(service->path,
1426                                 CONNMAN_SERVICE_INTERFACE, "AutoConnect",
1427                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
1428 }
1429
1430 static void append_security(DBusMessageIter *iter, void *user_data)
1431 {
1432         struct connman_service *service = user_data;
1433         const char *str;
1434
1435         str = security2string(service->security);
1436         if (str != NULL)
1437                 dbus_message_iter_append_basic(iter,
1438                                 DBUS_TYPE_STRING, &str);
1439
1440         /*
1441          * Some access points incorrectly advertise WPS even when they
1442          * are configured as open or no security, so filter
1443          * appropriately.
1444          */
1445         if (service->wps == TRUE) {
1446                 switch (service->security) {
1447                 case CONNMAN_SERVICE_SECURITY_PSK:
1448                 case CONNMAN_SERVICE_SECURITY_WPA:
1449                 case CONNMAN_SERVICE_SECURITY_RSN:
1450                         str = "wps";
1451                         dbus_message_iter_append_basic(iter,
1452                                 DBUS_TYPE_STRING, &str);
1453                         break;
1454                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
1455                 case CONNMAN_SERVICE_SECURITY_NONE:
1456                 case CONNMAN_SERVICE_SECURITY_WEP:
1457                 case CONNMAN_SERVICE_SECURITY_8021X:
1458                         break;
1459                 }
1460         }
1461 }
1462
1463 static void append_ethernet(DBusMessageIter *iter, void *user_data)
1464 {
1465         struct connman_service *service = user_data;
1466
1467         if (service->ipconfig_ipv4 != NULL)
1468                 __connman_ipconfig_append_ethernet(service->ipconfig_ipv4,
1469                                                                         iter);
1470         else if (service->ipconfig_ipv6 != NULL)
1471                 __connman_ipconfig_append_ethernet(service->ipconfig_ipv6,
1472                                                                         iter);
1473 }
1474
1475 static void append_ipv4(DBusMessageIter *iter, void *user_data)
1476 {
1477         struct connman_service *service = user_data;
1478
1479         DBG("ipv4 %p state %s", service->ipconfig_ipv4,
1480                                 state2string(service->state_ipv4));
1481
1482         if (is_connected_state(service, service->state_ipv4) == FALSE)
1483                 return;
1484
1485         if (service->ipconfig_ipv4 != NULL)
1486                 __connman_ipconfig_append_ipv4(service->ipconfig_ipv4, iter);
1487 }
1488
1489 static void append_ipv6(DBusMessageIter *iter, void *user_data)
1490 {
1491         struct connman_service *service = user_data;
1492
1493         DBG("ipv6 %p state %s", service->ipconfig_ipv6,
1494                                 state2string(service->state_ipv6));
1495
1496         if (is_connected_state(service, service->state_ipv6) == FALSE)
1497                 return;
1498
1499         if (service->ipconfig_ipv6 != NULL)
1500                 __connman_ipconfig_append_ipv6(service->ipconfig_ipv6, iter,
1501                                                 service->ipconfig_ipv4);
1502 }
1503
1504 static void append_ipv4config(DBusMessageIter *iter, void *user_data)
1505 {
1506         struct connman_service *service = user_data;
1507
1508         if (service->ipconfig_ipv4 != NULL)
1509                 __connman_ipconfig_append_ipv4config(service->ipconfig_ipv4,
1510                                                         iter);
1511 }
1512
1513 static void append_ipv6config(DBusMessageIter *iter, void *user_data)
1514 {
1515         struct connman_service *service = user_data;
1516
1517         if (service->ipconfig_ipv6 != NULL)
1518                 __connman_ipconfig_append_ipv6config(service->ipconfig_ipv6,
1519                                                         iter);
1520 }
1521
1522 static void append_nameserver(DBusMessageIter *iter, char ***nameservers)
1523 {
1524         char **servers;
1525         int i;
1526
1527         servers = *nameservers;
1528
1529         for (i = 0; servers[i] != NULL; i++) {
1530                 dbus_message_iter_append_basic(iter,
1531                                         DBUS_TYPE_STRING, &servers[i]);
1532         }
1533 }
1534
1535 static void append_dns(DBusMessageIter *iter, void *user_data)
1536 {
1537         struct connman_service *service = user_data;
1538
1539         if (is_connected(service) == FALSE)
1540                 return;
1541
1542         if (service->nameservers_config != NULL) {
1543                 append_nameserver(iter, &service->nameservers_config);
1544                 return;
1545         } else {
1546                 if (service->nameservers != NULL)
1547                         append_nameserver(iter, &service->nameservers);
1548
1549                 if (service->nameservers_auto != NULL)
1550                         append_nameserver(iter, &service->nameservers_auto);
1551         }
1552 }
1553
1554 static void append_dnsconfig(DBusMessageIter *iter, void *user_data)
1555 {
1556         struct connman_service *service = user_data;
1557         int i;
1558
1559         if (service->nameservers_config == NULL)
1560                 return;
1561
1562         for (i = 0; service->nameservers_config[i]; i++) {
1563                 dbus_message_iter_append_basic(iter,
1564                                 DBUS_TYPE_STRING,
1565                                 &service->nameservers_config[i]);
1566         }
1567 }
1568
1569 static void append_ts(DBusMessageIter *iter, void *user_data)
1570 {
1571         GSList *list = user_data;
1572
1573         while (list != NULL) {
1574                 char *timeserver = list->data;
1575
1576                 if (timeserver != NULL)
1577                         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
1578                                         &timeserver);
1579
1580                 list = g_slist_next(list);
1581         }
1582 }
1583
1584 static void append_tsconfig(DBusMessageIter *iter, void *user_data)
1585 {
1586         struct connman_service *service = user_data;
1587         int i;
1588
1589         if (service->timeservers_config == NULL)
1590                 return;
1591
1592         for (i = 0; service->timeservers_config[i]; i++) {
1593                 dbus_message_iter_append_basic(iter,
1594                                 DBUS_TYPE_STRING,
1595                                 &service->timeservers_config[i]);
1596         }
1597 }
1598
1599 static void append_domainconfig(DBusMessageIter *iter, void *user_data)
1600 {
1601         struct connman_service *service = user_data;
1602         int i;
1603
1604         if (service->domains == NULL)
1605                 return;
1606
1607         for (i = 0; service->domains[i]; i++)
1608                 dbus_message_iter_append_basic(iter,
1609                                 DBUS_TYPE_STRING, &service->domains[i]);
1610 }
1611
1612 static void append_domain(DBusMessageIter *iter, void *user_data)
1613 {
1614         struct connman_service *service = user_data;
1615
1616         if (is_connected(service) == FALSE &&
1617                                 is_connecting(service) == FALSE)
1618                 return;
1619
1620         if (service->domains != NULL)
1621                 append_domainconfig(iter, user_data);
1622         else if (service->domainname != NULL)
1623                 dbus_message_iter_append_basic(iter,
1624                                 DBUS_TYPE_STRING, &service->domainname);
1625 }
1626
1627 static void append_proxies(DBusMessageIter *iter, void *user_data)
1628 {
1629         struct connman_service *service = user_data;
1630         int i;
1631
1632         if (service->proxies == NULL)
1633                 return;
1634
1635         for (i = 0; service->proxies[i]; i++)
1636                 dbus_message_iter_append_basic(iter,
1637                                 DBUS_TYPE_STRING, &service->proxies[i]);
1638 }
1639
1640 static void append_excludes(DBusMessageIter *iter, void *user_data)
1641 {
1642         struct connman_service *service = user_data;
1643         int i;
1644
1645         if (service->excludes == NULL)
1646                 return;
1647
1648         for (i = 0; service->excludes[i]; i++)
1649                 dbus_message_iter_append_basic(iter,
1650                                 DBUS_TYPE_STRING, &service->excludes[i]);
1651 }
1652
1653 static void append_proxy(DBusMessageIter *iter, void *user_data)
1654 {
1655         struct connman_service *service = user_data;
1656         enum connman_service_proxy_method proxy;
1657         const char *pac = NULL;
1658         const char *method = proxymethod2string(
1659                 CONNMAN_SERVICE_PROXY_METHOD_DIRECT);
1660
1661         DBG("");
1662
1663         if (is_connected(service) == FALSE)
1664                 return;
1665
1666         proxy = connman_service_get_proxy_method(service);
1667
1668         switch (proxy) {
1669         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
1670                 return;
1671         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
1672                 goto done;
1673         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
1674                 connman_dbus_dict_append_array(iter, "Servers",
1675                                         DBUS_TYPE_STRING, append_proxies,
1676                                         service);
1677
1678                 connman_dbus_dict_append_array(iter, "Excludes",
1679                                         DBUS_TYPE_STRING, append_excludes,
1680                                         service);
1681                 break;
1682         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
1683                 /* Maybe DHCP, or WPAD,  has provided an url for a pac file */
1684                 if (service->ipconfig_ipv4 != NULL)
1685                         pac = __connman_ipconfig_get_proxy_autoconfig(
1686                                 service->ipconfig_ipv4);
1687                 else if (service->ipconfig_ipv6 != NULL)
1688                         pac = __connman_ipconfig_get_proxy_autoconfig(
1689                                 service->ipconfig_ipv6);
1690
1691                 if (service->pac == NULL && pac == NULL)
1692                         goto done;
1693
1694                 if (service->pac != NULL)
1695                         pac = service->pac;
1696
1697                 connman_dbus_dict_append_basic(iter, "URL",
1698                                         DBUS_TYPE_STRING, &pac);
1699                 break;
1700         }
1701
1702         method = proxymethod2string(proxy);
1703
1704 done:
1705         connman_dbus_dict_append_basic(iter, "Method",
1706                                         DBUS_TYPE_STRING, &method);
1707 }
1708
1709 static void append_proxyconfig(DBusMessageIter *iter, void *user_data)
1710 {
1711         struct connman_service *service = user_data;
1712         const char *method;
1713
1714         if (service->proxy_config == CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN)
1715                 return;
1716
1717         switch (service->proxy_config) {
1718         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
1719                 return;
1720         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
1721                 break;
1722         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
1723                 if (service->proxies != NULL)
1724                         connman_dbus_dict_append_array(iter, "Servers",
1725                                                 DBUS_TYPE_STRING,
1726                                                 append_proxies, service);
1727
1728                 if (service->excludes != NULL)
1729                         connman_dbus_dict_append_array(iter, "Excludes",
1730                                                 DBUS_TYPE_STRING,
1731                                                 append_excludes, service);
1732                 break;
1733         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
1734                 if (service->pac != NULL)
1735                         connman_dbus_dict_append_basic(iter, "URL",
1736                                         DBUS_TYPE_STRING, &service->pac);
1737                 break;
1738         }
1739
1740         method = proxymethod2string(service->proxy_config);
1741
1742         connman_dbus_dict_append_basic(iter, "Method",
1743                                 DBUS_TYPE_STRING, &method);
1744 }
1745
1746 static void append_provider(DBusMessageIter *iter, void *user_data)
1747 {
1748         struct connman_service *service = user_data;
1749
1750         DBG("%p %p", service, service->provider);
1751
1752         if (is_connected(service) == FALSE)
1753                 return;
1754
1755         if (service->provider != NULL)
1756                 __connman_provider_append_properties(service->provider, iter);
1757 }
1758
1759
1760 static void settings_changed(struct connman_service *service,
1761                                 struct connman_ipconfig *ipconfig)
1762 {
1763         connman_dbus_property_changed_dict(service->path,
1764                                         CONNMAN_SERVICE_INTERFACE, "IPv4",
1765                                                         append_ipv4, service);
1766
1767         connman_dbus_property_changed_dict(service->path,
1768                                         CONNMAN_SERVICE_INTERFACE, "IPv6",
1769                                                         append_ipv6, service);
1770
1771         __connman_notifier_ipconfig_changed(service, ipconfig);
1772 }
1773
1774 static void ipv4_configuration_changed(struct connman_service *service)
1775 {
1776         connman_dbus_property_changed_dict(service->path,
1777                                         CONNMAN_SERVICE_INTERFACE,
1778                                                         "IPv4.Configuration",
1779                                                         append_ipv4config,
1780                                                         service);
1781 }
1782
1783 static void ipv6_configuration_changed(struct connman_service *service)
1784 {
1785         connman_dbus_property_changed_dict(service->path,
1786                                         CONNMAN_SERVICE_INTERFACE,
1787                                                         "IPv6.Configuration",
1788                                                         append_ipv6config,
1789                                                         service);
1790 }
1791
1792 static void dns_changed(struct connman_service *service)
1793 {
1794         connman_dbus_property_changed_array(service->path,
1795                                 CONNMAN_SERVICE_INTERFACE, "Nameservers",
1796                                         DBUS_TYPE_STRING, append_dns, service);
1797 }
1798
1799 static void dns_configuration_changed(struct connman_service *service)
1800 {
1801         connman_dbus_property_changed_array(service->path,
1802                                 CONNMAN_SERVICE_INTERFACE,
1803                                 "Nameservers.Configuration",
1804                                 DBUS_TYPE_STRING, append_dnsconfig, service);
1805
1806         dns_changed(service);
1807 }
1808
1809 static void domain_changed(struct connman_service *service)
1810 {
1811         connman_dbus_property_changed_array(service->path,
1812                                 CONNMAN_SERVICE_INTERFACE, "Domains",
1813                                 DBUS_TYPE_STRING, append_domain, service);
1814 }
1815
1816 static void domain_configuration_changed(struct connman_service *service)
1817 {
1818         connman_dbus_property_changed_array(service->path,
1819                                 CONNMAN_SERVICE_INTERFACE,
1820                                 "Domains.Configuration",
1821                                 DBUS_TYPE_STRING, append_domainconfig, service);
1822 }
1823
1824 static void proxy_changed(struct connman_service *service)
1825 {
1826         connman_dbus_property_changed_dict(service->path,
1827                                         CONNMAN_SERVICE_INTERFACE, "Proxy",
1828                                                         append_proxy, service);
1829 }
1830
1831 static void proxy_configuration_changed(struct connman_service *service)
1832 {
1833         connman_dbus_property_changed_dict(service->path,
1834                         CONNMAN_SERVICE_INTERFACE, "Proxy.Configuration",
1835                                                 append_proxyconfig, service);
1836
1837         proxy_changed(service);
1838 }
1839
1840 static void timeservers_configuration_changed(struct connman_service *service)
1841 {
1842         connman_dbus_property_changed_array(service->path,
1843                         CONNMAN_SERVICE_INTERFACE,
1844                         "Timeservers.Configuration",
1845                         DBUS_TYPE_STRING,
1846                         append_tsconfig, service);
1847 }
1848
1849 static void link_changed(struct connman_service *service)
1850 {
1851         connman_dbus_property_changed_dict(service->path,
1852                                         CONNMAN_SERVICE_INTERFACE, "Ethernet",
1853                                                 append_ethernet, service);
1854 }
1855
1856 static void stats_append_counters(DBusMessageIter *dict,
1857                         struct connman_stats_data *stats,
1858                         struct connman_stats_data *counters,
1859                         connman_bool_t append_all)
1860 {
1861         if (counters->rx_packets != stats->rx_packets || append_all) {
1862                 counters->rx_packets = stats->rx_packets;
1863                 connman_dbus_dict_append_basic(dict, "RX.Packets",
1864                                         DBUS_TYPE_UINT32, &stats->rx_packets);
1865         }
1866
1867         if (counters->tx_packets != stats->tx_packets || append_all) {
1868                 counters->tx_packets = stats->tx_packets;
1869                 connman_dbus_dict_append_basic(dict, "TX.Packets",
1870                                         DBUS_TYPE_UINT32, &stats->tx_packets);
1871         }
1872
1873         if (counters->rx_bytes != stats->rx_bytes || append_all) {
1874                 counters->rx_bytes = stats->rx_bytes;
1875                 connman_dbus_dict_append_basic(dict, "RX.Bytes",
1876                                         DBUS_TYPE_UINT32, &stats->rx_bytes);
1877         }
1878
1879         if (counters->tx_bytes != stats->tx_bytes || append_all) {
1880                 counters->tx_bytes = stats->tx_bytes;
1881                 connman_dbus_dict_append_basic(dict, "TX.Bytes",
1882                                         DBUS_TYPE_UINT32, &stats->tx_bytes);
1883         }
1884
1885         if (counters->rx_errors != stats->rx_errors || append_all) {
1886                 counters->rx_errors = stats->rx_errors;
1887                 connman_dbus_dict_append_basic(dict, "RX.Errors",
1888                                         DBUS_TYPE_UINT32, &stats->rx_errors);
1889         }
1890
1891         if (counters->tx_errors != stats->tx_errors || append_all) {
1892                 counters->tx_errors = stats->tx_errors;
1893                 connman_dbus_dict_append_basic(dict, "TX.Errors",
1894                                         DBUS_TYPE_UINT32, &stats->tx_errors);
1895         }
1896
1897         if (counters->rx_dropped != stats->rx_dropped || append_all) {
1898                 counters->rx_dropped = stats->rx_dropped;
1899                 connman_dbus_dict_append_basic(dict, "RX.Dropped",
1900                                         DBUS_TYPE_UINT32, &stats->rx_dropped);
1901         }
1902
1903         if (counters->tx_dropped != stats->tx_dropped || append_all) {
1904                 counters->tx_dropped = stats->tx_dropped;
1905                 connman_dbus_dict_append_basic(dict, "TX.Dropped",
1906                                         DBUS_TYPE_UINT32, &stats->tx_dropped);
1907         }
1908
1909         if (counters->time != stats->time || append_all) {
1910                 counters->time = stats->time;
1911                 connman_dbus_dict_append_basic(dict, "Time",
1912                                         DBUS_TYPE_UINT32, &stats->time);
1913         }
1914 }
1915
1916 static void stats_append(struct connman_service *service,
1917                                 const char *counter,
1918                                 struct connman_stats_counter *counters,
1919                                 connman_bool_t append_all)
1920 {
1921         DBusMessageIter array, dict;
1922         DBusMessage *msg;
1923
1924         DBG("service %p counter %s", service, counter);
1925
1926         msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
1927         if (msg == NULL)
1928                 return;
1929
1930         dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH,
1931                                 &service->path, DBUS_TYPE_INVALID);
1932
1933         dbus_message_iter_init_append(msg, &array);
1934
1935         /* home counter */
1936         connman_dbus_dict_open(&array, &dict);
1937
1938         stats_append_counters(&dict, &service->stats.data,
1939                                 &counters->stats.data, append_all);
1940
1941         connman_dbus_dict_close(&array, &dict);
1942
1943         /* roaming counter */
1944         connman_dbus_dict_open(&array, &dict);
1945
1946         stats_append_counters(&dict, &service->stats_roaming.data,
1947                                 &counters->stats_roaming.data, append_all);
1948
1949         connman_dbus_dict_close(&array, &dict);
1950
1951         __connman_counter_send_usage(counter, msg);
1952 }
1953
1954 static void stats_update(struct connman_service *service,
1955                                 unsigned int rx_packets, unsigned int tx_packets,
1956                                 unsigned int rx_bytes, unsigned int tx_bytes,
1957                                 unsigned int rx_errors, unsigned int tx_errors,
1958                                 unsigned int rx_dropped, unsigned int tx_dropped)
1959 {
1960         struct connman_stats *stats = stats_get(service);
1961         struct connman_stats_data *data_last = &stats->data_last;
1962         struct connman_stats_data *data = &stats->data;
1963         unsigned int seconds;
1964
1965         DBG("service %p", service);
1966
1967         if (stats->valid == TRUE) {
1968                 data->rx_packets +=
1969                         rx_packets - data_last->rx_packets;
1970                 data->tx_packets +=
1971                         tx_packets - data_last->tx_packets;
1972                 data->rx_bytes +=
1973                         rx_bytes - data_last->rx_bytes;
1974                 data->tx_bytes +=
1975                         tx_bytes - data_last->tx_bytes;
1976                 data->rx_errors +=
1977                         rx_errors - data_last->rx_errors;
1978                 data->tx_errors +=
1979                         tx_errors - data_last->tx_errors;
1980                 data->rx_dropped +=
1981                         rx_dropped - data_last->rx_dropped;
1982                 data->tx_dropped +=
1983                         tx_dropped - data_last->tx_dropped;
1984         } else {
1985                 stats->valid = TRUE;
1986         }
1987
1988         data_last->rx_packets = rx_packets;
1989         data_last->tx_packets = tx_packets;
1990         data_last->rx_bytes = rx_bytes;
1991         data_last->tx_bytes = tx_bytes;
1992         data_last->rx_errors = rx_errors;
1993         data_last->tx_errors = tx_errors;
1994         data_last->rx_dropped = rx_dropped;
1995         data_last->tx_dropped = tx_dropped;
1996
1997         seconds = g_timer_elapsed(stats->timer, NULL);
1998         stats->data.time = stats->data_last.time + seconds;
1999 }
2000
2001 void __connman_service_notify(struct connman_service *service,
2002                         unsigned int rx_packets, unsigned int tx_packets,
2003                         unsigned int rx_bytes, unsigned int tx_bytes,
2004                         unsigned int rx_errors, unsigned int tx_errors,
2005                         unsigned int rx_dropped, unsigned int tx_dropped)
2006 {
2007         GHashTableIter iter;
2008         gpointer key, value;
2009         const char *counter;
2010         struct connman_stats_counter *counters;
2011         struct connman_stats_data *data;
2012         int err;
2013
2014         if (service == NULL)
2015                 return;
2016
2017         if (is_connected(service) == FALSE)
2018                 return;
2019
2020         stats_update(service,
2021                 rx_packets, tx_packets,
2022                 rx_bytes, tx_bytes,
2023                 rx_errors, tx_errors,
2024                 rx_dropped, tx_dropped);
2025
2026         data = &stats_get(service)->data;
2027         err = __connman_stats_update(service, service->roaming, data);
2028         if (err < 0)
2029                 connman_error("Failed to store statistics for %s",
2030                                 service->identifier);
2031
2032         g_hash_table_iter_init(&iter, service->counter_table);
2033         while (g_hash_table_iter_next(&iter, &key, &value)) {
2034                 counter = key;
2035                 counters = value;
2036
2037                 stats_append(service, counter, counters, counters->append_all);
2038                 counters->append_all = FALSE;
2039         }
2040 }
2041
2042 int __connman_service_counter_register(const char *counter)
2043 {
2044         struct connman_service *service;
2045         GSequenceIter *iter;
2046         struct connman_stats_counter *counters;
2047
2048         DBG("counter %s", counter);
2049
2050         counter_list = g_slist_append(counter_list, (gpointer)counter);
2051
2052         iter = g_sequence_get_begin_iter(service_list);
2053
2054         while (g_sequence_iter_is_end(iter) == FALSE) {
2055                 service = g_sequence_get(iter);
2056
2057                 counters = g_try_new0(struct connman_stats_counter, 1);
2058                 if (counters == NULL)
2059                         return -ENOMEM;
2060
2061                 counters->append_all = TRUE;
2062
2063                 g_hash_table_replace(service->counter_table, (gpointer)counter,
2064                                         counters);
2065
2066                 iter = g_sequence_iter_next(iter);
2067         }
2068
2069         return 0;
2070 }
2071
2072 void __connman_service_counter_unregister(const char *counter)
2073 {
2074         struct connman_service *service;
2075         GSequenceIter *iter;
2076
2077         DBG("counter %s", counter);
2078
2079         iter = g_sequence_get_begin_iter(service_list);
2080
2081         while (g_sequence_iter_is_end(iter) == FALSE) {
2082                 service = g_sequence_get(iter);
2083
2084                 g_hash_table_remove(service->counter_table, counter);
2085
2086                 iter = g_sequence_iter_next(iter);
2087         }
2088
2089         counter_list = g_slist_remove(counter_list, counter);
2090 }
2091
2092 GSequence *__connman_service_get_list(struct connman_session *session,
2093                                 service_match_cb service_match,
2094                                 create_service_entry_cb create_service_entry,
2095                                 GDestroyNotify destroy_service_entry)
2096 {
2097         GSequence *list;
2098         GSequenceIter *iter;
2099         struct connman_service *service;
2100         struct service_entry *entry;
2101
2102         list = g_sequence_new(destroy_service_entry);
2103         if (list == NULL)
2104                 return NULL;
2105
2106         iter = g_sequence_get_begin_iter(service_list);
2107
2108         while (g_sequence_iter_is_end(iter) == FALSE) {
2109                 service = g_sequence_get(iter);
2110
2111                 if (service_match(session, service) == TRUE) {
2112                         entry = create_service_entry(service, service->name,
2113                                                         service->state);
2114                         if (entry == NULL)
2115                                 return list;
2116
2117                         g_sequence_append(list, entry);
2118                 }
2119
2120                 iter = g_sequence_iter_next(iter);
2121         }
2122
2123         return list;
2124 }
2125
2126 void __connman_service_session_inc(struct connman_service *service)
2127 {
2128         DBG("service %p ref count %d", service,
2129                 service->session_usage_count + 1);
2130
2131         __sync_fetch_and_add(&service->session_usage_count, 1);
2132 }
2133
2134 connman_bool_t __connman_service_session_dec(struct connman_service *service)
2135 {
2136         DBG("service %p ref count %d", service,
2137                 service->session_usage_count - 1);
2138
2139         if (__sync_fetch_and_sub(&service->session_usage_count, 1) != 1)
2140                 return FALSE;
2141
2142         return TRUE;
2143 }
2144
2145 static void append_properties(DBusMessageIter *dict, dbus_bool_t limited,
2146                                         struct connman_service *service)
2147 {
2148         const char *str;
2149         GSList *list;
2150
2151         str = __connman_service_type2string(service->type);
2152         if (str != NULL)
2153                 connman_dbus_dict_append_basic(dict, "Type",
2154                                                 DBUS_TYPE_STRING, &str);
2155
2156         connman_dbus_dict_append_array(dict, "Security",
2157                                 DBUS_TYPE_STRING, append_security, service);
2158
2159         str = state2string(service->state);
2160         if (str != NULL)
2161                 connman_dbus_dict_append_basic(dict, "State",
2162                                                 DBUS_TYPE_STRING, &str);
2163
2164         str = error2string(service->error);
2165         if (str != NULL)
2166                 connman_dbus_dict_append_basic(dict, "Error",
2167                                                 DBUS_TYPE_STRING, &str);
2168
2169         if (service->strength > 0)
2170                 connman_dbus_dict_append_basic(dict, "Strength",
2171                                         DBUS_TYPE_BYTE, &service->strength);
2172
2173         connman_dbus_dict_append_basic(dict, "Favorite",
2174                                         DBUS_TYPE_BOOLEAN, &service->favorite);
2175
2176         connman_dbus_dict_append_basic(dict, "Immutable",
2177                                         DBUS_TYPE_BOOLEAN, &service->immutable);
2178
2179         if (service->favorite == TRUE)
2180                 connman_dbus_dict_append_basic(dict, "AutoConnect",
2181                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
2182         else
2183                 connman_dbus_dict_append_basic(dict, "AutoConnect",
2184                                         DBUS_TYPE_BOOLEAN, &service->favorite);
2185
2186         if (service->name != NULL)
2187                 connman_dbus_dict_append_basic(dict, "Name",
2188                                         DBUS_TYPE_STRING, &service->name);
2189
2190         switch (service->type) {
2191         case CONNMAN_SERVICE_TYPE_UNKNOWN:
2192         case CONNMAN_SERVICE_TYPE_SYSTEM:
2193         case CONNMAN_SERVICE_TYPE_GPS:
2194         case CONNMAN_SERVICE_TYPE_VPN:
2195         case CONNMAN_SERVICE_TYPE_GADGET:
2196                 break;
2197         case CONNMAN_SERVICE_TYPE_CELLULAR:
2198                 connman_dbus_dict_append_basic(dict, "Roaming",
2199                                         DBUS_TYPE_BOOLEAN, &service->roaming);
2200
2201                 connman_dbus_dict_append_dict(dict, "Ethernet",
2202                                                 append_ethernet, service);
2203                 break;
2204         case CONNMAN_SERVICE_TYPE_WIFI:
2205         case CONNMAN_SERVICE_TYPE_ETHERNET:
2206         case CONNMAN_SERVICE_TYPE_WIMAX:
2207         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2208                 connman_dbus_dict_append_dict(dict, "Ethernet",
2209                                                 append_ethernet, service);
2210                 break;
2211         }
2212
2213         connman_dbus_dict_append_dict(dict, "IPv4", append_ipv4, service);
2214
2215         connman_dbus_dict_append_dict(dict, "IPv4.Configuration",
2216                                                 append_ipv4config, service);
2217
2218         connman_dbus_dict_append_dict(dict, "IPv6", append_ipv6, service);
2219
2220         connman_dbus_dict_append_dict(dict, "IPv6.Configuration",
2221                                                 append_ipv6config, service);
2222
2223         connman_dbus_dict_append_array(dict, "Nameservers",
2224                                 DBUS_TYPE_STRING, append_dns, service);
2225
2226         connman_dbus_dict_append_array(dict, "Nameservers.Configuration",
2227                                 DBUS_TYPE_STRING, append_dnsconfig, service);
2228
2229         if (service->state == CONNMAN_SERVICE_STATE_READY ||
2230                         service->state == CONNMAN_SERVICE_STATE_ONLINE)
2231                 list = __connman_timeserver_get_all(service);
2232         else
2233                 list = NULL;
2234
2235         connman_dbus_dict_append_array(dict, "Timeservers",
2236                                 DBUS_TYPE_STRING, append_ts, list);
2237
2238         g_slist_free_full(list, g_free);
2239
2240         connman_dbus_dict_append_array(dict, "Timeservers.Configuration",
2241                                 DBUS_TYPE_STRING, append_tsconfig, service);
2242
2243         connman_dbus_dict_append_array(dict, "Domains",
2244                                 DBUS_TYPE_STRING, append_domain, service);
2245
2246         connman_dbus_dict_append_array(dict, "Domains.Configuration",
2247                                 DBUS_TYPE_STRING, append_domainconfig, service);
2248
2249         connman_dbus_dict_append_dict(dict, "Proxy", append_proxy, service);
2250
2251         connman_dbus_dict_append_dict(dict, "Proxy.Configuration",
2252                                                 append_proxyconfig, service);
2253
2254         connman_dbus_dict_append_dict(dict, "Provider",
2255                                                 append_provider, service);
2256 }
2257
2258 static void append_struct_service(DBusMessageIter *iter,
2259                 connman_dbus_append_cb_t function,
2260                 struct connman_service *service)
2261 {
2262         DBusMessageIter entry, dict;
2263
2264         dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &entry);
2265
2266         dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
2267                                                         &service->path);
2268
2269         connman_dbus_dict_open(&entry, &dict);
2270         if (function != NULL)
2271                 function(&dict, service);
2272         connman_dbus_dict_close(&entry, &dict);
2273
2274         dbus_message_iter_close_container(iter, &entry);
2275 }
2276
2277 static void append_dict_properties(DBusMessageIter *dict, void *user_data)
2278 {
2279         struct connman_service *service = user_data;
2280
2281         append_properties(dict, TRUE, service);
2282 }
2283
2284 static void append_struct(gpointer value, gpointer user_data)
2285 {
2286         struct connman_service *service = value;
2287         DBusMessageIter *iter = user_data;
2288
2289         if (service->path == NULL)
2290                 return;
2291
2292         append_struct_service(iter, append_dict_properties, service);
2293 }
2294
2295 void __connman_service_list_struct(DBusMessageIter *iter)
2296 {
2297         g_sequence_foreach(service_list, append_struct, iter);
2298 }
2299
2300 connman_bool_t __connman_service_is_hidden(struct connman_service *service)
2301 {
2302         return service->hidden;
2303 }
2304
2305 connman_bool_t
2306 __connman_service_is_split_routing(struct connman_service *service)
2307 {
2308         return service->do_split_routing;
2309 }
2310
2311 int __connman_service_get_index(struct connman_service *service)
2312 {
2313         if (service == NULL)
2314                 return -1;
2315
2316         if (service->network != NULL)
2317                 return connman_network_get_index(service->network);
2318         else if (service->provider != NULL)
2319                 return connman_provider_get_index(service->provider);
2320
2321         return -1;
2322 }
2323
2324 void __connman_service_set_hidden(struct connman_service *service)
2325 {
2326         if (service == NULL || service->hidden == TRUE)
2327                 return;
2328
2329         service->hidden_service = TRUE;
2330 }
2331
2332 void __connman_service_set_domainname(struct connman_service *service,
2333                                                 const char *domainname)
2334 {
2335         if (service == NULL || service->hidden == TRUE)
2336                 return;
2337
2338         g_free(service->domainname);
2339         service->domainname = g_strdup(domainname);
2340
2341         domain_changed(service);
2342 }
2343
2344 const char *connman_service_get_domainname(struct connman_service *service)
2345 {
2346         if (service == NULL)
2347                 return NULL;
2348
2349         if (service->domains != NULL)
2350                 return service->domains[0];
2351         else
2352                 return service->domainname;
2353 }
2354
2355 char **connman_service_get_nameservers(struct connman_service *service)
2356 {
2357         if (service == NULL)
2358                 return NULL;
2359
2360         if (service->nameservers_config != NULL)
2361                 return g_strdupv(service->nameservers_config);
2362         else if (service->nameservers != NULL ||
2363                                         service->nameservers_auto != NULL) {
2364                 int len = 0, len_auto = 0, i;
2365                 char **nameservers;
2366
2367                 if (service->nameservers != NULL)
2368                         len = g_strv_length(service->nameservers);
2369                 if (service->nameservers_auto != NULL)
2370                         len_auto = g_strv_length(service->nameservers_auto);
2371
2372                 nameservers = g_try_new0(char *, len + len_auto + 1);
2373                 if (nameservers == NULL)
2374                         return NULL;
2375
2376                 for (i = 0; i < len; i++)
2377                         nameservers[i] = g_strdup(service->nameservers[i]);
2378
2379                 for (i = 0; i < len_auto; i++)
2380                         nameservers[i + len] =
2381                                 g_strdup(service->nameservers_auto[i]);
2382
2383                 return nameservers;
2384         }
2385
2386         return NULL;
2387 }
2388
2389 char **connman_service_get_timeservers_config(struct connman_service *service)
2390 {
2391         if (service == NULL)
2392                 return NULL;
2393
2394         return service->timeservers_config;
2395 }
2396
2397 char **connman_service_get_timeservers(struct connman_service *service)
2398 {
2399         if (service == NULL)
2400                 return NULL;
2401
2402         if (service->timeservers != NULL)
2403                 return service->timeservers;
2404
2405         return NULL;
2406 }
2407
2408 void connman_service_set_proxy_method(struct connman_service *service,
2409                                         enum connman_service_proxy_method method)
2410 {
2411         if (service == NULL || service->hidden == TRUE)
2412                 return;
2413
2414         service->proxy = method;
2415
2416         proxy_changed(service);
2417
2418         if (method != CONNMAN_SERVICE_PROXY_METHOD_AUTO)
2419                 __connman_notifier_proxy_changed(service);
2420 }
2421
2422 enum connman_service_proxy_method connman_service_get_proxy_method(
2423                                         struct connman_service *service)
2424 {
2425         if (service == NULL)
2426                 return CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
2427
2428         if (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN) {
2429                 if (service->proxy_config == CONNMAN_SERVICE_PROXY_METHOD_AUTO &&
2430                                 service->pac == NULL)
2431                         return service->proxy;
2432
2433                 return service->proxy_config;
2434         }
2435
2436         return service->proxy;
2437 }
2438
2439 char **connman_service_get_proxy_servers(struct connman_service *service)
2440 {
2441         return g_strdupv(service->proxies);
2442 }
2443
2444 char **connman_service_get_proxy_excludes(struct connman_service *service)
2445 {
2446         return g_strdupv(service->excludes);
2447 }
2448
2449 const char *connman_service_get_proxy_url(struct connman_service *service)
2450 {
2451         if (service == NULL)
2452                 return NULL;
2453
2454         return service->pac;
2455 }
2456
2457 void __connman_service_set_proxy_autoconfig(struct connman_service *service,
2458                                                         const char *url)
2459 {
2460         if (service == NULL || service->hidden == TRUE)
2461                 return;
2462
2463         service->proxy = CONNMAN_SERVICE_PROXY_METHOD_AUTO;
2464
2465         if (service->ipconfig_ipv4) {
2466                 if (__connman_ipconfig_set_proxy_autoconfig(
2467                             service->ipconfig_ipv4, url) < 0)
2468                         return;
2469         } else if (service->ipconfig_ipv6) {
2470                 if (__connman_ipconfig_set_proxy_autoconfig(
2471                             service->ipconfig_ipv6, url) < 0)
2472                         return;
2473         } else
2474                 return;
2475
2476         proxy_changed(service);
2477
2478         __connman_notifier_proxy_changed(service);
2479 }
2480
2481 const char *connman_service_get_proxy_autoconfig(struct connman_service *service)
2482 {
2483         if (service == NULL)
2484                 return NULL;
2485
2486         if (service->ipconfig_ipv4)
2487                 return __connman_ipconfig_get_proxy_autoconfig(
2488                                                 service->ipconfig_ipv4);
2489         else if (service->ipconfig_ipv6)
2490                 return __connman_ipconfig_get_proxy_autoconfig(
2491                                                 service->ipconfig_ipv6);
2492         return NULL;
2493 }
2494
2495 int __connman_service_timeserver_append(struct connman_service *service,
2496                                                 const char *timeserver)
2497 {
2498         int len;
2499
2500         DBG("service %p timeserver %s", service, timeserver);
2501
2502         if (timeserver == NULL)
2503                 return -EINVAL;
2504
2505         if (service->timeservers != NULL) {
2506                 int i;
2507
2508                 for (i = 0; service->timeservers[i] != NULL; i++)
2509                         if (g_strcmp0(service->timeservers[i], timeserver) == 0)
2510                                 return -EEXIST;
2511
2512                 len = g_strv_length(service->timeservers);
2513                 service->timeservers = g_try_renew(char *, service->timeservers,
2514                                                         len + 2);
2515         } else {
2516                 len = 0;
2517                 service->timeservers = g_try_new0(char *, len + 2);
2518         }
2519
2520         if (service->timeservers == NULL)
2521                 return -ENOMEM;
2522
2523         service->timeservers[len] = g_strdup(timeserver);
2524         service->timeservers[len + 1] = NULL;
2525
2526         return 0;
2527 }
2528
2529 int __connman_service_timeserver_remove(struct connman_service *service,
2530                                                 const char *timeserver)
2531 {
2532         char **servers;
2533         int len, i, j, found = 0;
2534
2535         DBG("service %p timeserver %s", service, timeserver);
2536
2537         if (timeserver == NULL)
2538                 return -EINVAL;
2539
2540         if (service->timeservers == NULL)
2541                 return 0;
2542
2543         for (i = 0; service->timeservers != NULL &&
2544                                         service->timeservers[i] != NULL; i++)
2545                 if (g_strcmp0(service->timeservers[i], timeserver) == 0) {
2546                         found = 1;
2547                         break;
2548                 }
2549
2550         if (found == 0)
2551                 return 0;
2552
2553         len = g_strv_length(service->timeservers);
2554
2555         if (len == 1) {
2556                 g_strfreev(service->timeservers);
2557                 service->timeservers = NULL;
2558
2559                 return 0;
2560         }
2561
2562         servers = g_try_new0(char *, len);
2563         if (servers == NULL)
2564                 return -ENOMEM;
2565
2566         for (i = 0, j = 0; i < len; i++) {
2567                 if (g_strcmp0(service->timeservers[i], timeserver) != 0) {
2568                         servers[j] = g_strdup(service->timeservers[i]);
2569                         if (servers[j] == NULL)
2570                                 return -ENOMEM;
2571                         j++;
2572                 }
2573         }
2574         servers[len - 1] = NULL;
2575
2576         g_strfreev(service->timeservers);
2577         service->timeservers = servers;
2578
2579         return 0;
2580 }
2581
2582 void __connman_service_timeserver_changed(struct connman_service *service,
2583                 GSList *ts_list)
2584 {
2585         if (service == NULL)
2586                 return;
2587
2588         connman_dbus_property_changed_array(service->path,
2589                         CONNMAN_SERVICE_INTERFACE, "Timeservers",
2590                         DBUS_TYPE_STRING, append_ts, ts_list);
2591 }
2592
2593 void __connman_service_set_pac(struct connman_service *service,
2594                                         const char *pac)
2595 {
2596         if (service->hidden == TRUE)
2597                 return;
2598         g_free(service->pac);
2599         service->pac = g_strdup(pac);
2600
2601         proxy_changed(service);
2602 }
2603
2604 void __connman_service_set_identity(struct connman_service *service,
2605                                         const char *identity)
2606 {
2607         if (service->immutable || service->hidden == TRUE)
2608                 return;
2609
2610         g_free(service->identity);
2611         service->identity = g_strdup(identity);
2612
2613         if (service->network != NULL)
2614                 connman_network_set_string(service->network,
2615                                         "WiFi.Identity",
2616                                         service->identity);
2617 }
2618
2619 void __connman_service_set_agent_identity(struct connman_service *service,
2620                                                 const char *agent_identity)
2621 {
2622         if (service->hidden == TRUE)
2623                 return;
2624         g_free(service->agent_identity);
2625         service->agent_identity = g_strdup(agent_identity);
2626
2627         if (service->network != NULL)
2628                 connman_network_set_string(service->network,
2629                                         "WiFi.AgentIdentity",
2630                                         service->agent_identity);
2631 }
2632
2633 static int check_passphrase(enum connman_service_security security,
2634                                 const char *passphrase)
2635 {
2636         guint i;
2637         gsize length;
2638
2639         if (passphrase == NULL)
2640                 return 0;
2641
2642         length = strlen(passphrase);
2643
2644         switch (security) {
2645         case CONNMAN_SERVICE_SECURITY_PSK:
2646         case CONNMAN_SERVICE_SECURITY_WPA:
2647         case CONNMAN_SERVICE_SECURITY_RSN:
2648                 /* A raw key is always 64 bytes length,
2649                  * its content is in hex representation.
2650                  * A PSK key must be between [8..63].
2651                  */
2652                 if (length == 64) {
2653                         for (i = 0; i < 64; i++)
2654                                 if (!isxdigit((unsigned char)
2655                                               passphrase[i]))
2656                                         return -ENOKEY;
2657                 } else if (length < 8 || length > 63)
2658                         return -ENOKEY;
2659                 break;
2660         case CONNMAN_SERVICE_SECURITY_WEP:
2661                 /* length of WEP key is 10 or 26
2662                  * length of WEP passphrase is 5 or 13
2663                  */
2664                 if (length == 10 || length == 26) {
2665                         for (i = 0; i < length; i++)
2666                                 if (!isxdigit((unsigned char)
2667                                               passphrase[i]))
2668                                         return -ENOKEY;
2669                 } else if (length != 5 && length != 13)
2670                         return -ENOKEY;
2671                 break;
2672         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
2673         case CONNMAN_SERVICE_SECURITY_NONE:
2674         case CONNMAN_SERVICE_SECURITY_8021X:
2675                 break;
2676         }
2677
2678         return 0;
2679 }
2680
2681 int __connman_service_set_passphrase(struct connman_service *service,
2682                                         const char *passphrase)
2683 {
2684         int err = 0;
2685
2686         if (service->immutable == TRUE || service->hidden == TRUE)
2687                 return -EINVAL;
2688
2689         err = check_passphrase(service->security, passphrase);
2690
2691         if (err == 0) {
2692                 g_free(service->passphrase);
2693                 service->passphrase = g_strdup(passphrase);
2694
2695                 if (service->network != NULL)
2696                         connman_network_set_string(service->network,
2697                                                         "WiFi.Passphrase",
2698                                                         service->passphrase);
2699                 service_save(service);
2700         }
2701
2702         return err;
2703 }
2704
2705 void __connman_service_set_agent_passphrase(struct connman_service *service,
2706                                                 const char *agent_passphrase)
2707 {
2708         if (service->hidden == TRUE)
2709                 return;
2710         g_free(service->agent_passphrase);
2711         service->agent_passphrase = g_strdup(agent_passphrase);
2712
2713         if (service->network != NULL)
2714                 connman_network_set_string(service->network,
2715                                         "WiFi.AgentPassphrase",
2716                                         service->agent_passphrase);
2717 }
2718
2719 static DBusMessage *get_properties(DBusConnection *conn,
2720                                         DBusMessage *msg, void *user_data)
2721 {
2722         struct connman_service *service = user_data;
2723         DBusMessage *reply;
2724         DBusMessageIter array, dict;
2725
2726         DBG("service %p", service);
2727
2728         reply = dbus_message_new_method_return(msg);
2729         if (reply == NULL)
2730                 return NULL;
2731
2732         dbus_message_iter_init_append(reply, &array);
2733
2734         connman_dbus_dict_open(&array, &dict);
2735         append_properties(&dict, FALSE, service);
2736         connman_dbus_dict_close(&array, &dict);
2737
2738         return reply;
2739 }
2740
2741 static int update_proxy_configuration(struct connman_service *service,
2742                                 DBusMessageIter *array)
2743 {
2744         DBusMessageIter dict;
2745         enum connman_service_proxy_method method;
2746         GString *servers_str = NULL;
2747         GString *excludes_str = NULL;
2748         const char *url = NULL;
2749
2750         method = CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
2751
2752         dbus_message_iter_recurse(array, &dict);
2753
2754         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
2755                 DBusMessageIter entry, variant;
2756                 const char *key;
2757                 int type;
2758
2759                 dbus_message_iter_recurse(&dict, &entry);
2760
2761                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
2762                         goto error;
2763
2764                 dbus_message_iter_get_basic(&entry, &key);
2765                 dbus_message_iter_next(&entry);
2766
2767                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
2768                         goto error;
2769
2770                 dbus_message_iter_recurse(&entry, &variant);
2771
2772                 type = dbus_message_iter_get_arg_type(&variant);
2773
2774                 if (g_str_equal(key, "Method") == TRUE) {
2775                         const char *val;
2776
2777                         if (type != DBUS_TYPE_STRING)
2778                                 goto error;
2779
2780                         dbus_message_iter_get_basic(&variant, &val);
2781                         method = string2proxymethod(val);
2782                 } else if (g_str_equal(key, "URL") == TRUE) {
2783                         if (type != DBUS_TYPE_STRING)
2784                                 goto error;
2785
2786                         dbus_message_iter_get_basic(&variant, &url);
2787                 } else if (g_str_equal(key, "Servers") == TRUE) {
2788                         DBusMessageIter str_array;
2789
2790                         if (type != DBUS_TYPE_ARRAY)
2791                                 goto error;
2792
2793                         servers_str = g_string_new(NULL);
2794                         if (servers_str == NULL)
2795                                 goto error;
2796
2797                         dbus_message_iter_recurse(&variant, &str_array);
2798
2799                         while (dbus_message_iter_get_arg_type(&str_array) ==
2800                                                         DBUS_TYPE_STRING) {
2801                                 char *val = NULL;
2802
2803                                 dbus_message_iter_get_basic(&str_array, &val);
2804
2805                                 if (servers_str->len > 0)
2806                                         g_string_append_printf(servers_str,
2807                                                         " %s", val);
2808                                 else
2809                                         g_string_append(servers_str, val);
2810
2811                                 dbus_message_iter_next(&str_array);
2812                         }
2813                 } else if (g_str_equal(key, "Excludes") == TRUE) {
2814                         DBusMessageIter str_array;
2815
2816                         if (type != DBUS_TYPE_ARRAY)
2817                                 goto error;
2818
2819                         excludes_str = g_string_new(NULL);
2820                         if (excludes_str == NULL)
2821                                 goto error;
2822
2823                         dbus_message_iter_recurse(&variant, &str_array);
2824
2825                         while (dbus_message_iter_get_arg_type(&str_array) ==
2826                                                         DBUS_TYPE_STRING) {
2827                                 char *val = NULL;
2828
2829                                 dbus_message_iter_get_basic(&str_array, &val);
2830
2831                                 if (excludes_str->len > 0)
2832                                         g_string_append_printf(excludes_str,
2833                                                         " %s", val);
2834                                 else
2835                                         g_string_append(excludes_str, val);
2836
2837                                 dbus_message_iter_next(&str_array);
2838                         }
2839                 }
2840
2841                 dbus_message_iter_next(&dict);
2842         }
2843
2844         switch (method) {
2845         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
2846                 break;
2847         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
2848                 if (servers_str == NULL && service->proxies == NULL)
2849                         goto error;
2850
2851                 if (servers_str != NULL) {
2852                         g_strfreev(service->proxies);
2853
2854                         if (servers_str->len > 0)
2855                                 service->proxies = g_strsplit_set(
2856                                         servers_str->str, " ", 0);
2857                         else
2858                                 service->proxies = NULL;
2859                 }
2860
2861                 if (excludes_str != NULL) {
2862                         g_strfreev(service->excludes);
2863
2864                         if (excludes_str->len > 0)
2865                                 service->excludes = g_strsplit_set(
2866                                         excludes_str->str, " ", 0);
2867                         else
2868                                 service->excludes = NULL;
2869                 }
2870
2871                 if (service->proxies == NULL)
2872                         method = CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
2873
2874                 break;
2875         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
2876                 g_free(service->pac);
2877
2878                 if (url != NULL && strlen(url) > 0)
2879                         service->pac = g_strdup(url);
2880                 else
2881                         service->pac = NULL;
2882
2883                 /* if we are connected:
2884                    - if service->pac == NULL
2885                    - if __connman_ipconfig_get_proxy_autoconfig(
2886                    service->ipconfig) == NULL
2887                    --> We should start WPAD */
2888
2889                 break;
2890         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
2891                 goto error;
2892         }
2893
2894         if (servers_str != NULL)
2895                 g_string_free(servers_str, TRUE);
2896
2897         if (excludes_str != NULL)
2898                 g_string_free(excludes_str, TRUE);
2899
2900         service->proxy_config = method;
2901
2902         return 0;
2903
2904 error:
2905         if (servers_str != NULL)
2906                 g_string_free(servers_str, TRUE);
2907
2908         if (excludes_str != NULL)
2909                 g_string_free(excludes_str, TRUE);
2910
2911         return -EINVAL;
2912 }
2913
2914 static int set_ipconfig(struct connman_service *service,
2915                         struct connman_ipconfig *ipconfig,
2916                         DBusMessageIter *array,
2917                         enum connman_service_state state,
2918                         enum connman_service_state *new_state)
2919 {
2920         enum connman_ipconfig_method old_method;
2921         enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
2922         enum connman_ipconfig_type type;
2923         int err;
2924
2925         if (ipconfig == NULL)
2926                 return -EINVAL;
2927
2928         old_method = __connman_ipconfig_get_method(ipconfig);
2929
2930         if (is_connecting_state(service, state) ||
2931                                         is_connected_state(service, state))
2932                 __connman_network_clear_ipconfig(service->network, ipconfig);
2933
2934         err = __connman_ipconfig_set_config(ipconfig, array);
2935         method = __connman_ipconfig_get_method(ipconfig);
2936         type = __connman_ipconfig_get_config_type(ipconfig);
2937
2938         if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
2939                 if (err == 0 && old_method == CONNMAN_IPCONFIG_METHOD_OFF &&
2940                                 method == CONNMAN_IPCONFIG_METHOD_DHCP) {
2941                         *new_state = service->state_ipv4 =
2942                                 CONNMAN_SERVICE_STATE_CONFIGURATION;
2943                         __connman_ipconfig_enable(ipconfig);
2944                 }
2945
2946         } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
2947                 if (err == 0 && old_method == CONNMAN_IPCONFIG_METHOD_OFF &&
2948                                 method == CONNMAN_IPCONFIG_METHOD_AUTO) {
2949                         *new_state = service->state_ipv6;
2950                         __connman_ipconfig_enable(ipconfig);
2951                 }
2952         }
2953
2954         DBG("err %d ipconfig %p type %d method %d state %s", err, ipconfig,
2955                 type, method, state2string(*new_state));
2956
2957         return err;
2958 }
2959
2960 static DBusMessage *set_property(DBusConnection *conn,
2961                                         DBusMessage *msg, void *user_data)
2962 {
2963         struct connman_service *service = user_data;
2964         DBusMessageIter iter, value;
2965         const char *name;
2966         int type;
2967
2968         DBG("service %p", service);
2969
2970         if (dbus_message_iter_init(msg, &iter) == FALSE)
2971                 return __connman_error_invalid_arguments(msg);
2972
2973         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
2974                 return __connman_error_invalid_arguments(msg);
2975
2976         dbus_message_iter_get_basic(&iter, &name);
2977         dbus_message_iter_next(&iter);
2978
2979         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
2980                 return __connman_error_invalid_arguments(msg);
2981
2982         dbus_message_iter_recurse(&iter, &value);
2983
2984         type = dbus_message_iter_get_arg_type(&value);
2985
2986         if (g_str_equal(name, "AutoConnect") == TRUE) {
2987                 connman_bool_t autoconnect;
2988
2989                 if (type != DBUS_TYPE_BOOLEAN)
2990                         return __connman_error_invalid_arguments(msg);
2991
2992                 if (service->favorite == FALSE)
2993                         return __connman_error_invalid_service(msg);
2994
2995                 dbus_message_iter_get_basic(&value, &autoconnect);
2996
2997                 if (service->autoconnect == autoconnect)
2998                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2999
3000                 service->autoconnect = autoconnect;
3001
3002                 autoconnect_changed(service);
3003
3004                 service_save(service);
3005         } else if (g_str_equal(name, "Nameservers.Configuration") == TRUE) {
3006                 DBusMessageIter entry;
3007                 GString *str;
3008                 int index;
3009                 const char *gw;
3010
3011                 if (type != DBUS_TYPE_ARRAY)
3012                         return __connman_error_invalid_arguments(msg);
3013
3014                 str = g_string_new(NULL);
3015                 if (str == NULL)
3016                         return __connman_error_invalid_arguments(msg);
3017
3018                 index = connman_network_get_index(service->network);
3019                 gw = __connman_ipconfig_get_gateway_from_index(index,
3020                         CONNMAN_IPCONFIG_TYPE_ALL);
3021
3022                 if (gw && strlen(gw))
3023                         __connman_service_nameserver_del_routes(service,
3024                                                 CONNMAN_IPCONFIG_TYPE_ALL);
3025
3026                 dbus_message_iter_recurse(&value, &entry);
3027
3028                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
3029                         const char *val;
3030                         dbus_message_iter_get_basic(&entry, &val);
3031                         dbus_message_iter_next(&entry);
3032                         if (str->len > 0)
3033                                 g_string_append_printf(str, " %s", val);
3034                         else
3035                                 g_string_append(str, val);
3036                 }
3037
3038                 remove_nameservers(service, NULL, service->nameservers_config);
3039                 g_strfreev(service->nameservers_config);
3040
3041                 if (str->len > 0) {
3042                         service->nameservers_config =
3043                                 g_strsplit_set(str->str, " ", 0);
3044                 } else {
3045                         service->nameservers_config = NULL;
3046                 }
3047
3048                 g_string_free(str, TRUE);
3049
3050                 if (gw && strlen(gw))
3051                         __connman_service_nameserver_add_routes(service, gw);
3052
3053                 update_nameservers(service);
3054                 dns_configuration_changed(service);
3055
3056                 service_save(service);
3057         } else if (g_str_equal(name, "Timeservers.Configuration") == TRUE) {
3058                 DBusMessageIter entry;
3059                 GSList *list = NULL;
3060                 int count = 0;
3061
3062                 if (type != DBUS_TYPE_ARRAY)
3063                         return __connman_error_invalid_arguments(msg);
3064
3065                 dbus_message_iter_recurse(&value, &entry);
3066
3067                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
3068                         const char *val;
3069                         GSList *new_head;
3070
3071                         dbus_message_iter_get_basic(&entry, &val);
3072
3073                         new_head = __connman_timeserver_add_list(list, val);
3074                         if (list != new_head) {
3075                                 count++;
3076                                 list = new_head;
3077                         }
3078
3079                         dbus_message_iter_next(&entry);
3080                 }
3081
3082                 g_strfreev(service->timeservers_config);
3083                 service->timeservers_config = NULL;
3084
3085                 if (list != NULL) {
3086                         service->timeservers_config = g_new0(char *, count+1);
3087
3088                         while (list != NULL) {
3089                                 count--;
3090                                 service->timeservers_config[count] = list->data;
3091                                 list = g_slist_delete_link(list, list);
3092                         };
3093                 }
3094
3095                 service_save(service);
3096                 timeservers_configuration_changed(service);
3097
3098                 __connman_timeserver_sync(service);
3099         } else if (g_str_equal(name, "Domains.Configuration") == TRUE) {
3100                 DBusMessageIter entry;
3101                 GString *str;
3102
3103                 if (type != DBUS_TYPE_ARRAY)
3104                         return __connman_error_invalid_arguments(msg);
3105
3106                 str = g_string_new(NULL);
3107                 if (str == NULL)
3108                         return __connman_error_invalid_arguments(msg);
3109
3110                 dbus_message_iter_recurse(&value, &entry);
3111
3112                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
3113                         const char *val;
3114                         dbus_message_iter_get_basic(&entry, &val);
3115                         dbus_message_iter_next(&entry);
3116                         if (str->len > 0)
3117                                 g_string_append_printf(str, " %s", val);
3118                         else
3119                                 g_string_append(str, val);
3120                 }
3121
3122                 remove_searchdomains(service, NULL, service->domains);
3123                 g_strfreev(service->domains);
3124
3125                 if (str->len > 0)
3126                         service->domains = g_strsplit_set(str->str, " ", 0);
3127                 else
3128                         service->domains = NULL;
3129
3130                 g_string_free(str, TRUE);
3131
3132                 update_nameservers(service);
3133                 domain_configuration_changed(service);
3134
3135                 service_save(service);
3136         } else if (g_str_equal(name, "Proxy.Configuration") == TRUE) {
3137                 int err;
3138
3139                 if (type != DBUS_TYPE_ARRAY)
3140                         return __connman_error_invalid_arguments(msg);
3141
3142                 err = update_proxy_configuration(service, &value);
3143
3144                 if (err < 0)
3145                         return __connman_error_failed(msg, -err);
3146
3147                 proxy_configuration_changed(service);
3148
3149                 __connman_notifier_proxy_changed(service);
3150
3151                 service_save(service);
3152         } else if (g_str_equal(name, "IPv4.Configuration") == TRUE ||
3153                         g_str_equal(name, "IPv6.Configuration")) {
3154
3155                 struct connman_ipconfig *ipv4 = NULL, *ipv6 = NULL;
3156                 enum connman_service_state state =
3157                                                 CONNMAN_SERVICE_STATE_UNKNOWN;
3158                 int err = 0;
3159
3160                 DBG("%s", name);
3161
3162                 if (service->ipconfig_ipv4 == NULL &&
3163                                         service->ipconfig_ipv6 == NULL)
3164                         return __connman_error_invalid_property(msg);
3165
3166                 if (g_str_equal(name, "IPv4.Configuration") == TRUE) {
3167                         ipv4 = service->ipconfig_ipv4;
3168                         err = set_ipconfig(service, ipv4, &value,
3169                                         service->state_ipv4, &state);
3170
3171                 } else if (g_str_equal(name, "IPv6.Configuration") == TRUE) {
3172                         ipv6 = service->ipconfig_ipv6;
3173                         err = set_ipconfig(service, ipv6, &value,
3174                                         service->state_ipv6, &state);
3175                 }
3176
3177                 if (err < 0) {
3178                         if (is_connected_state(service, state) ||
3179                                         is_connecting_state(service, state))
3180                                 __connman_network_set_ipconfig(service->network,
3181                                                                 ipv4, ipv6);
3182                         return __connman_error_failed(msg, -err);
3183                 }
3184
3185                 if (ipv4)
3186                         ipv4_configuration_changed(service);
3187                 else if (ipv6)
3188                         ipv6_configuration_changed(service);
3189
3190                 if (is_connecting(service) || is_connected(service))
3191                         __connman_network_set_ipconfig(service->network,
3192                                                         ipv4, ipv6);
3193
3194                 service_save(service);
3195         } else
3196                 return __connman_error_invalid_property(msg);
3197
3198         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
3199 }
3200
3201 static void set_idle(struct connman_service *service)
3202 {
3203         service->state = service->state_ipv4 = service->state_ipv6 =
3204                                                 CONNMAN_SERVICE_STATE_IDLE;
3205         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
3206         state_changed(service);
3207 }
3208
3209 static DBusMessage *clear_property(DBusConnection *conn,
3210                                         DBusMessage *msg, void *user_data)
3211 {
3212         struct connman_service *service = user_data;
3213         const char *name;
3214
3215         DBG("service %p", service);
3216
3217         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
3218                                                         DBUS_TYPE_INVALID);
3219
3220         if (g_str_equal(name, "Error") == TRUE) {
3221                 set_idle(service);
3222
3223                 g_get_current_time(&service->modified);
3224                 service_save(service);
3225         } else
3226                 return __connman_error_invalid_property(msg);
3227
3228         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
3229 }
3230
3231 static connman_bool_t is_ignore(struct connman_service *service)
3232 {
3233         if (service->autoconnect == FALSE)
3234                 return TRUE;
3235
3236         if (service->roaming == TRUE)
3237                 return TRUE;
3238
3239         if (service->ignore == TRUE)
3240                 return TRUE;
3241
3242         if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
3243                 return TRUE;
3244
3245         return FALSE;
3246 }
3247
3248 struct preferred_tech_data {
3249         GSequence *preferred_list;
3250         enum connman_service_type type;
3251 };
3252
3253 static void preferred_tech_add_by_type(gpointer data, gpointer user_data)
3254 {
3255         struct connman_service *service = data;
3256         struct preferred_tech_data *tech_data = user_data;
3257
3258         if (service->type == tech_data->type) {
3259                 g_sequence_append(tech_data->preferred_list, service);
3260
3261                 DBG("type %d service %p %s", tech_data->type, service,
3262                                 service->name);
3263         }
3264 }
3265
3266 static GSequence* preferred_tech_list_get(GSequence *list)
3267 {
3268         unsigned int *tech_array;
3269         struct preferred_tech_data tech_data;
3270         int i;
3271
3272         tech_array = connman_setting_get_uint_list("PreferredTechnologies");
3273         if (tech_array == NULL)
3274                 return NULL;
3275
3276         tech_data.preferred_list = g_sequence_new(NULL);
3277
3278         for (i = 0; tech_array[i] != 0; i += 1) {
3279                 tech_data.type = tech_array[i];
3280                 g_sequence_foreach(service_list, preferred_tech_add_by_type,
3281                                 &tech_data);
3282         }
3283
3284         return tech_data.preferred_list;
3285 }
3286
3287 static connman_bool_t auto_connect_service(GSequenceIter* iter,
3288                 connman_bool_t preferred)
3289 {
3290         struct connman_service *service = NULL;
3291
3292         while (g_sequence_iter_is_end(iter) == FALSE) {
3293                 service = g_sequence_get(iter);
3294
3295                 if (service->pending != NULL)
3296                         return TRUE;
3297
3298                 if (is_connecting(service) == TRUE)
3299                         return TRUE;
3300
3301                 if (service->favorite == FALSE) {
3302                         if (preferred == TRUE)
3303                                 goto next_service;
3304                         return FALSE;
3305                 }
3306
3307                 if (is_connected(service) == TRUE) {
3308                         if (preferred == TRUE && service->state !=
3309                                         CONNMAN_SERVICE_STATE_ONLINE)
3310                                 goto next_service;
3311                         return TRUE;
3312                 }
3313
3314                 if (is_ignore(service) == FALSE && service->state ==
3315                                 CONNMAN_SERVICE_STATE_IDLE)
3316                         break;
3317
3318         next_service:
3319                 service = NULL;
3320
3321                 iter = g_sequence_iter_next(iter);
3322         }
3323
3324         if (service != NULL) {
3325
3326                 DBG("service %p %s %s", service, service->name,
3327                                 (preferred == TRUE)? "preferred": "auto");
3328
3329                 service->userconnect = FALSE;
3330                 __connman_service_connect(service);
3331                 return TRUE;
3332         }
3333         return FALSE;
3334 }
3335
3336 static gboolean run_auto_connect(gpointer data)
3337 {
3338         GSequenceIter *iter = NULL;
3339         GSequence *preferred_tech;
3340
3341         autoconnect_timeout = 0;
3342
3343         DBG("");
3344
3345         preferred_tech = preferred_tech_list_get(service_list);
3346         if (preferred_tech != NULL)
3347                 iter = g_sequence_get_begin_iter(preferred_tech);
3348
3349         if (iter == NULL || auto_connect_service(iter, TRUE) == FALSE)
3350                 iter = g_sequence_get_begin_iter(service_list);
3351
3352         if (iter != NULL)
3353                 auto_connect_service(iter, FALSE);
3354
3355         if (preferred_tech != NULL)
3356                 g_sequence_free(preferred_tech);
3357
3358         return FALSE;
3359 }
3360
3361 void __connman_service_auto_connect(void)
3362 {
3363         DBG("");
3364
3365         if (__connman_session_mode() == TRUE) {
3366                 DBG("Session mode enabled: auto connect disabled");
3367                 return;
3368         }
3369
3370         if (autoconnect_timeout != 0)
3371                 return;
3372
3373         autoconnect_timeout = g_timeout_add_seconds(0, run_auto_connect, NULL);
3374 }
3375
3376 static void remove_timeout(struct connman_service *service)
3377 {
3378         if (service->timeout > 0) {
3379                 g_source_remove(service->timeout);
3380                 service->timeout = 0;
3381         }
3382 }
3383
3384 static void reply_pending(struct connman_service *service, int error)
3385 {
3386         remove_timeout(service);
3387
3388         if (service->pending != NULL) {
3389                 if (error > 0) {
3390                         DBusMessage *reply;
3391
3392                         reply = __connman_error_failed(service->pending,
3393                                                                 error);
3394                         if (reply != NULL)
3395                                 g_dbus_send_message(connection, reply);
3396                 } else {
3397                         const char *sender;
3398
3399                         sender = dbus_message_get_interface(service->pending);
3400
3401                         DBG("sender %s", sender);
3402
3403                         if (g_strcmp0(sender, CONNMAN_MANAGER_INTERFACE) == 0)
3404                                 g_dbus_send_reply(connection, service->pending,
3405                                         DBUS_TYPE_OBJECT_PATH, &service->path,
3406                                                         DBUS_TYPE_INVALID);
3407                         else
3408                                 g_dbus_send_reply(connection, service->pending,
3409                                                         DBUS_TYPE_INVALID);
3410                 }
3411
3412                 dbus_message_unref(service->pending);
3413                 service->pending = NULL;
3414         }
3415 }
3416
3417 static gboolean connect_timeout(gpointer user_data)
3418 {
3419         struct connman_service *service = user_data;
3420         connman_bool_t autoconnect = FALSE;
3421
3422         DBG("service %p", service);
3423
3424         service->timeout = 0;
3425
3426         if (service->network != NULL)
3427                 __connman_network_disconnect(service->network);
3428
3429         __connman_ipconfig_disable(service->ipconfig_ipv4);
3430         __connman_ipconfig_disable(service->ipconfig_ipv6);
3431
3432         __connman_stats_service_unregister(service);
3433
3434         if (service->pending != NULL) {
3435                 DBusMessage *reply;
3436
3437                 reply = __connman_error_operation_timeout(service->pending);
3438                 if (reply != NULL)
3439                         g_dbus_send_message(connection, reply);
3440
3441                 dbus_message_unref(service->pending);
3442                 service->pending = NULL;
3443         } else
3444                 autoconnect = TRUE;
3445
3446         __connman_service_ipconfig_indicate_state(service,
3447                                         CONNMAN_SERVICE_STATE_FAILURE,
3448                                         CONNMAN_IPCONFIG_TYPE_IPV4);
3449         __connman_service_ipconfig_indicate_state(service,
3450                                         CONNMAN_SERVICE_STATE_FAILURE,
3451                                         CONNMAN_IPCONFIG_TYPE_IPV6);
3452
3453         if (autoconnect == TRUE && service->userconnect == FALSE)
3454                 __connman_service_auto_connect();
3455
3456         return FALSE;
3457 }
3458
3459 static void set_reconnect_state(struct connman_service *service,
3460                                                 connman_bool_t reconnect)
3461 {
3462         struct connman_device *device;
3463
3464         if (service->network == NULL)
3465                 return;
3466
3467         device = connman_network_get_device(service->network);
3468         if (device == NULL)
3469                 return;
3470
3471         __connman_device_set_reconnect(device, reconnect);
3472 }
3473
3474 static connman_bool_t get_reconnect_state(struct connman_service *service)
3475 {
3476         struct connman_device *device;
3477
3478         if (service->network == NULL)
3479                 return FALSE;
3480
3481         device = connman_network_get_device(service->network);
3482         if (device == NULL)
3483                 return FALSE;
3484
3485         return __connman_device_get_reconnect(device);
3486 }
3487
3488 static DBusMessage *connect_service(DBusConnection *conn,
3489                                         DBusMessage *msg, void *user_data)
3490 {
3491         struct connman_service *service = user_data;
3492         GSequenceIter *iter;
3493         int err;
3494
3495         DBG("service %p", service);
3496
3497         if (service->pending != NULL)
3498                 return __connman_error_in_progress(msg);
3499
3500         iter = g_sequence_get_begin_iter(service_list);
3501
3502         while (g_sequence_iter_is_end(iter) == FALSE) {
3503                 struct connman_service *temp = g_sequence_get(iter);
3504
3505                 if (service->type == temp->type && is_connecting(temp) == TRUE)
3506                         return __connman_error_in_progress(msg);
3507
3508                 iter = g_sequence_iter_next(iter);
3509         }
3510
3511         service->ignore = FALSE;
3512
3513         service->userconnect = TRUE;
3514
3515         service->pending = dbus_message_ref(msg);
3516
3517         set_reconnect_state(service, FALSE);
3518
3519         err = __connman_service_connect(service);
3520         if (err < 0) {
3521                 if (service->pending == NULL)
3522                         return NULL;
3523
3524                 if (err != -EINPROGRESS) {
3525                         dbus_message_unref(service->pending);
3526                         service->pending = NULL;
3527
3528                         return __connman_error_failed(msg, -err);
3529                 }
3530
3531                 return NULL;
3532         }
3533
3534         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
3535 }
3536
3537 static DBusMessage *disconnect_service(DBusConnection *conn,
3538                                         DBusMessage *msg, void *user_data)
3539 {
3540         struct connman_service *service = user_data;
3541         int err;
3542
3543         DBG("service %p", service);
3544
3545         reply_pending(service, ECONNABORTED);
3546
3547         service->ignore = TRUE;
3548
3549         set_reconnect_state(service, FALSE);
3550
3551         err = __connman_service_disconnect(service);
3552         if (err < 0) {
3553                 if (err != -EINPROGRESS)
3554                         return __connman_error_failed(msg, -err);
3555
3556                 return NULL;
3557         }
3558
3559         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
3560 }
3561
3562 static DBusMessage *remove_service(DBusConnection *conn,
3563                                         DBusMessage *msg, void *user_data)
3564 {
3565         struct connman_service *service = user_data;
3566
3567         DBG("service %p", service);
3568
3569         if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
3570                 return __connman_error_not_supported(msg);
3571
3572         if (service->immutable == TRUE || service->hidden == TRUE)
3573                 return __connman_error_not_supported(msg);
3574
3575         if (service->favorite == FALSE && service->state !=
3576                                                 CONNMAN_SERVICE_STATE_FAILURE)
3577                 return __connman_error_not_supported(msg);
3578
3579         set_reconnect_state(service, FALSE);
3580
3581         __connman_service_disconnect(service);
3582
3583         g_free(service->passphrase);
3584         service->passphrase = NULL;
3585
3586         set_idle(service);
3587
3588         __connman_service_set_favorite(service, FALSE);
3589         service_save(service);
3590
3591         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
3592 }
3593
3594 static gboolean check_suitable_state(enum connman_service_state a,
3595                                         enum connman_service_state b)
3596 {
3597         /*
3598          * Special check so that "ready" service can be moved before
3599          * "online" one.
3600          */
3601         if ((a == CONNMAN_SERVICE_STATE_ONLINE &&
3602                         b == CONNMAN_SERVICE_STATE_READY) ||
3603                 (b == CONNMAN_SERVICE_STATE_ONLINE &&
3604                         a == CONNMAN_SERVICE_STATE_READY))
3605                 return TRUE;
3606
3607         return a == b;
3608 }
3609
3610 static void downgrade_state(struct connman_service *service)
3611 {
3612         if (service == NULL)
3613                 return;
3614
3615         DBG("service %p state4 %d state6 %d", service, service->state_ipv4,
3616                                                 service->state_ipv6);
3617
3618         if (service->state_ipv4 == CONNMAN_SERVICE_STATE_ONLINE)
3619                 __connman_service_ipconfig_indicate_state(service,
3620                                                 CONNMAN_SERVICE_STATE_READY,
3621                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
3622
3623         if (service->state_ipv6 == CONNMAN_SERVICE_STATE_ONLINE)
3624                 __connman_service_ipconfig_indicate_state(service,
3625                                                 CONNMAN_SERVICE_STATE_READY,
3626                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
3627 }
3628
3629 static void apply_relevant_default_downgrade(struct connman_service *service)
3630 {
3631         struct connman_service *def_service;
3632
3633         def_service = __connman_service_get_default();
3634         if (def_service == NULL)
3635                 return;
3636
3637         if (def_service == service &&
3638                         def_service->state == CONNMAN_SERVICE_STATE_ONLINE)
3639                 def_service->state = CONNMAN_SERVICE_STATE_READY;
3640 }
3641
3642 static void switch_default_service(struct connman_service *default_service,
3643                 struct connman_service *downgrade_service)
3644 {
3645         GSequenceIter *src, *dst;
3646
3647         apply_relevant_default_downgrade(default_service);
3648         src = g_hash_table_lookup(service_hash, downgrade_service->identifier);
3649         dst = g_hash_table_lookup(service_hash, default_service->identifier);
3650         g_sequence_move(src, dst);
3651         downgrade_state(downgrade_service);
3652 }
3653
3654 static DBusMessage *move_service(DBusConnection *conn,
3655                                         DBusMessage *msg, void *user_data,
3656                                                                 gboolean before)
3657 {
3658         struct connman_service *service = user_data;
3659         struct connman_service *target;
3660         const char *path;
3661         enum connman_ipconfig_method target4, target6;
3662         enum connman_ipconfig_method service4, service6;
3663
3664         DBG("service %p", service);
3665
3666         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
3667                                                         DBUS_TYPE_INVALID);
3668
3669         if (service->favorite == FALSE)
3670                 return __connman_error_not_supported(msg);
3671
3672         target = find_service(path);
3673         if (target == NULL || target->favorite == FALSE || target == service)
3674                 return __connman_error_invalid_service(msg);
3675
3676         if (target->type == CONNMAN_SERVICE_TYPE_VPN) {
3677                 /*
3678                  * We only allow VPN route splitting if there are
3679                  * routes defined for a given VPN.
3680                  */
3681                 if (__connman_provider_check_routes(target->provider)
3682                                                                 == FALSE) {
3683                         connman_info("Cannot move service. "
3684                                 "No routes defined for provider %s",
3685                                 __connman_provider_get_ident(target->provider));
3686                         return __connman_error_invalid_service(msg);
3687                 }
3688
3689                 target->do_split_routing = TRUE;
3690         } else
3691                 target->do_split_routing = FALSE;
3692
3693         service->do_split_routing = FALSE;
3694
3695         target4 = __connman_ipconfig_get_method(target->ipconfig_ipv4);
3696         target6 = __connman_ipconfig_get_method(target->ipconfig_ipv6);
3697         service4 = __connman_ipconfig_get_method(service->ipconfig_ipv4);
3698         service6 = __connman_ipconfig_get_method(service->ipconfig_ipv6);
3699
3700         DBG("target %s method %d/%d state %d/%d split %d", target->identifier,
3701                 target4, target6, target->state_ipv4, target->state_ipv6,
3702                 target->do_split_routing);
3703
3704         DBG("service %s method %d/%d state %d/%d", service->identifier,
3705                                 service4, service6,
3706                                 service->state_ipv4, service->state_ipv6);
3707
3708         /*
3709          * If method is OFF, then we do not need to check the corresponding
3710          * ipconfig state.
3711          */
3712         if (target4 == CONNMAN_IPCONFIG_METHOD_OFF) {
3713                 if (service6 != CONNMAN_IPCONFIG_METHOD_OFF) {
3714                         if (check_suitable_state(target->state_ipv6,
3715                                                 service->state_ipv6) == FALSE)
3716                                 return __connman_error_invalid_service(msg);
3717                 }
3718         }
3719
3720         if (target6 == CONNMAN_IPCONFIG_METHOD_OFF) {
3721                 if (service4 != CONNMAN_IPCONFIG_METHOD_OFF) {
3722                         if (check_suitable_state(target->state_ipv4,
3723                                                 service->state_ipv4) == FALSE)
3724                                 return __connman_error_invalid_service(msg);
3725                 }
3726         }
3727
3728         if (service4 == CONNMAN_IPCONFIG_METHOD_OFF) {
3729                 if (target6 != CONNMAN_IPCONFIG_METHOD_OFF) {
3730                         if (check_suitable_state(target->state_ipv6,
3731                                                 service->state_ipv6) == FALSE)
3732                                 return __connman_error_invalid_service(msg);
3733                 }
3734         }
3735
3736         if (service6 == CONNMAN_IPCONFIG_METHOD_OFF) {
3737                 if (target4 != CONNMAN_IPCONFIG_METHOD_OFF) {
3738                         if (check_suitable_state(target->state_ipv4,
3739                                                 service->state_ipv4) == FALSE)
3740                                 return __connman_error_invalid_service(msg);
3741                 }
3742         }
3743
3744         g_get_current_time(&service->modified);
3745         service_save(service);
3746         service_save(target);
3747
3748         /*
3749          * If the service which goes down is the default service and is
3750          * online, we downgrade directly its state to ready so:
3751          * the service which goes up, needs to recompute its state which
3752          * is triggered via downgrading it - if relevant - to state ready.
3753          */
3754         if (before == TRUE)
3755                 switch_default_service(target, service);
3756         else
3757                 switch_default_service(service, target);
3758
3759         __connman_connection_update_gateway();
3760
3761         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
3762 }
3763
3764 static DBusMessage *move_before(DBusConnection *conn,
3765                                         DBusMessage *msg, void *user_data)
3766 {
3767         return move_service(conn, msg, user_data, TRUE);
3768 }
3769
3770 static DBusMessage *move_after(DBusConnection *conn,
3771                                         DBusMessage *msg, void *user_data)
3772 {
3773         return move_service(conn, msg, user_data, FALSE);
3774 }
3775
3776 static DBusMessage *reset_counters(DBusConnection *conn,
3777                                         DBusMessage *msg, void *user_data)
3778 {
3779         struct connman_service *service = user_data;
3780
3781         reset_stats(service);
3782
3783         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
3784 }
3785
3786 static struct _services_notify {
3787         int id;
3788         GHashTable *add;
3789         GHashTable *remove;
3790 } *services_notify;
3791
3792 static void service_append_added_foreach(gpointer data, gpointer user_data)
3793 {
3794         struct connman_service *service = data;
3795         DBusMessageIter *iter = user_data;
3796
3797         if (service == NULL || service->path == NULL) {
3798                 DBG("service %p or path is NULL", service);
3799                 return;
3800         }
3801
3802         if (g_hash_table_lookup(services_notify->add, service->path) != NULL) {
3803                 DBG("new %s", service->path);
3804
3805                 append_struct(service, iter);
3806                 g_hash_table_remove(services_notify->add, service->path);
3807         } else {
3808                 DBG("changed %s", service->path);
3809
3810                 append_struct_service(iter, NULL, service);
3811         }
3812 }
3813
3814 static void service_append_ordered(DBusMessageIter *iter, void *user_data)
3815 {
3816         if (service_list != NULL)
3817                 g_sequence_foreach(service_list,
3818                                         service_append_added_foreach, iter);
3819 }
3820
3821 static void append_removed(gpointer key, gpointer value, gpointer user_data)
3822 {
3823         char *objpath = key;
3824         DBusMessageIter *iter = user_data;
3825
3826         DBG("removed %s", objpath);
3827         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &objpath);
3828 }
3829
3830 static gboolean service_send_changed(gpointer data)
3831 {
3832         DBusMessage *signal;
3833         DBusMessageIter iter, array;
3834
3835         DBG("");
3836
3837         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
3838                         CONNMAN_MANAGER_INTERFACE, "ServicesChanged");
3839         if (signal == NULL)
3840                 return FALSE;
3841
3842         __connman_dbus_append_objpath_dict_array(signal,
3843                         service_append_ordered, NULL);
3844
3845         dbus_message_iter_init_append(signal, &iter);
3846         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
3847                         DBUS_TYPE_OBJECT_PATH_AS_STRING, &array);
3848
3849         g_hash_table_foreach(services_notify->remove, append_removed, &array);
3850
3851         dbus_message_iter_close_container(&iter, &array);
3852
3853         dbus_connection_send(connection, signal, NULL);
3854         dbus_message_unref(signal);
3855
3856         g_hash_table_remove_all(services_notify->remove);
3857         g_hash_table_remove_all(services_notify->add);
3858
3859         services_notify->id = 0;
3860         return FALSE;
3861 }
3862
3863 static void service_schedule_changed(void)
3864 {
3865         if (services_notify->id != 0)
3866                 return;
3867
3868         services_notify->id = g_timeout_add(100, service_send_changed, NULL);
3869 }
3870
3871 static void service_schedule_added(struct connman_service *service)
3872 {
3873         DBG("service %p", service);
3874
3875         g_hash_table_remove(services_notify->remove, service->path);
3876         g_hash_table_replace(services_notify->add, service->path, service);
3877
3878         service_schedule_changed();
3879 }
3880
3881 static void service_schedule_removed(struct connman_service *service)
3882 {
3883         DBG("service %p %s", service, service->path);
3884
3885         if (service == NULL || service->path == NULL) {
3886                 DBG("service %p or path is NULL", service);
3887                 return;
3888         }
3889
3890         g_hash_table_remove(services_notify->add, service->path);
3891         g_hash_table_replace(services_notify->remove, g_strdup(service->path),
3892                         NULL);
3893
3894         service_schedule_changed();
3895 }
3896
3897 static const GDBusMethodTable service_methods[] = {
3898         { GDBUS_DEPRECATED_METHOD("GetProperties",
3899                         NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
3900                         get_properties) },
3901         { GDBUS_METHOD("SetProperty",
3902                         GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
3903                         NULL, set_property) },
3904         { GDBUS_METHOD("ClearProperty",
3905                         GDBUS_ARGS({ "name", "s" }), NULL,
3906                         clear_property) },
3907         { GDBUS_ASYNC_METHOD("Connect", NULL, NULL,
3908                               connect_service) },
3909         { GDBUS_METHOD("Disconnect", NULL, NULL,
3910                         disconnect_service) },
3911         { GDBUS_METHOD("Remove", NULL, NULL, remove_service) },
3912         { GDBUS_METHOD("MoveBefore",
3913                         GDBUS_ARGS({ "service", "o" }), NULL,
3914                         move_before) },
3915         { GDBUS_METHOD("MoveAfter",
3916                         GDBUS_ARGS({ "service", "o" }), NULL,
3917                         move_after) },
3918         { GDBUS_METHOD("ResetCounters", NULL, NULL, reset_counters) },
3919         { },
3920 };
3921
3922 static const GDBusSignalTable service_signals[] = {
3923         { GDBUS_SIGNAL("PropertyChanged",
3924                         GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
3925         { },
3926 };
3927
3928 static void service_free(gpointer user_data)
3929 {
3930         struct connman_service *service = user_data;
3931         char *path = service->path;
3932
3933         DBG("service %p", service);
3934
3935         reply_pending(service, ENOENT);
3936
3937         g_hash_table_remove(service_hash, service->identifier);
3938
3939         __connman_notifier_service_remove(service);
3940         service_schedule_removed(service);
3941
3942         stats_stop(service);
3943
3944         service->path = NULL;
3945
3946         if (path != NULL) {
3947                 __connman_connection_update_gateway();
3948
3949                 g_dbus_unregister_interface(connection, path,
3950                                                 CONNMAN_SERVICE_INTERFACE);
3951                 g_free(path);
3952         }
3953
3954         g_hash_table_destroy(service->counter_table);
3955
3956         if (service->network != NULL) {
3957                 __connman_network_disconnect(service->network);
3958                 connman_network_unref(service->network);
3959                 service->network = NULL;
3960         }
3961
3962         if (service->provider != NULL)
3963                 connman_provider_unref(service->provider);
3964
3965         if (service->ipconfig_ipv4 != NULL) {
3966                 __connman_ipconfig_set_ops(service->ipconfig_ipv4, NULL);
3967                 __connman_ipconfig_set_data(service->ipconfig_ipv4, NULL);
3968                 __connman_ipconfig_unref(service->ipconfig_ipv4);
3969                 service->ipconfig_ipv4 = NULL;
3970         }
3971
3972         if (service->ipconfig_ipv6 != NULL) {
3973                 __connman_ipconfig_set_ops(service->ipconfig_ipv6, NULL);
3974                 __connman_ipconfig_set_data(service->ipconfig_ipv6, NULL);
3975                 __connman_ipconfig_unref(service->ipconfig_ipv6);
3976                 service->ipconfig_ipv6 = NULL;
3977         }
3978
3979         g_strfreev(service->timeservers);
3980         g_strfreev(service->timeservers_config);
3981         g_strfreev(service->nameservers);
3982         g_strfreev(service->nameservers_config);
3983         g_strfreev(service->nameservers_auto);
3984         g_strfreev(service->domains);
3985         g_strfreev(service->proxies);
3986         g_strfreev(service->excludes);
3987
3988         g_free(service->domainname);
3989         g_free(service->pac);
3990         g_free(service->name);
3991         g_free(service->passphrase);
3992         g_free(service->agent_passphrase);
3993         g_free(service->identifier);
3994         g_free(service->eap);
3995         g_free(service->identity);
3996         g_free(service->agent_identity);
3997         g_free(service->ca_cert_file);
3998         g_free(service->client_cert_file);
3999         g_free(service->private_key_file);
4000         g_free(service->private_key_passphrase);
4001         g_free(service->phase2);
4002
4003         if (service->stats.timer != NULL)
4004                 g_timer_destroy(service->stats.timer);
4005         if (service->stats_roaming.timer != NULL)
4006                 g_timer_destroy(service->stats_roaming.timer);
4007
4008         g_free(service);
4009 }
4010
4011 static void stats_init(struct connman_service *service)
4012 {
4013         /* home */
4014         service->stats.valid = FALSE;
4015         service->stats.enabled = FALSE;
4016         service->stats.timer = g_timer_new();
4017
4018         /* roaming */
4019         service->stats_roaming.valid = FALSE;
4020         service->stats_roaming.enabled = FALSE;
4021         service->stats_roaming.timer = g_timer_new();
4022 }
4023
4024 static void service_initialize(struct connman_service *service)
4025 {
4026         DBG("service %p", service);
4027
4028         service->refcount = 1;
4029         service->session_usage_count = 0;
4030
4031         service->type     = CONNMAN_SERVICE_TYPE_UNKNOWN;
4032         service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
4033
4034         service->state = CONNMAN_SERVICE_STATE_UNKNOWN;
4035         service->state_ipv4 = CONNMAN_SERVICE_STATE_UNKNOWN;
4036         service->state_ipv6 = CONNMAN_SERVICE_STATE_UNKNOWN;
4037
4038         service->favorite  = FALSE;
4039         service->immutable = FALSE;
4040         service->hidden = FALSE;
4041
4042         service->ignore = FALSE;
4043
4044         service->userconnect = FALSE;
4045
4046         service->order = 0;
4047
4048         stats_init(service);
4049
4050         service->provider = NULL;
4051
4052         service->wps = FALSE;
4053 }
4054
4055 /**
4056  * connman_service_create:
4057  *
4058  * Allocate a new service.
4059  *
4060  * Returns: a newly-allocated #connman_service structure
4061  */
4062 struct connman_service *connman_service_create(void)
4063 {
4064         GSList *list;
4065         struct connman_stats_counter *counters;
4066         const char *counter;
4067
4068         struct connman_service *service;
4069
4070         service = g_try_new0(struct connman_service, 1);
4071         if (service == NULL)
4072                 return NULL;
4073
4074         DBG("service %p", service);
4075
4076         service->counter_table = g_hash_table_new_full(g_str_hash,
4077                                                 g_str_equal, NULL, g_free);
4078
4079         for (list = counter_list; list; list = list->next) {
4080                 counter = list->data;
4081
4082                 counters = g_try_new0(struct connman_stats_counter, 1);
4083                 if (counters == NULL) {
4084                         g_hash_table_destroy(service->counter_table);
4085                         g_free(service);
4086                         return NULL;
4087                 }
4088
4089                 counters->append_all = TRUE;
4090
4091                 g_hash_table_replace(service->counter_table, (gpointer)counter,
4092                                 counters);
4093         }
4094
4095         service_initialize(service);
4096
4097         return service;
4098 }
4099
4100 /**
4101  * connman_service_ref:
4102  * @service: service structure
4103  *
4104  * Increase reference counter of service
4105  */
4106 struct connman_service *
4107 connman_service_ref_debug(struct connman_service *service,
4108                         const char *file, int line, const char *caller)
4109 {
4110         DBG("%p ref %d by %s:%d:%s()", service, service->refcount + 1,
4111                 file, line, caller);
4112
4113         __sync_fetch_and_add(&service->refcount, 1);
4114
4115         return service;
4116 }
4117
4118 /**
4119  * connman_service_unref:
4120  * @service: service structure
4121  *
4122  * Decrease reference counter of service and release service if no
4123  * longer needed.
4124  */
4125 void connman_service_unref_debug(struct connman_service *service,
4126                         const char *file, int line, const char *caller)
4127 {
4128         GSequenceIter *iter;
4129
4130         DBG("%p ref %d by %s:%d:%s()", service, service->refcount - 1,
4131                 file, line, caller);
4132
4133         if (__sync_fetch_and_sub(&service->refcount, 1) != 1)
4134                 return;
4135
4136         iter = g_hash_table_lookup(service_hash, service->identifier);
4137         if (iter != NULL) {
4138                 reply_pending(service, ECONNABORTED);
4139
4140                 __connman_service_disconnect(service);
4141
4142                 g_sequence_remove(iter);
4143         } else {
4144                 service_free(service);
4145         }
4146 }
4147
4148 static gint service_compare(gconstpointer a, gconstpointer b,
4149                                                         gpointer user_data)
4150 {
4151         struct connman_service *service_a = (void *) a;
4152         struct connman_service *service_b = (void *) b;
4153         enum connman_service_state state_a, state_b;
4154
4155         state_a = service_a->state;
4156         state_b = service_b->state;
4157
4158         if (state_a != state_b) {
4159                 gboolean a_connected = is_connected(service_a);
4160                 gboolean b_connected = is_connected(service_b);
4161
4162                 if (a_connected == TRUE && b_connected == TRUE) {
4163                         /* We prefer online over ready state */
4164                         if (state_a == CONNMAN_SERVICE_STATE_ONLINE)
4165                                 return -1;
4166
4167                         if (state_b == CONNMAN_SERVICE_STATE_ONLINE)
4168                                 return 1;
4169                 }
4170
4171                 if (a_connected == TRUE)
4172                         return -1;
4173                 if (b_connected == TRUE)
4174                         return 1;
4175
4176                 if (is_connecting(service_a) == TRUE)
4177                         return -1;
4178                 if (is_connecting(service_b) == TRUE)
4179                         return 1;
4180         }
4181
4182         if (service_a->order > service_b->order)
4183                 return -1;
4184
4185         if (service_a->order < service_b->order)
4186                 return 1;
4187
4188         if (service_a->favorite == TRUE && service_b->favorite == FALSE)
4189                 return -1;
4190
4191         if (service_a->favorite == FALSE && service_b->favorite == TRUE)
4192                 return 1;
4193
4194         if (service_a->type != service_b->type) {
4195                 switch (service_a->type) {
4196                 case CONNMAN_SERVICE_TYPE_UNKNOWN:
4197                 case CONNMAN_SERVICE_TYPE_SYSTEM:
4198                 case CONNMAN_SERVICE_TYPE_ETHERNET:
4199                 case CONNMAN_SERVICE_TYPE_GPS:
4200                 case CONNMAN_SERVICE_TYPE_VPN:
4201                 case CONNMAN_SERVICE_TYPE_GADGET:
4202                         break;
4203                 case CONNMAN_SERVICE_TYPE_WIFI:
4204                         return 1;
4205                 case CONNMAN_SERVICE_TYPE_WIMAX:
4206                 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
4207                 case CONNMAN_SERVICE_TYPE_CELLULAR:
4208                         return -1;
4209                 }
4210         }
4211
4212         return (gint) service_b->strength - (gint) service_a->strength;
4213 }
4214
4215 /**
4216  * connman_service_get_type:
4217  * @service: service structure
4218  *
4219  * Get the type of service
4220  */
4221 enum connman_service_type connman_service_get_type(struct connman_service *service)
4222 {
4223         if (service == NULL)
4224                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
4225
4226         return service->type;
4227 }
4228
4229 /**
4230  * connman_service_get_interface:
4231  * @service: service structure
4232  *
4233  * Get network interface of service
4234  */
4235 char *connman_service_get_interface(struct connman_service *service)
4236 {
4237         int index;
4238
4239         if (service == NULL)
4240                 return NULL;
4241
4242         if (service->type == CONNMAN_SERVICE_TYPE_VPN) {
4243                 if (service->ipconfig_ipv4)
4244                         index = __connman_ipconfig_get_index(
4245                                                 service->ipconfig_ipv4);
4246                 else if (service->ipconfig_ipv6)
4247                         index = __connman_ipconfig_get_index(
4248                                                 service->ipconfig_ipv6);
4249                 else
4250                         return NULL;
4251
4252                 return connman_inet_ifname(index);
4253         }
4254
4255         if (service->network == NULL)
4256                 return NULL;
4257
4258         index = connman_network_get_index(service->network);
4259
4260         return connman_inet_ifname(index);
4261 }
4262
4263 /**
4264  * connman_service_get_network:
4265  * @service: service structure
4266  *
4267  * Get the service network
4268  */
4269 struct connman_network *
4270 __connman_service_get_network(struct connman_service *service)
4271 {
4272         if (service == NULL)
4273                 return NULL;
4274
4275         return service->network;
4276 }
4277
4278 struct connman_ipconfig *
4279 __connman_service_get_ip4config(struct connman_service *service)
4280 {
4281         if (service == NULL)
4282                 return NULL;
4283
4284         return service->ipconfig_ipv4;
4285 }
4286
4287 struct connman_ipconfig *
4288 __connman_service_get_ip6config(struct connman_service *service)
4289 {
4290         if (service == NULL)
4291                 return NULL;
4292
4293         return service->ipconfig_ipv6;
4294 }
4295
4296 struct connman_ipconfig *
4297 __connman_service_get_ipconfig(struct connman_service *service, int family)
4298 {
4299         if (family == AF_INET)
4300                 return __connman_service_get_ip4config(service);
4301         else if (family == AF_INET6)
4302                 return __connman_service_get_ip6config(service);
4303         else
4304                 return NULL;
4305
4306 }
4307
4308 connman_bool_t __connman_service_is_connected_state(struct connman_service *service,
4309                                         enum connman_ipconfig_type type)
4310 {
4311         if (service == NULL)
4312                 return FALSE;
4313
4314         switch (type) {
4315         case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
4316                 break;
4317         case CONNMAN_IPCONFIG_TYPE_IPV4:
4318                 return is_connected_state(service, service->state_ipv4);
4319         case CONNMAN_IPCONFIG_TYPE_IPV6:
4320                 return is_connected_state(service, service->state_ipv6);
4321         }
4322
4323         return FALSE;
4324 }
4325 enum connman_service_security __connman_service_get_security(struct connman_service *service)
4326 {
4327         if (service == NULL)
4328                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
4329
4330         return service->security;
4331 }
4332
4333 const char *__connman_service_get_phase2(struct connman_service *service)
4334 {
4335         if (service == NULL)
4336                 return NULL;
4337
4338         return service->phase2;
4339 }
4340
4341 connman_bool_t __connman_service_wps_enabled(struct connman_service *service)
4342 {
4343         if (service == NULL)
4344                 return FALSE;
4345
4346         return service->wps;
4347 }
4348
4349 /**
4350  * __connman_service_set_favorite:
4351  * @service: service structure
4352  * @favorite: favorite value
4353  *
4354  * Change the favorite setting of service
4355  */
4356 int __connman_service_set_favorite(struct connman_service *service,
4357                                                 connman_bool_t favorite)
4358 {
4359         GSequenceIter *iter;
4360
4361         if (service->hidden == TRUE)
4362                 return -EOPNOTSUPP;
4363         iter = g_hash_table_lookup(service_hash, service->identifier);
4364         if (iter == NULL)
4365                 return -ENOENT;
4366
4367         if (service->favorite == favorite)
4368                 return -EALREADY;
4369
4370         service->favorite = favorite;
4371         service->order = __connman_service_get_order(service);
4372
4373         favorite_changed(service);
4374
4375         if (g_sequence_get_length(service_list) > 1) {
4376                 g_sequence_sort_changed(iter, service_compare, NULL);
4377                 service_schedule_changed();
4378         }
4379
4380         __connman_connection_update_gateway();
4381
4382         return 0;
4383 }
4384
4385 int __connman_service_set_immutable(struct connman_service *service,
4386                                                 connman_bool_t immutable)
4387 {
4388         if (service->hidden == TRUE)
4389                 return -EOPNOTSUPP;
4390         service->immutable = immutable;
4391
4392         immutable_changed(service);
4393
4394         return 0;
4395 }
4396
4397 void __connman_service_set_string(struct connman_service *service,
4398                                   const char *key, const char *value)
4399 {
4400         if (service->hidden == TRUE)
4401                 return;
4402         if (g_str_equal(key, "EAP") == TRUE) {
4403                 g_free(service->eap);
4404                 service->eap = g_strdup(value);
4405         } else if (g_str_equal(key, "Identity") == TRUE) {
4406                 g_free(service->identity);
4407                 service->identity = g_strdup(value);
4408         } else if (g_str_equal(key, "CACertFile") == TRUE) {
4409                 g_free(service->ca_cert_file);
4410                 service->ca_cert_file = g_strdup(value);
4411         } else if (g_str_equal(key, "ClientCertFile") == TRUE) {
4412                 g_free(service->client_cert_file);
4413                 service->client_cert_file = g_strdup(value);
4414         } else if (g_str_equal(key, "PrivateKeyFile") == TRUE) {
4415                 g_free(service->private_key_file);
4416                 service->private_key_file = g_strdup(value);
4417         } else if (g_str_equal(key, "PrivateKeyPassphrase") == TRUE) {
4418                 g_free(service->private_key_passphrase);
4419                 service->private_key_passphrase = g_strdup(value);
4420         } else if (g_str_equal(key, "Phase2") == TRUE) {
4421                 g_free(service->phase2);
4422                 service->phase2 = g_strdup(value);
4423         } else if (g_str_equal(key, "Passphrase") == TRUE) {
4424                 g_free(service->passphrase);
4425                 service->passphrase = g_strdup(value);
4426         }
4427 }
4428
4429 void __connman_service_set_userconnect(struct connman_service *service,
4430                                                 connman_bool_t userconnect)
4431 {
4432         if (service != NULL)
4433                 service->userconnect = userconnect;
4434 }
4435
4436 static void service_complete(struct connman_service *service)
4437 {
4438         reply_pending(service, EIO);
4439
4440         if (service->userconnect == FALSE)
4441                 __connman_service_auto_connect();
4442
4443         g_get_current_time(&service->modified);
4444         service_save(service);
4445 }
4446
4447 static void report_error_cb(struct connman_service *service,
4448                         gboolean retry, void *user_data)
4449 {
4450         if (retry == TRUE)
4451                 __connman_service_connect(service);
4452         else {
4453                 /* It is not relevant to stay on Failure state
4454                  * when failing is due to wrong user input */
4455                 service->state = CONNMAN_SERVICE_STATE_IDLE;
4456
4457                 service_complete(service);
4458                 __connman_connection_update_gateway();
4459         }
4460 }
4461
4462 int __connman_service_add_passphrase(struct connman_service *service,
4463                                 const gchar *passphrase)
4464 {
4465         int err = 0;
4466
4467         switch (service->security) {
4468         case CONNMAN_SERVICE_SECURITY_WEP:
4469         case CONNMAN_SERVICE_SECURITY_PSK:
4470                 err = __connman_service_set_passphrase(service, passphrase);
4471                 break;
4472         case CONNMAN_SERVICE_SECURITY_8021X:
4473                 __connman_service_set_agent_passphrase(service,
4474                                                 passphrase);
4475                 break;
4476         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
4477         case CONNMAN_SERVICE_SECURITY_NONE:
4478         case CONNMAN_SERVICE_SECURITY_WPA:
4479         case CONNMAN_SERVICE_SECURITY_RSN:
4480                 DBG("service security '%s' (%d) not handled",
4481                                 security2string(service->security),
4482                                 service->security);
4483                 break;
4484         }
4485
4486         return err;
4487 }
4488
4489 static int check_wpspin(struct connman_service *service, const char *wpspin)
4490 {
4491         int length;
4492         guint i;
4493
4494         if (wpspin == NULL)
4495                 return 0;
4496
4497         length = strlen(wpspin);
4498
4499         /* If 0, it will mean user wants to use PBC method */
4500         if (length == 0) {
4501                 connman_network_set_string(service->network,
4502                                                         "WiFi.PinWPS", NULL);
4503                 return 0;
4504         }
4505
4506         /* A WPS PIN is always 8 chars length,
4507          * its content is in digit representation.
4508          */
4509         if (length != 8)
4510                 return -ENOKEY;
4511
4512         for (i = 0; i < 8; i++)
4513                 if (!isdigit((unsigned char) wpspin[i]))
4514                         return -ENOKEY;
4515
4516         connman_network_set_string(service->network, "WiFi.PinWPS", wpspin);
4517
4518         return 0;
4519 }
4520
4521 static void request_input_cb (struct connman_service *service,
4522                         connman_bool_t values_received,
4523                         const char *name, int name_len,
4524                         const char *identity, const char *passphrase,
4525                         gboolean wps, const char *wpspin,
4526                         const char *error, void *user_data)
4527 {
4528         struct connman_device *device;
4529         int err = 0;
4530
4531         DBG ("RequestInput return, %p", service);
4532
4533         if (error != NULL) {
4534                 DBG("error: %s", error);
4535
4536                 if (g_strcmp0(error,
4537                                 "net.connman.Agent.Error.Canceled") == 0) {
4538                         err = -EINVAL;
4539                         goto done;
4540                 }
4541         }
4542
4543         if (service->hidden == TRUE && name_len > 0 && name_len <= 32) {
4544                 device = connman_network_get_device(service->network);
4545                 __connman_device_request_hidden_scan(device,
4546                                                 name, name_len,
4547                                                 identity, passphrase);
4548         }
4549
4550         if (values_received == FALSE || service->hidden == TRUE) {
4551                 err = -EINVAL;
4552                 goto done;
4553         }
4554
4555         if (wps == TRUE && service->network != NULL) {
4556                 err = check_wpspin(service, wpspin);
4557                 if (err < 0)
4558                         goto done;
4559
4560                 connman_network_set_bool(service->network, "WiFi.UseWPS", wps);
4561         }
4562
4563         if (identity != NULL)
4564                 __connman_service_set_agent_identity(service, identity);
4565
4566         if (passphrase != NULL)
4567                 err = __connman_service_add_passphrase(service, passphrase);
4568
4569  done:
4570         if (err >= 0) {
4571                 __connman_service_connect(service);
4572
4573                 /* Never cache agent provided credentials */
4574                 __connman_service_set_agent_identity(service, NULL);
4575                 __connman_service_set_agent_passphrase(service, NULL);
4576         } else if (err == -ENOKEY) {
4577                 __connman_service_indicate_error(service,
4578                                         CONNMAN_SERVICE_ERROR_INVALID_KEY);
4579                 __connman_agent_report_error(service,
4580                                         error2string(service->error),
4581                                         report_error_cb, NULL);
4582         } else {
4583                 /* It is not relevant to stay on Failure state
4584                  * when failing is due to wrong user input */
4585                 service->state = CONNMAN_SERVICE_STATE_IDLE;
4586
4587                 service_complete(service);
4588                 __connman_connection_update_gateway();
4589         }
4590 }
4591
4592 static void downgrade_connected_services(void)
4593 {
4594         struct connman_service *up_service;
4595         GSequenceIter *iter;
4596
4597         iter = g_sequence_get_begin_iter(service_list);
4598         while (g_sequence_iter_is_end(iter) == FALSE) {
4599                 up_service = g_sequence_get(iter);
4600
4601                 if (is_connected(up_service) == FALSE) {
4602                         iter = g_sequence_iter_next(iter);
4603                         continue;
4604                 }
4605
4606                 if (up_service->state == CONNMAN_SERVICE_STATE_ONLINE)
4607                         return;
4608
4609                 downgrade_state(up_service);
4610
4611                 iter = g_sequence_iter_next(iter);
4612         }
4613 }
4614
4615 static int service_update_preferred_order(struct connman_service *default_service,
4616                 struct connman_service *new_service,
4617                 enum connman_service_state new_state)
4618 {
4619         unsigned int *tech_array;
4620         int i;
4621
4622         if (default_service == NULL || default_service == new_service ||
4623                         default_service->state != new_state )
4624                 return 0;
4625
4626         tech_array = connman_setting_get_uint_list("PreferredTechnologies");
4627         if (tech_array != NULL) {
4628
4629                 for (i = 0; tech_array[i] != 0; i += 1) {
4630                         if (default_service->type == tech_array[i])
4631                                 return -EALREADY;
4632
4633                         if (new_service->type == tech_array[i]) {
4634                                 switch_default_service(new_service,
4635                                                 default_service);
4636                                 return 0;
4637                         }
4638                 }
4639                 return -EAGAIN;
4640         }
4641
4642         return -EALREADY;
4643 }
4644
4645 static int service_indicate_state(struct connman_service *service)
4646 {
4647         enum connman_service_state old_state, new_state;
4648         struct connman_service *def_service;
4649         int result;
4650         GSequenceIter *iter;
4651
4652         if (service == NULL)
4653                 return -EINVAL;
4654
4655         old_state = service->state;
4656         new_state = combine_state(service->state_ipv4, service->state_ipv6);
4657
4658         DBG("service %p old %s - new %s/%s => %s",
4659                                         service,
4660                                         state2string(old_state),
4661                                         state2string(service->state_ipv4),
4662                                         state2string(service->state_ipv6),
4663                                         state2string(new_state));
4664
4665         if (old_state == new_state)
4666                 return -EALREADY;
4667
4668         def_service = __connman_service_get_default();
4669
4670         if (new_state == CONNMAN_SERVICE_STATE_ONLINE) {
4671                 result = service_update_preferred_order(def_service,
4672                                 service, new_state);
4673                 if (result == -EALREADY)
4674                         return result;
4675                 if (result == -EAGAIN)
4676                         __connman_service_auto_connect();
4677         }
4678
4679         if (old_state == CONNMAN_SERVICE_STATE_ONLINE)
4680                 __connman_notifier_leave_online(service->type);
4681
4682         service->state = new_state;
4683         state_changed(service);
4684
4685         if (new_state == CONNMAN_SERVICE_STATE_IDLE &&
4686                         old_state != CONNMAN_SERVICE_STATE_DISCONNECT) {
4687                 reply_pending(service, ECONNABORTED);
4688
4689                 __connman_service_disconnect(service);
4690         }
4691
4692         if (new_state == CONNMAN_SERVICE_STATE_CONFIGURATION) {
4693                 if (service->new_service == FALSE &&
4694                                 __connman_stats_service_register(service) == 0) {
4695                         /*
4696                          * For new services the statistics are updated after
4697                          * we have successfully connected.
4698                          */
4699                         __connman_stats_get(service, FALSE,
4700                                                 &service->stats.data);
4701                         __connman_stats_get(service, TRUE,
4702                                                 &service->stats_roaming.data);
4703                 }
4704         }
4705
4706         if (new_state == CONNMAN_SERVICE_STATE_IDLE) {
4707                 connman_bool_t reconnect;
4708
4709                 reconnect = get_reconnect_state(service);
4710                 if (reconnect == TRUE)
4711                         __connman_service_auto_connect();
4712         }
4713
4714         if (new_state == CONNMAN_SERVICE_STATE_READY) {
4715                 enum connman_ipconfig_method method;
4716
4717                 if (service->new_service == TRUE &&
4718                                 __connman_stats_service_register(service) == 0) {
4719                         /*
4720                          * This is normally done after configuring state
4721                          * but for new service do this after we have connected
4722                          * successfully.
4723                          */
4724                         __connman_stats_get(service, FALSE,
4725                                                 &service->stats.data);
4726                         __connman_stats_get(service, TRUE,
4727                                                 &service->stats_roaming.data);
4728                 }
4729
4730                 service->new_service = FALSE;
4731
4732                 service_update_preferred_order(def_service, service, new_state);
4733
4734                 set_reconnect_state(service, TRUE);
4735
4736                 __connman_service_set_favorite(service, TRUE);
4737
4738                 reply_pending(service, 0);
4739
4740                 service->userconnect = FALSE;
4741
4742                 g_get_current_time(&service->modified);
4743                 service_save(service);
4744
4745                 update_nameservers(service);
4746                 dns_changed(service);
4747                 domain_changed(service);
4748
4749                 __connman_notifier_connect(service->type);
4750
4751                 if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
4752                         connman_network_get_bool(service->network,
4753                                                 "WiFi.UseWPS") == TRUE) {
4754                         const char *pass;
4755
4756                         pass = connman_network_get_string(service->network,
4757                                                         "WiFi.Passphrase");
4758
4759                         __connman_service_set_passphrase(service, pass);
4760
4761                         connman_network_set_bool(service->network,
4762                                                         "WiFi.UseWPS", FALSE);
4763                 }
4764
4765                 default_changed();
4766
4767                 method = __connman_ipconfig_get_method(service->ipconfig_ipv6);
4768                 if (method == CONNMAN_IPCONFIG_METHOD_OFF)
4769                         __connman_ipconfig_disable_ipv6(
4770                                                 service->ipconfig_ipv6);
4771
4772         } else if (new_state == CONNMAN_SERVICE_STATE_DISCONNECT) {
4773                 def_service = __connman_service_get_default();
4774
4775                 if (__connman_notifier_is_connected() == FALSE &&
4776                         def_service != NULL &&
4777                                 def_service->provider != NULL)
4778                         __connman_provider_disconnect(def_service->provider);
4779
4780                 default_changed();
4781
4782                 __connman_wispr_stop(service);
4783
4784                 __connman_wpad_stop(service);
4785
4786                 update_nameservers(service);
4787                 dns_changed(service);
4788                 domain_changed(service);
4789
4790                 __connman_notifier_disconnect(service->type);
4791
4792                 /*
4793                  * Previous services which are connected and which states
4794                  * are set to online should reset relevantly ipconfig_state
4795                  * to ready so wispr/portal will be rerun on those
4796                  */
4797                 downgrade_connected_services();
4798         }
4799
4800         if (new_state == CONNMAN_SERVICE_STATE_FAILURE) {
4801                 if (service->userconnect == TRUE &&
4802                         __connman_agent_report_error(service,
4803                                         error2string(service->error),
4804                                         report_error_cb, NULL) == -EINPROGRESS)
4805                         return 0;
4806                 service_complete(service);
4807         } else
4808                 service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
4809
4810         iter = g_hash_table_lookup(service_hash, service->identifier);
4811         if (iter != NULL && g_sequence_get_length(service_list) > 1) {
4812                 g_sequence_sort_changed(iter, service_compare, NULL);
4813                 service_schedule_changed();
4814         }
4815
4816         __connman_connection_update_gateway();
4817
4818         if (new_state == CONNMAN_SERVICE_STATE_ONLINE) {
4819                 __connman_notifier_enter_online(service->type);
4820                 default_changed();
4821         }
4822
4823         return 0;
4824 }
4825
4826 int __connman_service_indicate_error(struct connman_service *service,
4827                                         enum connman_service_error error)
4828 {
4829         DBG("service %p error %d", service, error);
4830
4831         if (service == NULL)
4832                 return -EINVAL;
4833
4834         service->error = error;
4835
4836         if (service->error == CONNMAN_SERVICE_ERROR_INVALID_KEY)
4837                 __connman_service_set_passphrase(service, NULL);
4838
4839         __connman_service_ipconfig_indicate_state(service,
4840                                                 CONNMAN_SERVICE_STATE_FAILURE,
4841                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
4842         __connman_service_ipconfig_indicate_state(service,
4843                                                 CONNMAN_SERVICE_STATE_FAILURE,
4844                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
4845         return 0;
4846 }
4847
4848 int __connman_service_clear_error(struct connman_service *service)
4849 {
4850         DBG("service %p", service);
4851
4852         if (service == NULL)
4853                 return -EINVAL;
4854
4855         if (service->state != CONNMAN_SERVICE_STATE_FAILURE)
4856                 return -EINVAL;
4857
4858         service->state_ipv4 = service->state_ipv6 =
4859                                                 CONNMAN_SERVICE_STATE_UNKNOWN;
4860         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;;
4861
4862         if (service->favorite == TRUE)
4863                 set_reconnect_state(service, TRUE);
4864
4865         __connman_service_ipconfig_indicate_state(service,
4866                                         CONNMAN_SERVICE_STATE_IDLE,
4867                                         CONNMAN_IPCONFIG_TYPE_IPV6);
4868
4869         /*
4870          * Toggling the IPv6 state to IDLE could trigger the auto connect
4871          * machinery and consequently the IPv4 state.
4872          */
4873         if (service->state_ipv4 != CONNMAN_SERVICE_STATE_UNKNOWN &&
4874                         service->state_ipv4 != CONNMAN_SERVICE_STATE_FAILURE)
4875                 return 0;
4876
4877         return __connman_service_ipconfig_indicate_state(service,
4878                                                 CONNMAN_SERVICE_STATE_IDLE,
4879                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
4880 }
4881
4882 int __connman_service_indicate_default(struct connman_service *service)
4883 {
4884         DBG("service %p", service);
4885
4886         default_changed();
4887
4888         return 0;
4889 }
4890
4891 enum connman_service_state __connman_service_ipconfig_get_state(
4892                                         struct connman_service *service,
4893                                         enum connman_ipconfig_type type)
4894 {
4895         if (service == NULL)
4896                 return CONNMAN_SERVICE_STATE_UNKNOWN;
4897
4898         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
4899                 return service->state_ipv4;
4900
4901         if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
4902                 return service->state_ipv6;
4903
4904         return CONNMAN_SERVICE_STATE_UNKNOWN;
4905 }
4906
4907 static void check_proxy_setup(struct connman_service *service)
4908 {
4909         /*
4910          * We start WPAD if we haven't got a PAC URL from DHCP and
4911          * if our proxy manual configuration is either empty or set
4912          * to AUTO with an empty URL.
4913          */
4914
4915         if (service->proxy != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN)
4916                 goto done;
4917
4918         if (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN &&
4919                 (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_AUTO ||
4920                         service->pac != NULL))
4921                 goto done;
4922
4923         if (__connman_wpad_start(service) < 0) {
4924                 service->proxy = CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
4925                 __connman_notifier_proxy_changed(service);
4926                 goto done;
4927         }
4928
4929         return;
4930
4931 done:
4932         __connman_wispr_start(service, CONNMAN_IPCONFIG_TYPE_IPV4);
4933 }
4934
4935 /*
4936  * How many networks are connected at the same time. If more than 1,
4937  * then set the rp_filter setting properly (loose mode routing) so that network
4938  * connectivity works ok. This is only done for IPv4 networks as IPv6
4939  * does not have rp_filter knob.
4940  */
4941 static int connected_networks_count;
4942 static int original_rp_filter;
4943
4944 static void service_rp_filter(struct connman_service *service,
4945                                 gboolean connected)
4946 {
4947         enum connman_ipconfig_method method;
4948
4949         method = __connman_ipconfig_get_method(service->ipconfig_ipv4);
4950
4951         switch (method) {
4952         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
4953         case CONNMAN_IPCONFIG_METHOD_OFF:
4954         case CONNMAN_IPCONFIG_METHOD_AUTO:
4955                 return;
4956         case CONNMAN_IPCONFIG_METHOD_FIXED:
4957         case CONNMAN_IPCONFIG_METHOD_MANUAL:
4958         case CONNMAN_IPCONFIG_METHOD_DHCP:
4959                 break;
4960         }
4961
4962         if (connected == TRUE) {
4963                 if (connected_networks_count == 1) {
4964                         int filter_value;
4965                         filter_value = __connman_ipconfig_set_rp_filter();
4966                         if (filter_value < 0)
4967                                 return;
4968
4969                         original_rp_filter = filter_value;
4970                 }
4971                 connected_networks_count++;
4972
4973         } else {
4974                 if (connected_networks_count == 2)
4975                         __connman_ipconfig_unset_rp_filter(original_rp_filter);
4976
4977                 connected_networks_count--;
4978                 if (connected_networks_count < 0)
4979                         connected_networks_count = 0;
4980         }
4981
4982         DBG("%s %s ipconfig %p method %d count %d filter %d",
4983                 connected ? "connected" : "disconnected", service->identifier,
4984                 service->ipconfig_ipv4, method,
4985                 connected_networks_count, original_rp_filter);
4986 }
4987
4988 static gboolean redo_wispr(gpointer user_data)
4989 {
4990         struct connman_service *service = user_data;
4991
4992         DBG("");
4993
4994         __connman_wispr_start(service, CONNMAN_IPCONFIG_TYPE_IPV6);
4995
4996         return FALSE;
4997 }
4998
4999 int __connman_service_online_check_failed(struct connman_service *service,
5000                                         enum connman_ipconfig_type type)
5001 {
5002         DBG("service %p type %d count %d", service, type,
5003                                                 service->online_check_count);
5004
5005         /* currently we only retry IPv6 stuff */
5006         if (type == CONNMAN_IPCONFIG_TYPE_IPV4 ||
5007                         service->online_check_count != 1) {
5008                 connman_warn("Online check failed for %p %s", service,
5009                         service->name);
5010                 return 0;
5011         }
5012
5013         service->online_check_count = 0;
5014
5015         /*
5016          * We set the timeout to 1 sec so that we have a chance to get
5017          * necessary IPv6 router advertisement messages that might have
5018          * DNS data etc.
5019          */
5020         g_timeout_add_seconds(1, redo_wispr, service);
5021
5022         return EAGAIN;
5023 }
5024
5025 int __connman_service_ipconfig_indicate_state(struct connman_service *service,
5026                                         enum connman_service_state new_state,
5027                                         enum connman_ipconfig_type type)
5028 {
5029         struct connman_ipconfig *ipconfig = NULL;
5030         enum connman_service_state old_state;
5031         int ret;
5032
5033         if (service == NULL)
5034                 return -EINVAL;
5035
5036         if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
5037                 old_state = service->state_ipv4;
5038                 ipconfig = service->ipconfig_ipv4;
5039         } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
5040                 old_state = service->state_ipv6;
5041                 ipconfig = service->ipconfig_ipv6;
5042         }
5043
5044         if (ipconfig == NULL)
5045                 return -EINVAL;
5046
5047         /* Any change? */
5048         if (old_state == new_state)
5049                 return -EALREADY;
5050
5051         DBG("service %p (%s) state %d (%s) type %d (%s)",
5052                 service, service ? service->identifier : NULL,
5053                 new_state, state2string(new_state),
5054                 type, __connman_ipconfig_type2string(type));
5055
5056         switch (new_state) {
5057         case CONNMAN_SERVICE_STATE_UNKNOWN:
5058         case CONNMAN_SERVICE_STATE_IDLE:
5059                 if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
5060                         return -EINVAL;
5061                 break;
5062         case CONNMAN_SERVICE_STATE_ASSOCIATION:
5063                 break;
5064         case CONNMAN_SERVICE_STATE_CONFIGURATION:
5065                 __connman_ipconfig_enable(ipconfig);
5066                 break;
5067         case CONNMAN_SERVICE_STATE_READY:
5068                 update_nameservers(service);
5069
5070                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
5071                         check_proxy_setup(service);
5072                         service_rp_filter(service, TRUE);
5073                 } else {
5074                         service->online_check_count = 1;
5075                         __connman_wispr_start(service, type);
5076                 }
5077                 break;
5078         case CONNMAN_SERVICE_STATE_ONLINE:
5079                 break;
5080         case CONNMAN_SERVICE_STATE_DISCONNECT:
5081                 if (service->state == CONNMAN_SERVICE_STATE_IDLE)
5082                         return -EINVAL;
5083
5084                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
5085                         service_rp_filter(service, FALSE);
5086
5087                 break;
5088         case CONNMAN_SERVICE_STATE_FAILURE:
5089                 break;
5090         }
5091
5092         /* We keep that state */
5093         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
5094                 service->state_ipv4 = new_state;
5095         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
5096                 service->state_ipv6 = new_state;
5097
5098         ret = service_indicate_state(service);
5099
5100         /*
5101          * If the ipconfig method is OFF, then we set the state to IDLE
5102          * so that it will not affect the combined state in the future.
5103          */
5104         if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
5105                 enum connman_ipconfig_method method;
5106                 method = __connman_ipconfig_get_method(service->ipconfig_ipv4);
5107                 if (method == CONNMAN_IPCONFIG_METHOD_OFF ||
5108                                 method == CONNMAN_IPCONFIG_METHOD_UNKNOWN) {
5109                         service->state_ipv4 = CONNMAN_SERVICE_STATE_IDLE;
5110                         ret = service_indicate_state(service);
5111                 }
5112
5113         } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
5114                 enum connman_ipconfig_method method;
5115                 method = __connman_ipconfig_get_method(service->ipconfig_ipv6);
5116                 if (method == CONNMAN_IPCONFIG_METHOD_OFF ||
5117                                 method == CONNMAN_IPCONFIG_METHOD_UNKNOWN) {
5118                         service->state_ipv6 = CONNMAN_SERVICE_STATE_IDLE;
5119                         ret = service_indicate_state(service);
5120                 }
5121         }
5122
5123         return ret;
5124 }
5125
5126 static connman_bool_t prepare_network(struct connman_service *service)
5127 {
5128         enum connman_network_type type;
5129         unsigned int ssid_len;
5130
5131         type = connman_network_get_type(service->network);
5132
5133         switch (type) {
5134         case CONNMAN_NETWORK_TYPE_UNKNOWN:
5135         case CONNMAN_NETWORK_TYPE_VENDOR:
5136                 return FALSE;
5137         case CONNMAN_NETWORK_TYPE_WIFI:
5138                 if (connman_network_get_blob(service->network, "WiFi.SSID",
5139                                                         &ssid_len) == NULL)
5140                         return FALSE;
5141
5142                 if (service->passphrase != NULL)
5143                         connman_network_set_string(service->network,
5144                                 "WiFi.Passphrase", service->passphrase);
5145                 break;
5146         case CONNMAN_NETWORK_TYPE_ETHERNET:
5147         case CONNMAN_NETWORK_TYPE_WIMAX:
5148         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
5149         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
5150         case CONNMAN_NETWORK_TYPE_CELLULAR:
5151                 break;
5152         }
5153
5154         return TRUE;
5155 }
5156
5157 static void prepare_8021x(struct connman_service *service)
5158 {
5159         if (service->eap != NULL)
5160                 connman_network_set_string(service->network, "WiFi.EAP",
5161                                                                 service->eap);
5162
5163         if (service->identity != NULL)
5164                 connman_network_set_string(service->network, "WiFi.Identity",
5165                                                         service->identity);
5166
5167         if (service->ca_cert_file != NULL)
5168                 connman_network_set_string(service->network, "WiFi.CACertFile",
5169                                                         service->ca_cert_file);
5170
5171         if (service->client_cert_file != NULL)
5172                 connman_network_set_string(service->network,
5173                                                 "WiFi.ClientCertFile",
5174                                                 service->client_cert_file);
5175
5176         if (service->private_key_file != NULL)
5177                 connman_network_set_string(service->network,
5178                                                 "WiFi.PrivateKeyFile",
5179                                                 service->private_key_file);
5180
5181         if (service->private_key_passphrase != NULL)
5182                 connman_network_set_string(service->network,
5183                                         "WiFi.PrivateKeyPassphrase",
5184                                         service->private_key_passphrase);
5185
5186         if (service->phase2 != NULL)
5187                 connman_network_set_string(service->network, "WiFi.Phase2",
5188                                                         service->phase2);
5189 }
5190
5191 static int service_connect(struct connman_service *service)
5192 {
5193         int err;
5194
5195         if (service->hidden == TRUE)
5196                 return -EPERM;
5197
5198         switch (service->type) {
5199         case CONNMAN_SERVICE_TYPE_UNKNOWN:
5200         case CONNMAN_SERVICE_TYPE_SYSTEM:
5201         case CONNMAN_SERVICE_TYPE_GPS:
5202         case CONNMAN_SERVICE_TYPE_GADGET:
5203                 return -EINVAL;
5204         case CONNMAN_SERVICE_TYPE_ETHERNET:
5205         case CONNMAN_SERVICE_TYPE_WIMAX:
5206         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
5207         case CONNMAN_SERVICE_TYPE_CELLULAR:
5208         case CONNMAN_SERVICE_TYPE_VPN:
5209                 break;
5210         case CONNMAN_SERVICE_TYPE_WIFI:
5211                 switch (service->security) {
5212                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
5213                 case CONNMAN_SERVICE_SECURITY_NONE:
5214                         break;
5215                 case CONNMAN_SERVICE_SECURITY_WEP:
5216                 case CONNMAN_SERVICE_SECURITY_PSK:
5217                 case CONNMAN_SERVICE_SECURITY_WPA:
5218                 case CONNMAN_SERVICE_SECURITY_RSN:
5219                         if (service->passphrase == NULL) {
5220                                 if (service->network == NULL)
5221                                         return -EOPNOTSUPP;
5222
5223                                 if (service->wps == FALSE ||
5224                                         connman_network_get_bool(
5225                                                         service->network,
5226                                                         "WiFi.UseWPS") == FALSE)
5227                                         return -ENOKEY;
5228                         }
5229                         break;
5230                 case CONNMAN_SERVICE_SECURITY_8021X:
5231                         if (service->eap == NULL)
5232                                 return -EINVAL;
5233
5234                         /*
5235                          * never request credentials if using EAP-TLS
5236                          * (EAP-TLS networks need to be fully provisioned)
5237                          */
5238                         if (g_str_equal(service->eap, "tls") == TRUE)
5239                                 break;
5240
5241                         /*
5242                          * Return -ENOKEY if either identity or passphrase is
5243                          * missing. Agent provided credentials can be used as
5244                          * fallback if needed.
5245                          */
5246                         if ((service->identity == NULL &&
5247                                         service->agent_identity == NULL) ||
5248                                         (service->passphrase == NULL &&
5249                                         service->agent_passphrase == NULL))
5250                                 return -ENOKEY;
5251
5252                         break;
5253                 }
5254                 break;
5255         }
5256
5257         if (service->network != NULL) {
5258                 if (prepare_network(service) == FALSE)
5259                         return -EINVAL;
5260
5261                 switch (service->security) {
5262                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
5263                 case CONNMAN_SERVICE_SECURITY_NONE:
5264                 case CONNMAN_SERVICE_SECURITY_WEP:
5265                 case CONNMAN_SERVICE_SECURITY_PSK:
5266                 case CONNMAN_SERVICE_SECURITY_WPA:
5267                 case CONNMAN_SERVICE_SECURITY_RSN:
5268                         break;
5269                 case CONNMAN_SERVICE_SECURITY_8021X:
5270                         prepare_8021x(service);
5271                         break;
5272                 }
5273
5274                 if (__connman_stats_service_register(service) == 0) {
5275                         __connman_stats_get(service, FALSE,
5276                                                 &service->stats.data);
5277                         __connman_stats_get(service, TRUE,
5278                                                 &service->stats_roaming.data);
5279                 }
5280
5281                 if (service->ipconfig_ipv4)
5282                         __connman_ipconfig_enable(service->ipconfig_ipv4);
5283                 if (service->ipconfig_ipv6)
5284                         __connman_ipconfig_enable(service->ipconfig_ipv6);
5285
5286                 err = __connman_network_connect(service->network);
5287         } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
5288                                         service->provider != NULL)
5289                 err = __connman_provider_connect(service->provider);
5290         else
5291                 return -EOPNOTSUPP;
5292
5293         if (err < 0) {
5294                 if (err != -EINPROGRESS) {
5295                         __connman_ipconfig_disable(service->ipconfig_ipv4);
5296                         __connman_ipconfig_disable(service->ipconfig_ipv6);
5297                         __connman_stats_service_unregister(service);
5298                 }
5299         }
5300
5301         return err;
5302 }
5303
5304
5305 int __connman_service_connect(struct connman_service *service)
5306 {
5307         int err;
5308
5309         DBG("service %p state %s", service, state2string(service->state));
5310
5311         if (is_connected(service) == TRUE)
5312                 return -EISCONN;
5313
5314         if (is_connecting(service) == TRUE)
5315                 return -EALREADY;
5316
5317         switch (service->type) {
5318         case CONNMAN_SERVICE_TYPE_UNKNOWN:
5319         case CONNMAN_SERVICE_TYPE_SYSTEM:
5320         case CONNMAN_SERVICE_TYPE_GPS:
5321         case CONNMAN_SERVICE_TYPE_GADGET:
5322                 return -EINVAL;
5323         default:
5324                 err = service_connect(service);
5325         }
5326
5327         if (err >= 0)
5328                 return 0;
5329
5330         if (err == -EINPROGRESS) {
5331                 if (service->timeout == 0)
5332                         service->timeout = g_timeout_add_seconds(
5333                                 CONNECT_TIMEOUT, connect_timeout, service);
5334
5335                 return -EINPROGRESS;
5336         }
5337
5338         if (service->network != NULL)
5339                 __connman_network_disconnect(service->network);
5340         else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
5341                                 service->provider != NULL)
5342                         __connman_provider_disconnect(service->provider);
5343
5344         if (service->userconnect == TRUE) {
5345                 if (err == -ENOKEY || err == -EPERM) {
5346                         return __connman_agent_request_passphrase_input(service,
5347                                         request_input_cb, NULL);
5348                 }
5349                 reply_pending(service, -err);
5350         }
5351
5352         return err;
5353 }
5354
5355 int __connman_service_disconnect(struct connman_service *service)
5356 {
5357         int err;
5358
5359         DBG("service %p", service);
5360
5361         if (service->network != NULL) {
5362                 err = __connman_network_disconnect(service->network);
5363         } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
5364                                         service->provider != NULL)
5365                 err = __connman_provider_disconnect(service->provider);
5366         else
5367                 return -EOPNOTSUPP;
5368
5369         if (err < 0 && err != -EINPROGRESS)
5370                 return err;
5371
5372         __connman_6to4_remove(service->ipconfig_ipv4);
5373
5374         if (service->ipconfig_ipv4)
5375                 __connman_ipconfig_set_proxy_autoconfig(service->ipconfig_ipv4,
5376                                                         NULL);
5377         else
5378                 __connman_ipconfig_set_proxy_autoconfig(service->ipconfig_ipv6,
5379                                                         NULL);
5380
5381         __connman_ipconfig_address_remove(service->ipconfig_ipv4);
5382         __connman_ipconfig_address_remove(service->ipconfig_ipv6);
5383
5384         __connman_ipconfig_disable(service->ipconfig_ipv4);
5385         __connman_ipconfig_disable(service->ipconfig_ipv6);
5386
5387         __connman_stats_service_unregister(service);
5388
5389         return err;
5390 }
5391
5392 int __connman_service_disconnect_all(void)
5393 {
5394         GSequenceIter *iter;
5395         GSList *services = NULL, *list;
5396
5397         DBG("");
5398
5399         iter = g_sequence_get_begin_iter(service_list);
5400
5401         while (g_sequence_iter_is_end(iter) == FALSE) {
5402                 struct connman_service *service = g_sequence_get(iter);
5403
5404                 services = g_slist_prepend(services, service);
5405
5406                 iter = g_sequence_iter_next(iter);
5407         }
5408
5409         for (list = services; list != NULL; list = list->next) {
5410                 struct connman_service *service = list->data;
5411
5412                 service->ignore = TRUE;
5413
5414                 set_reconnect_state(service, FALSE);
5415
5416                 __connman_service_disconnect(service);
5417         }
5418
5419         g_slist_free(list);
5420
5421         return 0;
5422
5423 }
5424
5425 /**
5426  * lookup_by_identifier:
5427  * @identifier: service identifier
5428  *
5429  * Look up a service by identifier (reference count will not be increased)
5430  */
5431 static struct connman_service *lookup_by_identifier(const char *identifier)
5432 {
5433         GSequenceIter *iter;
5434
5435         iter = g_hash_table_lookup(service_hash, identifier);
5436         if (iter != NULL)
5437                 return g_sequence_get(iter);
5438
5439         return NULL;
5440 }
5441
5442 static void provision_changed(gpointer value, gpointer user_data)
5443 {
5444         struct connman_service *service = value;
5445         char *path = user_data;
5446
5447         __connman_config_provision_service_ident(service, path);
5448 }
5449
5450 void __connman_service_provision_changed(const char *ident)
5451 {
5452         g_sequence_foreach(service_list, provision_changed, (void *)ident);
5453 }
5454
5455 /**
5456  * __connman_service_get:
5457  * @identifier: service identifier
5458  *
5459  * Look up a service by identifier or create a new one if not found
5460  */
5461 static struct connman_service *service_get(const char *identifier)
5462 {
5463         struct connman_service *service;
5464         GSequenceIter *iter;
5465
5466         iter = g_hash_table_lookup(service_hash, identifier);
5467         if (iter != NULL) {
5468                 service = g_sequence_get(iter);
5469                 if (service != NULL)
5470                         connman_service_ref(service);
5471                 return service;
5472         }
5473
5474         service = connman_service_create();
5475         if (service == NULL)
5476                 return NULL;
5477
5478         DBG("service %p", service);
5479
5480         service->identifier = g_strdup(identifier);
5481
5482         iter = g_sequence_insert_sorted(service_list, service,
5483                                                 service_compare, NULL);
5484
5485         g_hash_table_insert(service_hash, service->identifier, iter);
5486
5487         return service;
5488 }
5489
5490 static int service_register(struct connman_service *service)
5491 {
5492         GSequenceIter *iter;
5493
5494         DBG("service %p", service);
5495
5496         if (service->path != NULL)
5497                 return -EALREADY;
5498
5499         service->path = g_strdup_printf("%s/service/%s", CONNMAN_PATH,
5500                                                 service->identifier);
5501
5502         DBG("path %s", service->path);
5503
5504         __connman_config_provision_service(service);
5505
5506         service_load(service);
5507
5508         g_dbus_register_interface(connection, service->path,
5509                                         CONNMAN_SERVICE_INTERFACE,
5510                                         service_methods, service_signals,
5511                                                         NULL, service, NULL);
5512
5513         iter = g_hash_table_lookup(service_hash, service->identifier);
5514         if (iter != NULL && g_sequence_get_length(service_list) > 1) {
5515                 g_sequence_sort_changed(iter, service_compare, NULL);
5516                 service_schedule_changed();
5517         }
5518
5519         __connman_connection_update_gateway();
5520
5521         return 0;
5522 }
5523
5524 static void service_up(struct connman_ipconfig *ipconfig)
5525 {
5526         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
5527
5528         DBG("%s up", __connman_ipconfig_get_ifname(ipconfig));
5529
5530         link_changed(service);
5531
5532         service->stats.valid = FALSE;
5533         service->stats_roaming.valid = FALSE;
5534 }
5535
5536 static void service_down(struct connman_ipconfig *ipconfig)
5537 {
5538         DBG("%s down", __connman_ipconfig_get_ifname(ipconfig));
5539 }
5540
5541 static void service_lower_up(struct connman_ipconfig *ipconfig)
5542 {
5543         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
5544
5545         DBG("%s lower up", __connman_ipconfig_get_ifname(ipconfig));
5546
5547         stats_start(service);
5548 }
5549
5550 static void service_lower_down(struct connman_ipconfig *ipconfig)
5551 {
5552         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
5553
5554         DBG("%s lower down", __connman_ipconfig_get_ifname(ipconfig));
5555
5556         if (is_idle_state(service, service->state_ipv4) == FALSE)
5557                 __connman_ipconfig_disable(service->ipconfig_ipv4);
5558
5559         if (is_idle_state(service, service->state_ipv6) == FALSE)
5560                 __connman_ipconfig_disable(service->ipconfig_ipv6);
5561
5562         stats_stop(service);
5563         service_save(service);
5564 }
5565
5566 static void service_ip_bound(struct connman_ipconfig *ipconfig)
5567 {
5568         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
5569         enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
5570         enum connman_ipconfig_type type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
5571
5572         DBG("%s ip bound", __connman_ipconfig_get_ifname(ipconfig));
5573
5574         type = __connman_ipconfig_get_config_type(ipconfig);
5575         method = __connman_ipconfig_get_method(ipconfig);
5576
5577         DBG("service %p ipconfig %p type %d method %d", service, ipconfig,
5578                                                         type, method);
5579
5580         if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
5581                         method == CONNMAN_IPCONFIG_METHOD_AUTO)
5582                 __connman_service_ipconfig_indicate_state(service,
5583                                                 CONNMAN_SERVICE_STATE_READY,
5584                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
5585
5586         settings_changed(service, ipconfig);
5587 }
5588
5589 static void service_ip_release(struct connman_ipconfig *ipconfig)
5590 {
5591         struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
5592         enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
5593         enum connman_ipconfig_type type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
5594
5595         DBG("%s ip release", __connman_ipconfig_get_ifname(ipconfig));
5596
5597         type = __connman_ipconfig_get_config_type(ipconfig);
5598         method = __connman_ipconfig_get_method(ipconfig);
5599
5600         DBG("service %p ipconfig %p type %d method %d", service, ipconfig,
5601                                                         type, method);
5602
5603         if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
5604                         method == CONNMAN_IPCONFIG_METHOD_OFF)
5605                 __connman_service_ipconfig_indicate_state(service,
5606                                         CONNMAN_SERVICE_STATE_DISCONNECT,
5607                                         CONNMAN_IPCONFIG_TYPE_IPV6);
5608
5609         if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
5610                         method == CONNMAN_IPCONFIG_METHOD_OFF)
5611                 __connman_service_ipconfig_indicate_state(service,
5612                                         CONNMAN_SERVICE_STATE_DISCONNECT,
5613                                         CONNMAN_IPCONFIG_TYPE_IPV4);
5614
5615         settings_changed(service, ipconfig);
5616 }
5617
5618 static const struct connman_ipconfig_ops service_ops = {
5619         .up             = service_up,
5620         .down           = service_down,
5621         .lower_up       = service_lower_up,
5622         .lower_down     = service_lower_down,
5623         .ip_bound       = service_ip_bound,
5624         .ip_release     = service_ip_release,
5625 };
5626
5627 static void setup_ip4config(struct connman_service *service, int index,
5628                         enum connman_ipconfig_method method)
5629 {
5630         service->ipconfig_ipv4 = __connman_ipconfig_create(index,
5631                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
5632         if (service->ipconfig_ipv4 == NULL)
5633                 return;
5634
5635         __connman_ipconfig_set_method(service->ipconfig_ipv4, method);
5636
5637         __connman_ipconfig_set_data(service->ipconfig_ipv4, service);
5638
5639         __connman_ipconfig_set_ops(service->ipconfig_ipv4, &service_ops);
5640 }
5641
5642 static void setup_ip6config(struct connman_service *service, int index)
5643 {
5644         service->ipconfig_ipv6 = __connman_ipconfig_create(index,
5645                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
5646         if (service->ipconfig_ipv6 == NULL)
5647                 return;
5648
5649         __connman_ipconfig_set_data(service->ipconfig_ipv6, service);
5650
5651         __connman_ipconfig_set_ops(service->ipconfig_ipv6, &service_ops);
5652 }
5653
5654 void __connman_service_read_ip4config(struct connman_service *service)
5655 {
5656         GKeyFile *keyfile;
5657
5658         if (service->ipconfig_ipv4 == NULL)
5659                 return;
5660
5661         keyfile = connman_storage_load_service(service->identifier);
5662         if (keyfile == NULL)
5663                 return;
5664
5665         __connman_ipconfig_load(service->ipconfig_ipv4, keyfile,
5666                                 service->identifier, "IPv4.");
5667
5668         g_key_file_free(keyfile);
5669 }
5670
5671 void __connman_service_create_ip4config(struct connman_service *service,
5672                                         int index)
5673 {
5674         DBG("ipv4 %p", service->ipconfig_ipv4);
5675
5676         if (service->ipconfig_ipv4 != NULL)
5677                 return;
5678
5679         setup_ip4config(service, index, CONNMAN_IPCONFIG_METHOD_DHCP);
5680         __connman_service_read_ip4config(service);
5681 }
5682
5683 void __connman_service_read_ip6config(struct connman_service *service)
5684 {
5685         GKeyFile *keyfile;
5686
5687         if (service->ipconfig_ipv6 == NULL)
5688                 return;
5689
5690         keyfile = connman_storage_load_service(service->identifier);
5691         if (keyfile == NULL)
5692                 return;
5693
5694         __connman_ipconfig_load(service->ipconfig_ipv6, keyfile,
5695                                 service->identifier, "IPv6.");
5696
5697         g_key_file_free(keyfile);
5698 }
5699
5700 void __connman_service_create_ip6config(struct connman_service *service,
5701                                                                 int index)
5702 {
5703         DBG("ipv6 %p", service->ipconfig_ipv6);
5704
5705         if (service->ipconfig_ipv6 != NULL)
5706                 return;
5707
5708         setup_ip6config(service, index);
5709
5710         __connman_service_read_ip6config(service);
5711 }
5712
5713 /**
5714  * __connman_service_lookup_from_network:
5715  * @network: network structure
5716  *
5717  * Look up a service by network (reference count will not be increased)
5718  */
5719 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
5720 {
5721         struct connman_service *service;
5722         const char *ident, *group;
5723         char *name;
5724
5725         DBG("network %p", network);
5726
5727         if (network == NULL)
5728                 return NULL;
5729
5730         ident = __connman_network_get_ident(network);
5731         if (ident == NULL)
5732                 return NULL;
5733
5734         group = connman_network_get_group(network);
5735         if (group == NULL)
5736                 return NULL;
5737
5738         name = g_strdup_printf("%s_%s_%s",
5739                         __connman_network_get_type(network), ident, group);
5740         service = lookup_by_identifier(name);
5741         g_free(name);
5742
5743         return service;
5744 }
5745
5746 struct connman_service *__connman_service_lookup_from_index(int index)
5747 {
5748         struct connman_service *service;
5749         GSequenceIter *iter;
5750
5751         iter = g_sequence_get_begin_iter(service_list);
5752
5753         while (g_sequence_iter_is_end(iter) == FALSE) {
5754                 service = g_sequence_get(iter);
5755
5756                 if (__connman_ipconfig_get_index(service->ipconfig_ipv4)
5757                                                         == index)
5758                         return service;
5759
5760                 if (__connman_ipconfig_get_index(service->ipconfig_ipv6)
5761                                                         == index)
5762                         return service;
5763
5764                 iter = g_sequence_iter_next(iter);
5765         }
5766
5767         return NULL;
5768 }
5769
5770 const char *__connman_service_get_ident(struct connman_service *service)
5771 {
5772         return service->identifier;
5773 }
5774
5775 const char *__connman_service_get_path(struct connman_service *service)
5776 {
5777         return service->path;
5778 }
5779
5780 unsigned int __connman_service_get_order(struct connman_service *service)
5781 {
5782         GSequenceIter *iter;
5783
5784         if (service == NULL)
5785                 return 0;
5786
5787         if (service->favorite == FALSE) {
5788                 service->order = 0;
5789                 goto done;
5790         }
5791
5792         iter = g_hash_table_lookup(service_hash, service->identifier);
5793         if (iter != NULL) {
5794                 if (g_sequence_iter_get_position(iter) == 0)
5795                         service->order = 1;
5796                 else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
5797                                 service->do_split_routing == FALSE)
5798                         service->order = 10;
5799                 else
5800                         service->order = 0;
5801         }
5802
5803         DBG("service %p name %s order %d split %d", service, service->name,
5804                 service->order, service->do_split_routing);
5805
5806 done:
5807         return service->order;
5808 }
5809
5810 void __connman_service_update_ordering(void)
5811 {
5812         GSequenceIter *iter;
5813
5814         iter = g_sequence_get_begin_iter(service_list);
5815         if (iter != NULL && g_sequence_get_length(service_list) > 1)
5816                 g_sequence_sort_changed(iter, service_compare, NULL);
5817 }
5818
5819 static enum connman_service_type convert_network_type(struct connman_network *network)
5820 {
5821         enum connman_network_type type = connman_network_get_type(network);
5822
5823         switch (type) {
5824         case CONNMAN_NETWORK_TYPE_UNKNOWN:
5825         case CONNMAN_NETWORK_TYPE_VENDOR:
5826                 break;
5827         case CONNMAN_NETWORK_TYPE_ETHERNET:
5828                 return CONNMAN_SERVICE_TYPE_ETHERNET;
5829         case CONNMAN_NETWORK_TYPE_WIFI:
5830                 return CONNMAN_SERVICE_TYPE_WIFI;
5831         case CONNMAN_NETWORK_TYPE_WIMAX:
5832                 return CONNMAN_SERVICE_TYPE_WIMAX;
5833         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
5834         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
5835                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
5836         case CONNMAN_NETWORK_TYPE_CELLULAR:
5837                 return CONNMAN_SERVICE_TYPE_CELLULAR;
5838         }
5839
5840         return CONNMAN_SERVICE_TYPE_UNKNOWN;
5841 }
5842
5843 static enum connman_service_security convert_wifi_security(const char *security)
5844 {
5845         if (security == NULL)
5846                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
5847         else if (g_str_equal(security, "none") == TRUE)
5848                 return CONNMAN_SERVICE_SECURITY_NONE;
5849         else if (g_str_equal(security, "wep") == TRUE)
5850                 return CONNMAN_SERVICE_SECURITY_WEP;
5851         else if (g_str_equal(security, "psk") == TRUE)
5852                 return CONNMAN_SERVICE_SECURITY_PSK;
5853         else if (g_str_equal(security, "ieee8021x") == TRUE)
5854                 return CONNMAN_SERVICE_SECURITY_8021X;
5855         else if (g_str_equal(security, "wpa") == TRUE)
5856                 return CONNMAN_SERVICE_SECURITY_WPA;
5857         else if (g_str_equal(security, "rsn") == TRUE)
5858                 return CONNMAN_SERVICE_SECURITY_RSN;
5859         else
5860                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
5861 }
5862
5863 static void update_from_network(struct connman_service *service,
5864                                         struct connman_network *network)
5865 {
5866         connman_uint8_t strength = service->strength;
5867         GSequenceIter *iter;
5868         const char *str;
5869
5870         DBG("service %p network %p", service, network);
5871
5872         if (is_connected(service) == TRUE)
5873                 return;
5874
5875         if (is_connecting(service) == TRUE)
5876                 return;
5877
5878         str = connman_network_get_string(network, "Name");
5879         if (str != NULL) {
5880                 g_free(service->name);
5881                 service->name = g_strdup(str);
5882                 service->hidden = FALSE;
5883         } else {
5884                 g_free(service->name);
5885                 service->name = NULL;
5886                 service->hidden = TRUE;
5887         }
5888
5889         service->strength = connman_network_get_strength(network);
5890         service->roaming = connman_network_get_bool(network, "Roaming");
5891
5892         if (service->strength == 0) {
5893                 /*
5894                  * Filter out 0-values; it's unclear what they mean
5895                  * and they cause anomalous sorting of the priority list.
5896                  */
5897                 service->strength = strength;
5898         }
5899
5900         str = connman_network_get_string(network, "WiFi.Security");
5901         service->security = convert_wifi_security(str);
5902
5903         if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
5904                 service->wps = connman_network_get_bool(network, "WiFi.WPS");
5905
5906         if (service->strength > strength && service->network != NULL) {
5907                 connman_network_unref(service->network);
5908                 service->network = connman_network_ref(network);
5909
5910                 strength_changed(service);
5911         }
5912
5913         if (service->network == NULL)
5914                 service->network = connman_network_ref(network);
5915
5916         iter = g_hash_table_lookup(service_hash, service->identifier);
5917         if (iter != NULL && g_sequence_get_length(service_list) > 1) {
5918                 g_sequence_sort_changed(iter, service_compare, NULL);
5919                 service_schedule_changed();
5920         }
5921 }
5922
5923 /**
5924  * __connman_service_create_from_network:
5925  * @network: network structure
5926  *
5927  * Look up service by network and if not found, create one
5928  */
5929 struct connman_service * __connman_service_create_from_network(struct connman_network *network)
5930 {
5931         struct connman_service *service;
5932         struct connman_device *device;
5933         const char *ident, *group;
5934         char *name;
5935         unsigned int *auto_connect_types;
5936         int i, index;
5937
5938         DBG("network %p", network);
5939
5940         if (network == NULL)
5941                 return NULL;
5942
5943         ident = __connman_network_get_ident(network);
5944         if (ident == NULL)
5945                 return NULL;
5946
5947         group = connman_network_get_group(network);
5948         if (group == NULL)
5949                 return NULL;
5950
5951         name = g_strdup_printf("%s_%s_%s",
5952                         __connman_network_get_type(network), ident, group);
5953         service = service_get(name);
5954         g_free(name);
5955
5956         if (service == NULL)
5957                 return NULL;
5958
5959         if (__connman_network_get_weakness(network) == TRUE)
5960                 return service;
5961
5962         if (service->path != NULL) {
5963                 update_from_network(service, network);
5964                 __connman_connection_update_gateway();
5965                 return service;
5966         }
5967
5968         service->type = convert_network_type(network);
5969
5970         auto_connect_types = connman_setting_get_uint_list("DefaultAutoConnectTechnologies");
5971         service->autoconnect = FALSE;
5972         for (i = 0; auto_connect_types != NULL &&
5973                      auto_connect_types[i] != 0; i++) {
5974                 if (service->type == auto_connect_types[i]) {
5975                         service->autoconnect = TRUE;
5976                         break;
5977                 }
5978         }
5979
5980         switch (service->type) {
5981         case CONNMAN_SERVICE_TYPE_UNKNOWN:
5982         case CONNMAN_SERVICE_TYPE_SYSTEM:
5983         case CONNMAN_SERVICE_TYPE_WIMAX:
5984         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
5985         case CONNMAN_SERVICE_TYPE_GPS:
5986         case CONNMAN_SERVICE_TYPE_VPN:
5987         case CONNMAN_SERVICE_TYPE_GADGET:
5988         case CONNMAN_SERVICE_TYPE_WIFI:
5989         case CONNMAN_SERVICE_TYPE_CELLULAR:
5990                 break;
5991         case CONNMAN_SERVICE_TYPE_ETHERNET:
5992                 service->favorite = TRUE;
5993                 break;
5994         }
5995
5996         service->state_ipv4 = service->state_ipv6 = CONNMAN_SERVICE_STATE_IDLE;
5997         service->state = combine_state(service->state_ipv4, service->state_ipv6);
5998
5999         update_from_network(service, network);
6000
6001         index = connman_network_get_index(network);
6002
6003         if (service->ipconfig_ipv4 == NULL)
6004                 setup_ip4config(service, index, CONNMAN_IPCONFIG_METHOD_DHCP);
6005
6006         if (service->ipconfig_ipv6 == NULL)
6007                 setup_ip6config(service, index);
6008
6009         service_register(service);
6010
6011         if (service->favorite == TRUE) {
6012                 device = connman_network_get_device(service->network);
6013                 if (device && connman_device_get_scanning(device) == FALSE)
6014                         __connman_service_auto_connect();
6015         }
6016
6017         __connman_notifier_service_add(service, service->name);
6018         service_schedule_added(service);
6019
6020         return service;
6021 }
6022
6023 void __connman_service_update_from_network(struct connman_network *network)
6024 {
6025         connman_bool_t need_sort = FALSE;
6026         struct connman_service *service;
6027         connman_uint8_t strength;
6028         connman_bool_t roaming;
6029         GSequenceIter *iter;
6030         const char *name;
6031         connman_bool_t stats_enable;
6032
6033         DBG("network %p", network);
6034
6035         service = __connman_service_lookup_from_network(network);
6036         if (service == NULL)
6037                 return;
6038
6039         if (service->network == NULL)
6040                 return;
6041
6042         name = connman_network_get_string(service->network, "Name");
6043         if (g_strcmp0(service->name, name) != 0) {
6044                 g_free(service->name);
6045                 service->name = g_strdup(name);
6046                 connman_dbus_property_changed_basic(service->path,
6047                                 CONNMAN_SERVICE_INTERFACE, "Name",
6048                                 DBUS_TYPE_STRING, &service->name);
6049         }
6050
6051         if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
6052                 service->wps = connman_network_get_bool(network, "WiFi.WPS");
6053
6054         strength = connman_network_get_strength(service->network);
6055         if (strength == service->strength)
6056                 goto roaming;
6057
6058         service->strength = strength;
6059         need_sort = TRUE;
6060
6061         strength_changed(service);
6062
6063 roaming:
6064         roaming = connman_network_get_bool(service->network, "Roaming");
6065         if (roaming == service->roaming)
6066                 goto sorting;
6067
6068         stats_enable = stats_enabled(service);
6069         if (stats_enable == TRUE)
6070                 stats_stop(service);
6071
6072         service->roaming = roaming;
6073         need_sort = TRUE;
6074
6075         if (stats_enable == TRUE)
6076                 stats_start(service);
6077
6078         roaming_changed(service);
6079
6080 sorting:
6081         if (need_sort == TRUE) {
6082                 iter = g_hash_table_lookup(service_hash, service->identifier);
6083                 if (iter != NULL && g_sequence_get_length(service_list) > 1) {
6084                         g_sequence_sort_changed(iter, service_compare, NULL);
6085                         service_schedule_changed();
6086                 }
6087         }
6088 }
6089
6090 void __connman_service_remove_from_network(struct connman_network *network)
6091 {
6092         struct connman_service *service;
6093
6094         DBG("network %p", network);
6095
6096         service = __connman_service_lookup_from_network(network);
6097         if (service == NULL)
6098                 return;
6099
6100         service->ignore = TRUE;
6101
6102         __connman_connection_gateway_remove(service,
6103                                         CONNMAN_IPCONFIG_TYPE_ALL);
6104
6105         connman_service_unref(service);
6106 }
6107
6108 /**
6109  * __connman_service_create_from_provider:
6110  * @provider: provider structure
6111  *
6112  * Look up service by provider and if not found, create one
6113  */
6114 struct connman_service *
6115 __connman_service_create_from_provider(struct connman_provider *provider)
6116 {
6117         struct connman_service *service;
6118         const char *ident, *str;
6119         char *name;
6120         int index = connman_provider_get_index(provider);
6121
6122         DBG("provider %p", provider);
6123
6124         ident = __connman_provider_get_ident(provider);
6125         if (ident == NULL)
6126                 return NULL;
6127
6128         name = g_strdup_printf("vpn_%s", ident);
6129         service = service_get(name);
6130         g_free(name);
6131
6132         if (service == NULL)
6133                 return NULL;
6134
6135         service->type = CONNMAN_SERVICE_TYPE_VPN;
6136         service->provider = connman_provider_ref(provider);
6137         service->autoconnect = FALSE;
6138         service->userconnect = TRUE;
6139
6140         service->state_ipv4 = service->state_ipv6 = CONNMAN_SERVICE_STATE_IDLE;
6141         service->state = combine_state(service->state_ipv4, service->state_ipv6);
6142
6143         str = connman_provider_get_string(provider, "Name");
6144         if (str != NULL) {
6145                 g_free(service->name);
6146                 service->name = g_strdup(str);
6147                 service->hidden = FALSE;
6148         } else {
6149                 g_free(service->name);
6150                 service->name = NULL;
6151                 service->hidden = TRUE;
6152         }
6153
6154         service->strength = 0;
6155
6156         if (service->ipconfig_ipv4 == NULL)
6157                 setup_ip4config(service, index, CONNMAN_IPCONFIG_METHOD_MANUAL);
6158
6159         if (service->ipconfig_ipv6 == NULL)
6160                 setup_ip6config(service, index);
6161
6162         service_register(service);
6163
6164         __connman_notifier_service_add(service, service->name);
6165         service_schedule_added(service);
6166
6167         return service;
6168 }
6169
6170 int __connman_service_init(void)
6171 {
6172         DBG("");
6173
6174         connection = connman_dbus_get_connection();
6175
6176         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
6177                                                                 NULL, NULL);
6178
6179         service_list = g_sequence_new(service_free);
6180
6181         services_notify = g_new0(struct _services_notify, 1);
6182         services_notify->remove = g_hash_table_new_full(g_str_hash,
6183                         g_str_equal, g_free, NULL);
6184         services_notify->add = g_hash_table_new(g_str_hash, g_str_equal);
6185
6186         return 0;
6187 }
6188
6189 void __connman_service_cleanup(void)
6190 {
6191         GSequence *list;
6192
6193         DBG("");
6194
6195         if (autoconnect_timeout != 0) {
6196                 g_source_remove(autoconnect_timeout);
6197                 autoconnect_timeout = 0;
6198         }
6199
6200         list = service_list;
6201         service_list = NULL;
6202         g_sequence_free(list);
6203
6204         g_hash_table_destroy(service_hash);
6205         service_hash = NULL;
6206
6207         g_slist_free(counter_list);
6208         counter_list = NULL;
6209
6210         if (services_notify->id != 0) {
6211                 g_source_remove(services_notify->id);
6212                 service_send_changed(NULL);
6213                 g_hash_table_destroy(services_notify->remove);
6214                 g_hash_table_destroy(services_notify->add);
6215         }
6216         g_free(services_notify);
6217
6218         dbus_connection_unref(connection);
6219 }