src/service.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <gdbus.h>
  29
  30 #include "connman.h"
  31
  32 #define CONNECT_TIMEOUT         120
  33
  34 static DBusConnection *connection = NULL;
  35
  36 static GSequence *service_list = NULL;
  37 static GHashTable *service_hash = NULL;
  38
  39 struct connman_stats {
  40         connman_bool_t valid;
  41         connman_bool_t enabled;
  42         unsigned int rx_packets_last;
  43         unsigned int tx_packets_last;
  44         unsigned int rx_packets;
  45         unsigned int tx_packets;
  46         unsigned int rx_bytes_last;
  47         unsigned int tx_bytes_last;
  48         unsigned int rx_bytes;
  49         unsigned int tx_bytes;
  50         unsigned int rx_errors_last;
  51         unsigned int tx_errors_last;
  52         unsigned int rx_errors;
  53         unsigned int tx_errors;
  54         unsigned int rx_dropped_last;
  55         unsigned int tx_dropped_last;
  56         unsigned int rx_dropped;
  57         unsigned int tx_dropped;
  58         unsigned int time_start;
  59         unsigned int time;
  60         GTimer *timer;
  61 };
  62
  63 struct connman_service {
  64         gint refcount;
  65         char *identifier;
  66         char *path;
  67         enum connman_service_type type;
  68         enum connman_service_mode mode;
  69         enum connman_service_security security;
  70         enum connman_service_state state;
  71         enum connman_service_error error;
  72         connman_uint8_t strength;
  73         connman_bool_t favorite;
  74         connman_bool_t immutable;
  75         connman_bool_t hidden;
  76         connman_bool_t ignore;
  77         connman_bool_t autoconnect;
  78         connman_bool_t userconnect;
  79         GTimeVal modified;
  80         unsigned int order;
  81         char *name;
  82         char *passphrase;
  83         char *profile;
  84         char *apn;
  85         char *username;
  86         char *password;
  87         char *mcc;
  88         char *mnc;
  89         connman_bool_t roaming;
  90         connman_bool_t login_required;
  91         struct connman_ipconfig *ipconfig;
  92         struct connman_network *network;
  93         struct connman_provider *provider;
  94         char **nameservers;
  95         char *nameserver;
  96         char **domains;
  97         char *domainname;
  98         /* 802.1x settings from the config files */
  99         char *eap;
 100         char *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_location *location;
 109         struct connman_stats stats;
 110 };
 111
 112 static void append_path(gpointer value, gpointer user_data)
 113 {
 114         struct connman_service *service = value;
 115         DBusMessageIter *iter = user_data;
 116
 117         if (service->path == NULL || service->hidden == TRUE)
 118                 return;
 119
 120         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
 121                                                         &service->path);
 122 }
 123
 124 void __connman_service_list(DBusMessageIter *iter, void *user_data)
 125 {
 126         g_sequence_foreach(service_list, append_path, iter);
 127 }
 128
 129 struct find_data {
 130         const char *path;
 131         struct connman_service *service;
 132 };
 133
 134 static void compare_path(gpointer value, gpointer user_data)
 135 {
 136         struct connman_service *service = value;
 137         struct find_data *data = user_data;
 138
 139         if (data->service != NULL)
 140                 return;
 141
 142         if (g_strcmp0(service->path, data->path) == 0)
 143                 data->service = service;
 144 }
 145
 146 static struct connman_service *find_service(const char *path)
 147 {
 148         struct find_data data = { .path = path, .service = NULL };
 149
 150         DBG("path %s", path);
 151
 152         g_sequence_foreach(service_list, compare_path, &data);
 153
 154         return data.service;
 155 }
 156
 157 const char *__connman_service_type2string(enum connman_service_type type)
 158 {
 159         switch (type) {
 160         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 161                 break;
 162         case CONNMAN_SERVICE_TYPE_SYSTEM:
 163                 return "system";
 164         case CONNMAN_SERVICE_TYPE_ETHERNET:
 165                 return "ethernet";
 166         case CONNMAN_SERVICE_TYPE_WIFI:
 167                 return "wifi";
 168         case CONNMAN_SERVICE_TYPE_WIMAX:
 169                 return "wimax";
 170         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 171                 return "bluetooth";
 172         case CONNMAN_SERVICE_TYPE_CELLULAR:
 173                 return "cellular";
 174         case CONNMAN_SERVICE_TYPE_GPS:
 175                 return "gps";
 176         case CONNMAN_SERVICE_TYPE_VPN:
 177                 return "vpn";
 178         }
 179
 180         return NULL;
 181 }
 182
 183 static const char *mode2string(enum connman_service_mode mode)
 184 {
 185         switch (mode) {
 186         case CONNMAN_SERVICE_MODE_UNKNOWN:
 187                 break;
 188         case CONNMAN_SERVICE_MODE_MANAGED:
 189                 return "managed";
 190         case CONNMAN_SERVICE_MODE_ADHOC:
 191                 return "adhoc";
 192         case CONNMAN_SERVICE_MODE_GPRS:
 193                 return "gprs";
 194         case CONNMAN_SERVICE_MODE_EDGE:
 195                 return "edge";
 196         case CONNMAN_SERVICE_MODE_UMTS:
 197                 return "umts";
 198         }
 199
 200         return NULL;
 201 }
 202
 203 static const char *security2string(enum connman_service_security security)
 204 {
 205         switch (security) {
 206         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 207                 break;
 208         case CONNMAN_SERVICE_SECURITY_NONE:
 209                 return "none";
 210         case CONNMAN_SERVICE_SECURITY_WEP:
 211                 return "wep";
 212         case CONNMAN_SERVICE_SECURITY_PSK:
 213                 return "psk";
 214         case CONNMAN_SERVICE_SECURITY_8021X:
 215                 return "ieee8021x";
 216         case CONNMAN_SERVICE_SECURITY_WPA:
 217                 return "wpa";
 218         case CONNMAN_SERVICE_SECURITY_RSN:
 219                 return "rsn";
 220         }
 221
 222         return NULL;
 223 }
 224
 225 static const char *state2string(enum connman_service_state state)
 226 {
 227         switch (state) {
 228         case CONNMAN_SERVICE_STATE_UNKNOWN:
 229                 break;
 230         case CONNMAN_SERVICE_STATE_IDLE:
 231                 return "idle";
 232         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 233                 return "association";
 234         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 235                 return "configuration";
 236         case CONNMAN_SERVICE_STATE_READY:
 237                 return "ready";
 238         case CONNMAN_SERVICE_STATE_ONLINE:
 239                 return "online";
 240         case CONNMAN_SERVICE_STATE_DISCONNECT:
 241                 return "disconnect";
 242         case CONNMAN_SERVICE_STATE_FAILURE:
 243                 return "failure";
 244         }
 245
 246         return NULL;
 247 }
 248
 249 static const char *error2string(enum connman_service_error error)
 250 {
 251         switch (error) {
 252         case CONNMAN_SERVICE_ERROR_UNKNOWN:
 253                 break;
 254         case CONNMAN_SERVICE_ERROR_OUT_OF_RANGE:
 255                 return "out-of-range";
 256         case CONNMAN_SERVICE_ERROR_PIN_MISSING:
 257                 return "pin-missing";
 258         case CONNMAN_SERVICE_ERROR_DHCP_FAILED:
 259                 return "dhcp-failed";
 260         case CONNMAN_SERVICE_ERROR_CONNECT_FAILED:
 261                 return "connect-failed";
 262         }
 263
 264         return NULL;
 265 }
 266
 267 static enum connman_service_error string2error(const char *error)
 268 {
 269         if (g_strcmp0(error, "dhcp-failed") == 0)
 270                 return CONNMAN_SERVICE_ERROR_DHCP_FAILED;
 271         else if (g_strcmp0(error, "pin-missing") == 0)
 272                 return CONNMAN_SERVICE_ERROR_PIN_MISSING;
 273
 274         return CONNMAN_SERVICE_ERROR_UNKNOWN;
 275 }
 276
 277 static connman_bool_t is_connecting(struct connman_service *service)
 278 {
 279         switch (service->state) {
 280         case CONNMAN_SERVICE_STATE_UNKNOWN:
 281         case CONNMAN_SERVICE_STATE_IDLE:
 282         case CONNMAN_SERVICE_STATE_FAILURE:
 283         case CONNMAN_SERVICE_STATE_DISCONNECT:
 284         case CONNMAN_SERVICE_STATE_READY:
 285         case CONNMAN_SERVICE_STATE_ONLINE:
 286                 break;
 287         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 288         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 289                 return TRUE;
 290         }
 291
 292         return FALSE;
 293 }
 294
 295 static connman_bool_t is_connected(const struct connman_service *service)
 296 {
 297         switch (service->state) {
 298         case CONNMAN_SERVICE_STATE_UNKNOWN:
 299         case CONNMAN_SERVICE_STATE_IDLE:
 300         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 301         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 302         case CONNMAN_SERVICE_STATE_DISCONNECT:
 303         case CONNMAN_SERVICE_STATE_FAILURE:
 304                 break;
 305         case CONNMAN_SERVICE_STATE_READY:
 306         case CONNMAN_SERVICE_STATE_ONLINE:
 307                 return TRUE;
 308         }
 309
 310         return FALSE;
 311 }
 312
 313 static void update_nameservers(struct connman_service *service)
 314 {
 315         const char *ifname = connman_ipconfig_get_ifname(service->ipconfig);
 316
 317         if (ifname == NULL)
 318                 return;
 319
 320         switch (service->state) {
 321         case CONNMAN_SERVICE_STATE_UNKNOWN:
 322         case CONNMAN_SERVICE_STATE_IDLE:
 323         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 324         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 325                 return;
 326         case CONNMAN_SERVICE_STATE_FAILURE:
 327         case CONNMAN_SERVICE_STATE_DISCONNECT:
 328                 connman_resolver_remove_all(ifname);
 329                 return;
 330         case CONNMAN_SERVICE_STATE_READY:
 331         case CONNMAN_SERVICE_STATE_ONLINE:
 332                 break;
 333         }
 334
 335         connman_resolver_remove_all(ifname);
 336
 337         if (service->nameservers != NULL) {
 338                 int i;
 339
 340                 for (i = 0; service->nameservers[i]; i++)
 341                         connman_resolver_append(ifname, NULL,
 342                                                 service->nameservers[i]);
 343         } else if (service->nameserver != NULL)
 344                 connman_resolver_append(ifname, NULL, service->nameserver);
 345
 346         connman_resolver_flush();
 347 }
 348
 349 void __connman_service_append_nameserver(struct connman_service *service,
 350                                                 const char *nameserver)
 351 {
 352         DBG("service %p nameserver %s", service, nameserver);
 353
 354         if (nameserver == NULL)
 355                 return;
 356
 357         g_free(service->nameserver);
 358         service->nameserver = g_strdup(nameserver);
 359
 360         update_nameservers(service);
 361 }
 362
 363 void __connman_service_remove_nameserver(struct connman_service *service,
 364                                                 const char *nameserver)
 365 {
 366         DBG("service %p nameserver %s", service, nameserver);
 367
 368         if (nameserver == NULL)
 369                 return;
 370
 371         g_free(service->nameserver);
 372         service->nameserver = NULL;
 373
 374         update_nameservers(service);
 375 }
 376
 377 void __connman_service_nameserver_add_routes(struct connman_service *service,
 378                                                 const char *gw)
 379 {
 380         int index;
 381
 382         if (service == NULL)
 383                 return;
 384
 385         index = connman_network_get_index(service->network);
 386
 387         if (service->nameservers != NULL) {
 388                 int i;
 389
 390                 /*
 391                  * We add nameservers host routes for nameservers that
 392                  * are not on our subnet. For those who are, the subnet
 393                  * route will be installed by the time the dns proxy code
 394                  * tries to reach them. The subnet route is installed
 395                  * when setting the interface IP address.
 396                  */
 397                 for (i = 0; service->nameservers[i]; i++) {
 398                         if (connman_inet_compare_subnet(index,
 399                                                         service->nameservers[i]))
 400                                 continue;
 401
 402                         connman_inet_add_host_route(index,
 403                                                 service->nameservers[i], gw);
 404                 }
 405         } else if (service->nameserver != NULL) {
 406                 if (connman_inet_compare_subnet(index, service->nameserver))
 407                         return;
 408
 409                 connman_inet_add_host_route(index, service->nameserver, gw);
 410         }
 411 }
 412
 413 void __connman_service_nameserver_del_routes(struct connman_service *service)
 414 {
 415         int index;
 416
 417         if (service == NULL)
 418                 return;
 419
 420         index = connman_network_get_index(service->network);
 421
 422         if (service->nameservers != NULL) {
 423                 int i;
 424
 425                 for (i = 0; service->nameservers[i]; i++)
 426                         connman_inet_del_host_route(index,
 427                                                 service->nameservers[i]);
 428         } else if (service->nameserver != NULL) {
 429                 connman_inet_del_host_route(index, service->nameserver);
 430         }
 431 }
 432
 433 static void __connman_service_stats_start(struct connman_service *service)
 434 {
 435         DBG("service %p", service);
 436
 437         if (service->stats.timer == NULL)
 438                 return;
 439
 440         service->stats.enabled = TRUE;
 441
 442         service->stats.time_start = service->stats.time;
 443
 444         g_timer_start(service->stats.timer);
 445
 446         __connman_counter_add_service(service);
 447 }
 448
 449 static void __connman_service_stats_stop(struct connman_service *service)
 450 {
 451         unsigned int seconds;
 452
 453         DBG("service %p", service);
 454
 455         if (service->stats.timer == NULL)
 456                 return;
 457
 458         if (service->stats.enabled == FALSE)
 459                 return;
 460
 461         __connman_counter_remove_service(service);
 462
 463         g_timer_stop(service->stats.timer);
 464
 465         seconds = g_timer_elapsed(service->stats.timer, NULL);
 466         service->stats.time = service->stats.time_start + seconds;
 467
 468         service->stats.enabled = FALSE;
 469 }
 470
 471 static int __connman_service_stats_load(struct connman_service *service,
 472                 GKeyFile *keyfile, const char *identifier)
 473 {
 474         service->stats.rx_packets = g_key_file_get_integer(keyfile,
 475                                 identifier, "rx_packets", NULL);
 476         service->stats.tx_packets = g_key_file_get_integer(keyfile,
 477                                 identifier, "tx_packets", NULL);
 478         service->stats.rx_bytes = g_key_file_get_integer(keyfile,
 479                                 identifier, "rx_bytes", NULL);
 480         service->stats.tx_bytes = g_key_file_get_integer(keyfile,
 481                                 identifier, "tx_bytes", NULL);
 482         service->stats.rx_errors = g_key_file_get_integer(keyfile,
 483                                 identifier, "rx_errors", NULL);
 484         service->stats.tx_errors = g_key_file_get_integer(keyfile,
 485                                 identifier, "tx_errors", NULL);
 486         service->stats.rx_dropped = g_key_file_get_integer(keyfile,
 487                                 identifier, "rx_dropped", NULL);
 488         service->stats.tx_dropped = g_key_file_get_integer(keyfile,
 489                                 identifier, "tx_dropped", NULL);
 490         service->stats.time = g_key_file_get_integer(keyfile,
 491                                 identifier, "time", NULL);
 492
 493         return 0;
 494 }
 495
 496 static int __connman_service_stats_save(struct connman_service *service,
 497                 GKeyFile *keyfile, const char *identifier)
 498 {
 499         g_key_file_set_integer(keyfile, identifier, "rx_packets",
 500                         service->stats.rx_packets);
 501         g_key_file_set_integer(keyfile, identifier, "tx_packets",
 502                         service->stats.tx_packets);
 503         g_key_file_set_integer(keyfile, identifier, "rx_bytes",
 504                         service->stats.rx_bytes);
 505         g_key_file_set_integer(keyfile, identifier, "tx_bytes",
 506                         service->stats.tx_bytes);
 507         g_key_file_set_integer(keyfile, identifier, "rx_errors",
 508                         service->stats.rx_errors);
 509         g_key_file_set_integer(keyfile, identifier, "tx_errors",
 510                         service->stats.tx_errors);
 511         g_key_file_set_integer(keyfile, identifier, "rx_dropped",
 512                         service->stats.rx_dropped);
 513         g_key_file_set_integer(keyfile, identifier, "tx_dropped",
 514                         service->stats.tx_dropped);
 515         g_key_file_set_integer(keyfile, identifier, "time",
 516                         service->stats.time);
 517
 518         return 0;
 519 }
 520
 521 static void __connman_service_reset_stats(struct connman_service *service)
 522 {
 523         DBG("service %p", service);
 524
 525         service->stats.valid = FALSE;
 526         service->stats.rx_packets = 0;
 527         service->stats.tx_packets = 0;
 528         service->stats.rx_bytes = 0;
 529         service->stats.tx_bytes = 0;
 530         service->stats.rx_errors = 0;
 531         service->stats.tx_errors = 0;
 532         service->stats.rx_dropped = 0;
 533         service->stats.tx_dropped = 0;
 534         service->stats.time = 0;
 535         service->stats.time_start = 0;
 536         g_timer_reset(service->stats.timer);
 537
 538 }
 539
 540 unsigned long __connman_service_stats_get_rx_packets(struct connman_service *service)
 541 {
 542         return service->stats.rx_packets;
 543 }
 544
 545 unsigned long __connman_service_stats_get_tx_packets(struct connman_service *service)
 546 {
 547         return service->stats.tx_packets;
 548 }
 549
 550 unsigned long __connman_service_stats_get_rx_bytes(struct connman_service *service)
 551 {
 552         return service->stats.rx_bytes;
 553 }
 554
 555 unsigned long __connman_service_stats_get_tx_bytes(struct connman_service *service)
 556 {
 557         return service->stats.tx_bytes;
 558 }
 559
 560 unsigned long __connman_service_stats_get_rx_errors(struct connman_service *service)
 561 {
 562         return service->stats.rx_errors;
 563 }
 564
 565 unsigned long __connman_service_stats_get_tx_errors(struct connman_service *service)
 566 {
 567         return service->stats.tx_errors;
 568 }
 569
 570 unsigned long __connman_service_stats_get_rx_dropped(struct connman_service *service)
 571 {
 572         return service->stats.rx_dropped;
 573 }
 574
 575 unsigned long __connman_service_stats_get_tx_dropped(struct connman_service *service)
 576 {
 577         return service->stats.tx_dropped;
 578 }
 579
 580 unsigned long __connman_service_stats_get_time(struct connman_service *service)
 581 {
 582         return service->stats.time;
 583 }
 584
 585 static struct connman_service *get_default(void)
 586 {
 587         struct connman_service *service;
 588         GSequenceIter *iter;
 589
 590         iter = g_sequence_get_begin_iter(service_list);
 591
 592         if (g_sequence_iter_is_end(iter) == TRUE)
 593                 return NULL;
 594
 595         service = g_sequence_get(iter);
 596
 597         if (is_connected(service) == FALSE)
 598                 return NULL;
 599
 600         return service;
 601 }
 602
 603 static void default_changed(void)
 604 {
 605         struct connman_service *service = get_default();
 606
 607         __connman_notifier_default_changed(service);
 608 }
 609
 610 const char *__connman_service_default(void)
 611 {
 612         struct connman_service *service;
 613
 614         service = get_default();
 615         if (service == NULL)
 616                 return "";
 617
 618         return __connman_service_type2string(service->type);
 619 }
 620
 621 static void mode_changed(struct connman_service *service)
 622 {
 623         const char *str;
 624
 625         str = mode2string(service->mode);
 626         if (str == NULL)
 627                 return;
 628
 629         connman_dbus_property_changed_basic(service->path,
 630                                 CONNMAN_SERVICE_INTERFACE, "Mode",
 631                                                 DBUS_TYPE_STRING, &str);
 632 }
 633
 634 static void state_changed(struct connman_service *service)
 635 {
 636         const char *str;
 637
 638         str = state2string(service->state);
 639         if (str == NULL)
 640                 return;
 641
 642         connman_dbus_property_changed_basic(service->path,
 643                                 CONNMAN_SERVICE_INTERFACE, "State",
 644                                                 DBUS_TYPE_STRING, &str);
 645 }
 646
 647 static void strength_changed(struct connman_service *service)
 648 {
 649         if (service->strength == 0)
 650                 return;
 651
 652         connman_dbus_property_changed_basic(service->path,
 653                                 CONNMAN_SERVICE_INTERFACE, "Strength",
 654                                         DBUS_TYPE_BYTE, &service->strength);
 655 }
 656
 657 static void favorite_changed(struct connman_service *service)
 658 {
 659         if (service->path == NULL)
 660                 return;
 661
 662         connman_dbus_property_changed_basic(service->path,
 663                                 CONNMAN_SERVICE_INTERFACE, "Favorite",
 664                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 665 }
 666
 667 static void immutable_changed(struct connman_service *service)
 668 {
 669         if (service->path == NULL)
 670                 return;
 671
 672         connman_dbus_property_changed_basic(service->path,
 673                                 CONNMAN_SERVICE_INTERFACE, "Immutable",
 674                                         DBUS_TYPE_BOOLEAN, &service->immutable);
 675 }
 676
 677 static void roaming_changed(struct connman_service *service)
 678 {
 679         if (service->path == NULL)
 680                 return;
 681
 682         connman_dbus_property_changed_basic(service->path,
 683                                 CONNMAN_SERVICE_INTERFACE, "Roaming",
 684                                         DBUS_TYPE_BOOLEAN, &service->roaming);
 685 }
 686
 687 static void autoconnect_changed(struct connman_service *service)
 688 {
 689         if (service->path == NULL)
 690                 return;
 691
 692         connman_dbus_property_changed_basic(service->path,
 693                                 CONNMAN_SERVICE_INTERFACE, "AutoConnect",
 694                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
 695 }
 696
 697 static void passphrase_changed(struct connman_service *service)
 698 {
 699         dbus_bool_t required;
 700
 701         switch (service->type) {
 702         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 703         case CONNMAN_SERVICE_TYPE_SYSTEM:
 704         case CONNMAN_SERVICE_TYPE_ETHERNET:
 705         case CONNMAN_SERVICE_TYPE_WIMAX:
 706         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 707         case CONNMAN_SERVICE_TYPE_CELLULAR:
 708         case CONNMAN_SERVICE_TYPE_GPS:
 709         case CONNMAN_SERVICE_TYPE_VPN:
 710                 return;
 711         case CONNMAN_SERVICE_TYPE_WIFI:
 712                 required = FALSE;
 713
 714                 switch (service->security) {
 715                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 716                 case CONNMAN_SERVICE_SECURITY_NONE:
 717                         break;
 718                 case CONNMAN_SERVICE_SECURITY_WEP:
 719                 case CONNMAN_SERVICE_SECURITY_PSK:
 720                 case CONNMAN_SERVICE_SECURITY_WPA:
 721                 case CONNMAN_SERVICE_SECURITY_RSN:
 722                         if (service->passphrase == NULL)
 723                                 required = TRUE;
 724                         break;
 725                 case CONNMAN_SERVICE_SECURITY_8021X:
 726                         break;
 727                 }
 728                 break;
 729         }
 730
 731         connman_dbus_property_changed_basic(service->path,
 732                                 CONNMAN_SERVICE_INTERFACE, "PassphraseRequired",
 733                                                 DBUS_TYPE_BOOLEAN, &required);
 734 }
 735
 736 static void login_changed(struct connman_service *service)
 737 {
 738         dbus_bool_t required = service->login_required;
 739
 740         if (service->path == NULL)
 741                 return;
 742
 743         connman_dbus_property_changed_basic(service->path,
 744                                 CONNMAN_SERVICE_INTERFACE, "LoginRequired",
 745                                                 DBUS_TYPE_BOOLEAN, &required);
 746 }
 747
 748 static void apn_changed(struct connman_service *service)
 749 {
 750         dbus_bool_t required;
 751
 752         switch (service->type) {
 753         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 754         case CONNMAN_SERVICE_TYPE_SYSTEM:
 755         case CONNMAN_SERVICE_TYPE_ETHERNET:
 756         case CONNMAN_SERVICE_TYPE_WIMAX:
 757         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 758         case CONNMAN_SERVICE_TYPE_WIFI:
 759         case CONNMAN_SERVICE_TYPE_GPS:
 760         case CONNMAN_SERVICE_TYPE_VPN:
 761                 return;
 762         case CONNMAN_SERVICE_TYPE_CELLULAR:
 763                 break;
 764         }
 765
 766         required = (service->apn == NULL) ? TRUE : FALSE;
 767
 768         connman_dbus_property_changed_basic(service->path,
 769                                 CONNMAN_SERVICE_INTERFACE, "SetupRequired",
 770                                                 DBUS_TYPE_BOOLEAN, &required);
 771 }
 772
 773 static void append_ethernet(DBusMessageIter *iter, void *user_data)
 774 {
 775         struct connman_service *service = user_data;
 776
 777         if (is_connecting(service) == FALSE &&
 778                         is_connected(service) == FALSE)
 779                 return;
 780
 781         if (service->ipconfig != NULL)
 782                 __connman_ipconfig_append_ethernet(service->ipconfig, iter);
 783 }
 784
 785 static void append_ipv4(DBusMessageIter *iter, void *user_data)
 786 {
 787         struct connman_service *service = user_data;
 788
 789         if (is_connected(service) == FALSE)
 790                 return;
 791
 792         if (service->ipconfig != NULL)
 793                 __connman_ipconfig_append_ipv4(service->ipconfig, iter);
 794 }
 795
 796 static void append_ipv6(DBusMessageIter *iter, void *user_data)
 797 {
 798         struct connman_service *service = user_data;
 799         struct connman_ipconfig *ipv6config;
 800
 801         if (is_connected(service) == FALSE)
 802                 return;
 803
 804         if (service->ipconfig == NULL)
 805                 return;
 806
 807         ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
 808         if (ipv6config == NULL)
 809                 return;
 810
 811         __connman_ipconfig_append_ipv6(ipv6config, iter);
 812 }
 813
 814 static void append_ipv4config(DBusMessageIter *iter, void *user_data)
 815 {
 816         struct connman_service *service = user_data;
 817
 818         if (service->ipconfig != NULL)
 819                 __connman_ipconfig_append_ipv4config(service->ipconfig, iter);
 820 }
 821
 822 static void append_ipv6config(DBusMessageIter *iter, void *user_data)
 823 {
 824         struct connman_service *service = user_data;
 825         struct connman_ipconfig *ipv6config;
 826
 827         if (service->ipconfig == NULL)
 828                 return;
 829
 830         ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
 831         if (ipv6config == NULL)
 832                 return;
 833
 834         __connman_ipconfig_append_ipv6config(ipv6config, iter);
 835 }
 836
 837 static void append_dns(DBusMessageIter *iter, void *user_data)
 838 {
 839         struct connman_service *service = user_data;
 840
 841         if (is_connected(service) == FALSE)
 842                 return;
 843
 844         if (service->nameservers != NULL) {
 845                 int i;
 846
 847                 for (i = 0; service->nameservers[i]; i++)
 848                         dbus_message_iter_append_basic(iter,
 849                                 DBUS_TYPE_STRING, &service->nameservers[i]);
 850
 851                 return;
 852         }
 853
 854         if (service->nameserver == NULL)
 855                 return;
 856
 857         dbus_message_iter_append_basic(iter,
 858                                 DBUS_TYPE_STRING, &service->nameserver);
 859 }
 860
 861 static void append_dnsconfig(DBusMessageIter *iter, void *user_data)
 862 {
 863         struct connman_service *service = user_data;
 864         int i;
 865
 866         if (service->nameservers == NULL)
 867                 return;
 868
 869         for (i = 0; service->nameservers[i]; i++)
 870                 dbus_message_iter_append_basic(iter,
 871                                 DBUS_TYPE_STRING, &service->nameservers[i]);
 872 }
 873
 874 static void append_domain(DBusMessageIter *iter, void *user_data)
 875 {
 876         struct connman_service *service = user_data;
 877
 878         if (is_connected(service) == FALSE && is_connecting(service) == FALSE)
 879                 return;
 880
 881         if (service->domainname == NULL)
 882                 return;
 883
 884         dbus_message_iter_append_basic(iter,
 885                                 DBUS_TYPE_STRING, &service->domainname);
 886 }
 887
 888 static void append_domainconfig(DBusMessageIter *iter, void *user_data)
 889 {
 890         struct connman_service *service = user_data;
 891         int i;
 892
 893         if (service->domains == NULL)
 894                 return;
 895
 896         for (i = 0; service->domains[i]; i++)
 897                 dbus_message_iter_append_basic(iter,
 898                                 DBUS_TYPE_STRING, &service->domains[i]);
 899 }
 900
 901 static void append_proxy(DBusMessageIter *iter, void *user_data)
 902 {
 903         struct connman_service *service = user_data;
 904
 905         if (is_connected(service) == FALSE)
 906                 return;
 907
 908         if (service->ipconfig != NULL)
 909                 __connman_ipconfig_append_proxy(service->ipconfig, iter);
 910 }
 911
 912 static void settings_changed(struct connman_service *service)
 913 {
 914         connman_dbus_property_changed_dict(service->path,
 915                                         CONNMAN_SERVICE_INTERFACE, "IPv4",
 916                                                         append_ipv4, service);
 917
 918         connman_dbus_property_changed_dict(service->path,
 919                                         CONNMAN_SERVICE_INTERFACE, "IPv6",
 920                                                         append_ipv6, service);
 921 }
 922
 923 static void ipv4_configuration_changed(struct connman_service *service)
 924 {
 925         connman_dbus_property_changed_dict(service->path,
 926                                         CONNMAN_SERVICE_INTERFACE,
 927                                                         "IPv4.Configuration",
 928                                                         append_ipv4config,
 929                                                         service);
 930 }
 931
 932 static void ipv6_configuration_changed(struct connman_service *service)
 933 {
 934         connman_dbus_property_changed_dict(service->path,
 935                                         CONNMAN_SERVICE_INTERFACE,
 936                                                         "IPv6.Configuration",
 937                                                         append_ipv6config,
 938                                                         service);
 939 }
 940
 941 static void dns_changed(struct connman_service *service)
 942 {
 943         connman_dbus_property_changed_array(service->path,
 944                                 CONNMAN_SERVICE_INTERFACE, "Nameservers",
 945                                         DBUS_TYPE_STRING, append_dns, service);
 946 }
 947
 948 static void dns_configuration_changed(struct connman_service *service)
 949 {
 950         connman_dbus_property_changed_array(service->path,
 951                                 CONNMAN_SERVICE_INTERFACE,
 952                                 "Nameservers.Configuration",
 953                                 DBUS_TYPE_STRING, append_dnsconfig, service);
 954
 955         dns_changed(service);
 956 }
 957
 958 static void domain_changed(struct connman_service *service)
 959 {
 960         connman_dbus_property_changed_array(service->path,
 961                                 CONNMAN_SERVICE_INTERFACE, "Domains",
 962                                 DBUS_TYPE_STRING, append_domain, service);
 963 }
 964
 965 static void domain_configuration_changed(struct connman_service *service)
 966 {
 967         connman_dbus_property_changed_array(service->path,
 968                                 CONNMAN_SERVICE_INTERFACE,
 969                                 "Domains.Configuration",
 970                                 DBUS_TYPE_STRING, append_domainconfig, service);
 971 }
 972
 973 static void proxy_changed(struct connman_service *service)
 974 {
 975         connman_dbus_property_changed_dict(service->path,
 976                                         CONNMAN_SERVICE_INTERFACE, "Proxy",
 977                                                         append_proxy, service);
 978 }
 979
 980 static void append_properties(DBusMessageIter *dict, dbus_bool_t limited,
 981                                         struct connman_service *service)
 982 {
 983         dbus_bool_t required;
 984         const char *str;
 985
 986         str = __connman_service_type2string(service->type);
 987         if (str != NULL)
 988                 connman_dbus_dict_append_basic(dict, "Type",
 989                                                 DBUS_TYPE_STRING, &str);
 990
 991         str = mode2string(service->mode);
 992         if (str != NULL)
 993                 connman_dbus_dict_append_basic(dict, "Mode",
 994                                                 DBUS_TYPE_STRING, &str);
 995
 996         str = security2string(service->security);
 997         if (str != NULL)
 998                 connman_dbus_dict_append_basic(dict, "Security",
 999                                                 DBUS_TYPE_STRING, &str);
1000
1001         str = state2string(service->state);
1002         if (str != NULL)
1003                 connman_dbus_dict_append_basic(dict, "State",
1004                                                 DBUS_TYPE_STRING, &str);
1005
1006         str = error2string(service->error);
1007         if (str != NULL)
1008                 connman_dbus_dict_append_basic(dict, "Error",
1009                                                 DBUS_TYPE_STRING, &str);
1010
1011         if (service->strength > 0)
1012                 connman_dbus_dict_append_basic(dict, "Strength",
1013                                         DBUS_TYPE_BYTE, &service->strength);
1014
1015         connman_dbus_dict_append_basic(dict, "Favorite",
1016                                         DBUS_TYPE_BOOLEAN, &service->favorite);
1017
1018         connman_dbus_dict_append_basic(dict, "Immutable",
1019                                         DBUS_TYPE_BOOLEAN, &service->immutable);
1020
1021         if (service->favorite == TRUE)
1022                 connman_dbus_dict_append_basic(dict, "AutoConnect",
1023                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
1024         else
1025                 connman_dbus_dict_append_basic(dict, "AutoConnect",
1026                                         DBUS_TYPE_BOOLEAN, &service->favorite);
1027
1028         if (service->name != NULL)
1029                 connman_dbus_dict_append_basic(dict, "Name",
1030                                         DBUS_TYPE_STRING, &service->name);
1031
1032         connman_dbus_dict_append_basic(dict, "LoginRequired",
1033                                 DBUS_TYPE_BOOLEAN, &service->login_required);
1034
1035         switch (service->type) {
1036         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1037         case CONNMAN_SERVICE_TYPE_SYSTEM:
1038         case CONNMAN_SERVICE_TYPE_GPS:
1039         case CONNMAN_SERVICE_TYPE_VPN:
1040                 break;
1041         case CONNMAN_SERVICE_TYPE_CELLULAR:
1042                 connman_dbus_dict_append_basic(dict, "Roaming",
1043                                         DBUS_TYPE_BOOLEAN, &service->roaming);
1044
1045                 if (service->mcc != NULL && service->mnc != NULL) {
1046                         connman_dbus_dict_append_basic(dict, "MCC",
1047                                         DBUS_TYPE_STRING, &service->mcc);
1048                         connman_dbus_dict_append_basic(dict, "MNC",
1049                                         DBUS_TYPE_STRING, &service->mnc);
1050                 }
1051
1052                 if (service->apn != NULL) {
1053                         connman_dbus_dict_append_basic(dict, "APN",
1054                                         DBUS_TYPE_STRING, &service->apn);
1055
1056                         if (service->username != NULL)
1057                                 connman_dbus_dict_append_basic(dict,
1058                                         "Username", DBUS_TYPE_STRING,
1059                                                         &service->username);
1060
1061                         if (service->password != NULL)
1062                                 connman_dbus_dict_append_basic(dict,
1063                                         "Password", DBUS_TYPE_STRING,
1064                                                         &service->password);
1065
1066                         required = FALSE;
1067                 } else
1068                         required = TRUE;
1069
1070                 connman_dbus_dict_append_basic(dict, "SetupRequired",
1071                                                 DBUS_TYPE_BOOLEAN, &required);
1072                 connman_dbus_dict_append_dict(dict, "Ethernet",
1073                                                 append_ethernet, service);
1074                 break;
1075         case CONNMAN_SERVICE_TYPE_WIFI:
1076                 if (service->passphrase != NULL && limited == FALSE)
1077                         connman_dbus_dict_append_basic(dict, "Passphrase",
1078                                 DBUS_TYPE_STRING, &service->passphrase);
1079
1080                 required = FALSE;
1081
1082                 switch (service->security) {
1083                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
1084                 case CONNMAN_SERVICE_SECURITY_NONE:
1085                         break;
1086                 case CONNMAN_SERVICE_SECURITY_WEP:
1087                 case CONNMAN_SERVICE_SECURITY_PSK:
1088                 case CONNMAN_SERVICE_SECURITY_WPA:
1089                 case CONNMAN_SERVICE_SECURITY_RSN:
1090                         if (service->passphrase == NULL)
1091                                 required = TRUE;
1092                         break;
1093                 case CONNMAN_SERVICE_SECURITY_8021X:
1094                         break;
1095                 }
1096
1097                 connman_dbus_dict_append_basic(dict, "PassphraseRequired",
1098                                                 DBUS_TYPE_BOOLEAN, &required);
1099                 /* fall through */
1100         case CONNMAN_SERVICE_TYPE_ETHERNET:
1101         case CONNMAN_SERVICE_TYPE_WIMAX:
1102         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1103                 connman_dbus_dict_append_dict(dict, "Ethernet",
1104                                                 append_ethernet, service);
1105                 break;
1106         }
1107
1108         connman_dbus_dict_append_dict(dict, "IPv4", append_ipv4, service);
1109
1110         connman_dbus_dict_append_dict(dict, "IPv4.Configuration",
1111                                                 append_ipv4config, service);
1112
1113         connman_dbus_dict_append_dict(dict, "IPv6", append_ipv6, service);
1114
1115         connman_dbus_dict_append_dict(dict, "IPv6.Configuration",
1116                                                 append_ipv6config, service);
1117
1118         connman_dbus_dict_append_array(dict, "Nameservers",
1119                                 DBUS_TYPE_STRING, append_dns, service);
1120
1121         connman_dbus_dict_append_array(dict, "Nameservers.Configuration",
1122                                 DBUS_TYPE_STRING, append_dnsconfig, service);
1123
1124         connman_dbus_dict_append_array(dict, "Domains",
1125                                 DBUS_TYPE_STRING, append_domain, service);
1126
1127         connman_dbus_dict_append_array(dict, "Domains.Configuration",
1128                                 DBUS_TYPE_STRING, append_domainconfig, service);
1129
1130         connman_dbus_dict_append_dict(dict, "Proxy", append_proxy, service);
1131 }
1132
1133 static void append_struct(gpointer value, gpointer user_data)
1134 {
1135         struct connman_service *service = value;
1136         DBusMessageIter *iter = user_data;
1137         DBusMessageIter entry, dict;
1138
1139         if (service->path == NULL || service->hidden == TRUE)
1140                 return;
1141
1142         dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &entry);
1143
1144         dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
1145                                                         &service->path);
1146
1147         connman_dbus_dict_open(&entry, &dict);
1148         append_properties(&dict, TRUE, service);
1149         connman_dbus_dict_close(&entry, &dict);
1150
1151         dbus_message_iter_close_container(iter, &entry);
1152 }
1153
1154 void __connman_service_list_struct(DBusMessageIter *iter)
1155 {
1156         g_sequence_foreach(service_list, append_struct, iter);
1157 }
1158
1159 int __connman_service_get_index(struct connman_service *service)
1160 {
1161         if (service == NULL)
1162                 return -1;
1163
1164         if (service->network == NULL)
1165                 return -1;
1166
1167         return connman_network_get_index(service->network);
1168 }
1169
1170 void __connman_service_set_domainname(struct connman_service *service,
1171                                                 const char *domainname)
1172 {
1173         if (service == NULL)
1174                 return;
1175
1176         g_free(service->domainname);
1177         service->domainname = g_strdup(domainname);
1178
1179         domain_changed(service);
1180 }
1181
1182 const char *__connman_service_get_domainname(struct connman_service *service)
1183 {
1184         if (service == NULL)
1185                 return NULL;
1186
1187         return service->domainname;
1188 }
1189
1190 const char *__connman_service_get_nameserver(struct connman_service *service)
1191 {
1192         if (service == NULL)
1193                 return NULL;
1194
1195         return service->nameserver;
1196 }
1197
1198 void __connman_service_set_proxy_autoconfig(struct connman_service *service,
1199                                                         const char *url)
1200 {
1201         if (service == NULL)
1202                 return;
1203
1204         if (__connman_ipconfig_set_proxy_autoconfig(service->ipconfig,
1205                                                                 url) < 0)
1206                 return;
1207
1208         proxy_changed(service);
1209 }
1210
1211 static DBusMessage *get_properties(DBusConnection *conn,
1212                                         DBusMessage *msg, void *user_data)
1213 {
1214         struct connman_service *service = user_data;
1215         DBusMessage *reply;
1216         DBusMessageIter array, dict;
1217         dbus_bool_t limited = TRUE;
1218
1219         DBG("service %p", service);
1220
1221         if (__connman_security_check_privilege(msg,
1222                                 CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
1223                 limited = FALSE;
1224
1225         reply = dbus_message_new_method_return(msg);
1226         if (reply == NULL)
1227                 return NULL;
1228
1229         dbus_message_iter_init_append(reply, &array);
1230
1231         connman_dbus_dict_open(&array, &dict);
1232         append_properties(&dict, limited, service);
1233         connman_dbus_dict_close(&array, &dict);
1234
1235         return reply;
1236 }
1237
1238 static DBusMessage *set_property(DBusConnection *conn,
1239                                         DBusMessage *msg, void *user_data)
1240 {
1241         struct connman_service *service = user_data;
1242         DBusMessageIter iter, value;
1243         const char *name;
1244         int type;
1245
1246         DBG("service %p", service);
1247
1248         if (dbus_message_iter_init(msg, &iter) == FALSE)
1249                 return __connman_error_invalid_arguments(msg);
1250
1251         dbus_message_iter_get_basic(&iter, &name);
1252         dbus_message_iter_next(&iter);
1253         dbus_message_iter_recurse(&iter, &value);
1254
1255         if (__connman_security_check_privilege(msg,
1256                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
1257                 return __connman_error_permission_denied(msg);
1258
1259         type = dbus_message_iter_get_arg_type(&value);
1260
1261         if (g_str_has_prefix(name, "AutoConnect") == TRUE) {
1262                 connman_bool_t autoconnect;
1263
1264                 if (type != DBUS_TYPE_BOOLEAN)
1265                         return __connman_error_invalid_arguments(msg);
1266
1267                 if (service->favorite == FALSE)
1268                         return __connman_error_invalid_service(msg);
1269
1270                 dbus_message_iter_get_basic(&value, &autoconnect);
1271
1272                 if (service->autoconnect == autoconnect)
1273                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1274
1275                 service->autoconnect = autoconnect;
1276
1277                 autoconnect_changed(service);
1278
1279                 __connman_storage_save_service(service);
1280         } else if (g_str_equal(name, "Passphrase") == TRUE) {
1281                 const char *passphrase;
1282
1283                 if (type != DBUS_TYPE_STRING)
1284                         return __connman_error_invalid_arguments(msg);
1285
1286                 if (service->immutable == TRUE)
1287                         return __connman_error_not_supported(msg);
1288
1289                 if (__connman_security_check_privilege(msg,
1290                                         CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0)
1291                         return __connman_error_permission_denied(msg);
1292
1293                 dbus_message_iter_get_basic(&value, &passphrase);
1294
1295                 g_free(service->passphrase);
1296                 service->passphrase = g_strdup(passphrase);
1297
1298                 passphrase_changed(service);
1299
1300                 if (service->network != NULL)
1301                         connman_network_set_string(service->network,
1302                                 "WiFi.Passphrase", service->passphrase);
1303
1304                 __connman_storage_save_service(service);
1305         } else if (g_str_equal(name, "APN") == TRUE) {
1306                 const char *apn;
1307
1308                 if (type != DBUS_TYPE_STRING)
1309                         return __connman_error_invalid_arguments(msg);
1310
1311                 if (service->immutable == TRUE)
1312                         return __connman_error_not_supported(msg);
1313
1314                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1315                         return __connman_error_invalid_service(msg);
1316
1317                 dbus_message_iter_get_basic(&value, &apn);
1318
1319                 g_free(service->apn);
1320                 service->apn = g_strdup(apn);
1321
1322                 apn_changed(service);
1323
1324                 if (service->network != NULL)
1325                         connman_network_set_string(service->network,
1326                                                 "Cellular.APN", service->apn);
1327
1328                 __connman_storage_save_service(service);
1329         } else if (g_str_equal(name, "Username") == TRUE) {
1330                 const char *username;
1331
1332                 if (type != DBUS_TYPE_STRING)
1333                         return __connman_error_invalid_arguments(msg);
1334
1335                 if (service->immutable == TRUE)
1336                         return __connman_error_not_supported(msg);
1337
1338                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1339                         return __connman_error_invalid_service(msg);
1340
1341                 dbus_message_iter_get_basic(&value, &username);
1342
1343                 g_free(service->username);
1344                 service->username = g_strdup(username);
1345
1346                 if (service->network != NULL)
1347                         connman_network_set_string(service->network,
1348                                         "Cellular.Username", service->username);
1349
1350                 __connman_storage_save_service(service);
1351         } else if (g_str_equal(name, "Password") == TRUE) {
1352                 const char *password;
1353
1354                 if (type != DBUS_TYPE_STRING)
1355                         return __connman_error_invalid_arguments(msg);
1356
1357                 if (service->immutable == TRUE)
1358                         return __connman_error_not_supported(msg);
1359
1360                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1361                         return __connman_error_invalid_service(msg);
1362
1363                 dbus_message_iter_get_basic(&value, &password);
1364
1365                 g_free(service->password);
1366                 service->password = g_strdup(password);
1367
1368                 if (service->network != NULL)
1369                         connman_network_set_string(service->network,
1370                                         "Cellular.Password", service->password);
1371
1372                 __connman_storage_save_service(service);
1373         } else if (g_str_equal(name, "Nameservers.Configuration") == TRUE) {
1374                 DBusMessageIter entry;
1375                 GString *str;
1376                 int index;
1377                 const char *gw;
1378
1379                 if (type != DBUS_TYPE_ARRAY)
1380                         return __connman_error_invalid_arguments(msg);
1381
1382                 str = g_string_new(NULL);
1383                 if (str == NULL)
1384                         return __connman_error_invalid_arguments(msg);
1385
1386                 index = connman_network_get_index(service->network);
1387                 gw = __connman_ipconfig_get_gateway(index);
1388
1389                 if (gw && strlen(gw))
1390                         __connman_service_nameserver_del_routes(service);
1391
1392                 dbus_message_iter_recurse(&value, &entry);
1393
1394                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
1395                         const char *val;
1396                         dbus_message_iter_get_basic(&entry, &val);
1397                         dbus_message_iter_next(&entry);
1398                         if (str->len > 0)
1399                                 g_string_append_printf(str, " %s", val);
1400                         else
1401                                 g_string_append(str, val);
1402                 }
1403
1404                 g_strfreev(service->nameservers);
1405
1406                 if (str->len > 0)
1407                         service->nameservers = g_strsplit_set(str->str, " ", 0);
1408                 else
1409                         service->nameservers = NULL;
1410
1411                 g_string_free(str, TRUE);
1412
1413                 if (gw && strlen(gw))
1414                         __connman_service_nameserver_add_routes(service, gw);
1415
1416                 update_nameservers(service);
1417                 dns_configuration_changed(service);
1418
1419                 __connman_storage_save_service(service);
1420         } else if (g_str_equal(name, "Domains.Configuration") == TRUE) {
1421                 DBusMessageIter entry;
1422                 GString *str;
1423
1424                 if (type != DBUS_TYPE_ARRAY)
1425                         return __connman_error_invalid_arguments(msg);
1426
1427                 str = g_string_new(NULL);
1428                 if (str == NULL)
1429                         return __connman_error_invalid_arguments(msg);
1430
1431                 dbus_message_iter_recurse(&value, &entry);
1432
1433                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
1434                         const char *val;
1435                         dbus_message_iter_get_basic(&entry, &val);
1436                         dbus_message_iter_next(&entry);
1437                         if (str->len > 0)
1438                                 g_string_append_printf(str, " %s", val);
1439                         else
1440                                 g_string_append(str, val);
1441                 }
1442
1443                 g_strfreev(service->domains);
1444
1445                 if (str->len > 0)
1446                         service->domains = g_strsplit_set(str->str, " ", 0);
1447                 else
1448                         service->domains = NULL;
1449
1450                 g_string_free(str, TRUE);
1451
1452                 //update_domains(service);
1453                 domain_configuration_changed(service);
1454
1455                 __connman_storage_save_service(service);
1456         } else if (g_str_equal(name, "IPv4.Configuration") == TRUE ||
1457                         g_str_equal(name, "IPv6.Configuration")) {
1458
1459                 enum connman_ipconfig_type type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
1460                 int err = 0;
1461                 struct connman_ipconfig *ipv6config;
1462
1463                 DBG("%s", name);
1464
1465                 ipv6config = connman_ipconfig_get_ipv6config(
1466                                                 service->ipconfig);
1467                 if (service->ipconfig == NULL)
1468                         return __connman_error_invalid_property(msg);
1469
1470                 if (is_connecting(service) ||
1471                                 is_connected(service)) {
1472                         __connman_network_clear_ipconfig(service->network,
1473                                                         service->ipconfig);
1474                         __connman_network_clear_ipconfig(service->network,
1475                                                                 ipv6config);
1476                 }
1477
1478                 if (g_str_equal(name, "IPv4.Configuration") == TRUE) {
1479                         type = CONNMAN_IPCONFIG_TYPE_IPV4;
1480                         err = __connman_ipconfig_set_config(
1481                                         service->ipconfig, type, &value);
1482                 } else if (g_str_equal(name, "IPv6.Configuration") == TRUE) {
1483                         type = CONNMAN_IPCONFIG_TYPE_IPV6;
1484                         err = __connman_ipconfig_set_config(
1485                                                 ipv6config, type, &value);
1486                 }
1487
1488                 if (err < 0) {
1489                         if (is_connected(service) ||
1490                                         is_connecting(service))
1491                                 __connman_network_set_ipconfig(
1492                                                         service->network,
1493                                                         service->ipconfig);
1494                         return __connman_error_failed(msg, -err);
1495                 }
1496
1497                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1498                         ipv4_configuration_changed(service);
1499                 else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1500                         ipv6_configuration_changed(service);
1501
1502                 if (is_connecting(service) ||
1503                                 is_connected(service))
1504                         __connman_network_set_ipconfig(service->network,
1505                                                         service->ipconfig);
1506
1507                 __connman_storage_save_service(service);
1508         } else
1509                 return __connman_error_invalid_property(msg);
1510
1511         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1512 }
1513
1514 static void set_idle(struct connman_service *service)
1515 {
1516         service->state = CONNMAN_SERVICE_STATE_IDLE;
1517         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
1518         state_changed(service);
1519 }
1520
1521 static DBusMessage *clear_property(DBusConnection *conn,
1522                                         DBusMessage *msg, void *user_data)
1523 {
1524         struct connman_service *service = user_data;
1525         const char *name;
1526
1527         DBG("service %p", service);
1528
1529         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
1530                                                         DBUS_TYPE_INVALID);
1531
1532         if (__connman_security_check_privilege(msg,
1533                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
1534                 return __connman_error_permission_denied(msg);
1535
1536         if (g_str_equal(name, "Error") == TRUE) {
1537                 set_idle(service);
1538
1539                 g_get_current_time(&service->modified);
1540                 __connman_storage_save_service(service);
1541         } else if (g_str_equal(name, "Passphrase") == TRUE) {
1542                 if (service->immutable == TRUE)
1543                         return __connman_error_not_supported(msg);
1544
1545                 g_free(service->passphrase);
1546                 service->passphrase = NULL;
1547
1548                 passphrase_changed(service);
1549
1550                 __connman_storage_save_service(service);
1551         } else
1552                 return __connman_error_invalid_property(msg);
1553
1554         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1555 }
1556
1557 static connman_bool_t is_ignore(struct connman_service *service)
1558 {
1559         if (service->autoconnect == FALSE)
1560                 return TRUE;
1561
1562         if (service->roaming == TRUE)
1563                 return TRUE;
1564
1565         if (service->ignore == TRUE)
1566                 return TRUE;
1567
1568         if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
1569                 return TRUE;
1570
1571         return FALSE;
1572 }
1573
1574 void __connman_service_auto_connect(void)
1575 {
1576         struct connman_service *service = NULL;
1577         GSequenceIter *iter;
1578
1579         DBG("");
1580
1581         iter = g_sequence_get_begin_iter(service_list);
1582
1583         while (g_sequence_iter_is_end(iter) == FALSE) {
1584                 service = g_sequence_get(iter);
1585
1586                 if (service->pending != NULL)
1587                         return;
1588
1589                 if (is_connecting(service) == TRUE)
1590                         return;
1591
1592                 if (service->favorite == FALSE)
1593                         return;
1594
1595                 if (is_connected(service) == TRUE)
1596                         return;
1597
1598                 if (is_ignore(service) == FALSE &&
1599                                 service->state == CONNMAN_SERVICE_STATE_IDLE)
1600                         break;
1601
1602                 service = NULL;
1603
1604                 iter = g_sequence_iter_next(iter);
1605         }
1606
1607         if (service != NULL) {
1608                 service->userconnect = FALSE;
1609                 __connman_service_connect(service);
1610         }
1611 }
1612
1613 static void remove_timeout(struct connman_service *service)
1614 {
1615         if (service->timeout > 0) {
1616                 g_source_remove(service->timeout);
1617                 service->timeout = 0;
1618         }
1619 }
1620
1621 static void reply_pending(struct connman_service *service, int error)
1622 {
1623         remove_timeout(service);
1624
1625         if (service->pending != NULL) {
1626                 if (error > 0) {
1627                         DBusMessage *reply;
1628
1629                         reply = __connman_error_failed(service->pending,
1630                                                                 error);
1631                         if (reply != NULL)
1632                                 g_dbus_send_message(connection, reply);
1633                 } else
1634                         g_dbus_send_reply(connection, service->pending,
1635                                                         DBUS_TYPE_INVALID);
1636
1637                 dbus_message_unref(service->pending);
1638                 service->pending = NULL;
1639         }
1640 }
1641
1642 static gboolean connect_timeout(gpointer user_data)
1643 {
1644         struct connman_service *service = user_data;
1645         connman_bool_t autoconnect = FALSE;
1646
1647         DBG("service %p", service);
1648
1649         service->timeout = 0;
1650
1651         if (service->network != NULL)
1652                 __connman_network_disconnect(service->network);
1653
1654         __connman_ipconfig_disable(service->ipconfig);
1655
1656         if (service->pending != NULL) {
1657                 DBusMessage *reply;
1658
1659                 reply = __connman_error_operation_timeout(service->pending);
1660                 if (reply != NULL)
1661                         g_dbus_send_message(connection, reply);
1662
1663                 dbus_message_unref(service->pending);
1664                 service->pending = NULL;
1665         } else
1666                 autoconnect = TRUE;
1667
1668         __connman_service_indicate_state(service,
1669                                         CONNMAN_SERVICE_STATE_FAILURE);
1670
1671         if (autoconnect == TRUE && service->userconnect == FALSE)
1672                 __connman_service_auto_connect();
1673
1674         return FALSE;
1675 }
1676
1677 static void set_reconnect_state(struct connman_service *service,
1678                                                 connman_bool_t reconnect)
1679 {
1680         struct connman_device *device;
1681
1682         if (service->network == NULL)
1683                 return;
1684
1685         device = connman_network_get_device(service->network);
1686         if (device == NULL)
1687                 return;
1688
1689         __connman_device_set_reconnect(device, reconnect);
1690 }
1691
1692 static connman_bool_t get_reconnect_state(struct connman_service *service)
1693 {
1694         struct connman_device *device;
1695
1696         if (service->network == NULL)
1697                 return FALSE;
1698
1699         device = connman_network_get_device(service->network);
1700         if (device == NULL)
1701                 return FALSE;
1702
1703         return __connman_device_get_reconnect(device);
1704 }
1705
1706 struct connman_service *
1707 __connman_service_connect_type(enum connman_service_type type)
1708 {
1709         struct connman_service *service;
1710         GSequenceIter *iter;
1711         int err;
1712
1713         DBG("type %d", type);
1714
1715         /*
1716          * We go through the already sorted service list.
1717          * We pick the first one matching our type, or just
1718          * the first available one if we have no type.
1719          */
1720         iter = g_sequence_get_begin_iter(service_list);
1721         if (g_sequence_iter_is_end(iter))
1722                 return NULL;
1723         service = g_sequence_get(iter);
1724
1725         /*
1726          * If the first service is connected or about to be
1727          * connected, we return it, regardless of the type.
1728          */
1729         if ((g_sequence_iter_is_end(iter) == FALSE) &&
1730                 (is_connecting(service) == TRUE ||
1731                         is_connected(service) == TRUE))
1732                 return service;
1733
1734         while (g_sequence_iter_is_end(iter) == FALSE) {
1735                 if (service->type == type ||
1736                         type == CONNMAN_SERVICE_TYPE_UNKNOWN)
1737                         break;
1738
1739                 iter = g_sequence_iter_next(iter);
1740                 service = g_sequence_get(iter);
1741         }
1742
1743         if (g_sequence_iter_is_end(iter))
1744                 return NULL;
1745
1746         service->ignore = FALSE;
1747
1748         service->userconnect = TRUE;
1749
1750         set_reconnect_state(service, FALSE);
1751
1752         err = __connman_service_connect(service);
1753         if (err < 0) {
1754                 if (err == -ENOKEY)
1755                         if (__connman_agent_request_passphrase(service,
1756                                                                 NULL, NULL))
1757                                 return service;
1758
1759                 if (err != -EINPROGRESS)
1760                         return NULL;
1761         }
1762
1763         return service;
1764 }
1765
1766 static DBusMessage *connect_service(DBusConnection *conn,
1767                                         DBusMessage *msg, void *user_data)
1768 {
1769         struct connman_service *service = user_data;
1770         GSequenceIter *iter;
1771         int err;
1772
1773         DBG("service %p", service);
1774
1775         if (service->pending != NULL)
1776                 return __connman_error_in_progress(msg);
1777
1778         iter = g_sequence_get_begin_iter(service_list);
1779
1780         while (g_sequence_iter_is_end(iter) == FALSE) {
1781                 struct connman_service *temp = g_sequence_get(iter);
1782
1783                 if (service->type == temp->type &&
1784                                         is_connecting(temp) == TRUE)
1785                         return __connman_error_in_progress(msg);
1786
1787                 iter = g_sequence_iter_next(iter);
1788         }
1789
1790         service->ignore = FALSE;
1791
1792         service->userconnect = TRUE;
1793
1794         service->pending = dbus_message_ref(msg);
1795
1796         set_reconnect_state(service, FALSE);
1797
1798         err = __connman_service_connect(service);
1799         if (err < 0) {
1800                 if (err == -ENOKEY) {
1801                         if (__connman_agent_request_passphrase(service,
1802                                                         NULL, NULL) == 0)
1803                                 return NULL;
1804                 }
1805
1806                 if (err != -EINPROGRESS) {
1807                         dbus_message_unref(service->pending);
1808                         service->pending = NULL;
1809
1810                         return __connman_error_failed(msg, -err);
1811                 }
1812
1813                 return NULL;
1814         }
1815
1816         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1817 }
1818
1819 static DBusMessage *disconnect_service(DBusConnection *conn,
1820                                         DBusMessage *msg, void *user_data)
1821 {
1822         struct connman_service *service = user_data;
1823         int err;
1824
1825         DBG("service %p", service);
1826
1827         reply_pending(service, ECONNABORTED);
1828
1829         service->ignore = TRUE;
1830
1831         set_reconnect_state(service, FALSE);
1832
1833         err = __connman_service_disconnect(service);
1834         if (err < 0) {
1835                 if (err != -EINPROGRESS)
1836                         return __connman_error_failed(msg, -err);
1837
1838                 return NULL;
1839         }
1840
1841         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1842 }
1843
1844 static DBusMessage *remove_service(DBusConnection *conn,
1845                                         DBusMessage *msg, void *user_data)
1846 {
1847         struct connman_service *service = user_data;
1848
1849         DBG("service %p", service);
1850
1851         if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
1852                 return __connman_error_not_supported(msg);
1853
1854         if (service->immutable == TRUE)
1855                 return __connman_error_not_supported(msg);
1856
1857         if (service->favorite == FALSE &&
1858                         service->state != CONNMAN_SERVICE_STATE_FAILURE)
1859                 return __connman_error_not_supported(msg);
1860
1861         if (service->network != NULL) {
1862                 set_reconnect_state(service, FALSE);
1863
1864                 __connman_network_disconnect(service->network);
1865         }
1866
1867         g_free(service->passphrase);
1868         service->passphrase = NULL;
1869
1870         passphrase_changed(service);
1871
1872         g_free(service->apn);
1873         service->apn = NULL;
1874
1875         g_free(service->username);
1876         service->username = NULL;
1877
1878         g_free(service->password);
1879         service->password = NULL;
1880
1881         apn_changed(service);
1882
1883         set_idle(service);
1884
1885         __connman_service_set_favorite(service, FALSE);
1886         __connman_storage_save_service(service);
1887
1888         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1889 }
1890
1891 static DBusMessage *move_service(DBusConnection *conn,
1892                                         DBusMessage *msg, void *user_data,
1893                                                                 gboolean before)
1894 {
1895         struct connman_service *service = user_data;
1896         struct connman_service *target;
1897         const char *path;
1898         GSequenceIter *src, *dst;
1899
1900         DBG("service %p", service);
1901
1902         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1903                                                         DBUS_TYPE_INVALID);
1904
1905         if (service->favorite == FALSE)
1906                 return __connman_error_not_supported(msg);
1907
1908         target = find_service(path);
1909         if (target == NULL || target->favorite == FALSE || target == service)
1910                 return __connman_error_invalid_service(msg);
1911
1912         DBG("target %s", target->identifier);
1913
1914         if (target->state != service->state)
1915                 return __connman_error_invalid_service(msg);
1916
1917         g_get_current_time(&service->modified);
1918         __connman_storage_save_service(service);
1919
1920         src = g_hash_table_lookup(service_hash, service->identifier);
1921         dst = g_hash_table_lookup(service_hash, target->identifier);
1922
1923         before ? g_sequence_move(src, dst) : g_sequence_move(dst, src);
1924
1925         __connman_profile_changed(FALSE);
1926
1927         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1928 }
1929
1930 static DBusMessage *move_before(DBusConnection *conn,
1931                                         DBusMessage *msg, void *user_data)
1932 {
1933         return move_service(conn, msg, user_data, TRUE);
1934 }
1935
1936 static DBusMessage *move_after(DBusConnection *conn,
1937                                         DBusMessage *msg, void *user_data)
1938 {
1939         return move_service(conn, msg, user_data, FALSE);
1940 }
1941
1942 static DBusMessage *reset_stats(DBusConnection *conn,
1943                                         DBusMessage *msg, void *user_data)
1944 {
1945         struct connman_service *service = user_data;
1946
1947         __connman_service_reset_stats(service);
1948
1949         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1950 }
1951
1952 static GDBusMethodTable service_methods[] = {
1953         { "GetProperties", "",   "a{sv}", get_properties     },
1954         { "SetProperty",   "sv", "",      set_property       },
1955         { "ClearProperty", "s",  "",      clear_property     },
1956         { "Connect",       "",   "",      connect_service,
1957                                                 G_DBUS_METHOD_FLAG_ASYNC },
1958         { "Disconnect",    "",   "",      disconnect_service },
1959         { "Remove",        "",   "",      remove_service     },
1960         { "MoveBefore",    "o",  "",      move_before        },
1961         { "MoveAfter",     "o",  "",      move_after         },
1962         { "ResetCounters", "",   "",      reset_stats        },
1963         { },
1964 };
1965
1966 static GDBusSignalTable service_signals[] = {
1967         { "PropertyChanged", "sv" },
1968         { },
1969 };
1970
1971 static void service_free(gpointer user_data)
1972 {
1973         struct connman_service *service = user_data;
1974         char *path = service->path;
1975
1976         DBG("service %p", service);
1977
1978         reply_pending(service, ENOENT);
1979
1980         g_hash_table_remove(service_hash, service->identifier);
1981
1982         __connman_service_stats_stop(service);
1983         __connman_storage_save_service(service);
1984
1985         service->path = NULL;
1986
1987         if (path != NULL) {
1988                 __connman_profile_changed(FALSE);
1989
1990                 g_dbus_unregister_interface(connection, path,
1991                                                 CONNMAN_SERVICE_INTERFACE);
1992                 g_free(path);
1993         }
1994
1995         if (service->network != NULL)
1996                 connman_network_unref(service->network);
1997
1998         if (service->ipconfig != NULL) {
1999                 connman_ipconfig_unref(service->ipconfig);
2000                 service->ipconfig = NULL;
2001         }
2002
2003         if (service->location != NULL)
2004                 connman_location_unref(service->location);
2005
2006         g_strfreev(service->nameservers);
2007         g_strfreev(service->domains);
2008
2009         g_free(service->nameserver);
2010         g_free(service->domainname);
2011         g_free(service->mcc);
2012         g_free(service->mnc);
2013         g_free(service->apn);
2014         g_free(service->username);
2015         g_free(service->password);
2016         g_free(service->profile);
2017         g_free(service->name);
2018         g_free(service->passphrase);
2019         g_free(service->identifier);
2020         g_free(service->eap);
2021         g_free(service->identity);
2022         g_free(service->ca_cert_file);
2023         g_free(service->client_cert_file);
2024         g_free(service->private_key_file);
2025         g_free(service->private_key_passphrase);
2026         g_free(service->phase2);
2027
2028         if (service->stats.timer != NULL)
2029                 g_timer_destroy(service->stats.timer);
2030
2031         g_free(service);
2032 }
2033
2034 /**
2035  * __connman_service_put:
2036  * @service: service structure
2037  *
2038  * Release service if no longer needed
2039  */
2040 void __connman_service_put(struct connman_service *service)
2041 {
2042         DBG("service %p", service);
2043
2044         if (g_atomic_int_dec_and_test(&service->refcount) == TRUE) {
2045                 GSequenceIter *iter;
2046
2047                 iter = g_hash_table_lookup(service_hash, service->identifier);
2048                 if (iter != NULL) {
2049                         reply_pending(service, ECONNABORTED);
2050
2051                         __connman_service_disconnect(service);
2052
2053                         g_sequence_remove(iter);
2054                 } else
2055                         service_free(service);
2056         }
2057 }
2058
2059 static void __connman_service_initialize(struct connman_service *service)
2060 {
2061         DBG("service %p", service);
2062
2063         service->refcount = 1;
2064
2065         service->type     = CONNMAN_SERVICE_TYPE_UNKNOWN;
2066         service->mode     = CONNMAN_SERVICE_MODE_UNKNOWN;
2067         service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
2068         service->state    = CONNMAN_SERVICE_STATE_UNKNOWN;
2069
2070         service->favorite  = FALSE;
2071         service->immutable = FALSE;
2072         service->hidden = FALSE;
2073
2074         service->ignore = FALSE;
2075
2076         service->userconnect = FALSE;
2077
2078         service->order = 0;
2079
2080         service->stats.valid = FALSE;
2081         service->stats.enabled = FALSE;
2082         service->stats.timer = g_timer_new();
2083 }
2084
2085 /**
2086  * connman_service_create:
2087  *
2088  * Allocate a new service.
2089  *
2090  * Returns: a newly-allocated #connman_service structure
2091  */
2092 struct connman_service *connman_service_create(void)
2093 {
2094         struct connman_service *service;
2095
2096         service = g_try_new0(struct connman_service, 1);
2097         if (service == NULL)
2098                 return NULL;
2099
2100         DBG("service %p", service);
2101
2102         __connman_service_initialize(service);
2103
2104         service->location = __connman_location_create(service);
2105
2106         return service;
2107 }
2108
2109 struct connman_location *__connman_service_get_location(struct connman_service *service)
2110 {
2111         return service->location;
2112 }
2113
2114 /**
2115  * connman_service_ref:
2116  * @service: service structure
2117  *
2118  * Increase reference counter of service
2119  */
2120 struct connman_service *connman_service_ref(struct connman_service *service)
2121 {
2122         g_atomic_int_inc(&service->refcount);
2123
2124         return service;
2125 }
2126
2127 /**
2128  * connman_service_unref:
2129  * @service: service structure
2130  *
2131  * Decrease reference counter of service
2132  */
2133 void connman_service_unref(struct connman_service *service)
2134 {
2135         __connman_service_put(service);
2136 }
2137
2138 static gint service_compare(gconstpointer a, gconstpointer b,
2139                                                         gpointer user_data)
2140 {
2141         struct connman_service *service_a = (void *) a;
2142         struct connman_service *service_b = (void *) b;
2143
2144         if (service_a->state != service_b->state) {
2145                 if (is_connected(service_a) == TRUE)
2146                         return -1;
2147                 if (is_connected(service_b) == TRUE)
2148                         return 1;
2149         }
2150
2151         if (service_a->order > service_b->order)
2152                 return -1;
2153
2154         if (service_a->order < service_b->order)
2155                 return 1;
2156
2157         if (service_a->favorite == TRUE && service_b->favorite == FALSE)
2158                 return -1;
2159
2160         if (service_a->favorite == FALSE && service_b->favorite == TRUE)
2161                 return 1;
2162
2163         if (service_a->type != service_b->type) {
2164                 switch (service_a->type) {
2165                 case CONNMAN_SERVICE_TYPE_UNKNOWN:
2166                 case CONNMAN_SERVICE_TYPE_SYSTEM:
2167                 case CONNMAN_SERVICE_TYPE_ETHERNET:
2168                 case CONNMAN_SERVICE_TYPE_GPS:
2169                 case CONNMAN_SERVICE_TYPE_VPN:
2170                         break;
2171                 case CONNMAN_SERVICE_TYPE_WIFI:
2172                         return 1;
2173                 case CONNMAN_SERVICE_TYPE_WIMAX:
2174                 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2175                 case CONNMAN_SERVICE_TYPE_CELLULAR:
2176                         return -1;
2177                 }
2178         }
2179
2180         return (gint) service_b->strength - (gint) service_a->strength;
2181 }
2182
2183 /**
2184  * connman_service_get_type:
2185  * @service: service structure
2186  *
2187  * Get the type of service
2188  */
2189 enum connman_service_type connman_service_get_type(struct connman_service *service)
2190 {
2191         if (service == NULL)
2192                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
2193
2194         return service->type;
2195 }
2196
2197 /**
2198  * connman_service_get_interface:
2199  * @service: service structure
2200  *
2201  * Get network interface of service
2202  */
2203 char *connman_service_get_interface(struct connman_service *service)
2204 {
2205         int index;
2206
2207         if (service == NULL)
2208                 return NULL;
2209
2210         if (service->network == NULL)
2211                 return NULL;
2212
2213         index = connman_network_get_index(service->network);
2214
2215         return connman_inet_ifname(index);
2216 }
2217
2218 /**
2219  * connman_service_get_network:
2220  * @service: service structure
2221  *
2222  * Get the service network
2223  */
2224 struct connman_network *
2225 __connman_service_get_network(struct connman_service *service)
2226 {
2227         if (service == NULL)
2228                 return NULL;
2229
2230         return service->network;
2231 }
2232
2233 struct connman_ipconfig *__connman_service_get_ipconfig(struct connman_service *service)
2234 {
2235         if (service == NULL)
2236                 return NULL;
2237
2238         return service->ipconfig;
2239 }
2240
2241 /**
2242  * __connman_service_set_favorite:
2243  * @service: service structure
2244  * @favorite: favorite value
2245  *
2246  * Change the favorite setting of service
2247  */
2248 int __connman_service_set_favorite(struct connman_service *service,
2249                                                 connman_bool_t favorite)
2250 {
2251         GSequenceIter *iter;
2252
2253         iter = g_hash_table_lookup(service_hash, service->identifier);
2254         if (iter == NULL)
2255                 return -ENOENT;
2256
2257         if (service->favorite == favorite)
2258                 return -EALREADY;
2259
2260         service->favorite = favorite;
2261
2262         favorite_changed(service);
2263
2264         g_sequence_sort_changed(iter, service_compare, NULL);
2265
2266         __connman_profile_changed(FALSE);
2267
2268         return 0;
2269 }
2270
2271 int __connman_service_set_immutable(struct connman_service *service,
2272                                                 connman_bool_t immutable)
2273 {
2274         service->immutable = immutable;
2275
2276         immutable_changed(service);
2277
2278         return 0;
2279 }
2280
2281 void __connman_service_set_string(struct connman_service *service,
2282                                   const char *key, const char *value)
2283 {
2284         if (g_str_equal(key, "EAP") == TRUE) {
2285                 g_free(service->eap);
2286                 service->eap = g_strdup(value);
2287         } else if (g_str_equal(key, "Identity") == TRUE) {
2288                 g_free(service->identity);
2289                 service->identity = g_strdup(value);
2290         } else if (g_str_equal(key, "CACertFile") == TRUE) {
2291                 g_free(service->ca_cert_file);
2292                 service->ca_cert_file = g_strdup(value);
2293         } else if (g_str_equal(key, "ClientCertFile") == TRUE) {
2294                 g_free(service->client_cert_file);
2295                 service->client_cert_file = g_strdup(value);
2296         } else if (g_str_equal(key, "PrivateKeyFile") == TRUE) {
2297                 g_free(service->private_key_file);
2298                 service->private_key_file = g_strdup(value);
2299         } else if (g_str_equal(key, "PrivateKeyPassphrase") == TRUE) {
2300                 g_free(service->private_key_passphrase);
2301                 service->private_key_passphrase = g_strdup(value);
2302         } else if (g_str_equal(key, "Phase2") == TRUE) {
2303                 g_free(service->phase2);
2304                 service->phase2 = g_strdup(value);
2305         } else if (g_str_equal(key, "Passphrase") == TRUE) {
2306                 g_free(service->passphrase);
2307                 service->passphrase = g_strdup(value);
2308         }
2309 }
2310
2311 int __connman_service_indicate_state(struct connman_service *service,
2312                                         enum connman_service_state state)
2313 {
2314         GSequenceIter *iter;
2315
2316         DBG("service %p state %d", service, state);
2317
2318         if (service == NULL)
2319                 return -EINVAL;
2320
2321         if (service->state == state)
2322                 return -EALREADY;
2323
2324         if (service->state == CONNMAN_SERVICE_STATE_FAILURE &&
2325                                 state == CONNMAN_SERVICE_STATE_IDLE)
2326                 return -EINVAL;
2327
2328         if (service->state == CONNMAN_SERVICE_STATE_IDLE &&
2329                                 state == CONNMAN_SERVICE_STATE_DISCONNECT)
2330                 return -EINVAL;
2331
2332         if (state == CONNMAN_SERVICE_STATE_IDLE &&
2333                         service->state != CONNMAN_SERVICE_STATE_DISCONNECT) {
2334                 service->state = CONNMAN_SERVICE_STATE_DISCONNECT;
2335                 state_changed(service);
2336
2337                 reply_pending(service, ECONNABORTED);
2338
2339                 __connman_service_disconnect(service);
2340         }
2341
2342         if (state == CONNMAN_SERVICE_STATE_CONFIGURATION)
2343                 __connman_ipconfig_enable(service->ipconfig);
2344
2345         service->state = state;
2346         state_changed(service);
2347
2348         if (state == CONNMAN_SERVICE_STATE_ONLINE) {
2349                 if (service->login_required == TRUE) {
2350                         service->login_required = FALSE;
2351                         login_changed(service);
2352                 }
2353
2354                 connman_timeserver_sync();
2355         }
2356
2357         if (state == CONNMAN_SERVICE_STATE_IDLE) {
2358                 connman_bool_t reconnect;
2359
2360                 reconnect = get_reconnect_state(service);
2361                 if (reconnect == TRUE)
2362                         __connman_service_auto_connect();
2363         }
2364
2365         if (state == CONNMAN_SERVICE_STATE_READY) {
2366                 set_reconnect_state(service, TRUE);
2367
2368                 __connman_service_set_favorite(service, TRUE);
2369
2370                 reply_pending(service, 0);
2371
2372                 service->userconnect = FALSE;
2373
2374                 g_get_current_time(&service->modified);
2375                 __connman_storage_save_service(service);
2376
2377                 update_nameservers(service);
2378                 dns_changed(service);
2379
2380                 __connman_wpad_start(service);
2381
2382                 __connman_notifier_connect(service->type);
2383
2384                 default_changed();
2385         } else if (state == CONNMAN_SERVICE_STATE_DISCONNECT) {
2386                 __connman_location_finish(service);
2387
2388                 default_changed();
2389
2390                 __connman_wpad_stop(service);
2391
2392                 update_nameservers(service);
2393                 dns_changed(service);
2394
2395                 __connman_notifier_disconnect(service->type);
2396         }
2397
2398         if (state == CONNMAN_SERVICE_STATE_FAILURE) {
2399                 reply_pending(service, EIO);
2400
2401                 if (service->userconnect == FALSE)
2402                         __connman_service_auto_connect();
2403
2404                 g_get_current_time(&service->modified);
2405                 __connman_storage_save_service(service);
2406         } else
2407                 service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
2408
2409         iter = g_hash_table_lookup(service_hash, service->identifier);
2410         if (iter != NULL)
2411                 g_sequence_sort_changed(iter, service_compare, NULL);
2412
2413         __connman_profile_changed(FALSE);
2414
2415         if (service->state == CONNMAN_SERVICE_STATE_IDLE ||
2416                         service->state == CONNMAN_SERVICE_STATE_FAILURE)
2417                 __connman_element_request_scan(CONNMAN_ELEMENT_TYPE_UNKNOWN);
2418
2419         return 0;
2420 }
2421
2422 int __connman_service_indicate_error(struct connman_service *service,
2423                                         enum connman_service_error error)
2424 {
2425         DBG("service %p error %d", service, error);
2426
2427         if (service == NULL)
2428                 return -EINVAL;
2429
2430         service->error = error;
2431
2432         return __connman_service_indicate_state(service,
2433                                         CONNMAN_SERVICE_STATE_FAILURE);
2434 }
2435
2436 int __connman_service_indicate_default(struct connman_service *service)
2437 {
2438         DBG("service %p", service);
2439
2440         default_changed();
2441
2442         __connman_location_detect(service);
2443
2444         return 0;
2445 }
2446
2447 int __connman_service_request_login(struct connman_service *service)
2448 {
2449         DBG("service %p", service);
2450
2451         if (service == NULL)
2452                 return -EINVAL;
2453
2454         service->login_required = TRUE;
2455         login_changed(service);
2456
2457         return 0;
2458 }
2459
2460 static connman_bool_t prepare_network(struct connman_service *service)
2461 {
2462         enum connman_network_type type;
2463         unsigned int ssid_len;
2464
2465         type = connman_network_get_type(service->network);
2466
2467         switch (type) {
2468         case CONNMAN_NETWORK_TYPE_UNKNOWN:
2469         case CONNMAN_NETWORK_TYPE_VENDOR:
2470                 return FALSE;
2471         case CONNMAN_NETWORK_TYPE_WIFI:
2472                 if (connman_network_get_blob(service->network, "WiFi.SSID",
2473                                                         &ssid_len) == NULL)
2474                         return FALSE;
2475
2476                 connman_network_set_string(service->network,
2477                                 "WiFi.Passphrase", service->passphrase);
2478                 break;
2479         case CONNMAN_NETWORK_TYPE_ETHERNET:
2480         case CONNMAN_NETWORK_TYPE_WIMAX:
2481         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
2482         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
2483                 break;
2484         case CONNMAN_NETWORK_TYPE_CELLULAR:
2485                 connman_network_set_string(service->network,
2486                                                 "Cellular.APN", service->apn);
2487
2488                 connman_network_set_string(service->network,
2489                                         "Cellular.Username", service->username);
2490                 connman_network_set_string(service->network,
2491                                         "Cellular.Password", service->password);
2492                 break;
2493         }
2494
2495         return TRUE;
2496 }
2497
2498 static void prepare_8021x(struct connman_service *service)
2499 {
2500         if (service->eap != NULL)
2501                 connman_network_set_string(service->network, "WiFi.EAP",
2502                                                                 service->eap);
2503
2504         if (service->identity != NULL)
2505                 connman_network_set_string(service->network, "WiFi.Identity",
2506                                                         service->identity);
2507
2508         if (service->ca_cert_file != NULL)
2509                 connman_network_set_string(service->network, "WiFi.CACertFile",
2510                                                         service->ca_cert_file);
2511
2512         if (service->client_cert_file != NULL)
2513                 connman_network_set_string(service->network,
2514                                                 "WiFi.ClientCertFile",
2515                                                 service->client_cert_file);
2516
2517         if (service->private_key_file != NULL)
2518                 connman_network_set_string(service->network,
2519                                                 "WiFi.PrivateKeyFile",
2520                                                 service->private_key_file);
2521
2522         if (service->private_key_passphrase != NULL)
2523                 connman_network_set_string(service->network,
2524                                         "WiFi.PrivateKeyPassphrase",
2525                                         service->private_key_passphrase);
2526
2527         if (service->phase2 != NULL)
2528                 connman_network_set_string(service->network, "WiFi.Phase2",
2529                                                         service->phase2);
2530 }
2531
2532 int __connman_service_connect(struct connman_service *service)
2533 {
2534         int err;
2535
2536         DBG("service %p", service);
2537
2538         if (is_connected(service) == TRUE)
2539                 return -EISCONN;
2540
2541         if (is_connecting(service) == TRUE)
2542                 return -EALREADY;
2543
2544         switch (service->type) {
2545         case CONNMAN_SERVICE_TYPE_UNKNOWN:
2546         case CONNMAN_SERVICE_TYPE_SYSTEM:
2547         case CONNMAN_SERVICE_TYPE_GPS:
2548         case CONNMAN_SERVICE_TYPE_VPN:
2549                 return -EINVAL;
2550         case CONNMAN_SERVICE_TYPE_ETHERNET:
2551         case CONNMAN_SERVICE_TYPE_WIMAX:
2552         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2553                 break;
2554         case CONNMAN_SERVICE_TYPE_CELLULAR:
2555                 if (service->apn == NULL)
2556                         return -EINVAL;
2557                 break;
2558         case CONNMAN_SERVICE_TYPE_WIFI:
2559                 switch (service->security) {
2560                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
2561                 case CONNMAN_SERVICE_SECURITY_NONE:
2562                         break;
2563                 case CONNMAN_SERVICE_SECURITY_WEP:
2564                 case CONNMAN_SERVICE_SECURITY_PSK:
2565                 case CONNMAN_SERVICE_SECURITY_WPA:
2566                 case CONNMAN_SERVICE_SECURITY_RSN:
2567                         if (service->passphrase == NULL)
2568                                 return -ENOKEY;
2569                         break;
2570                 case CONNMAN_SERVICE_SECURITY_8021X:
2571                         break;
2572                 }
2573                 break;
2574         }
2575
2576         if (service->network != NULL) {
2577                 if (prepare_network(service) == FALSE)
2578                         return -EINVAL;
2579
2580                 switch (service->security) {
2581                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
2582                 case CONNMAN_SERVICE_SECURITY_NONE:
2583                 case CONNMAN_SERVICE_SECURITY_WEP:
2584                 case CONNMAN_SERVICE_SECURITY_PSK:
2585                 case CONNMAN_SERVICE_SECURITY_WPA:
2586                 case CONNMAN_SERVICE_SECURITY_RSN:
2587                         break;
2588                 case CONNMAN_SERVICE_SECURITY_8021X:
2589                         prepare_8021x(service);
2590                         break;
2591                 }
2592
2593                 __connman_ipconfig_enable(service->ipconfig);
2594
2595                 err = __connman_network_connect(service->network);
2596         } else
2597                 return -EOPNOTSUPP;
2598
2599         if (err < 0) {
2600                 if (err != -EINPROGRESS) {
2601                         __connman_ipconfig_disable(service->ipconfig);
2602                         return err;
2603                 }
2604
2605                 service->timeout = g_timeout_add_seconds(CONNECT_TIMEOUT,
2606                                                 connect_timeout, service);
2607
2608                 return -EINPROGRESS;
2609         }
2610
2611         return 0;
2612 }
2613
2614 int __connman_service_disconnect(struct connman_service *service)
2615 {
2616         struct connman_ipconfig *ipv6config;
2617         int err;
2618
2619         DBG("service %p", service);
2620
2621         if (service->network != NULL) {
2622                 err = __connman_network_disconnect(service->network);
2623         } else
2624                 return -EOPNOTSUPP;
2625
2626         __connman_ipconfig_clear_address(service->ipconfig);
2627
2628         ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
2629
2630         __connman_ipconfig_clear_address(ipv6config);
2631
2632         __connman_ipconfig_disable(service->ipconfig);
2633
2634         if (err < 0) {
2635                 if (err != -EINPROGRESS)
2636                         return err;
2637
2638                 return -EINPROGRESS;
2639         }
2640
2641         return 0;
2642 }
2643
2644 /**
2645  * __connman_service_lookup:
2646  * @pattern: search pattern
2647  * @path: return object path
2648  *
2649  * Look up a service path from a search pattern
2650  */
2651 int __connman_service_lookup(const char *pattern, const char **path)
2652 {
2653         GHashTableIter iter;
2654         gpointer key, value;
2655
2656         g_hash_table_iter_init(&iter, service_hash);
2657
2658         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
2659                 GSequenceIter *iter = value;
2660                 struct connman_service *service = g_sequence_get(iter);
2661
2662                 if (g_strcmp0(service->identifier, pattern) == 0 ||
2663                                 g_strcmp0(service->name, pattern) == 0) {
2664                         *path = (const char *) service->path;
2665                         return 0;
2666                 }
2667         }
2668
2669         return -ENXIO;
2670 }
2671
2672 /**
2673  * lookup_by_identifier:
2674  * @identifier: service identifier
2675  *
2676  * Look up a service by identifier (reference count will not be increased)
2677  */
2678 static struct connman_service *lookup_by_identifier(const char *identifier)
2679 {
2680         GSequenceIter *iter;
2681
2682         iter = g_hash_table_lookup(service_hash, identifier);
2683         if (iter != NULL)
2684                 return g_sequence_get(iter);
2685
2686         return NULL;
2687 }
2688
2689 static struct connman_network *create_hidden_wifi(struct connman_device *device,
2690                 const char *ssid, const char *mode, const char *security)
2691 {
2692         struct connman_network *network;
2693         char *name;
2694         int index;
2695         unsigned int i, ssid_len;
2696
2697         ssid_len = strlen(ssid);
2698         if (ssid_len < 1)
2699                 return NULL;
2700
2701         network = connman_network_create(NULL, CONNMAN_NETWORK_TYPE_WIFI);
2702         if (network == NULL)
2703                 return NULL;
2704
2705         connman_network_set_blob(network, "WiFi.SSID",
2706                                         (unsigned char *) ssid, ssid_len);
2707
2708         connman_network_set_string(network, "WiFi.Mode", mode);
2709         connman_network_set_string(network, "WiFi.Security", security);
2710
2711         name = g_try_malloc0(ssid_len + 1);
2712         if (name == NULL) {
2713                 connman_network_unref(network);
2714                 return NULL;
2715         }
2716
2717         for (i = 0; i < ssid_len; i++) {
2718                 if (g_ascii_isprint(ssid[i]))
2719                         name[i] = ssid[i];
2720                 else
2721                         name[i] = ' ';
2722         }
2723
2724         connman_network_set_name(network, name);
2725
2726         g_free(name);
2727
2728         index = connman_device_get_index(device);
2729         connman_network_set_index(network, index);
2730
2731         connman_network_set_protocol(network, CONNMAN_NETWORK_PROTOCOL_IP);
2732
2733         if (connman_device_add_network(device, network) < 0) {
2734                 connman_network_unref(network);
2735                 return NULL;
2736         }
2737
2738         connman_network_set_available(network, TRUE);
2739
2740         return network;
2741 }
2742
2743 int __connman_service_create_and_connect(DBusMessage *msg)
2744 {
2745         struct connman_service *service;
2746         struct connman_network *network;
2747         struct connman_device *device;
2748         DBusMessageIter iter, array;
2749         const char *mode = "managed", *security = "none", *group_security;
2750         const char *type = NULL, *ssid = NULL, *passphrase = NULL;
2751         unsigned int ssid_len = 0;
2752         const char *ident;
2753         char *name, *group;
2754         gboolean created = FALSE;
2755         int err;
2756
2757         dbus_message_iter_init(msg, &iter);
2758         dbus_message_iter_recurse(&iter, &array);
2759
2760         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
2761                 DBusMessageIter entry, value;
2762                 const char *key;
2763
2764                 dbus_message_iter_recurse(&array, &entry);
2765                 dbus_message_iter_get_basic(&entry, &key);
2766
2767                 dbus_message_iter_next(&entry);
2768                 dbus_message_iter_recurse(&entry, &value);
2769
2770                 switch (dbus_message_iter_get_arg_type(&value)) {
2771                 case DBUS_TYPE_STRING:
2772                         if (g_str_equal(key, "Type") == TRUE)
2773                                 dbus_message_iter_get_basic(&value, &type);
2774                         else if (g_str_equal(key, "WiFi.Mode") == TRUE ||
2775                                         g_str_equal(key, "Mode") == TRUE)
2776                                 dbus_message_iter_get_basic(&value, &mode);
2777                         else if (g_str_equal(key, "WiFi.Security") == TRUE ||
2778                                         g_str_equal(key, "Security") == TRUE)
2779                                 dbus_message_iter_get_basic(&value, &security);
2780                         else if (g_str_equal(key, "WiFi.Passphrase") == TRUE ||
2781                                         g_str_equal(key, "Passphrase") == TRUE)
2782                                 dbus_message_iter_get_basic(&value, &passphrase);
2783                         else if (g_str_equal(key, "WiFi.SSID") == TRUE ||
2784                                         g_str_equal(key, "SSID") == TRUE)
2785                                 dbus_message_iter_get_basic(&value, &ssid);
2786                 }
2787
2788                 dbus_message_iter_next(&array);
2789         }
2790
2791         if (type == NULL)
2792                 return -EINVAL;
2793
2794         if (g_strcmp0(type, "wifi") != 0 || g_strcmp0(mode, "managed") != 0)
2795                 return -EOPNOTSUPP;
2796
2797         if (ssid == NULL)
2798                 return -EINVAL;
2799
2800         ssid_len = strlen(ssid);
2801         if (ssid_len < 1)
2802                 return -EINVAL;
2803
2804         if (g_strcmp0(security, "none") != 0 &&
2805                                 g_strcmp0(security, "wep") != 0 &&
2806                                 g_strcmp0(security, "psk") != 0 &&
2807                                 g_strcmp0(security, "wpa") != 0 &&
2808                                 g_strcmp0(security, "rsn") != 0 &&
2809                                 g_strcmp0(security, "ieee8021x") != 0)
2810                 return -EINVAL;
2811
2812         device = __connman_element_find_device(CONNMAN_DEVICE_TYPE_WIFI);
2813         if (device == NULL)
2814                 return -EOPNOTSUPP;
2815
2816         ident = __connman_device_get_ident(device);
2817         if (ident == NULL)
2818                 return -EOPNOTSUPP;
2819
2820
2821         if (!g_strcmp0(security, "wpa") ||
2822                 !g_strcmp0(security, "rsn"))
2823                 group_security = "psk";
2824         else
2825                 group_security = security;
2826
2827         group = connman_wifi_build_group_name((unsigned char *) ssid,
2828                                                 ssid_len, mode, group_security);
2829         if (group == NULL)
2830                 return -EINVAL;
2831
2832         name = g_strdup_printf("%s_%s_%s", type, ident, group);
2833
2834         service = lookup_by_identifier(name);
2835
2836         if (service != NULL)
2837                 goto done;
2838
2839         network = create_hidden_wifi(device, ssid, mode, security);
2840         if (network != NULL) {
2841                 connman_network_set_group(network, group);
2842                 created = TRUE;
2843         }
2844
2845         service = lookup_by_identifier(name);
2846
2847 done:
2848         g_free(name);
2849         g_free(group);
2850
2851         if (service == NULL) {
2852                 err = -EOPNOTSUPP;
2853                 goto failed;
2854         }
2855
2856         set_reconnect_state(service, FALSE);
2857
2858         __connman_device_disconnect(device);
2859
2860         if (passphrase != NULL) {
2861                 g_free(service->passphrase);
2862                 service->passphrase = g_strdup(passphrase);
2863         }
2864
2865         service->userconnect = TRUE;
2866
2867         err = __connman_service_connect(service);
2868         if (err < 0 && err != -EINPROGRESS)
2869                 goto failed;
2870
2871         g_dbus_send_reply(connection, msg,
2872                                 DBUS_TYPE_OBJECT_PATH, &service->path,
2873                                                         DBUS_TYPE_INVALID);
2874
2875         return 0;
2876
2877 failed:
2878         if (service != NULL && created == TRUE) {
2879                 struct connman_network *network = service->network;
2880
2881                 if (network != NULL) {
2882                         connman_network_set_available(network, FALSE);
2883                         __connman_device_cleanup_networks(device);
2884                 } else
2885                         __connman_service_put(service);
2886         }
2887
2888         return err;
2889 }
2890
2891 /**
2892  * __connman_service_get:
2893  * @identifier: service identifier
2894  *
2895  * Look up a service by identifier or create a new one if not found
2896  */
2897 static struct connman_service *__connman_service_get(const char *identifier)
2898 {
2899         struct connman_service *service;
2900         GSequenceIter *iter;
2901
2902         iter = g_hash_table_lookup(service_hash, identifier);
2903         if (iter != NULL) {
2904                 service = g_sequence_get(iter);
2905                 if (service != NULL)
2906                         g_atomic_int_inc(&service->refcount);
2907                 return service;
2908         }
2909
2910         service = connman_service_create();
2911         if (service == NULL)
2912                 return NULL;
2913
2914         DBG("service %p", service);
2915
2916         service->identifier = g_strdup(identifier);
2917
2918         service->profile = g_strdup(__connman_profile_active_ident());
2919
2920         iter = g_sequence_insert_sorted(service_list, service,
2921                                                 service_compare, NULL);
2922
2923         g_hash_table_insert(service_hash, service->identifier, iter);
2924
2925         return service;
2926 }
2927
2928 static int service_register(struct connman_service *service)
2929 {
2930         const char *path = __connman_profile_active_path();
2931         GSequenceIter *iter;
2932
2933         DBG("service %p", service);
2934
2935         if (service->path != NULL)
2936                 return -EALREADY;
2937
2938         service->path = g_strdup_printf("%s/%s", path, service->identifier);
2939
2940         DBG("path %s", service->path);
2941
2942         __connman_config_provision_service(service);
2943
2944         __connman_storage_load_service(service);
2945
2946         g_dbus_register_interface(connection, service->path,
2947                                         CONNMAN_SERVICE_INTERFACE,
2948                                         service_methods, service_signals,
2949                                                         NULL, service, NULL);
2950
2951         iter = g_hash_table_lookup(service_hash, service->identifier);
2952         if (iter != NULL)
2953                 g_sequence_sort_changed(iter, service_compare, NULL);
2954
2955         __connman_profile_changed(TRUE);
2956
2957         return 0;
2958 }
2959
2960 static void service_up(struct connman_ipconfig *ipconfig)
2961 {
2962         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
2963
2964         connman_info("%s up", connman_ipconfig_get_ifname(ipconfig));
2965
2966         service->stats.valid = FALSE;
2967 }
2968
2969 static void service_down(struct connman_ipconfig *ipconfig)
2970 {
2971         connman_info("%s down", connman_ipconfig_get_ifname(ipconfig));
2972 }
2973
2974 static void service_lower_up(struct connman_ipconfig *ipconfig)
2975 {
2976         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
2977
2978         connman_info("%s lower up", connman_ipconfig_get_ifname(ipconfig));
2979
2980         __connman_service_stats_start(service);
2981 }
2982
2983 static void service_lower_down(struct connman_ipconfig *ipconfig)
2984 {
2985         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
2986
2987         connman_info("%s lower down", connman_ipconfig_get_ifname(ipconfig));
2988
2989         __connman_service_stats_stop(service);
2990         __connman_storage_save_service(service);
2991 }
2992
2993 static void service_ip_bound(struct connman_ipconfig *ipconfig)
2994 {
2995         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
2996
2997         connman_info("%s ip bound", connman_ipconfig_get_ifname(ipconfig));
2998
2999         settings_changed(service);
3000 }
3001
3002 static void service_ip_release(struct connman_ipconfig *ipconfig)
3003 {
3004         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3005
3006         connman_info("%s ip release", connman_ipconfig_get_ifname(ipconfig));
3007
3008         settings_changed(service);
3009 }
3010
3011 static const struct connman_ipconfig_ops service_ops = {
3012         .up             = service_up,
3013         .down           = service_down,
3014         .lower_up       = service_lower_up,
3015         .lower_down     = service_lower_down,
3016         .ip_bound       = service_ip_bound,
3017         .ip_release     = service_ip_release,
3018 };
3019
3020 static void setup_ipconfig(struct connman_service *service, int index)
3021 {
3022         if (index < 0)
3023                 return;
3024
3025         service->ipconfig = connman_ipconfig_create(index);
3026         if (service->ipconfig == NULL)
3027                 return;
3028
3029         connman_ipconfig_set_method(service->ipconfig,
3030                                         CONNMAN_IPCONFIG_METHOD_DHCP);
3031
3032         connman_ipconfig_set_data(service->ipconfig, service);
3033
3034         connman_ipconfig_set_ops(service->ipconfig, &service_ops);
3035 }
3036
3037 void __connman_service_create_ipconfig(struct connman_service *service,
3038                                                                 int index)
3039 {
3040         struct connman_ipconfig *ipv6config;
3041         const char *ident = service->profile;
3042         GKeyFile *keyfile;
3043
3044         if (service->ipconfig != NULL)
3045                 return;
3046
3047         setup_ipconfig(service, index);
3048
3049         if (ident == NULL)
3050                 return;
3051
3052         keyfile = __connman_storage_open_profile(ident);
3053         if (keyfile == NULL)
3054                 return;
3055
3056
3057         ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
3058         if (ipv6config != NULL)
3059                 __connman_ipconfig_load(ipv6config, keyfile,
3060                                         service->identifier, "IPv6.");
3061
3062         __connman_ipconfig_load(service->ipconfig, keyfile,
3063                                         service->identifier, "IPv4.");
3064         g_key_file_free(keyfile);
3065 }
3066
3067 /**
3068  * __connman_service_lookup_from_network:
3069  * @network: network structure
3070  *
3071  * Look up a service by network (reference count will not be increased)
3072  */
3073 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
3074 {
3075         struct connman_service *service;
3076         const char *ident, *group;
3077         char *name;
3078
3079         DBG("network %p", network);
3080
3081         ident = __connman_network_get_ident(network);
3082         if (ident == NULL)
3083                 return NULL;
3084
3085         group = connman_network_get_group(network);
3086         if (group == NULL)
3087                 return NULL;
3088
3089         name = g_strdup_printf("%s_%s_%s",
3090                         __connman_network_get_type(network), ident, group);
3091         service = lookup_by_identifier(name);
3092         g_free(name);
3093
3094         return service;
3095 }
3096
3097 const char *__connman_service_get_path(struct connman_service *service)
3098 {
3099         return service->path;
3100 }
3101
3102 unsigned int __connman_service_get_order(struct connman_service *service)
3103 {
3104         GSequenceIter *iter;
3105
3106         if (service == NULL)
3107                 return 0;
3108
3109         if (service->favorite == FALSE) {
3110                 service->order = 0;
3111                 goto done;
3112         }
3113
3114         iter = g_hash_table_lookup(service_hash, service->identifier);
3115         if (iter != NULL) {
3116                 if (g_sequence_iter_get_position(iter) == 0)
3117                         service->order = 1;
3118                 else
3119                         service->order = 0;
3120         }
3121
3122 done:
3123         return service->order;
3124 }
3125
3126 static enum connman_service_type convert_network_type(struct connman_network *network)
3127 {
3128         enum connman_network_type type = connman_network_get_type(network);
3129
3130         switch (type) {
3131         case CONNMAN_NETWORK_TYPE_UNKNOWN:
3132         case CONNMAN_NETWORK_TYPE_VENDOR:
3133                 break;
3134         case CONNMAN_NETWORK_TYPE_ETHERNET:
3135                 return CONNMAN_SERVICE_TYPE_ETHERNET;
3136         case CONNMAN_NETWORK_TYPE_WIFI:
3137                 return CONNMAN_SERVICE_TYPE_WIFI;
3138         case CONNMAN_NETWORK_TYPE_WIMAX:
3139                 return CONNMAN_SERVICE_TYPE_WIMAX;
3140         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
3141         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
3142                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
3143         case CONNMAN_NETWORK_TYPE_CELLULAR:
3144                 return CONNMAN_SERVICE_TYPE_CELLULAR;
3145         }
3146
3147         return CONNMAN_SERVICE_TYPE_UNKNOWN;
3148 }
3149
3150 static enum connman_service_mode convert_wifi_mode(const char *mode)
3151 {
3152         if (mode == NULL)
3153                 return CONNMAN_SERVICE_MODE_UNKNOWN;
3154         else if (g_str_equal(mode, "managed") == TRUE)
3155                 return CONNMAN_SERVICE_MODE_MANAGED;
3156         else if (g_str_equal(mode, "adhoc") == TRUE)
3157                 return CONNMAN_SERVICE_MODE_ADHOC;
3158         else
3159                 return CONNMAN_SERVICE_MODE_UNKNOWN;
3160 }
3161
3162 static enum connman_service_security convert_wifi_security(const char *security)
3163 {
3164         if (security == NULL)
3165                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
3166         else if (g_str_equal(security, "none") == TRUE)
3167                 return CONNMAN_SERVICE_SECURITY_NONE;
3168         else if (g_str_equal(security, "wep") == TRUE)
3169                 return CONNMAN_SERVICE_SECURITY_WEP;
3170         else if (g_str_equal(security, "psk") == TRUE)
3171                 return CONNMAN_SERVICE_SECURITY_PSK;
3172         else if (g_str_equal(security, "ieee8021x") == TRUE)
3173                 return CONNMAN_SERVICE_SECURITY_8021X;
3174         else if (g_str_equal(security, "wpa") == TRUE)
3175                 return CONNMAN_SERVICE_SECURITY_WPA;
3176         else if (g_str_equal(security, "rsn") == TRUE)
3177                 return CONNMAN_SERVICE_SECURITY_RSN;
3178         else
3179                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
3180 }
3181
3182 static enum connman_service_mode convert_cellular_mode(connman_uint8_t mode)
3183 {
3184         switch (mode) {
3185         case 0:
3186         case 1:
3187                 return CONNMAN_SERVICE_MODE_GPRS;
3188         case 3:
3189                 return CONNMAN_SERVICE_MODE_EDGE;
3190         case 2:
3191         case 4:
3192         case 5:
3193         case 6:
3194                 return CONNMAN_SERVICE_MODE_UMTS;
3195         }
3196
3197         return CONNMAN_SERVICE_MODE_UNKNOWN;
3198 }
3199
3200 static void update_from_network(struct connman_service *service,
3201                                         struct connman_network *network)
3202 {
3203         connman_uint8_t strength = service->strength;
3204         GSequenceIter *iter;
3205         const char *str;
3206
3207         DBG("service %p network %p", service, network);
3208
3209         if (is_connected(service) == TRUE)
3210                 return;
3211
3212         if (is_connecting(service) == TRUE)
3213                 return;
3214
3215         str = connman_network_get_string(network, "Name");
3216         if (str != NULL) {
3217                 g_free(service->name);
3218                 service->name = g_strdup(str);
3219                 service->hidden = FALSE;
3220         } else {
3221                 g_free(service->name);
3222                 service->name = NULL;
3223                 service->hidden = TRUE;
3224         }
3225
3226         service->strength = connman_network_get_uint8(network, "Strength");
3227         service->roaming = connman_network_get_bool(network, "Roaming");
3228
3229         if (service->strength == 0) {
3230                 /*
3231                  * Filter out 0-values; it's unclear what they mean
3232                  * and they cause anomalous sorting of the priority list.
3233                  */
3234                 service->strength = strength;
3235         }
3236
3237         str = connman_network_get_string(network, "WiFi.Mode");
3238         service->mode = convert_wifi_mode(str);
3239
3240         str = connman_network_get_string(network, "WiFi.Security");
3241         service->security = convert_wifi_security(str);
3242
3243         str = connman_network_get_string(network, "Cellular.MCC");
3244         g_free(service->mcc);
3245         service->mcc = g_strdup(str);
3246
3247         str = connman_network_get_string(network, "Cellular.MNC");
3248         g_free(service->mnc);
3249         service->mnc = g_strdup(str);
3250
3251         if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR) {
3252                 connman_uint8_t value = connman_network_get_uint8(network,
3253                                                         "Cellular.Mode");
3254
3255                 service->mode = convert_cellular_mode(value);
3256         }
3257
3258         if (service->strength > strength && service->network != NULL) {
3259                 connman_network_unref(service->network);
3260                 service->network = connman_network_ref(network);
3261
3262                 strength_changed(service);
3263         }
3264
3265         if (service->network == NULL)
3266                 service->network = connman_network_ref(network);
3267
3268         iter = g_hash_table_lookup(service_hash, service->identifier);
3269         if (iter != NULL)
3270                 g_sequence_sort_changed(iter, service_compare, NULL);
3271 }
3272
3273 /**
3274  * __connman_service_create_from_network:
3275  * @network: network structure
3276  *
3277  * Look up service by network and if not found, create one
3278  */
3279 struct connman_service * __connman_service_create_from_network(struct connman_network *network)
3280 {
3281         struct connman_service *service;
3282         const char *ident, *group;
3283         char *name;
3284
3285         DBG("network %p", network);
3286
3287         ident = __connman_network_get_ident(network);
3288         if (ident == NULL)
3289                 return NULL;
3290
3291         group = connman_network_get_group(network);
3292         if (group == NULL)
3293                 return NULL;
3294
3295         name = g_strdup_printf("%s_%s_%s",
3296                         __connman_network_get_type(network), ident, group);
3297         service = __connman_service_get(name);
3298         g_free(name);
3299
3300         if (service == NULL)
3301                 return NULL;
3302
3303         if (__connman_network_get_weakness(network) == TRUE)
3304                 return service;
3305
3306         if (service->path != NULL) {
3307                 update_from_network(service, network);
3308                 __connman_profile_changed(TRUE);
3309                 return service;
3310         }
3311
3312         service->type = convert_network_type(network);
3313
3314         switch (service->type) {
3315         case CONNMAN_SERVICE_TYPE_UNKNOWN:
3316         case CONNMAN_SERVICE_TYPE_SYSTEM:
3317         case CONNMAN_SERVICE_TYPE_ETHERNET:
3318         case CONNMAN_SERVICE_TYPE_WIMAX:
3319         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
3320         case CONNMAN_SERVICE_TYPE_GPS:
3321         case CONNMAN_SERVICE_TYPE_VPN:
3322                 service->autoconnect = FALSE;
3323                 break;
3324         case CONNMAN_SERVICE_TYPE_WIFI:
3325         case CONNMAN_SERVICE_TYPE_CELLULAR:
3326                 service->autoconnect = TRUE;
3327                 break;
3328         }
3329
3330         service->state = CONNMAN_SERVICE_STATE_IDLE;
3331
3332         update_from_network(service, network);
3333
3334         setup_ipconfig(service, connman_network_get_index(network));
3335
3336         service_register(service);
3337
3338         if (service->favorite == TRUE)
3339                 __connman_service_auto_connect();
3340
3341         return service;
3342 }
3343
3344 void __connman_service_update_from_network(struct connman_network *network)
3345 {
3346         struct connman_service *service;
3347         enum connman_service_mode mode;
3348         connman_uint8_t strength, value;
3349         connman_bool_t roaming;
3350         GSequenceIter *iter;
3351         const char *name;
3352
3353         DBG("network %p", network);
3354
3355         service = __connman_service_lookup_from_network(network);
3356         if (service == NULL)
3357                 return;
3358
3359         if (service->network == NULL)
3360                 return;
3361
3362         name = connman_network_get_string(service->network, "Name");
3363         if (g_strcmp0(service->name, name) != 0) {
3364                 g_free(service->name);
3365                 service->name = g_strdup(name);
3366                 connman_dbus_property_changed_basic(service->path,
3367                                 CONNMAN_SERVICE_INTERFACE, "Name",
3368                                 DBUS_TYPE_STRING, &service->name);
3369         }
3370
3371         strength = connman_network_get_uint8(service->network, "Strength");
3372         if (strength == service->strength)
3373                 goto roaming;
3374
3375         service->strength = strength;
3376
3377         strength_changed(service);
3378
3379 roaming:
3380         roaming = connman_network_get_bool(service->network, "Roaming");
3381         if (roaming == service->roaming)
3382                 goto done;
3383
3384         service->roaming = roaming;
3385
3386         roaming_changed(service);
3387
3388         iter = g_hash_table_lookup(service_hash, service->identifier);
3389         if (iter != NULL)
3390                 g_sequence_sort_changed(iter, service_compare, NULL);
3391
3392 done:
3393         if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
3394                 return;
3395
3396         value = connman_network_get_uint8(service->network, "Cellular.Mode");
3397         mode = convert_cellular_mode(value);
3398
3399         if (mode == service->mode)
3400                 return;
3401
3402         service->mode = mode;
3403
3404         mode_changed(service);
3405 }
3406
3407 void __connman_service_remove_from_network(struct connman_network *network)
3408 {
3409         struct connman_service *service;
3410
3411         DBG("network %p", network);
3412
3413         service = __connman_service_lookup_from_network(network);
3414         if (service == NULL)
3415                 return;
3416
3417         __connman_service_put(service);
3418 }
3419
3420 /**
3421  * __connman_service_create_from_provider:
3422  * @provider: provider structure
3423  *
3424  * Look up service by provider and if not found, create one
3425  */
3426 struct connman_service *
3427 __connman_service_create_from_provider(struct connman_provider *provider)
3428 {
3429         struct connman_service *service;
3430         const char *ident, *str;
3431         char *name;
3432         int index = connman_provider_get_index(provider);
3433
3434         DBG("provider %p", provider);
3435
3436         ident = __connman_provider_get_ident(provider);
3437         if (ident == NULL)
3438                 return NULL;
3439
3440         name = g_strdup_printf("vpn_%s", ident);
3441         service = __connman_service_get(name);
3442         g_free(name);
3443
3444         if (service == NULL)
3445                 return NULL;
3446
3447         service->type = CONNMAN_SERVICE_TYPE_VPN;
3448         service->provider = provider;
3449         service->autoconnect = FALSE;
3450
3451         service->state = CONNMAN_SERVICE_STATE_IDLE;
3452
3453         str = connman_provider_get_string(provider, "Name");
3454         if (str != NULL) {
3455                 g_free(service->name);
3456                 service->name = g_strdup(str);
3457                 service->hidden = FALSE;
3458         } else {
3459                 g_free(service->name);
3460                 service->name = NULL;
3461                 service->hidden = TRUE;
3462         }
3463
3464         service->strength = 0;
3465
3466         service->ipconfig = connman_ipconfig_create(index);
3467         if (service->ipconfig == NULL)
3468                 return service;
3469
3470         connman_ipconfig_set_method(service->ipconfig,
3471                                         CONNMAN_IPCONFIG_METHOD_MANUAL);
3472
3473         connman_ipconfig_set_data(service->ipconfig, service);
3474
3475         connman_ipconfig_set_ops(service->ipconfig, &service_ops);
3476
3477         service_register(service);
3478
3479         return service;
3480 }
3481
3482 void __connman_service_stats_update(struct connman_service *service,
3483                                 unsigned int rx_packets, unsigned int tx_packets,
3484                                 unsigned int rx_bytes, unsigned int tx_bytes,
3485                                 unsigned int rx_errors, unsigned int tx_errors,
3486                                 unsigned int rx_dropped, unsigned int tx_dropped)
3487 {
3488         unsigned int seconds;
3489         struct connman_stats *stats = &service->stats;
3490
3491         DBG("service %p", service);
3492
3493         if (is_connected(service) == FALSE)
3494                 return;
3495
3496         if (stats->valid == TRUE) {
3497                 stats->rx_packets +=
3498                         rx_packets - stats->rx_packets_last;
3499                 stats->tx_packets +=
3500                         tx_packets - stats->tx_packets_last;
3501                 stats->rx_bytes +=
3502                         rx_bytes - stats->rx_bytes_last;
3503                 stats->tx_bytes +=
3504                         tx_bytes - stats->tx_bytes_last;
3505                 stats->rx_errors +=
3506                         rx_errors - stats->rx_errors_last;
3507                 stats->tx_errors +=
3508                         tx_errors - stats->tx_errors_last;
3509                 stats->rx_dropped +=
3510                         rx_dropped - stats->rx_dropped_last;
3511                 stats->tx_dropped +=
3512                         tx_dropped - stats->tx_dropped_last;
3513         } else {
3514                 stats->valid = TRUE;
3515         }
3516
3517         stats->rx_packets_last = rx_packets;
3518         stats->tx_packets_last = tx_packets;
3519         stats->rx_bytes_last = rx_bytes;
3520         stats->tx_bytes_last = tx_bytes;
3521         stats->rx_errors_last = rx_errors;
3522         stats->tx_errors_last = tx_errors;
3523         stats->rx_dropped_last = rx_dropped;
3524         stats->tx_dropped_last = tx_dropped;
3525
3526         seconds = g_timer_elapsed(stats->timer, NULL);
3527         stats->time = stats->time_start + seconds;
3528 }
3529
3530 static int service_load(struct connman_service *service)
3531 {
3532         const char *ident = service->profile;
3533         GKeyFile *keyfile;
3534         GError *error = NULL;
3535         gchar *pathname, *data = NULL;
3536         gsize length;
3537         gchar *str;
3538         connman_bool_t autoconnect;
3539         unsigned int ssid_len;
3540         int err = 0;
3541
3542         DBG("service %p", service);
3543
3544         if (ident == NULL)
3545                 return -EINVAL;
3546
3547         pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
3548         if (pathname == NULL)
3549                 return -ENOMEM;
3550
3551         keyfile = g_key_file_new();
3552
3553         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
3554                 g_free(pathname);
3555                 return -ENOENT;
3556         }
3557
3558         g_free(pathname);
3559
3560         if (g_key_file_load_from_data(keyfile, data, length,
3561                                                         0, NULL) == FALSE) {
3562                 g_free(data);
3563                 return -EILSEQ;
3564         }
3565
3566         g_free(data);
3567
3568         switch (service->type) {
3569         case CONNMAN_SERVICE_TYPE_UNKNOWN:
3570         case CONNMAN_SERVICE_TYPE_SYSTEM:
3571         case CONNMAN_SERVICE_TYPE_ETHERNET:
3572         case CONNMAN_SERVICE_TYPE_GPS:
3573         case CONNMAN_SERVICE_TYPE_VPN:
3574                 break;
3575         case CONNMAN_SERVICE_TYPE_WIFI:
3576                 if (service->name == NULL) {
3577                         gchar *name;
3578
3579                         name = g_key_file_get_string(keyfile,
3580                                         service->identifier, "Name", NULL);
3581                         if (name != NULL) {
3582                                 g_free(service->name);
3583                                 service->name = name;
3584                         }
3585
3586                         if (service->network != NULL)
3587                                 connman_network_set_name(service->network,
3588                                                                         name);
3589                 }
3590
3591                 if (service->network &&
3592                                 connman_network_get_blob(service->network,
3593                                         "WiFi.SSID", &ssid_len) == NULL) {
3594                         gchar *hex_ssid;
3595
3596                         hex_ssid = g_key_file_get_string(keyfile,
3597                                                         service->identifier,
3598                                                                 "SSID", NULL);
3599
3600                         if (hex_ssid != NULL) {
3601                                 gchar *ssid;
3602                                 unsigned int i, j = 0, hex;
3603                                 size_t hex_ssid_len = strlen(hex_ssid);
3604
3605                                 ssid = g_try_malloc0(hex_ssid_len / 2);
3606                                 if (ssid == NULL) {
3607                                         g_free(hex_ssid);
3608                                         err = -ENOMEM;
3609                                         goto done;
3610                                 }
3611
3612                                 for (i = 0; i < hex_ssid_len; i += 2) {
3613                                         sscanf(hex_ssid + i, "%02x", &hex);
3614                                         ssid[j++] = hex;
3615                                 }
3616
3617                                 connman_network_set_blob(service->network,
3618                                         "WiFi.SSID", ssid, hex_ssid_len / 2);
3619                         }
3620
3621                         g_free(hex_ssid);
3622                 }
3623                 /* fall through */
3624
3625         case CONNMAN_SERVICE_TYPE_WIMAX:
3626         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
3627         case CONNMAN_SERVICE_TYPE_CELLULAR:
3628                 service->apn = g_key_file_get_string(keyfile,
3629                                         service->identifier, "APN", NULL);
3630
3631                 service->username = g_key_file_get_string(keyfile,
3632                                         service->identifier, "Username", NULL);
3633
3634                 service->password = g_key_file_get_string(keyfile,
3635                                         service->identifier, "Password", NULL);
3636
3637                 service->favorite = g_key_file_get_boolean(keyfile,
3638                                 service->identifier, "Favorite", NULL);
3639
3640                 autoconnect = g_key_file_get_boolean(keyfile,
3641                                 service->identifier, "AutoConnect", &error);
3642                 if (error == NULL)
3643                         service->autoconnect = autoconnect;
3644                 g_clear_error(&error);
3645
3646                 str = g_key_file_get_string(keyfile,
3647                                 service->identifier, "Failure", NULL);
3648                 if (str != NULL) {
3649                         service->state = CONNMAN_SERVICE_STATE_FAILURE;
3650                         service->error = string2error(str);
3651                 }
3652                 break;
3653         }
3654
3655         str = g_key_file_get_string(keyfile,
3656                                 service->identifier, "Modified", NULL);
3657         if (str != NULL) {
3658                 g_time_val_from_iso8601(str, &service->modified);
3659                 g_free(str);
3660         }
3661
3662         str = g_key_file_get_string(keyfile,
3663                                 service->identifier, "Passphrase", NULL);
3664         if (str != NULL) {
3665                 g_free(service->passphrase);
3666                 service->passphrase = str;
3667         }
3668
3669         if (service->ipconfig != NULL) {
3670                 struct connman_ipconfig *ipv6config;
3671
3672                 ipv6config = connman_ipconfig_get_ipv6config(
3673                                                 service->ipconfig);
3674                 if (ipv6config != NULL)
3675                         __connman_ipconfig_load(ipv6config, keyfile,
3676                                         service->identifier, "IPv6.");
3677
3678                 __connman_ipconfig_load(service->ipconfig, keyfile,
3679                                         service->identifier, "IPv4.");
3680         }
3681
3682         service->nameservers = g_key_file_get_string_list(keyfile,
3683                         service->identifier, "Nameservers", &length, NULL);
3684         if (service->nameservers != NULL && length == 0) {
3685                 g_strfreev(service->nameservers);
3686                 service->nameservers = NULL;
3687         }
3688
3689         service->domains = g_key_file_get_string_list(keyfile,
3690                         service->identifier, "Domains", &length, NULL);
3691         if (service->domains != NULL && length == 0) {
3692                 g_strfreev(service->domains);
3693                 service->domains = NULL;
3694         }
3695
3696         __connman_service_stats_load(service, keyfile, service->identifier);
3697 done:
3698         g_key_file_free(keyfile);
3699
3700         return err;
3701 }
3702
3703 static int service_save(struct connman_service *service)
3704 {
3705         const char *ident = service->profile;
3706         GKeyFile *keyfile;
3707         gchar *pathname, *data = NULL;
3708         gsize length;
3709         gchar *str;
3710         int err = 0;
3711
3712         DBG("service %p", service);
3713
3714         if (ident == NULL)
3715                 return -EINVAL;
3716
3717         pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
3718         if (pathname == NULL)
3719                 return -ENOMEM;
3720
3721         keyfile = g_key_file_new();
3722
3723         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
3724                 goto update;
3725
3726         if (length > 0) {
3727                 if (g_key_file_load_from_data(keyfile, data, length,
3728                                                         0, NULL) == FALSE)
3729                         goto done;
3730         }
3731
3732         g_free(data);
3733
3734 update:
3735         if (service->name != NULL)
3736                 g_key_file_set_string(keyfile, service->identifier,
3737                                                 "Name", service->name);
3738
3739         switch (service->type) {
3740         case CONNMAN_SERVICE_TYPE_UNKNOWN:
3741         case CONNMAN_SERVICE_TYPE_SYSTEM:
3742         case CONNMAN_SERVICE_TYPE_ETHERNET:
3743         case CONNMAN_SERVICE_TYPE_GPS:
3744         case CONNMAN_SERVICE_TYPE_VPN:
3745                 break;
3746         case CONNMAN_SERVICE_TYPE_WIFI:
3747                 if (service->network) {
3748                         const unsigned char *ssid;
3749                         unsigned int ssid_len = 0;
3750
3751                         ssid = connman_network_get_blob(service->network,
3752                                                         "WiFi.SSID", &ssid_len);
3753
3754                         if (ssid != NULL && ssid_len > 0 && ssid[0] != '\0') {
3755                                 char *identifier = service->identifier;
3756                                 GString *str;
3757                                 unsigned int i;
3758
3759                                 str = g_string_sized_new(ssid_len * 2);
3760                                 if (str == NULL) {
3761                                         err = -ENOMEM;
3762                                         goto done;
3763                                 }
3764
3765                                 for (i = 0; i < ssid_len; i++)
3766                                         g_string_append_printf(str,
3767                                                         "%02x", ssid[i]);
3768
3769                                 g_key_file_set_string(keyfile, identifier,
3770                                                         "SSID", str->str);
3771
3772                                 g_string_free(str, TRUE);
3773                         }
3774                 }
3775                 /* fall through */
3776
3777         case CONNMAN_SERVICE_TYPE_WIMAX:
3778         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
3779         case CONNMAN_SERVICE_TYPE_CELLULAR:
3780                 if (service->apn != NULL)
3781                         g_key_file_set_string(keyfile, service->identifier,
3782                                                         "APN", service->apn);
3783
3784                 if (service->username != NULL)
3785                         g_key_file_set_string(keyfile, service->identifier,
3786                                                 "Username", service->username);
3787
3788                 if (service->password != NULL)
3789                         g_key_file_set_string(keyfile, service->identifier,
3790                                                 "Password", service->password);
3791
3792                 g_key_file_set_boolean(keyfile, service->identifier,
3793                                         "Favorite", service->favorite);
3794
3795                 if (service->favorite == TRUE)
3796                         g_key_file_set_boolean(keyfile, service->identifier,
3797                                         "AutoConnect", service->autoconnect);
3798
3799                 if (service->state == CONNMAN_SERVICE_STATE_FAILURE) {
3800                         const char *failure = error2string(service->error);
3801                         if (failure != NULL)
3802                                 g_key_file_set_string(keyfile,
3803                                                         service->identifier,
3804                                                         "Failure", failure);
3805                 } else {
3806                         g_key_file_remove_key(keyfile, service->identifier,
3807                                                         "Failure", NULL);
3808                 }
3809                 break;
3810         }
3811
3812         str = g_time_val_to_iso8601(&service->modified);
3813         if (str != NULL) {
3814                 g_key_file_set_string(keyfile, service->identifier,
3815                                                         "Modified", str);
3816                 g_free(str);
3817         }
3818
3819         if (service->passphrase != NULL && strlen(service->passphrase) > 0)
3820                 g_key_file_set_string(keyfile, service->identifier,
3821                                         "Passphrase", service->passphrase);
3822         else
3823                 g_key_file_remove_key(keyfile, service->identifier,
3824                                                         "Passphrase", NULL);
3825
3826         if (service->ipconfig != NULL) {
3827                 struct connman_ipconfig *ipv6config;
3828
3829                 ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
3830                 if (ipv6config != NULL)
3831                         __connman_ipconfig_save(ipv6config, keyfile,
3832                                                 service->identifier, "IPv6.");
3833
3834                 __connman_ipconfig_save(service->ipconfig, keyfile,
3835                                         service->identifier, "IPv4.");
3836         }
3837
3838         if (service->nameservers != NULL) {
3839                 guint len = g_strv_length(service->nameservers);
3840
3841                 g_key_file_set_string_list(keyfile, service->identifier,
3842                                                                 "Nameservers",
3843                                 (const gchar **) service->nameservers, len);
3844         } else
3845                 g_key_file_remove_key(keyfile, service->identifier,
3846                                                         "Nameservers", NULL);
3847
3848         if (service->domains != NULL) {
3849                 guint len = g_strv_length(service->domains);
3850
3851                 g_key_file_set_string_list(keyfile, service->identifier,
3852                                                                 "Domains",
3853                                 (const gchar **) service->domains, len);
3854         } else
3855                 g_key_file_remove_key(keyfile, service->identifier,
3856                                                         "Domains", NULL);
3857
3858         __connman_service_stats_save(service, keyfile, service->identifier);
3859
3860         data = g_key_file_to_data(keyfile, &length, NULL);
3861
3862         if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
3863                 connman_error("Failed to store service information");
3864
3865 done:
3866         g_free(data);
3867
3868         g_key_file_free(keyfile);
3869
3870         g_free(pathname);
3871
3872         return err;
3873 }
3874
3875 static struct connman_storage service_storage = {
3876         .name           = "service",
3877         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
3878         .service_load   = service_load,
3879         .service_save   = service_save,
3880 };
3881
3882 int __connman_service_init(void)
3883 {
3884         DBG("");
3885
3886         connection = connman_dbus_get_connection();
3887
3888         if (connman_storage_register(&service_storage) < 0)
3889                 connman_error("Failed to register service storage");
3890
3891         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
3892                                                                 NULL, NULL);
3893
3894         service_list = g_sequence_new(service_free);
3895
3896         return 0;
3897 }
3898
3899 void __connman_service_cleanup(void)
3900 {
3901         DBG("");
3902
3903         g_sequence_free(service_list);
3904         service_list = NULL;
3905
3906         g_hash_table_destroy(service_hash);
3907         service_hash = NULL;
3908
3909         connman_storage_unregister(&service_storage);
3910
3911         dbus_connection_unref(connection);
3912 }