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 static GSList *counter_list = NULL;
  39
  40 struct connman_stats {
  41         connman_bool_t valid;
  42         connman_bool_t enabled;
  43         struct connman_stats_data data_last;
  44         struct connman_stats_data data;
  45         GTimer *timer;
  46 };
  47
  48 struct connman_stats_counter {
  49         connman_bool_t append_all;
  50         struct connman_stats stats;
  51         struct connman_stats stats_roaming;
  52 };
  53
  54 struct connman_service {
  55         gint refcount;
  56         char *identifier;
  57         char *path;
  58         enum connman_service_type type;
  59         enum connman_service_mode mode;
  60         enum connman_service_security security;
  61         enum connman_service_state state;
  62         enum connman_service_error error;
  63         connman_uint8_t strength;
  64         connman_bool_t favorite;
  65         connman_bool_t immutable;
  66         connman_bool_t hidden;
  67         connman_bool_t ignore;
  68         connman_bool_t autoconnect;
  69         connman_bool_t userconnect;
  70         GTimeVal modified;
  71         unsigned int order;
  72         char *name;
  73         char *passphrase;
  74         char *profile;
  75         char *apn;
  76         char *username;
  77         char *password;
  78         char *mcc;
  79         char *mnc;
  80         connman_bool_t roaming;
  81         connman_bool_t login_required;
  82         struct connman_ipconfig *ipconfig_ipv4;
  83         struct connman_ipconfig *ipconfig_ipv6;
  84         struct connman_network *network;
  85         struct connman_provider *provider;
  86         char **nameservers;
  87         char *nameserver;
  88         char **domains;
  89         char *domainname;
  90         /* 802.1x settings from the config files */
  91         char *eap;
  92         char *identity;
  93         char *ca_cert_file;
  94         char *client_cert_file;
  95         char *private_key_file;
  96         char *private_key_passphrase;
  97         char *phase2;
  98         DBusMessage *pending;
  99         guint timeout;
 100         struct connman_location *location;
 101         struct connman_stats stats;
 102         struct connman_stats stats_roaming;
 103         GHashTable *counter_table;
 104         enum connman_service_proxy_method proxy;
 105         enum connman_service_proxy_method proxy_config;
 106         char **proxies;
 107         char **excludes;
 108         char *pac;
 109 };
 110
 111 static void append_path(gpointer value, gpointer user_data)
 112 {
 113         struct connman_service *service = value;
 114         DBusMessageIter *iter = user_data;
 115
 116         if (service->path == NULL || service->hidden == TRUE)
 117                 return;
 118
 119         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
 120                                                         &service->path);
 121 }
 122
 123 void __connman_service_list(DBusMessageIter *iter, void *user_data)
 124 {
 125         g_sequence_foreach(service_list, append_path, iter);
 126 }
 127
 128 struct find_data {
 129         const char *path;
 130         struct connman_service *service;
 131 };
 132
 133 static void compare_path(gpointer value, gpointer user_data)
 134 {
 135         struct connman_service *service = value;
 136         struct find_data *data = user_data;
 137
 138         if (data->service != NULL)
 139                 return;
 140
 141         if (g_strcmp0(service->path, data->path) == 0)
 142                 data->service = service;
 143 }
 144
 145 static struct connman_service *find_service(const char *path)
 146 {
 147         struct find_data data = { .path = path, .service = NULL };
 148
 149         DBG("path %s", path);
 150
 151         g_sequence_foreach(service_list, compare_path, &data);
 152
 153         return data.service;
 154 }
 155
 156 const char *__connman_service_type2string(enum connman_service_type type)
 157 {
 158         switch (type) {
 159         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 160                 break;
 161         case CONNMAN_SERVICE_TYPE_SYSTEM:
 162                 return "system";
 163         case CONNMAN_SERVICE_TYPE_ETHERNET:
 164                 return "ethernet";
 165         case CONNMAN_SERVICE_TYPE_WIFI:
 166                 return "wifi";
 167         case CONNMAN_SERVICE_TYPE_WIMAX:
 168                 return "wimax";
 169         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 170                 return "bluetooth";
 171         case CONNMAN_SERVICE_TYPE_CELLULAR:
 172                 return "cellular";
 173         case CONNMAN_SERVICE_TYPE_GPS:
 174                 return "gps";
 175         case CONNMAN_SERVICE_TYPE_VPN:
 176                 return "vpn";
 177         case CONNMAN_SERVICE_TYPE_GADGET:
 178                 return "gadget";
 179         }
 180
 181         return NULL;
 182 }
 183
 184 static const char *mode2string(enum connman_service_mode mode)
 185 {
 186         switch (mode) {
 187         case CONNMAN_SERVICE_MODE_UNKNOWN:
 188                 break;
 189         case CONNMAN_SERVICE_MODE_MANAGED:
 190                 return "managed";
 191         case CONNMAN_SERVICE_MODE_ADHOC:
 192                 return "adhoc";
 193         case CONNMAN_SERVICE_MODE_GPRS:
 194                 return "gprs";
 195         case CONNMAN_SERVICE_MODE_EDGE:
 196                 return "edge";
 197         case CONNMAN_SERVICE_MODE_UMTS:
 198                 return "umts";
 199         }
 200
 201         return NULL;
 202 }
 203
 204 static const char *security2string(enum connman_service_security security)
 205 {
 206         switch (security) {
 207         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 208                 break;
 209         case CONNMAN_SERVICE_SECURITY_NONE:
 210                 return "none";
 211         case CONNMAN_SERVICE_SECURITY_WEP:
 212                 return "wep";
 213         case CONNMAN_SERVICE_SECURITY_PSK:
 214                 return "psk";
 215         case CONNMAN_SERVICE_SECURITY_8021X:
 216                 return "ieee8021x";
 217         case CONNMAN_SERVICE_SECURITY_WPA:
 218                 return "wpa";
 219         case CONNMAN_SERVICE_SECURITY_RSN:
 220                 return "rsn";
 221         }
 222
 223         return NULL;
 224 }
 225
 226 static const char *state2string(enum connman_service_state state)
 227 {
 228         switch (state) {
 229         case CONNMAN_SERVICE_STATE_UNKNOWN:
 230                 break;
 231         case CONNMAN_SERVICE_STATE_IDLE:
 232                 return "idle";
 233         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 234                 return "association";
 235         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 236                 return "configuration";
 237         case CONNMAN_SERVICE_STATE_READY:
 238                 return "ready";
 239         case CONNMAN_SERVICE_STATE_ONLINE:
 240                 return "online";
 241         case CONNMAN_SERVICE_STATE_DISCONNECT:
 242                 return "disconnect";
 243         case CONNMAN_SERVICE_STATE_FAILURE:
 244                 return "failure";
 245         }
 246
 247         return NULL;
 248 }
 249
 250 static const char *error2string(enum connman_service_error error)
 251 {
 252         switch (error) {
 253         case CONNMAN_SERVICE_ERROR_UNKNOWN:
 254                 break;
 255         case CONNMAN_SERVICE_ERROR_OUT_OF_RANGE:
 256                 return "out-of-range";
 257         case CONNMAN_SERVICE_ERROR_PIN_MISSING:
 258                 return "pin-missing";
 259         case CONNMAN_SERVICE_ERROR_DHCP_FAILED:
 260                 return "dhcp-failed";
 261         case CONNMAN_SERVICE_ERROR_CONNECT_FAILED:
 262                 return "connect-failed";
 263         }
 264
 265         return NULL;
 266 }
 267
 268 static enum connman_service_error string2error(const char *error)
 269 {
 270         if (g_strcmp0(error, "dhcp-failed") == 0)
 271                 return CONNMAN_SERVICE_ERROR_DHCP_FAILED;
 272         else if (g_strcmp0(error, "pin-missing") == 0)
 273                 return CONNMAN_SERVICE_ERROR_PIN_MISSING;
 274
 275         return CONNMAN_SERVICE_ERROR_UNKNOWN;
 276 }
 277
 278 static const char *proxymethod2string(enum connman_service_proxy_method method)
 279 {
 280         switch (method) {
 281         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
 282                 return "direct";
 283         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
 284                 return "manual";
 285         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
 286                 return "auto";
 287         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
 288                 break;
 289         }
 290
 291         return NULL;
 292 }
 293
 294 static enum connman_service_proxy_method string2proxymethod(const char *method)
 295 {
 296         if (g_strcmp0(method, "direct") == 0)
 297                 return CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
 298         else if (g_strcmp0(method, "auto") == 0)
 299                 return CONNMAN_SERVICE_PROXY_METHOD_AUTO;
 300         else if (g_strcmp0(method, "manual") == 0)
 301                 return CONNMAN_SERVICE_PROXY_METHOD_MANUAL;
 302         else
 303                 return CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
 304 }
 305
 306 static connman_bool_t is_connecting(struct connman_service *service)
 307 {
 308         switch (service->state) {
 309         case CONNMAN_SERVICE_STATE_UNKNOWN:
 310         case CONNMAN_SERVICE_STATE_IDLE:
 311         case CONNMAN_SERVICE_STATE_FAILURE:
 312                 if (service->network != NULL)
 313                         return __connman_network_get_connecting(
 314                                                         service->network);
 315         case CONNMAN_SERVICE_STATE_DISCONNECT:
 316         case CONNMAN_SERVICE_STATE_READY:
 317         case CONNMAN_SERVICE_STATE_ONLINE:
 318                 break;
 319         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 320         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 321                 return TRUE;
 322         }
 323
 324         return FALSE;
 325 }
 326
 327 static connman_bool_t is_connected(const struct connman_service *service)
 328 {
 329         switch (service->state) {
 330         case CONNMAN_SERVICE_STATE_UNKNOWN:
 331         case CONNMAN_SERVICE_STATE_IDLE:
 332         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 333         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 334         case CONNMAN_SERVICE_STATE_DISCONNECT:
 335         case CONNMAN_SERVICE_STATE_FAILURE:
 336                 break;
 337         case CONNMAN_SERVICE_STATE_READY:
 338         case CONNMAN_SERVICE_STATE_ONLINE:
 339                 return TRUE;
 340         }
 341
 342         return FALSE;
 343 }
 344
 345 static void update_nameservers(struct connman_service *service)
 346 {
 347         const char *ifname;
 348
 349         if (service->ipconfig_ipv4)
 350                 ifname = connman_ipconfig_get_ifname(service->ipconfig_ipv4);
 351         else if (service->ipconfig_ipv6)
 352                 ifname = connman_ipconfig_get_ifname(service->ipconfig_ipv6);
 353         else
 354                 ifname = NULL;
 355
 356         if (ifname == NULL)
 357                 return;
 358
 359         switch (service->state) {
 360         case CONNMAN_SERVICE_STATE_UNKNOWN:
 361         case CONNMAN_SERVICE_STATE_IDLE:
 362         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 363         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 364                 return;
 365         case CONNMAN_SERVICE_STATE_FAILURE:
 366         case CONNMAN_SERVICE_STATE_DISCONNECT:
 367                 connman_resolver_remove_all(ifname);
 368                 return;
 369         case CONNMAN_SERVICE_STATE_READY:
 370         case CONNMAN_SERVICE_STATE_ONLINE:
 371                 break;
 372         }
 373
 374         connman_resolver_remove_all(ifname);
 375
 376         if (service->nameservers != NULL) {
 377                 int i;
 378
 379                 for (i = 0; service->nameservers[i]; i++)
 380                         connman_resolver_append(ifname, NULL,
 381                                                 service->nameservers[i]);
 382         } else if (service->nameserver != NULL)
 383                 connman_resolver_append(ifname, NULL, service->nameserver);
 384
 385         if (service->domains != NULL) {
 386                 int i;
 387
 388                 for (i = 0; service->domains[i]; i++)
 389                         connman_resolver_append(ifname, service->domains[i],
 390                                                 NULL);
 391         } else if (service->domainname != NULL)
 392                 connman_resolver_append(ifname, service->domainname, NULL);
 393
 394         connman_resolver_flush();
 395 }
 396
 397 void __connman_service_append_nameserver(struct connman_service *service,
 398                                                 const char *nameserver)
 399 {
 400         DBG("service %p nameserver %s", service, nameserver);
 401
 402         if (nameserver == NULL)
 403                 return;
 404
 405         g_free(service->nameserver);
 406         service->nameserver = g_strdup(nameserver);
 407
 408         update_nameservers(service);
 409 }
 410
 411 void __connman_service_remove_nameserver(struct connman_service *service,
 412                                                 const char *nameserver)
 413 {
 414         DBG("service %p nameserver %s", service, nameserver);
 415
 416         if (nameserver == NULL)
 417                 return;
 418
 419         g_free(service->nameserver);
 420         service->nameserver = NULL;
 421
 422         update_nameservers(service);
 423 }
 424
 425 void __connman_service_nameserver_add_routes(struct connman_service *service,
 426                                                 const char *gw)
 427 {
 428         int index;
 429
 430         if (service == NULL)
 431                 return;
 432
 433         index = connman_network_get_index(service->network);
 434
 435         if (service->nameservers != NULL) {
 436                 int i;
 437
 438                 /*
 439                  * We add nameservers host routes for nameservers that
 440                  * are not on our subnet. For those who are, the subnet
 441                  * route will be installed by the time the dns proxy code
 442                  * tries to reach them. The subnet route is installed
 443                  * when setting the interface IP address.
 444                  */
 445                 for (i = 0; service->nameservers[i]; i++) {
 446                         if (connman_inet_compare_subnet(index,
 447                                                         service->nameservers[i]))
 448                                 continue;
 449
 450                         connman_inet_add_host_route(index,
 451                                                 service->nameservers[i], gw);
 452                 }
 453         } else if (service->nameserver != NULL) {
 454                 if (connman_inet_compare_subnet(index, service->nameserver))
 455                         return;
 456
 457                 connman_inet_add_host_route(index, service->nameserver, gw);
 458         }
 459 }
 460
 461 void __connman_service_nameserver_del_routes(struct connman_service *service)
 462 {
 463         int index;
 464
 465         if (service == NULL)
 466                 return;
 467
 468         index = connman_network_get_index(service->network);
 469
 470         if (service->nameservers != NULL) {
 471                 int i;
 472
 473                 for (i = 0; service->nameservers[i]; i++)
 474                         connman_inet_del_host_route(index,
 475                                                 service->nameservers[i]);
 476         } else if (service->nameserver != NULL) {
 477                 connman_inet_del_host_route(index, service->nameserver);
 478         }
 479 }
 480
 481 static struct connman_stats *stats_get(struct connman_service *service)
 482 {
 483         if (service->roaming == TRUE)
 484                 return &service->stats_roaming;
 485         else
 486                 return &service->stats;
 487 }
 488
 489 static connman_bool_t stats_enabled(struct connman_service *service)
 490 {
 491         struct connman_stats *stats = stats_get(service);
 492
 493         return stats->enabled;
 494 }
 495
 496 static void stats_start(struct connman_service *service)
 497 {
 498         struct connman_stats *stats = stats_get(service);
 499
 500         DBG("service %p", service);
 501
 502         if (stats->timer == NULL)
 503                 return;
 504
 505         stats->enabled = TRUE;
 506         stats->data_last.time = stats->data.time;
 507
 508         g_timer_start(stats->timer);
 509 }
 510
 511 static void stats_stop(struct connman_service *service)
 512 {
 513         struct connman_stats *stats = stats_get(service);
 514         unsigned int seconds;
 515
 516         DBG("service %p", service);
 517
 518         if (stats->timer == NULL)
 519                 return;
 520
 521         if (stats->enabled == FALSE)
 522                 return;
 523
 524         g_timer_stop(stats->timer);
 525
 526         seconds = g_timer_elapsed(stats->timer, NULL);
 527         stats->data.time = stats->data_last.time + seconds;
 528
 529         stats->enabled = FALSE;
 530 }
 531
 532 static void reset_stats(struct connman_service *service)
 533 {
 534         DBG("service %p", service);
 535
 536         /* home */
 537         service->stats.valid = FALSE;
 538
 539         service->stats.data.rx_packets = 0;
 540         service->stats.data.tx_packets = 0;
 541         service->stats.data.rx_bytes = 0;
 542         service->stats.data.tx_bytes = 0;
 543         service->stats.data.rx_errors = 0;
 544         service->stats.data.tx_errors = 0;
 545         service->stats.data.rx_dropped = 0;
 546         service->stats.data.tx_dropped = 0;
 547         service->stats.data.time = 0;
 548         service->stats.data_last.time = 0;
 549
 550         g_timer_reset(service->stats.timer);
 551
 552         /* roaming */
 553         service->stats_roaming.valid = FALSE;
 554
 555         service->stats_roaming.data.rx_packets = 0;
 556         service->stats_roaming.data.tx_packets = 0;
 557         service->stats_roaming.data.rx_bytes = 0;
 558         service->stats_roaming.data.tx_bytes = 0;
 559         service->stats_roaming.data.rx_errors = 0;
 560         service->stats_roaming.data.tx_errors = 0;
 561         service->stats_roaming.data.rx_dropped = 0;
 562         service->stats_roaming.data.tx_dropped = 0;
 563         service->stats_roaming.data.time = 0;
 564         service->stats_roaming.data_last.time = 0;
 565
 566         g_timer_reset(service->stats_roaming.timer);
 567 }
 568
 569 static struct connman_service *get_default(void)
 570 {
 571         struct connman_service *service;
 572         GSequenceIter *iter;
 573
 574         iter = g_sequence_get_begin_iter(service_list);
 575
 576         if (g_sequence_iter_is_end(iter) == TRUE)
 577                 return NULL;
 578
 579         service = g_sequence_get(iter);
 580
 581         if (is_connected(service) == FALSE)
 582                 return NULL;
 583
 584         return service;
 585 }
 586
 587 static void default_changed(void)
 588 {
 589         struct connman_service *service = get_default();
 590
 591         __connman_notifier_default_changed(service);
 592 }
 593
 594 const char *__connman_service_default(void)
 595 {
 596         struct connman_service *service;
 597
 598         service = get_default();
 599         if (service == NULL)
 600                 return "";
 601
 602         return __connman_service_type2string(service->type);
 603 }
 604
 605 static void mode_changed(struct connman_service *service)
 606 {
 607         const char *str;
 608
 609         str = mode2string(service->mode);
 610         if (str == NULL)
 611                 return;
 612
 613         connman_dbus_property_changed_basic(service->path,
 614                                 CONNMAN_SERVICE_INTERFACE, "Mode",
 615                                                 DBUS_TYPE_STRING, &str);
 616 }
 617
 618 static void state_changed(struct connman_service *service)
 619 {
 620         const char *str;
 621
 622         str = state2string(service->state);
 623         if (str == NULL)
 624                 return;
 625
 626         connman_dbus_property_changed_basic(service->path,
 627                                 CONNMAN_SERVICE_INTERFACE, "State",
 628                                                 DBUS_TYPE_STRING, &str);
 629 }
 630
 631 static void strength_changed(struct connman_service *service)
 632 {
 633         if (service->strength == 0)
 634                 return;
 635
 636         connman_dbus_property_changed_basic(service->path,
 637                                 CONNMAN_SERVICE_INTERFACE, "Strength",
 638                                         DBUS_TYPE_BYTE, &service->strength);
 639 }
 640
 641 static void favorite_changed(struct connman_service *service)
 642 {
 643         if (service->path == NULL)
 644                 return;
 645
 646         connman_dbus_property_changed_basic(service->path,
 647                                 CONNMAN_SERVICE_INTERFACE, "Favorite",
 648                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 649 }
 650
 651 static void immutable_changed(struct connman_service *service)
 652 {
 653         if (service->path == NULL)
 654                 return;
 655
 656         connman_dbus_property_changed_basic(service->path,
 657                                 CONNMAN_SERVICE_INTERFACE, "Immutable",
 658                                         DBUS_TYPE_BOOLEAN, &service->immutable);
 659 }
 660
 661 static void roaming_changed(struct connman_service *service)
 662 {
 663         if (service->path == NULL)
 664                 return;
 665
 666         connman_dbus_property_changed_basic(service->path,
 667                                 CONNMAN_SERVICE_INTERFACE, "Roaming",
 668                                         DBUS_TYPE_BOOLEAN, &service->roaming);
 669 }
 670
 671 static void autoconnect_changed(struct connman_service *service)
 672 {
 673         if (service->path == NULL)
 674                 return;
 675
 676         connman_dbus_property_changed_basic(service->path,
 677                                 CONNMAN_SERVICE_INTERFACE, "AutoConnect",
 678                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
 679 }
 680
 681 static void passphrase_changed(struct connman_service *service)
 682 {
 683         dbus_bool_t required;
 684
 685         switch (service->type) {
 686         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 687         case CONNMAN_SERVICE_TYPE_SYSTEM:
 688         case CONNMAN_SERVICE_TYPE_ETHERNET:
 689         case CONNMAN_SERVICE_TYPE_WIMAX:
 690         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 691         case CONNMAN_SERVICE_TYPE_CELLULAR:
 692         case CONNMAN_SERVICE_TYPE_GPS:
 693         case CONNMAN_SERVICE_TYPE_VPN:
 694         case CONNMAN_SERVICE_TYPE_GADGET:
 695                 return;
 696         case CONNMAN_SERVICE_TYPE_WIFI:
 697                 required = FALSE;
 698
 699                 switch (service->security) {
 700                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 701                 case CONNMAN_SERVICE_SECURITY_NONE:
 702                         break;
 703                 case CONNMAN_SERVICE_SECURITY_WEP:
 704                 case CONNMAN_SERVICE_SECURITY_PSK:
 705                 case CONNMAN_SERVICE_SECURITY_WPA:
 706                 case CONNMAN_SERVICE_SECURITY_RSN:
 707                         if (service->passphrase == NULL)
 708                                 required = TRUE;
 709                         break;
 710                 case CONNMAN_SERVICE_SECURITY_8021X:
 711                         break;
 712                 }
 713                 break;
 714         }
 715
 716         connman_dbus_property_changed_basic(service->path,
 717                                 CONNMAN_SERVICE_INTERFACE, "PassphraseRequired",
 718                                                 DBUS_TYPE_BOOLEAN, &required);
 719 }
 720
 721 static void login_changed(struct connman_service *service)
 722 {
 723         dbus_bool_t required = service->login_required;
 724
 725         if (service->path == NULL)
 726                 return;
 727
 728         connman_dbus_property_changed_basic(service->path,
 729                                 CONNMAN_SERVICE_INTERFACE, "LoginRequired",
 730                                                 DBUS_TYPE_BOOLEAN, &required);
 731 }
 732
 733 static void apn_changed(struct connman_service *service)
 734 {
 735         dbus_bool_t required;
 736
 737         switch (service->type) {
 738         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 739         case CONNMAN_SERVICE_TYPE_SYSTEM:
 740         case CONNMAN_SERVICE_TYPE_ETHERNET:
 741         case CONNMAN_SERVICE_TYPE_WIMAX:
 742         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 743         case CONNMAN_SERVICE_TYPE_WIFI:
 744         case CONNMAN_SERVICE_TYPE_GPS:
 745         case CONNMAN_SERVICE_TYPE_VPN:
 746         case CONNMAN_SERVICE_TYPE_GADGET:
 747                 return;
 748         case CONNMAN_SERVICE_TYPE_CELLULAR:
 749                 break;
 750         }
 751
 752         required = (service->apn == NULL) ? TRUE : FALSE;
 753
 754         connman_dbus_property_changed_basic(service->path,
 755                                 CONNMAN_SERVICE_INTERFACE, "SetupRequired",
 756                                                 DBUS_TYPE_BOOLEAN, &required);
 757 }
 758
 759 static void append_ethernet(DBusMessageIter *iter, void *user_data)
 760 {
 761         struct connman_service *service = user_data;
 762
 763         if (service->ipconfig_ipv4 != NULL)
 764                 __connman_ipconfig_append_ethernet(service->ipconfig_ipv4,
 765                                                                         iter);
 766         else if (service->ipconfig_ipv6 != NULL)
 767                 __connman_ipconfig_append_ethernet(service->ipconfig_ipv6,
 768                                                                         iter);
 769 }
 770
 771 static void append_ipv4(DBusMessageIter *iter, void *user_data)
 772 {
 773         struct connman_service *service = user_data;
 774
 775         if (is_connected(service) == FALSE)
 776                 return;
 777
 778         if (service->ipconfig_ipv4 != NULL)
 779                 __connman_ipconfig_append_ipv4(service->ipconfig_ipv4, iter);
 780 }
 781
 782 static void append_ipv6(DBusMessageIter *iter, void *user_data)
 783 {
 784         struct connman_service *service = user_data;
 785
 786         if (is_connected(service) == FALSE)
 787                 return;
 788
 789         if (service->ipconfig_ipv6 != NULL)
 790                 __connman_ipconfig_append_ipv6(service->ipconfig_ipv6, iter);
 791 }
 792
 793 static void append_ipv4config(DBusMessageIter *iter, void *user_data)
 794 {
 795         struct connman_service *service = user_data;
 796
 797         if (service->ipconfig_ipv4 != NULL)
 798                 __connman_ipconfig_append_ipv4config(service->ipconfig_ipv4,
 799                                                         iter);
 800 }
 801
 802 static void append_ipv6config(DBusMessageIter *iter, void *user_data)
 803 {
 804         struct connman_service *service = user_data;
 805
 806         if (service->ipconfig_ipv6 != NULL)
 807                 __connman_ipconfig_append_ipv6config(service->ipconfig_ipv6,
 808                                                         iter);
 809 }
 810
 811 static void append_dns(DBusMessageIter *iter, void *user_data)
 812 {
 813         struct connman_service *service = user_data;
 814
 815         if (is_connected(service) == FALSE)
 816                 return;
 817
 818         if (service->nameservers != NULL) {
 819                 int i;
 820
 821                 for (i = 0; service->nameservers[i]; i++)
 822                         dbus_message_iter_append_basic(iter,
 823                                 DBUS_TYPE_STRING, &service->nameservers[i]);
 824
 825                 return;
 826         }
 827
 828         if (service->nameserver == NULL)
 829                 return;
 830
 831         dbus_message_iter_append_basic(iter,
 832                                 DBUS_TYPE_STRING, &service->nameserver);
 833 }
 834
 835 static void append_dnsconfig(DBusMessageIter *iter, void *user_data)
 836 {
 837         struct connman_service *service = user_data;
 838         int i;
 839
 840         if (service->nameservers == NULL)
 841                 return;
 842
 843         for (i = 0; service->nameservers[i]; i++)
 844                 dbus_message_iter_append_basic(iter,
 845                                 DBUS_TYPE_STRING, &service->nameservers[i]);
 846 }
 847
 848 static void append_domain(DBusMessageIter *iter, void *user_data)
 849 {
 850         struct connman_service *service = user_data;
 851
 852         if (is_connected(service) == FALSE && is_connecting(service) == FALSE)
 853                 return;
 854
 855         if (service->domainname == NULL)
 856                 return;
 857
 858         dbus_message_iter_append_basic(iter,
 859                                 DBUS_TYPE_STRING, &service->domainname);
 860 }
 861
 862 static void append_domainconfig(DBusMessageIter *iter, void *user_data)
 863 {
 864         struct connman_service *service = user_data;
 865         int i;
 866
 867         if (service->domains == NULL)
 868                 return;
 869
 870         for (i = 0; service->domains[i]; i++)
 871                 dbus_message_iter_append_basic(iter,
 872                                 DBUS_TYPE_STRING, &service->domains[i]);
 873 }
 874
 875 static void append_proxies(DBusMessageIter *iter, void *user_data)
 876 {
 877         struct connman_service *service = user_data;
 878         int i;
 879
 880         if (service->proxies == NULL)
 881                 return;
 882
 883         for (i = 0; service->proxies[i]; i++)
 884                 dbus_message_iter_append_basic(iter,
 885                                 DBUS_TYPE_STRING, &service->proxies[i]);
 886 }
 887
 888 static void append_excludes(DBusMessageIter *iter, void *user_data)
 889 {
 890         struct connman_service *service = user_data;
 891         int i;
 892
 893         if (service->excludes == NULL)
 894                 return;
 895
 896         for (i = 0; service->excludes[i]; i++)
 897                 dbus_message_iter_append_basic(iter,
 898                                 DBUS_TYPE_STRING, &service->excludes[i]);
 899 }
 900
 901 static void append_proxy(DBusMessageIter *iter, void *user_data)
 902 {
 903         struct connman_service *service = user_data;
 904         enum connman_service_proxy_method proxy;
 905         const char *pac = NULL;
 906         const char *method = proxymethod2string(
 907                 CONNMAN_SERVICE_PROXY_METHOD_DIRECT);
 908
 909         DBG("");
 910
 911         if (is_connected(service) == FALSE)
 912                 return;
 913
 914         proxy = connman_service_get_proxy_method(service);
 915
 916         switch (proxy) {
 917         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
 918                 return;
 919         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
 920                 goto done;
 921         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
 922                 connman_dbus_dict_append_array(iter, "Servers",
 923                                         DBUS_TYPE_STRING, append_proxies,
 924                                         service);
 925
 926                 connman_dbus_dict_append_array(iter, "Excludes",
 927                                         DBUS_TYPE_STRING, append_excludes,
 928                                         service);
 929                 break;
 930         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
 931                 /* Maybe DHCP, or WPAD,  has provided an url for a pac file */
 932                 if (service->ipconfig_ipv4 != NULL)
 933                         pac = __connman_ipconfig_get_proxy_autoconfig(
 934                                 service->ipconfig_ipv4);
 935                 else if (service->ipconfig_ipv6 != NULL)
 936                         pac = __connman_ipconfig_get_proxy_autoconfig(
 937                                 service->ipconfig_ipv6);
 938
 939                 if (service->pac == NULL && pac == NULL)
 940                         goto done;
 941
 942                 if (service->pac != NULL)
 943                         pac = service->pac;
 944
 945                 connman_dbus_dict_append_basic(iter, "URL",
 946                                         DBUS_TYPE_STRING, &pac);
 947                 break;
 948         }
 949
 950         method = proxymethod2string(proxy);
 951
 952 done:
 953         connman_dbus_dict_append_basic(iter, "Method",
 954                                         DBUS_TYPE_STRING, &method);
 955 }
 956
 957 static void append_proxyconfig(DBusMessageIter *iter, void *user_data)
 958 {
 959         struct connman_service *service = user_data;
 960         const char *method;
 961
 962         if (service->proxy_config == CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN)
 963                 return;
 964
 965         switch (service->proxy_config) {
 966         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
 967                 return;
 968         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
 969                 break;
 970         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
 971                 if (service->proxies != NULL)
 972                         connman_dbus_dict_append_array(iter, "Servers",
 973                                                 DBUS_TYPE_STRING,
 974                                                 append_proxies, service);
 975
 976                 if (service->excludes != NULL)
 977                         connman_dbus_dict_append_array(iter, "Excludes",
 978                                                 DBUS_TYPE_STRING,
 979                                                 append_excludes, service);
 980                 break;
 981         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
 982                 if (service->pac != NULL)
 983                         connman_dbus_dict_append_basic(iter, "URL",
 984                                         DBUS_TYPE_STRING, &service->pac);
 985                 break;
 986         }
 987
 988         method = proxymethod2string(service->proxy_config);
 989
 990         connman_dbus_dict_append_basic(iter, "Method",
 991                                 DBUS_TYPE_STRING, &method);
 992 }
 993
 994 static void append_provider(DBusMessageIter *iter, void *user_data)
 995 {
 996         struct connman_service *service = user_data;
 997
 998         DBG("%p %p", service, service->provider);
 999
1000         if (is_connected(service) == FALSE)
1001                 return;
1002
1003         if (service->provider != NULL)
1004                 __connman_provider_append_properties(service->provider, iter);
1005 }
1006
1007
1008 static void settings_changed(struct connman_service *service)
1009 {
1010         connman_dbus_property_changed_dict(service->path,
1011                                         CONNMAN_SERVICE_INTERFACE, "IPv4",
1012                                                         append_ipv4, service);
1013
1014         connman_dbus_property_changed_dict(service->path,
1015                                         CONNMAN_SERVICE_INTERFACE, "IPv6",
1016                                                         append_ipv6, service);
1017 }
1018
1019 static void ipv4_configuration_changed(struct connman_service *service)
1020 {
1021         connman_dbus_property_changed_dict(service->path,
1022                                         CONNMAN_SERVICE_INTERFACE,
1023                                                         "IPv4.Configuration",
1024                                                         append_ipv4config,
1025                                                         service);
1026 }
1027
1028 static void ipv6_configuration_changed(struct connman_service *service)
1029 {
1030         connman_dbus_property_changed_dict(service->path,
1031                                         CONNMAN_SERVICE_INTERFACE,
1032                                                         "IPv6.Configuration",
1033                                                         append_ipv6config,
1034                                                         service);
1035 }
1036
1037 static void dns_changed(struct connman_service *service)
1038 {
1039         connman_dbus_property_changed_array(service->path,
1040                                 CONNMAN_SERVICE_INTERFACE, "Nameservers",
1041                                         DBUS_TYPE_STRING, append_dns, service);
1042 }
1043
1044 static void dns_configuration_changed(struct connman_service *service)
1045 {
1046         connman_dbus_property_changed_array(service->path,
1047                                 CONNMAN_SERVICE_INTERFACE,
1048                                 "Nameservers.Configuration",
1049                                 DBUS_TYPE_STRING, append_dnsconfig, service);
1050
1051         dns_changed(service);
1052 }
1053
1054 static void domain_changed(struct connman_service *service)
1055 {
1056         connman_dbus_property_changed_array(service->path,
1057                                 CONNMAN_SERVICE_INTERFACE, "Domains",
1058                                 DBUS_TYPE_STRING, append_domain, service);
1059 }
1060
1061 static void domain_configuration_changed(struct connman_service *service)
1062 {
1063         connman_dbus_property_changed_array(service->path,
1064                                 CONNMAN_SERVICE_INTERFACE,
1065                                 "Domains.Configuration",
1066                                 DBUS_TYPE_STRING, append_domainconfig, service);
1067 }
1068
1069 static void proxy_changed(struct connman_service *service)
1070 {
1071         connman_dbus_property_changed_dict(service->path,
1072                                         CONNMAN_SERVICE_INTERFACE, "Proxy",
1073                                                         append_proxy, service);
1074 }
1075
1076 static void proxy_configuration_changed(struct connman_service *service)
1077 {
1078         connman_dbus_property_changed_dict(service->path,
1079                         CONNMAN_SERVICE_INTERFACE, "Proxy.Configuration",
1080                                                 append_proxyconfig, service);
1081
1082         proxy_changed(service);
1083 }
1084
1085 static void link_changed(struct connman_service *service)
1086 {
1087         connman_dbus_property_changed_dict(service->path,
1088                                         CONNMAN_SERVICE_INTERFACE, "Ethernet",
1089                                                 append_ethernet, service);
1090 }
1091
1092 static void stats_append_counters(DBusMessageIter *dict,
1093                         struct connman_stats_data *stats,
1094                         struct connman_stats_data *counters,
1095                         connman_bool_t append_all)
1096 {
1097         if (counters->rx_packets != stats->rx_packets || append_all) {
1098                 counters->rx_packets = stats->rx_packets;
1099                 connman_dbus_dict_append_basic(dict, "RX.Packets",
1100                                         DBUS_TYPE_UINT32, &stats->rx_packets);
1101         }
1102
1103         if (counters->tx_packets != stats->tx_packets || append_all) {
1104                 counters->tx_packets = stats->tx_packets;
1105                 connman_dbus_dict_append_basic(dict, "TX.Packets",
1106                                         DBUS_TYPE_UINT32, &stats->tx_packets);
1107         }
1108
1109         if (counters->rx_bytes != stats->rx_bytes || append_all) {
1110                 counters->rx_bytes = stats->rx_bytes;
1111                 connman_dbus_dict_append_basic(dict, "RX.Bytes",
1112                                         DBUS_TYPE_UINT32, &stats->rx_bytes);
1113         }
1114
1115         if (counters->tx_bytes != stats->tx_bytes || append_all) {
1116                 counters->tx_bytes = stats->tx_bytes;
1117                 connman_dbus_dict_append_basic(dict, "TX.Bytes",
1118                                         DBUS_TYPE_UINT32, &stats->tx_bytes);
1119         }
1120
1121         if (counters->rx_errors != stats->rx_errors || append_all) {
1122                 counters->rx_errors = stats->rx_errors;
1123                 connman_dbus_dict_append_basic(dict, "RX.Errors",
1124                                         DBUS_TYPE_UINT32, &stats->rx_errors);
1125         }
1126
1127         if (counters->tx_errors != stats->tx_errors || append_all) {
1128                 counters->tx_errors = stats->tx_errors;
1129                 connman_dbus_dict_append_basic(dict, "TX.Errors",
1130                                         DBUS_TYPE_UINT32, &stats->tx_errors);
1131         }
1132
1133         if (counters->rx_dropped != stats->rx_dropped || append_all) {
1134                 counters->rx_dropped = stats->rx_dropped;
1135                 connman_dbus_dict_append_basic(dict, "RX.Dropped",
1136                                         DBUS_TYPE_UINT32, &stats->rx_dropped);
1137         }
1138
1139         if (counters->tx_dropped != stats->tx_dropped || append_all) {
1140                 counters->tx_dropped = stats->tx_dropped;
1141                 connman_dbus_dict_append_basic(dict, "TX.Dropped",
1142                                         DBUS_TYPE_UINT32, &stats->tx_dropped);
1143         }
1144
1145         if (counters->time != stats->time || append_all) {
1146                 counters->time = stats->time;
1147                 connman_dbus_dict_append_basic(dict, "Time",
1148                                         DBUS_TYPE_UINT32, &stats->time);
1149         }
1150 }
1151
1152 static void stats_append(struct connman_service *service,
1153                                 const char *counter,
1154                                 struct connman_stats_counter *counters,
1155                                 connman_bool_t append_all)
1156 {
1157         DBusMessageIter array, dict;
1158         DBusMessage *msg;
1159
1160         DBG("service %p counter %s", service, counter);
1161
1162         msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
1163         if (msg == NULL)
1164                 return;
1165
1166         dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH,
1167                                 &service->path, DBUS_TYPE_INVALID);
1168
1169         dbus_message_iter_init_append(msg, &array);
1170
1171         /* home counter */
1172         connman_dbus_dict_open(&array, &dict);
1173
1174         stats_append_counters(&dict, &service->stats.data,
1175                                 &counters->stats.data, append_all);
1176
1177         connman_dbus_dict_close(&array, &dict);
1178
1179         /* roaming counter */
1180         connman_dbus_dict_open(&array, &dict);
1181
1182         stats_append_counters(&dict, &service->stats_roaming.data,
1183                                 &counters->stats_roaming.data, append_all);
1184
1185         connman_dbus_dict_close(&array, &dict);
1186
1187         __connman_counter_send_usage(counter, msg);
1188 }
1189
1190 static void stats_update(struct connman_service *service,
1191                                 unsigned int rx_packets, unsigned int tx_packets,
1192                                 unsigned int rx_bytes, unsigned int tx_bytes,
1193                                 unsigned int rx_errors, unsigned int tx_errors,
1194                                 unsigned int rx_dropped, unsigned int tx_dropped)
1195 {
1196         struct connman_stats *stats = stats_get(service);
1197         struct connman_stats_data *data_last = &stats->data_last;
1198         struct connman_stats_data *data = &stats->data;
1199         unsigned int seconds;
1200
1201         DBG("service %p", service);
1202
1203         if (stats->valid == TRUE) {
1204                 data->rx_packets +=
1205                         rx_packets - data_last->rx_packets;
1206                 data->tx_packets +=
1207                         tx_packets - data_last->tx_packets;
1208                 data->rx_bytes +=
1209                         rx_bytes - data_last->rx_bytes;
1210                 data->tx_bytes +=
1211                         tx_bytes - data_last->tx_bytes;
1212                 data->rx_errors +=
1213                         rx_errors - data_last->rx_errors;
1214                 data->tx_errors +=
1215                         tx_errors - data_last->tx_errors;
1216                 data->rx_dropped +=
1217                         rx_dropped - data_last->rx_dropped;
1218                 data->tx_dropped +=
1219                         tx_dropped - data_last->tx_dropped;
1220         } else {
1221                 stats->valid = TRUE;
1222         }
1223
1224         data_last->rx_packets = rx_packets;
1225         data_last->tx_packets = tx_packets;
1226         data_last->rx_bytes = rx_bytes;
1227         data_last->tx_bytes = tx_bytes;
1228         data_last->rx_errors = rx_errors;
1229         data_last->tx_errors = tx_errors;
1230         data_last->rx_dropped = rx_dropped;
1231         data_last->tx_dropped = tx_dropped;
1232
1233         seconds = g_timer_elapsed(stats->timer, NULL);
1234         stats->data.time = stats->data_last.time + seconds;
1235 }
1236
1237 void __connman_service_notify(struct connman_service *service,
1238                         unsigned int rx_packets, unsigned int tx_packets,
1239                         unsigned int rx_bytes, unsigned int tx_bytes,
1240                         unsigned int rx_errors, unsigned int tx_errors,
1241                         unsigned int rx_dropped, unsigned int tx_dropped)
1242 {
1243         GHashTableIter iter;
1244         gpointer key, value;
1245         const char *counter;
1246         struct connman_stats_counter *counters;
1247         struct connman_stats_data *data;
1248         int err;
1249
1250         if (service == NULL)
1251                 return;
1252
1253         if (is_connected(service) == FALSE)
1254                 return;
1255
1256         stats_update(service,
1257                 rx_packets, tx_packets,
1258                 rx_bytes, tx_bytes,
1259                 rx_errors, tx_errors,
1260                 rx_dropped, tx_dropped);
1261
1262         data = &stats_get(service)->data;
1263         err = __connman_stats_update(service, service->roaming, data);
1264         if (err < 0)
1265                 connman_error("Failed to store statistics for %s",
1266                                 service->identifier);
1267
1268         g_hash_table_iter_init(&iter, service->counter_table);
1269         while (g_hash_table_iter_next(&iter, &key, &value)) {
1270                 counter = key;
1271                 counters = value;
1272
1273                 stats_append(service, counter, counters, counters->append_all);
1274                 counters->append_all = FALSE;
1275         }
1276 }
1277
1278 int __connman_service_counter_register(const char *counter)
1279 {
1280         struct connman_service *service;
1281         GSequenceIter *iter;
1282         struct connman_stats_counter *counters;
1283
1284         DBG("counter %s", counter);
1285
1286         counter_list = g_slist_append(counter_list, (gpointer)counter);
1287
1288         iter = g_sequence_get_begin_iter(service_list);
1289
1290         while (g_sequence_iter_is_end(iter) == FALSE) {
1291                 service = g_sequence_get(iter);
1292
1293                 counters = g_try_new0(struct connman_stats_counter, 1);
1294                 if (counters == NULL)
1295                         return -ENOMEM;
1296
1297                 counters->append_all = TRUE;
1298
1299                 g_hash_table_replace(service->counter_table, (gpointer)counter,
1300                                         counters);
1301
1302                 iter = g_sequence_iter_next(iter);
1303         }
1304
1305         return 0;
1306 }
1307
1308 void __connman_service_counter_unregister(const char *counter)
1309 {
1310         struct connman_service *service;
1311         GSequenceIter *iter;
1312
1313         DBG("counter %s", counter);
1314
1315         iter = g_sequence_get_begin_iter(service_list);
1316
1317         while (g_sequence_iter_is_end(iter) == FALSE) {
1318                 service = g_sequence_get(iter);
1319
1320                 g_hash_table_remove(service->counter_table, counter);
1321
1322                 iter = g_sequence_iter_next(iter);
1323         }
1324
1325         counter_list = g_slist_remove(counter_list, counter);
1326 }
1327
1328 static void append_properties(DBusMessageIter *dict, dbus_bool_t limited,
1329                                         struct connman_service *service)
1330 {
1331         dbus_bool_t required;
1332         const char *str;
1333
1334         str = __connman_service_type2string(service->type);
1335         if (str != NULL)
1336                 connman_dbus_dict_append_basic(dict, "Type",
1337                                                 DBUS_TYPE_STRING, &str);
1338
1339         str = mode2string(service->mode);
1340         if (str != NULL)
1341                 connman_dbus_dict_append_basic(dict, "Mode",
1342                                                 DBUS_TYPE_STRING, &str);
1343
1344         str = security2string(service->security);
1345         if (str != NULL)
1346                 connman_dbus_dict_append_basic(dict, "Security",
1347                                                 DBUS_TYPE_STRING, &str);
1348
1349         str = state2string(service->state);
1350         if (str != NULL)
1351                 connman_dbus_dict_append_basic(dict, "State",
1352                                                 DBUS_TYPE_STRING, &str);
1353
1354         str = error2string(service->error);
1355         if (str != NULL)
1356                 connman_dbus_dict_append_basic(dict, "Error",
1357                                                 DBUS_TYPE_STRING, &str);
1358
1359         if (service->strength > 0)
1360                 connman_dbus_dict_append_basic(dict, "Strength",
1361                                         DBUS_TYPE_BYTE, &service->strength);
1362
1363         connman_dbus_dict_append_basic(dict, "Favorite",
1364                                         DBUS_TYPE_BOOLEAN, &service->favorite);
1365
1366         connman_dbus_dict_append_basic(dict, "Immutable",
1367                                         DBUS_TYPE_BOOLEAN, &service->immutable);
1368
1369         if (service->favorite == TRUE)
1370                 connman_dbus_dict_append_basic(dict, "AutoConnect",
1371                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
1372         else
1373                 connman_dbus_dict_append_basic(dict, "AutoConnect",
1374                                         DBUS_TYPE_BOOLEAN, &service->favorite);
1375
1376         if (service->name != NULL)
1377                 connman_dbus_dict_append_basic(dict, "Name",
1378                                         DBUS_TYPE_STRING, &service->name);
1379
1380         connman_dbus_dict_append_basic(dict, "LoginRequired",
1381                                 DBUS_TYPE_BOOLEAN, &service->login_required);
1382
1383         switch (service->type) {
1384         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1385         case CONNMAN_SERVICE_TYPE_SYSTEM:
1386         case CONNMAN_SERVICE_TYPE_GPS:
1387         case CONNMAN_SERVICE_TYPE_VPN:
1388         case CONNMAN_SERVICE_TYPE_GADGET:
1389                 break;
1390         case CONNMAN_SERVICE_TYPE_CELLULAR:
1391                 connman_dbus_dict_append_basic(dict, "Roaming",
1392                                         DBUS_TYPE_BOOLEAN, &service->roaming);
1393
1394                 if (service->mcc != NULL && service->mnc != NULL) {
1395                         connman_dbus_dict_append_basic(dict, "MCC",
1396                                         DBUS_TYPE_STRING, &service->mcc);
1397                         connman_dbus_dict_append_basic(dict, "MNC",
1398                                         DBUS_TYPE_STRING, &service->mnc);
1399                 }
1400
1401                 if (service->apn != NULL) {
1402                         connman_dbus_dict_append_basic(dict, "APN",
1403                                         DBUS_TYPE_STRING, &service->apn);
1404
1405                         if (service->username != NULL)
1406                                 connman_dbus_dict_append_basic(dict,
1407                                         "Username", DBUS_TYPE_STRING,
1408                                                         &service->username);
1409
1410                         if (service->password != NULL)
1411                                 connman_dbus_dict_append_basic(dict,
1412                                         "Password", DBUS_TYPE_STRING,
1413                                                         &service->password);
1414
1415                         required = FALSE;
1416                 } else
1417                         required = TRUE;
1418
1419                 connman_dbus_dict_append_basic(dict, "SetupRequired",
1420                                                 DBUS_TYPE_BOOLEAN, &required);
1421                 connman_dbus_dict_append_dict(dict, "Ethernet",
1422                                                 append_ethernet, service);
1423                 break;
1424         case CONNMAN_SERVICE_TYPE_WIFI:
1425                 if (service->passphrase != NULL && limited == FALSE)
1426                         connman_dbus_dict_append_basic(dict, "Passphrase",
1427                                 DBUS_TYPE_STRING, &service->passphrase);
1428
1429                 required = FALSE;
1430
1431                 switch (service->security) {
1432                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
1433                 case CONNMAN_SERVICE_SECURITY_NONE:
1434                         break;
1435                 case CONNMAN_SERVICE_SECURITY_WEP:
1436                 case CONNMAN_SERVICE_SECURITY_PSK:
1437                 case CONNMAN_SERVICE_SECURITY_WPA:
1438                 case CONNMAN_SERVICE_SECURITY_RSN:
1439                         if (service->passphrase == NULL)
1440                                 required = TRUE;
1441                         break;
1442                 case CONNMAN_SERVICE_SECURITY_8021X:
1443                         break;
1444                 }
1445
1446                 connman_dbus_dict_append_basic(dict, "PassphraseRequired",
1447                                                 DBUS_TYPE_BOOLEAN, &required);
1448                 /* fall through */
1449         case CONNMAN_SERVICE_TYPE_ETHERNET:
1450         case CONNMAN_SERVICE_TYPE_WIMAX:
1451         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1452                 connman_dbus_dict_append_dict(dict, "Ethernet",
1453                                                 append_ethernet, service);
1454                 break;
1455         }
1456
1457         connman_dbus_dict_append_dict(dict, "IPv4", append_ipv4, service);
1458
1459         connman_dbus_dict_append_dict(dict, "IPv4.Configuration",
1460                                                 append_ipv4config, service);
1461
1462         connman_dbus_dict_append_dict(dict, "IPv6", append_ipv6, service);
1463
1464         connman_dbus_dict_append_dict(dict, "IPv6.Configuration",
1465                                                 append_ipv6config, service);
1466
1467         connman_dbus_dict_append_array(dict, "Nameservers",
1468                                 DBUS_TYPE_STRING, append_dns, service);
1469
1470         connman_dbus_dict_append_array(dict, "Nameservers.Configuration",
1471                                 DBUS_TYPE_STRING, append_dnsconfig, service);
1472
1473         connman_dbus_dict_append_array(dict, "Domains",
1474                                 DBUS_TYPE_STRING, append_domain, service);
1475
1476         connman_dbus_dict_append_array(dict, "Domains.Configuration",
1477                                 DBUS_TYPE_STRING, append_domainconfig, service);
1478
1479         connman_dbus_dict_append_dict(dict, "Proxy", append_proxy, service);
1480
1481         connman_dbus_dict_append_dict(dict, "Proxy.Configuration",
1482                                                 append_proxyconfig, service);
1483
1484         connman_dbus_dict_append_dict(dict, "Provider",
1485                                                 append_provider, service);
1486 }
1487
1488 static void append_struct(gpointer value, gpointer user_data)
1489 {
1490         struct connman_service *service = value;
1491         DBusMessageIter *iter = user_data;
1492         DBusMessageIter entry, dict;
1493
1494         if (service->path == NULL || service->hidden == TRUE)
1495                 return;
1496
1497         dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &entry);
1498
1499         dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
1500                                                         &service->path);
1501
1502         connman_dbus_dict_open(&entry, &dict);
1503         append_properties(&dict, TRUE, service);
1504         connman_dbus_dict_close(&entry, &dict);
1505
1506         dbus_message_iter_close_container(iter, &entry);
1507 }
1508
1509 void __connman_service_list_struct(DBusMessageIter *iter)
1510 {
1511         g_sequence_foreach(service_list, append_struct, iter);
1512 }
1513
1514 int __connman_service_get_index(struct connman_service *service)
1515 {
1516         if (service == NULL)
1517                 return -1;
1518
1519         if (service->network == NULL)
1520                 return -1;
1521
1522         return connman_network_get_index(service->network);
1523 }
1524
1525 void __connman_service_set_domainname(struct connman_service *service,
1526                                                 const char *domainname)
1527 {
1528         if (service == NULL)
1529                 return;
1530
1531         g_free(service->domainname);
1532         service->domainname = g_strdup(domainname);
1533
1534         domain_changed(service);
1535 }
1536
1537 const char *connman_service_get_domainname(struct connman_service *service)
1538 {
1539         if (service == NULL)
1540                 return NULL;
1541
1542         if (service->domains != NULL)
1543                 return service->domains[0];
1544         else
1545                 return service->domainname;
1546 }
1547
1548 const char *connman_service_get_nameserver(struct connman_service *service)
1549 {
1550         if (service == NULL)
1551                 return NULL;
1552
1553         return service->nameserver;
1554 }
1555
1556 void connman_service_set_proxy_method(struct connman_service *service,
1557                                         enum connman_service_proxy_method method)
1558 {
1559         if (service == NULL)
1560                 return;
1561
1562         service->proxy = method;
1563
1564         proxy_changed(service);
1565
1566         if (method != CONNMAN_SERVICE_PROXY_METHOD_AUTO)
1567                 __connman_notifier_proxy_changed(service);
1568 }
1569
1570 enum connman_service_proxy_method connman_service_get_proxy_method(
1571                                         struct connman_service *service)
1572 {
1573         if (service == NULL)
1574                 return CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
1575
1576         if (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN) {
1577                 if (service->proxy_config == CONNMAN_SERVICE_PROXY_METHOD_AUTO &&
1578                                 service->pac == NULL)
1579                         return service->proxy;
1580
1581                 return service->proxy_config;
1582         }
1583
1584         return service->proxy;
1585 }
1586
1587 char **connman_service_get_proxy_servers(struct connman_service *service)
1588 {
1589         return g_strdupv(service->proxies);
1590 }
1591
1592 char **connman_service_get_proxy_excludes(struct connman_service *service)
1593 {
1594         return g_strdupv(service->excludes);
1595 }
1596
1597 const char *connman_service_get_proxy_url(struct connman_service *service)
1598 {
1599         if (service == NULL)
1600                 return NULL;
1601
1602         return service->pac;
1603 }
1604
1605 void __connman_service_set_proxy_autoconfig(struct connman_service *service,
1606                                                         const char *url)
1607 {
1608         if (service == NULL)
1609                 return;
1610
1611         service->proxy = CONNMAN_SERVICE_PROXY_METHOD_AUTO;
1612
1613         if (service->ipconfig_ipv4) {
1614                 if (__connman_ipconfig_set_proxy_autoconfig(
1615                             service->ipconfig_ipv4, url) < 0)
1616                         return;
1617         } else if (service->ipconfig_ipv6) {
1618                 if (__connman_ipconfig_set_proxy_autoconfig(
1619                             service->ipconfig_ipv6, url) < 0)
1620                         return;
1621         } else
1622                 return;
1623
1624         proxy_changed(service);
1625
1626         __connman_notifier_proxy_changed(service);
1627 }
1628
1629 const char *connman_service_get_proxy_autoconfig(struct connman_service *service)
1630 {
1631         if (service == NULL)
1632                 return NULL;
1633
1634         if (service->ipconfig_ipv4)
1635                 return __connman_ipconfig_get_proxy_autoconfig(
1636                                                 service->ipconfig_ipv4);
1637         else if (service->ipconfig_ipv6)
1638                 return __connman_ipconfig_get_proxy_autoconfig(
1639                                                 service->ipconfig_ipv6);
1640         return NULL;
1641 }
1642
1643 void __connman_service_set_passphrase(struct connman_service *service,
1644                                         const char* passphrase)
1645 {
1646         if (service->immutable == TRUE)
1647                 return;
1648
1649         g_free(service->passphrase);
1650         service->passphrase = g_strdup(passphrase);
1651
1652         passphrase_changed(service);
1653
1654         if (service->network != NULL)
1655                 connman_network_set_string(service->network,
1656                                         "WiFi.Passphrase",
1657                                         service->passphrase);
1658
1659         __connman_storage_save_service(service);
1660 }
1661
1662 static DBusMessage *get_properties(DBusConnection *conn,
1663                                         DBusMessage *msg, void *user_data)
1664 {
1665         struct connman_service *service = user_data;
1666         DBusMessage *reply;
1667         DBusMessageIter array, dict;
1668
1669         DBG("service %p", service);
1670
1671         reply = dbus_message_new_method_return(msg);
1672         if (reply == NULL)
1673                 return NULL;
1674
1675         dbus_message_iter_init_append(reply, &array);
1676
1677         connman_dbus_dict_open(&array, &dict);
1678         append_properties(&dict, FALSE, service);
1679         connman_dbus_dict_close(&array, &dict);
1680
1681         return reply;
1682 }
1683
1684 static int update_proxy_configuration(struct connman_service *service,
1685                                 DBusMessageIter *array)
1686 {
1687         DBusMessageIter dict;
1688         enum connman_service_proxy_method method;
1689         GString *servers_str = NULL;
1690         GString *excludes_str = NULL;
1691         const char *url = NULL;
1692
1693         method = CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
1694
1695         dbus_message_iter_recurse(array, &dict);
1696
1697         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1698                 DBusMessageIter entry, variant;
1699                 const char *key;
1700                 int type;
1701
1702                 dbus_message_iter_recurse(&dict, &entry);
1703
1704                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
1705                         goto error;
1706
1707                 dbus_message_iter_get_basic(&entry, &key);
1708                 dbus_message_iter_next(&entry);
1709
1710                 if (dbus_message_iter_get_arg_type(&entry) !=
1711                                                         DBUS_TYPE_VARIANT)
1712                         goto error;
1713
1714                 dbus_message_iter_recurse(&entry, &variant);
1715                 type = dbus_message_iter_get_arg_type(&variant);
1716
1717                 if (g_str_equal(key, "Method") == TRUE) {
1718                         const char *val;
1719
1720                         if (type != DBUS_TYPE_STRING)
1721                                 goto error;
1722
1723                         dbus_message_iter_get_basic(&variant, &val);
1724                         method = string2proxymethod(val);
1725                 } else if (g_str_equal(key, "URL") == TRUE) {
1726                         if (type != DBUS_TYPE_STRING)
1727                                 goto error;
1728
1729                         dbus_message_iter_get_basic(&variant, &url);
1730                 } else if (g_str_equal(key, "Servers") == TRUE) {
1731                         DBusMessageIter str_array;
1732
1733                         if (type != DBUS_TYPE_ARRAY)
1734                                 goto error;
1735
1736                         servers_str = g_string_new(NULL);
1737                         if (servers_str == NULL)
1738                                 goto error;
1739
1740                         dbus_message_iter_recurse(&variant, &str_array);
1741
1742                         while (dbus_message_iter_get_arg_type(&str_array) ==
1743                                                         DBUS_TYPE_STRING) {
1744                                 char *val = NULL;
1745
1746                                 dbus_message_iter_get_basic(&str_array, &val);
1747
1748                                 if (servers_str->len > 0)
1749                                         g_string_append_printf(servers_str,
1750                                                         " %s", val);
1751                                 else
1752                                         g_string_append(servers_str, val);
1753
1754                                 dbus_message_iter_next(&str_array);
1755                         }
1756                 } else if (g_str_equal(key, "Excludes") == TRUE) {
1757                         DBusMessageIter str_array;
1758
1759                         if (type != DBUS_TYPE_ARRAY)
1760                                 goto error;
1761
1762                         excludes_str = g_string_new(NULL);
1763                         if (excludes_str == NULL)
1764                                 goto error;
1765
1766                         dbus_message_iter_recurse(&variant, &str_array);
1767
1768                         while (dbus_message_iter_get_arg_type(&str_array) ==
1769                                                         DBUS_TYPE_STRING) {
1770                                 char *val = NULL;
1771
1772                                 dbus_message_iter_get_basic(&str_array, &val);
1773
1774                                 if (excludes_str->len > 0)
1775                                         g_string_append_printf(excludes_str,
1776                                                         " %s", val);
1777                                 else
1778                                         g_string_append(excludes_str, val);
1779
1780                                 dbus_message_iter_next(&str_array);
1781                         }
1782                 }
1783
1784                 dbus_message_iter_next(&dict);
1785         }
1786
1787         switch (method) {
1788         case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
1789                 break;
1790         case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
1791                 if (servers_str == NULL && service->proxies == NULL)
1792                         goto error;
1793
1794                 if (servers_str != NULL) {
1795                         g_strfreev(service->proxies);
1796
1797                         if (servers_str->len > 0)
1798                                 service->proxies = g_strsplit_set(
1799                                         servers_str->str, " ", 0);
1800                         else
1801                                 service->proxies = NULL;
1802                 }
1803
1804                 if (excludes_str != NULL) {
1805                         g_strfreev(service->excludes);
1806
1807                         if (excludes_str->len > 0)
1808                                 service->excludes = g_strsplit_set(
1809                                         excludes_str->str, " ", 0);
1810                         else
1811                                 service->excludes = NULL;
1812                 }
1813
1814                 if (service->proxies == NULL)
1815                         method = CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
1816
1817                 break;
1818         case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
1819                 g_free(service->pac);
1820
1821                 if (url != NULL && strlen(url) > 0)
1822                         service->pac = g_strdup(url);
1823                 else
1824                         service->pac = NULL;
1825
1826                 /* if we are connected:
1827                    - if service->pac == NULL
1828                    - if __connman_ipconfig_get_proxy_autoconfig(
1829                    service->ipconfig) == NULL
1830                    --> We should start WPAD */
1831
1832                 break;
1833         case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
1834                 goto error;
1835         }
1836
1837         if (servers_str != NULL)
1838                 g_string_free(servers_str, TRUE);
1839
1840         if (excludes_str != NULL)
1841                 g_string_free(excludes_str, TRUE);
1842
1843         service->proxy_config = method;
1844
1845         return 0;
1846
1847 error:
1848         if (servers_str != NULL)
1849                 g_string_free(servers_str, TRUE);
1850
1851         if (excludes_str != NULL)
1852                 g_string_free(excludes_str, TRUE);
1853
1854         return -EINVAL;
1855 }
1856
1857 static DBusMessage *set_property(DBusConnection *conn,
1858                                         DBusMessage *msg, void *user_data)
1859 {
1860         struct connman_service *service = user_data;
1861         DBusMessageIter iter, value;
1862         const char *name;
1863         int type;
1864
1865         DBG("service %p", service);
1866
1867         if (dbus_message_iter_init(msg, &iter) == FALSE)
1868                 return __connman_error_invalid_arguments(msg);
1869
1870         dbus_message_iter_get_basic(&iter, &name);
1871         dbus_message_iter_next(&iter);
1872         dbus_message_iter_recurse(&iter, &value);
1873
1874         type = dbus_message_iter_get_arg_type(&value);
1875
1876         if (g_str_has_prefix(name, "AutoConnect") == TRUE) {
1877                 connman_bool_t autoconnect;
1878
1879                 if (type != DBUS_TYPE_BOOLEAN)
1880                         return __connman_error_invalid_arguments(msg);
1881
1882                 if (service->favorite == FALSE)
1883                         return __connman_error_invalid_service(msg);
1884
1885                 dbus_message_iter_get_basic(&value, &autoconnect);
1886
1887                 if (service->autoconnect == autoconnect)
1888                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1889
1890                 service->autoconnect = autoconnect;
1891
1892                 autoconnect_changed(service);
1893
1894                 __connman_storage_save_service(service);
1895         } else if (g_str_equal(name, "Passphrase") == TRUE) {
1896                 const char *passphrase;
1897
1898                 if (type != DBUS_TYPE_STRING)
1899                         return __connman_error_invalid_arguments(msg);
1900
1901                 if (service->immutable == TRUE)
1902                         return __connman_error_not_supported(msg);
1903
1904                 dbus_message_iter_get_basic(&value, &passphrase);
1905
1906                 __connman_service_set_passphrase(service, passphrase);
1907         } else if (g_str_equal(name, "APN") == TRUE) {
1908                 const char *apn;
1909
1910                 if (type != DBUS_TYPE_STRING)
1911                         return __connman_error_invalid_arguments(msg);
1912
1913                 if (service->immutable == TRUE)
1914                         return __connman_error_not_supported(msg);
1915
1916                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1917                         return __connman_error_invalid_service(msg);
1918
1919                 dbus_message_iter_get_basic(&value, &apn);
1920
1921                 g_free(service->apn);
1922                 service->apn = g_strdup(apn);
1923
1924                 apn_changed(service);
1925
1926                 if (service->network != NULL)
1927                         connman_network_set_string(service->network,
1928                                                 "Cellular.APN", service->apn);
1929
1930                 __connman_storage_save_service(service);
1931         } else if (g_str_equal(name, "Username") == TRUE) {
1932                 const char *username;
1933
1934                 if (type != DBUS_TYPE_STRING)
1935                         return __connman_error_invalid_arguments(msg);
1936
1937                 if (service->immutable == TRUE)
1938                         return __connman_error_not_supported(msg);
1939
1940                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1941                         return __connman_error_invalid_service(msg);
1942
1943                 dbus_message_iter_get_basic(&value, &username);
1944
1945                 g_free(service->username);
1946                 service->username = g_strdup(username);
1947
1948                 if (service->network != NULL)
1949                         connman_network_set_string(service->network,
1950                                         "Cellular.Username", service->username);
1951
1952                 __connman_storage_save_service(service);
1953         } else if (g_str_equal(name, "Password") == TRUE) {
1954                 const char *password;
1955
1956                 if (type != DBUS_TYPE_STRING)
1957                         return __connman_error_invalid_arguments(msg);
1958
1959                 if (service->immutable == TRUE)
1960                         return __connman_error_not_supported(msg);
1961
1962                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1963                         return __connman_error_invalid_service(msg);
1964
1965                 dbus_message_iter_get_basic(&value, &password);
1966
1967                 g_free(service->password);
1968                 service->password = g_strdup(password);
1969
1970                 if (service->network != NULL)
1971                         connman_network_set_string(service->network,
1972                                         "Cellular.Password", service->password);
1973
1974                 __connman_storage_save_service(service);
1975         } else if (g_str_equal(name, "Nameservers.Configuration") == TRUE) {
1976                 DBusMessageIter entry;
1977                 GString *str;
1978                 int index;
1979                 const char *gw;
1980
1981                 if (type != DBUS_TYPE_ARRAY)
1982                         return __connman_error_invalid_arguments(msg);
1983
1984                 str = g_string_new(NULL);
1985                 if (str == NULL)
1986                         return __connman_error_invalid_arguments(msg);
1987
1988                 index = connman_network_get_index(service->network);
1989                 gw = __connman_ipconfig_get_gateway(index);
1990
1991                 if (gw && strlen(gw))
1992                         __connman_service_nameserver_del_routes(service);
1993
1994                 dbus_message_iter_recurse(&value, &entry);
1995
1996                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
1997                         const char *val;
1998                         dbus_message_iter_get_basic(&entry, &val);
1999                         dbus_message_iter_next(&entry);
2000                         if (str->len > 0)
2001                                 g_string_append_printf(str, " %s", val);
2002                         else
2003                                 g_string_append(str, val);
2004                 }
2005
2006                 g_strfreev(service->nameservers);
2007
2008                 if (str->len > 0)
2009                         service->nameservers = g_strsplit_set(str->str, " ", 0);
2010                 else
2011                         service->nameservers = NULL;
2012
2013                 g_string_free(str, TRUE);
2014
2015                 if (gw && strlen(gw))
2016                         __connman_service_nameserver_add_routes(service, gw);
2017
2018                 update_nameservers(service);
2019                 dns_configuration_changed(service);
2020
2021                 __connman_storage_save_service(service);
2022         } else if (g_str_equal(name, "Domains.Configuration") == TRUE) {
2023                 DBusMessageIter entry;
2024                 GString *str;
2025
2026                 if (type != DBUS_TYPE_ARRAY)
2027                         return __connman_error_invalid_arguments(msg);
2028
2029                 str = g_string_new(NULL);
2030                 if (str == NULL)
2031                         return __connman_error_invalid_arguments(msg);
2032
2033                 dbus_message_iter_recurse(&value, &entry);
2034
2035                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
2036                         const char *val;
2037                         dbus_message_iter_get_basic(&entry, &val);
2038                         dbus_message_iter_next(&entry);
2039                         if (str->len > 0)
2040                                 g_string_append_printf(str, " %s", val);
2041                         else
2042                                 g_string_append(str, val);
2043                 }
2044
2045                 g_strfreev(service->domains);
2046
2047                 if (str->len > 0)
2048                         service->domains = g_strsplit_set(str->str, " ", 0);
2049                 else
2050                         service->domains = NULL;
2051
2052                 g_string_free(str, TRUE);
2053
2054                 update_nameservers(service);
2055                 domain_configuration_changed(service);
2056
2057                 __connman_storage_save_service(service);
2058         } else if (g_str_equal(name, "Proxy.Configuration") == TRUE) {
2059                 int err;
2060
2061                 if (type != DBUS_TYPE_ARRAY)
2062                         return __connman_error_invalid_arguments(msg);
2063
2064                 err = update_proxy_configuration(service, &value);
2065
2066                 if (err < 0)
2067                         return __connman_error_failed(msg, -err);
2068
2069                 proxy_configuration_changed(service);
2070
2071                 __connman_storage_save_service(service);
2072         } else if (g_str_equal(name, "IPv4.Configuration") == TRUE ||
2073                         g_str_equal(name, "IPv6.Configuration")) {
2074
2075                 struct connman_ipconfig *ipv4 = NULL, *ipv6 = NULL;
2076                 int err = 0;
2077
2078                 DBG("%s", name);
2079
2080                 if (service->ipconfig_ipv4 == NULL &&
2081                                         service->ipconfig_ipv6 == NULL)
2082                         return __connman_error_invalid_property(msg);
2083
2084                 if (g_str_equal(name, "IPv4.Configuration") == TRUE) {
2085                         if (is_connecting(service) || is_connected(service))
2086                                 __connman_network_clear_ipconfig(
2087                                                 service->network,
2088                                                 service->ipconfig_ipv4);
2089
2090                         ipv4 = service->ipconfig_ipv4;
2091                         err = __connman_ipconfig_set_config(ipv4, &value);
2092
2093                 } else if (g_str_equal(name, "IPv6.Configuration") == TRUE) {
2094                         if (is_connecting(service) || is_connected(service))
2095                                 __connman_network_clear_ipconfig(
2096                                                 service->network,
2097                                                 service->ipconfig_ipv6);
2098
2099                         ipv6 = service->ipconfig_ipv6;
2100                         err = __connman_ipconfig_set_config(ipv6, &value);
2101                 }
2102
2103                 if (err < 0) {
2104                         if (is_connected(service) || is_connecting(service))
2105                                 __connman_network_set_ipconfig(service->network,
2106                                                                 ipv4, ipv6);
2107                         return __connman_error_failed(msg, -err);
2108                 }
2109
2110                 if (ipv4)
2111                         ipv4_configuration_changed(service);
2112                 else if (ipv6)
2113                         ipv6_configuration_changed(service);
2114
2115                 if (is_connecting(service) || is_connected(service))
2116                         __connman_network_set_ipconfig(service->network,
2117                                                         ipv4, ipv6);
2118
2119                 __connman_storage_save_service(service);
2120         } else
2121                 return __connman_error_invalid_property(msg);
2122
2123         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2124 }
2125
2126 static void set_idle(struct connman_service *service)
2127 {
2128         service->state = CONNMAN_SERVICE_STATE_IDLE;
2129         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
2130         state_changed(service);
2131 }
2132
2133 static DBusMessage *clear_property(DBusConnection *conn,
2134                                         DBusMessage *msg, void *user_data)
2135 {
2136         struct connman_service *service = user_data;
2137         const char *name;
2138
2139         DBG("service %p", service);
2140
2141         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
2142                                                         DBUS_TYPE_INVALID);
2143
2144         if (g_str_equal(name, "Error") == TRUE) {
2145                 set_idle(service);
2146
2147                 g_get_current_time(&service->modified);
2148                 __connman_storage_save_service(service);
2149         } else if (g_str_equal(name, "Passphrase") == TRUE) {
2150                 if (service->immutable == TRUE)
2151                         return __connman_error_not_supported(msg);
2152
2153                 g_free(service->passphrase);
2154                 service->passphrase = NULL;
2155
2156                 passphrase_changed(service);
2157
2158                 __connman_storage_save_service(service);
2159         } else
2160                 return __connman_error_invalid_property(msg);
2161
2162         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2163 }
2164
2165 static connman_bool_t is_ignore(struct connman_service *service)
2166 {
2167         if (service->autoconnect == FALSE)
2168                 return TRUE;
2169
2170         if (service->roaming == TRUE)
2171                 return TRUE;
2172
2173         if (service->ignore == TRUE)
2174                 return TRUE;
2175
2176         if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
2177                 return TRUE;
2178
2179         return FALSE;
2180 }
2181
2182 void __connman_service_auto_connect(void)
2183 {
2184         struct connman_service *service = NULL;
2185         GSequenceIter *iter;
2186
2187         DBG("");
2188
2189         iter = g_sequence_get_begin_iter(service_list);
2190
2191         while (g_sequence_iter_is_end(iter) == FALSE) {
2192                 service = g_sequence_get(iter);
2193
2194                 if (service->pending != NULL)
2195                         return;
2196
2197                 if (is_connecting(service) == TRUE)
2198                         return;
2199
2200                 if (service->favorite == FALSE)
2201                         return;
2202
2203                 if (is_connected(service) == TRUE)
2204                         return;
2205
2206                 if (is_ignore(service) == FALSE &&
2207                                 service->state == CONNMAN_SERVICE_STATE_IDLE)
2208                         break;
2209
2210                 service = NULL;
2211
2212                 iter = g_sequence_iter_next(iter);
2213         }
2214
2215         if (service != NULL) {
2216                 service->userconnect = FALSE;
2217                 __connman_service_connect(service);
2218         }
2219 }
2220
2221 static void remove_timeout(struct connman_service *service)
2222 {
2223         if (service->timeout > 0) {
2224                 g_source_remove(service->timeout);
2225                 service->timeout = 0;
2226         }
2227 }
2228
2229 static void reply_pending(struct connman_service *service, int error)
2230 {
2231         remove_timeout(service);
2232
2233         if (service->pending != NULL) {
2234                 if (error > 0) {
2235                         DBusMessage *reply;
2236
2237                         reply = __connman_error_failed(service->pending,
2238                                                                 error);
2239                         if (reply != NULL)
2240                                 g_dbus_send_message(connection, reply);
2241                 } else
2242                         g_dbus_send_reply(connection, service->pending,
2243                                                         DBUS_TYPE_INVALID);
2244
2245                 dbus_message_unref(service->pending);
2246                 service->pending = NULL;
2247         }
2248 }
2249
2250 static gboolean connect_timeout(gpointer user_data)
2251 {
2252         struct connman_service *service = user_data;
2253         connman_bool_t autoconnect = FALSE;
2254
2255         DBG("service %p", service);
2256
2257         service->timeout = 0;
2258
2259         if (service->network != NULL)
2260                 __connman_network_disconnect(service->network);
2261
2262         __connman_ipconfig_disable(service->ipconfig_ipv4);
2263         __connman_ipconfig_disable(service->ipconfig_ipv6);
2264
2265         __connman_stats_service_unregister(service);
2266
2267         if (service->pending != NULL) {
2268                 DBusMessage *reply;
2269
2270                 reply = __connman_error_operation_timeout(service->pending);
2271                 if (reply != NULL)
2272                         g_dbus_send_message(connection, reply);
2273
2274                 dbus_message_unref(service->pending);
2275                 service->pending = NULL;
2276         } else
2277                 autoconnect = TRUE;
2278
2279         __connman_service_indicate_state(service,
2280                                         CONNMAN_SERVICE_STATE_FAILURE);
2281
2282         if (autoconnect == TRUE && service->userconnect == FALSE)
2283                 __connman_service_auto_connect();
2284
2285         return FALSE;
2286 }
2287
2288 static void set_reconnect_state(struct connman_service *service,
2289                                                 connman_bool_t reconnect)
2290 {
2291         struct connman_device *device;
2292
2293         if (service->network == NULL)
2294                 return;
2295
2296         device = connman_network_get_device(service->network);
2297         if (device == NULL)
2298                 return;
2299
2300         __connman_device_set_reconnect(device, reconnect);
2301 }
2302
2303 static connman_bool_t get_reconnect_state(struct connman_service *service)
2304 {
2305         struct connman_device *device;
2306
2307         if (service->network == NULL)
2308                 return FALSE;
2309
2310         device = connman_network_get_device(service->network);
2311         if (device == NULL)
2312                 return FALSE;
2313
2314         return __connman_device_get_reconnect(device);
2315 }
2316
2317 static void request_input_cb (struct connman_service *service,
2318                         const char *passphrase, void *user_data)
2319 {
2320         DBG ("RequestInput return, %p", service);
2321
2322         if (passphrase == NULL)
2323                 return;
2324         __connman_service_set_passphrase(service, passphrase);
2325         __connman_service_connect(service);
2326 }
2327
2328 struct connman_service *
2329 __connman_service_connect_type(enum connman_service_type type)
2330 {
2331         struct connman_service *service;
2332         GSequenceIter *iter;
2333         int err;
2334
2335         DBG("type %d", type);
2336
2337         /*
2338          * We go through the already sorted service list.
2339          * We pick the first one matching our type, or just
2340          * the first available one if we have no type.
2341          */
2342         iter = g_sequence_get_begin_iter(service_list);
2343         if (g_sequence_iter_is_end(iter))
2344                 return NULL;
2345         service = g_sequence_get(iter);
2346
2347         /*
2348          * If the first service is connected or about to be
2349          * connected, we return it, regardless of the type.
2350          */
2351         if ((g_sequence_iter_is_end(iter) == FALSE) &&
2352                 (is_connecting(service) == TRUE ||
2353                         is_connected(service) == TRUE))
2354                 return service;
2355
2356         while (g_sequence_iter_is_end(iter) == FALSE) {
2357                 if (service->type == type ||
2358                         type == CONNMAN_SERVICE_TYPE_UNKNOWN)
2359                         break;
2360
2361                 iter = g_sequence_iter_next(iter);
2362                 service = g_sequence_get(iter);
2363         }
2364
2365         if (g_sequence_iter_is_end(iter))
2366                 return NULL;
2367
2368         service->ignore = FALSE;
2369
2370         service->userconnect = TRUE;
2371
2372         set_reconnect_state(service, FALSE);
2373
2374         err = __connman_service_connect(service);
2375         if (err < 0) {
2376                 if (err == -ENOKEY)
2377                         if ( __connman_agent_request_input(service,
2378                                                         request_input_cb,
2379                                                         NULL))
2380                                 return service;
2381
2382                 if (err != -EINPROGRESS)
2383                         return NULL;
2384         }
2385
2386         return service;
2387 }
2388
2389 static DBusMessage *connect_service(DBusConnection *conn,
2390                                         DBusMessage *msg, void *user_data)
2391 {
2392         struct connman_service *service = user_data;
2393         GSequenceIter *iter;
2394         int err;
2395
2396         DBG("service %p", service);
2397
2398         if (service->pending != NULL)
2399                 return __connman_error_in_progress(msg);
2400
2401         iter = g_sequence_get_begin_iter(service_list);
2402
2403         while (g_sequence_iter_is_end(iter) == FALSE) {
2404                 struct connman_service *temp = g_sequence_get(iter);
2405
2406                 if (service->type == temp->type &&
2407                                         is_connecting(temp) == TRUE)
2408                         return __connman_error_in_progress(msg);
2409
2410                 iter = g_sequence_iter_next(iter);
2411         }
2412
2413         service->ignore = FALSE;
2414
2415         service->userconnect = TRUE;
2416
2417         service->pending = dbus_message_ref(msg);
2418
2419         set_reconnect_state(service, FALSE);
2420
2421         err = __connman_service_connect(service);
2422         if (err < 0) {
2423                 if (err == -ENOKEY) {
2424                         if (__connman_agent_request_input(service,
2425                                                         request_input_cb,
2426                                                         NULL) == 0)
2427                                 return NULL;
2428                 }
2429
2430                 if (err != -EINPROGRESS) {
2431                         dbus_message_unref(service->pending);
2432                         service->pending = NULL;
2433
2434                         return __connman_error_failed(msg, -err);
2435                 }
2436
2437                 return NULL;
2438         }
2439
2440         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2441 }
2442
2443 static DBusMessage *disconnect_service(DBusConnection *conn,
2444                                         DBusMessage *msg, void *user_data)
2445 {
2446         struct connman_service *service = user_data;
2447         int err;
2448
2449         DBG("service %p", service);
2450
2451         reply_pending(service, ECONNABORTED);
2452
2453         service->ignore = TRUE;
2454
2455         set_reconnect_state(service, FALSE);
2456
2457         err = __connman_service_disconnect(service);
2458         if (err < 0) {
2459                 if (err != -EINPROGRESS)
2460                         return __connman_error_failed(msg, -err);
2461
2462                 return NULL;
2463         }
2464
2465         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2466 }
2467
2468 static DBusMessage *remove_service(DBusConnection *conn,
2469                                         DBusMessage *msg, void *user_data)
2470 {
2471         struct connman_service *service = user_data;
2472
2473         DBG("service %p", service);
2474
2475         if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
2476                 return __connman_error_not_supported(msg);
2477
2478         if (service->immutable == TRUE)
2479                 return __connman_error_not_supported(msg);
2480
2481         if (service->favorite == FALSE &&
2482                         service->state != CONNMAN_SERVICE_STATE_FAILURE)
2483                 return __connman_error_not_supported(msg);
2484
2485         if (service->network != NULL) {
2486                 set_reconnect_state(service, FALSE);
2487
2488                 __connman_network_disconnect(service->network);
2489         }
2490
2491         g_hash_table_destroy(service->counter_table);
2492
2493         g_free(service->passphrase);
2494         service->passphrase = NULL;
2495
2496         passphrase_changed(service);
2497
2498         g_free(service->apn);
2499         service->apn = NULL;
2500
2501         g_free(service->username);
2502         service->username = NULL;
2503
2504         g_free(service->password);
2505         service->password = NULL;
2506
2507         apn_changed(service);
2508
2509         set_idle(service);
2510
2511         __connman_service_set_favorite(service, FALSE);
2512         __connman_storage_save_service(service);
2513
2514         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2515 }
2516
2517 static DBusMessage *move_service(DBusConnection *conn,
2518                                         DBusMessage *msg, void *user_data,
2519                                                                 gboolean before)
2520 {
2521         struct connman_service *service = user_data;
2522         struct connman_service *target;
2523         const char *path;
2524         GSequenceIter *src, *dst;
2525
2526         DBG("service %p", service);
2527
2528         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
2529                                                         DBUS_TYPE_INVALID);
2530
2531         if (service->favorite == FALSE)
2532                 return __connman_error_not_supported(msg);
2533
2534         target = find_service(path);
2535         if (target == NULL || target->favorite == FALSE || target == service)
2536                 return __connman_error_invalid_service(msg);
2537
2538         DBG("target %s", target->identifier);
2539
2540         if (target->state != service->state)
2541                 return __connman_error_invalid_service(msg);
2542
2543         g_get_current_time(&service->modified);
2544         __connman_storage_save_service(service);
2545
2546         src = g_hash_table_lookup(service_hash, service->identifier);
2547         dst = g_hash_table_lookup(service_hash, target->identifier);
2548
2549         before ? g_sequence_move(src, dst) : g_sequence_move(dst, src);
2550
2551         __connman_profile_changed(FALSE);
2552
2553         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2554 }
2555
2556 static DBusMessage *move_before(DBusConnection *conn,
2557                                         DBusMessage *msg, void *user_data)
2558 {
2559         return move_service(conn, msg, user_data, TRUE);
2560 }
2561
2562 static DBusMessage *move_after(DBusConnection *conn,
2563                                         DBusMessage *msg, void *user_data)
2564 {
2565         return move_service(conn, msg, user_data, FALSE);
2566 }
2567
2568 static DBusMessage *reset_counters(DBusConnection *conn,
2569                                         DBusMessage *msg, void *user_data)
2570 {
2571         struct connman_service *service = user_data;
2572
2573         reset_stats(service);
2574
2575         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2576 }
2577
2578 static GDBusMethodTable service_methods[] = {
2579         { "GetProperties", "",   "a{sv}", get_properties     },
2580         { "SetProperty",   "sv", "",      set_property       },
2581         { "ClearProperty", "s",  "",      clear_property     },
2582         { "Connect",       "",   "",      connect_service,
2583                                                 G_DBUS_METHOD_FLAG_ASYNC },
2584         { "Disconnect",    "",   "",      disconnect_service },
2585         { "Remove",        "",   "",      remove_service     },
2586         { "MoveBefore",    "o",  "",      move_before        },
2587         { "MoveAfter",     "o",  "",      move_after         },
2588         { "ResetCounters", "",   "",      reset_counters     },
2589         { },
2590 };
2591
2592 static GDBusSignalTable service_signals[] = {
2593         { "PropertyChanged", "sv" },
2594         { },
2595 };
2596
2597 static void service_free(gpointer user_data)
2598 {
2599         struct connman_service *service = user_data;
2600         char *path = service->path;
2601
2602         DBG("service %p", service);
2603
2604         reply_pending(service, ENOENT);
2605
2606         g_hash_table_remove(service_hash, service->identifier);
2607
2608         stats_stop(service);
2609         __connman_storage_save_service(service);
2610
2611         service->path = NULL;
2612
2613         if (path != NULL) {
2614                 __connman_profile_changed(FALSE);
2615
2616                 g_dbus_unregister_interface(connection, path,
2617                                                 CONNMAN_SERVICE_INTERFACE);
2618                 g_free(path);
2619         }
2620
2621         if (service->network != NULL)
2622                 connman_network_unref(service->network);
2623
2624         if (service->provider != NULL)
2625                 connman_provider_unref(service->provider);
2626
2627         if (service->ipconfig_ipv4 != NULL) {
2628                 connman_ipconfig_unref(service->ipconfig_ipv4);
2629                 service->ipconfig_ipv4 = NULL;
2630         }
2631
2632         if (service->ipconfig_ipv6 != NULL) {
2633                 connman_ipconfig_unref(service->ipconfig_ipv6);
2634                 service->ipconfig_ipv6 = NULL;
2635         }
2636
2637         if (service->location != NULL)
2638                 connman_location_unref(service->location);
2639
2640         g_strfreev(service->nameservers);
2641         g_strfreev(service->domains);
2642         g_strfreev(service->proxies);
2643         g_strfreev(service->excludes);
2644
2645         g_free(service->nameserver);
2646         g_free(service->domainname);
2647         g_free(service->pac);
2648         g_free(service->mcc);
2649         g_free(service->mnc);
2650         g_free(service->apn);
2651         g_free(service->username);
2652         g_free(service->password);
2653         g_free(service->profile);
2654         g_free(service->name);
2655         g_free(service->passphrase);
2656         g_free(service->identifier);
2657         g_free(service->eap);
2658         g_free(service->identity);
2659         g_free(service->ca_cert_file);
2660         g_free(service->client_cert_file);
2661         g_free(service->private_key_file);
2662         g_free(service->private_key_passphrase);
2663         g_free(service->phase2);
2664
2665         if (service->stats.timer != NULL)
2666                 g_timer_destroy(service->stats.timer);
2667         if (service->stats_roaming.timer != NULL)
2668                 g_timer_destroy(service->stats_roaming.timer);
2669
2670         g_free(service);
2671 }
2672
2673 /**
2674  * __connman_service_put:
2675  * @service: service structure
2676  *
2677  * Release service if no longer needed
2678  */
2679 void __connman_service_put(struct connman_service *service)
2680 {
2681         DBG("service %p", service);
2682
2683         if (g_atomic_int_dec_and_test(&service->refcount) == TRUE) {
2684                 GSequenceIter *iter;
2685
2686                 iter = g_hash_table_lookup(service_hash, service->identifier);
2687                 if (iter != NULL) {
2688                         reply_pending(service, ECONNABORTED);
2689
2690                         __connman_service_disconnect(service);
2691
2692                         g_sequence_remove(iter);
2693                 } else
2694                         service_free(service);
2695         }
2696 }
2697
2698 static void stats_init(struct connman_service *service)
2699 {
2700         /* home */
2701         service->stats.valid = FALSE;
2702         service->stats.enabled = FALSE;
2703         service->stats.timer = g_timer_new();
2704
2705         /* roaming */
2706         service->stats_roaming.valid = FALSE;
2707         service->stats_roaming.enabled = FALSE;
2708         service->stats_roaming.timer = g_timer_new();
2709 }
2710
2711 static void service_initialize(struct connman_service *service)
2712 {
2713         DBG("service %p", service);
2714
2715         service->refcount = 1;
2716
2717         service->type     = CONNMAN_SERVICE_TYPE_UNKNOWN;
2718         service->mode     = CONNMAN_SERVICE_MODE_UNKNOWN;
2719         service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
2720         service->state    = CONNMAN_SERVICE_STATE_UNKNOWN;
2721
2722         service->favorite  = FALSE;
2723         service->immutable = FALSE;
2724         service->hidden = FALSE;
2725
2726         service->ignore = FALSE;
2727
2728         service->userconnect = FALSE;
2729
2730         service->order = 0;
2731
2732         stats_init(service);
2733
2734         service->provider = NULL;
2735 }
2736
2737 /**
2738  * connman_service_create:
2739  *
2740  * Allocate a new service.
2741  *
2742  * Returns: a newly-allocated #connman_service structure
2743  */
2744 struct connman_service *connman_service_create(void)
2745 {
2746         GSList *list;
2747         struct connman_stats_counter *counters;
2748         const char *counter;
2749
2750         struct connman_service *service;
2751
2752         service = g_try_new0(struct connman_service, 1);
2753         if (service == NULL)
2754                 return NULL;
2755
2756         DBG("service %p", service);
2757
2758         service->counter_table = g_hash_table_new_full(g_str_hash,
2759                                                 g_str_equal, NULL, g_free);
2760
2761         for (list = counter_list; list; list = list->next) {
2762                 counter = list->data;
2763
2764                 counters = g_try_new0(struct connman_stats_counter, 1);
2765                 if (counters == NULL) {
2766                         g_hash_table_destroy(service->counter_table);
2767                         g_free(service);
2768                         return NULL;
2769                 }
2770
2771                 counters->append_all = TRUE;
2772
2773                 g_hash_table_replace(service->counter_table, (gpointer)counter,
2774                                 counters);
2775         }
2776
2777         service_initialize(service);
2778
2779         service->location = __connman_location_create(service);
2780
2781         return service;
2782 }
2783
2784 struct connman_location *__connman_service_get_location(struct connman_service *service)
2785 {
2786         return service->location;
2787 }
2788
2789 /**
2790  * connman_service_ref:
2791  * @service: service structure
2792  *
2793  * Increase reference counter of service
2794  */
2795 struct connman_service *connman_service_ref(struct connman_service *service)
2796 {
2797         DBG("%p", service);
2798
2799         g_atomic_int_inc(&service->refcount);
2800
2801         return service;
2802 }
2803
2804 /**
2805  * connman_service_unref:
2806  * @service: service structure
2807  *
2808  * Decrease reference counter of service
2809  */
2810 void connman_service_unref(struct connman_service *service)
2811 {
2812         __connman_service_put(service);
2813 }
2814
2815 static gint service_compare(gconstpointer a, gconstpointer b,
2816                                                         gpointer user_data)
2817 {
2818         struct connman_service *service_a = (void *) a;
2819         struct connman_service *service_b = (void *) b;
2820
2821         if (service_a->state != service_b->state) {
2822                 if (is_connected(service_a) == TRUE)
2823                         return -1;
2824                 if (is_connected(service_b) == TRUE)
2825                         return 1;
2826
2827                 if (is_connecting(service_a) == TRUE)
2828                         return -1;
2829                 if (is_connecting(service_b) == TRUE)
2830                         return 1;
2831         }
2832
2833         if (service_a->order > service_b->order)
2834                 return -1;
2835
2836         if (service_a->order < service_b->order)
2837                 return 1;
2838
2839         if (service_a->favorite == TRUE && service_b->favorite == FALSE)
2840                 return -1;
2841
2842         if (service_a->favorite == FALSE && service_b->favorite == TRUE)
2843                 return 1;
2844
2845         if (service_a->type != service_b->type) {
2846                 switch (service_a->type) {
2847                 case CONNMAN_SERVICE_TYPE_UNKNOWN:
2848                 case CONNMAN_SERVICE_TYPE_SYSTEM:
2849                 case CONNMAN_SERVICE_TYPE_ETHERNET:
2850                 case CONNMAN_SERVICE_TYPE_GPS:
2851                 case CONNMAN_SERVICE_TYPE_VPN:
2852                 case CONNMAN_SERVICE_TYPE_GADGET:
2853                         break;
2854                 case CONNMAN_SERVICE_TYPE_WIFI:
2855                         return 1;
2856                 case CONNMAN_SERVICE_TYPE_WIMAX:
2857                 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2858                 case CONNMAN_SERVICE_TYPE_CELLULAR:
2859                         return -1;
2860                 }
2861         }
2862
2863         return (gint) service_b->strength - (gint) service_a->strength;
2864 }
2865
2866 /**
2867  * connman_service_get_type:
2868  * @service: service structure
2869  *
2870  * Get the type of service
2871  */
2872 enum connman_service_type connman_service_get_type(struct connman_service *service)
2873 {
2874         if (service == NULL)
2875                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
2876
2877         return service->type;
2878 }
2879
2880 /**
2881  * connman_service_get_interface:
2882  * @service: service structure
2883  *
2884  * Get network interface of service
2885  */
2886 char *connman_service_get_interface(struct connman_service *service)
2887 {
2888         int index;
2889
2890         if (service == NULL)
2891                 return NULL;
2892
2893         if (service->type == CONNMAN_SERVICE_TYPE_VPN) {
2894                 if (service->ipconfig_ipv4)
2895                         index = connman_ipconfig_get_index(
2896                                                 service->ipconfig_ipv4);
2897                 else if (service->ipconfig_ipv6)
2898                         index = connman_ipconfig_get_index(
2899                                                 service->ipconfig_ipv6);
2900                 else
2901                         return NULL;
2902
2903                 return connman_inet_ifname(index);
2904         }
2905
2906         if (service->network == NULL)
2907                 return NULL;
2908
2909         index = connman_network_get_index(service->network);
2910
2911         return connman_inet_ifname(index);
2912 }
2913
2914 /**
2915  * connman_service_get_network:
2916  * @service: service structure
2917  *
2918  * Get the service network
2919  */
2920 struct connman_network *
2921 __connman_service_get_network(struct connman_service *service)
2922 {
2923         if (service == NULL)
2924                 return NULL;
2925
2926         return service->network;
2927 }
2928
2929 struct connman_ipconfig *
2930 __connman_service_get_ip4config(struct connman_service *service)
2931 {
2932         if (service == NULL)
2933                 return NULL;
2934
2935         return service->ipconfig_ipv4;
2936 }
2937
2938 struct connman_ipconfig *
2939 __connman_service_get_ip6config(struct connman_service *service)
2940 {
2941         if (service == NULL)
2942                 return NULL;
2943
2944         return service->ipconfig_ipv6;
2945 }
2946
2947 enum connman_service_security __connman_service_get_security(struct connman_service *service)
2948 {
2949         if (service == NULL)
2950                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
2951
2952         return service->security;
2953 }
2954
2955 /**
2956  * __connman_service_set_favorite:
2957  * @service: service structure
2958  * @favorite: favorite value
2959  *
2960  * Change the favorite setting of service
2961  */
2962 int __connman_service_set_favorite(struct connman_service *service,
2963                                                 connman_bool_t favorite)
2964 {
2965         GSequenceIter *iter;
2966
2967         iter = g_hash_table_lookup(service_hash, service->identifier);
2968         if (iter == NULL)
2969                 return -ENOENT;
2970
2971         if (service->favorite == favorite)
2972                 return -EALREADY;
2973
2974         service->favorite = favorite;
2975
2976         favorite_changed(service);
2977
2978         g_sequence_sort_changed(iter, service_compare, NULL);
2979
2980         __connman_profile_changed(FALSE);
2981
2982         return 0;
2983 }
2984
2985 int __connman_service_set_immutable(struct connman_service *service,
2986                                                 connman_bool_t immutable)
2987 {
2988         service->immutable = immutable;
2989
2990         immutable_changed(service);
2991
2992         return 0;
2993 }
2994
2995 void __connman_service_set_string(struct connman_service *service,
2996                                   const char *key, const char *value)
2997 {
2998         if (g_str_equal(key, "EAP") == TRUE) {
2999                 g_free(service->eap);
3000                 service->eap = g_strdup(value);
3001         } else if (g_str_equal(key, "Identity") == TRUE) {
3002                 g_free(service->identity);
3003                 service->identity = g_strdup(value);
3004         } else if (g_str_equal(key, "CACertFile") == TRUE) {
3005                 g_free(service->ca_cert_file);
3006                 service->ca_cert_file = g_strdup(value);
3007         } else if (g_str_equal(key, "ClientCertFile") == TRUE) {
3008                 g_free(service->client_cert_file);
3009                 service->client_cert_file = g_strdup(value);
3010         } else if (g_str_equal(key, "PrivateKeyFile") == TRUE) {
3011                 g_free(service->private_key_file);
3012                 service->private_key_file = g_strdup(value);
3013         } else if (g_str_equal(key, "PrivateKeyPassphrase") == TRUE) {
3014                 g_free(service->private_key_passphrase);
3015                 service->private_key_passphrase = g_strdup(value);
3016         } else if (g_str_equal(key, "Phase2") == TRUE) {
3017                 g_free(service->phase2);
3018                 service->phase2 = g_strdup(value);
3019         } else if (g_str_equal(key, "Passphrase") == TRUE) {
3020                 g_free(service->passphrase);
3021                 service->passphrase = g_strdup(value);
3022         }
3023 }
3024
3025 static void service_complete(struct connman_service *service)
3026 {
3027         reply_pending(service, EIO);
3028
3029         if (service->userconnect == FALSE)
3030                 __connman_service_auto_connect();
3031
3032         g_get_current_time(&service->modified);
3033         __connman_storage_save_service(service);
3034 }
3035
3036 static void report_error_cb(struct connman_service *service,
3037                         gboolean retry, void *user_data)
3038 {
3039         if (retry == TRUE)
3040                 __connman_service_connect(service);
3041         else {
3042                 service_complete(service);
3043                 __connman_profile_changed(FALSE);
3044                 __connman_element_request_scan(CONNMAN_ELEMENT_TYPE_UNKNOWN);
3045         }
3046 }
3047
3048 int __connman_service_indicate_state(struct connman_service *service,
3049                                         enum connman_service_state state)
3050 {
3051         GSequenceIter *iter;
3052
3053         DBG("service %p state %d", service, state);
3054
3055         if (service == NULL)
3056                 return -EINVAL;
3057
3058         if (service->state == state)
3059                 return -EALREADY;
3060
3061         if (service->state == CONNMAN_SERVICE_STATE_FAILURE &&
3062                                 state == CONNMAN_SERVICE_STATE_IDLE)
3063                 return -EINVAL;
3064
3065         if (service->state == CONNMAN_SERVICE_STATE_IDLE &&
3066                                 state == CONNMAN_SERVICE_STATE_DISCONNECT)
3067                 return -EINVAL;
3068
3069         if (state == CONNMAN_SERVICE_STATE_IDLE &&
3070                         service->state != CONNMAN_SERVICE_STATE_DISCONNECT) {
3071                 service->state = CONNMAN_SERVICE_STATE_DISCONNECT;
3072                 state_changed(service);
3073
3074                 reply_pending(service, ECONNABORTED);
3075
3076                 __connman_service_disconnect(service);
3077         }
3078
3079         if (state == CONNMAN_SERVICE_STATE_CONFIGURATION) {
3080                 if (__connman_stats_service_register(service) == 0) {
3081                         __connman_stats_get(service, FALSE,
3082                                                 &service->stats.data);
3083                         __connman_stats_get(service, TRUE,
3084                                                 &service->stats_roaming.data);
3085                 }
3086
3087                 if (service->ipconfig_ipv4)
3088                         __connman_ipconfig_enable(service->ipconfig_ipv4);
3089                 if (service->ipconfig_ipv6)
3090                         __connman_ipconfig_enable(service->ipconfig_ipv6);
3091         }
3092
3093         service->state = state;
3094         state_changed(service);
3095
3096         if (state == CONNMAN_SERVICE_STATE_ONLINE) {
3097                 if (service->login_required == TRUE) {
3098                         service->login_required = FALSE;
3099                         login_changed(service);
3100                 }
3101
3102                 connman_timeserver_sync();
3103         }
3104
3105         if (state == CONNMAN_SERVICE_STATE_IDLE) {
3106                 connman_bool_t reconnect;
3107
3108                 reconnect = get_reconnect_state(service);
3109                 if (reconnect == TRUE)
3110                         __connman_service_auto_connect();
3111         }
3112
3113         if (state == CONNMAN_SERVICE_STATE_READY) {
3114                 enum connman_service_proxy_method proxy_config;
3115
3116                 set_reconnect_state(service, TRUE);
3117
3118                 __connman_service_set_favorite(service, TRUE);
3119
3120                 reply_pending(service, 0);
3121
3122                 service->userconnect = FALSE;
3123
3124                 g_get_current_time(&service->modified);
3125                 __connman_storage_save_service(service);
3126
3127                 update_nameservers(service);
3128                 dns_changed(service);
3129                 domain_changed(service);
3130
3131                 proxy_config = service->proxy_config;
3132
3133                 /*
3134                  * We start WPAD if we haven't got a PAC URL from DHCP and
3135                  * if our proxy manual configuration is either empty or set
3136                  * to AUTO with an empty URL.
3137                  */
3138                 if (service->proxy == CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN &&
3139                         (proxy_config == CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN ||
3140                                 (proxy_config ==
3141                                         CONNMAN_SERVICE_PROXY_METHOD_AUTO &&
3142                                         service->pac == NULL)))
3143                         if (__connman_wpad_start(service) < 0) {
3144                                 service->proxy =
3145                                         CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
3146
3147                                 __connman_notifier_proxy_changed(service);
3148                         }
3149
3150                 __connman_notifier_connect(service->type);
3151
3152                 default_changed();
3153         } else if (state == CONNMAN_SERVICE_STATE_DISCONNECT) {
3154                 __connman_location_finish(service);
3155
3156                 default_changed();
3157
3158                 __connman_wpad_stop(service);
3159
3160                 update_nameservers(service);
3161                 dns_changed(service);
3162                 domain_changed(service);
3163
3164                 __connman_notifier_disconnect(service->type);
3165         }
3166
3167         if (state == CONNMAN_SERVICE_STATE_FAILURE) {
3168                 if (service->userconnect == TRUE &&
3169                         __connman_agent_report_error(service,
3170                                         error2string(service->error),
3171                                         report_error_cb, NULL) == -EIO)
3172                         return 0;
3173                 service_complete(service);
3174         } else
3175                 service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
3176
3177         iter = g_hash_table_lookup(service_hash, service->identifier);
3178         if (iter != NULL)
3179                 g_sequence_sort_changed(iter, service_compare, NULL);
3180
3181         __connman_profile_changed(FALSE);
3182
3183         if (service->state == CONNMAN_SERVICE_STATE_ONLINE)
3184                 default_changed();
3185
3186         if (service->state == CONNMAN_SERVICE_STATE_DISCONNECT) {
3187                 struct connman_service *def_service = get_default();
3188
3189                 if (__connman_notifier_count_connected() == 0 &&
3190                         def_service != NULL &&
3191                                 def_service->provider != NULL)
3192                         __connman_provider_disconnect(def_service->provider);
3193         }
3194
3195         if (service->state == CONNMAN_SERVICE_STATE_IDLE ||
3196                         service->state == CONNMAN_SERVICE_STATE_FAILURE)
3197                 __connman_element_request_scan(CONNMAN_ELEMENT_TYPE_UNKNOWN);
3198
3199         return 0;
3200 }
3201
3202 int __connman_service_indicate_error(struct connman_service *service,
3203                                         enum connman_service_error error)
3204 {
3205         DBG("service %p error %d", service, error);
3206
3207         if (service == NULL)
3208                 return -EINVAL;
3209
3210         service->error = error;
3211
3212         return __connman_service_indicate_state(service,
3213                                         CONNMAN_SERVICE_STATE_FAILURE);
3214 }
3215
3216 int __connman_service_indicate_default(struct connman_service *service)
3217 {
3218         DBG("service %p", service);
3219
3220         default_changed();
3221
3222         __connman_location_detect(service);
3223
3224         return 0;
3225 }
3226
3227 int __connman_service_request_login(struct connman_service *service)
3228 {
3229         DBG("service %p", service);
3230
3231         if (service == NULL)
3232                 return -EINVAL;
3233
3234         service->login_required = TRUE;
3235         login_changed(service);
3236
3237         return 0;
3238 }
3239
3240 static connman_bool_t prepare_network(struct connman_service *service)
3241 {
3242         enum connman_network_type type;
3243         unsigned int ssid_len;
3244
3245         type = connman_network_get_type(service->network);
3246
3247         switch (type) {
3248         case CONNMAN_NETWORK_TYPE_UNKNOWN:
3249         case CONNMAN_NETWORK_TYPE_VENDOR:
3250                 return FALSE;
3251         case CONNMAN_NETWORK_TYPE_WIFI:
3252                 if (connman_network_get_blob(service->network, "WiFi.SSID",
3253                                                         &ssid_len) == NULL)
3254                         return FALSE;
3255
3256                 connman_network_set_string(service->network,
3257                                 "WiFi.Passphrase", service->passphrase);
3258                 break;
3259         case CONNMAN_NETWORK_TYPE_ETHERNET:
3260         case CONNMAN_NETWORK_TYPE_WIMAX:
3261         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
3262         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
3263                 break;
3264         case CONNMAN_NETWORK_TYPE_CELLULAR:
3265                 connman_network_set_string(service->network,
3266                                                 "Cellular.APN", service->apn);
3267
3268                 connman_network_set_string(service->network,
3269                                         "Cellular.Username", service->username);
3270                 connman_network_set_string(service->network,
3271                                         "Cellular.Password", service->password);
3272                 break;
3273         }
3274
3275         return TRUE;
3276 }
3277
3278 static void prepare_8021x(struct connman_service *service)
3279 {
3280         if (service->eap != NULL)
3281                 connman_network_set_string(service->network, "WiFi.EAP",
3282                                                                 service->eap);
3283
3284         if (service->identity != NULL)
3285                 connman_network_set_string(service->network, "WiFi.Identity",
3286                                                         service->identity);
3287
3288         if (service->ca_cert_file != NULL)
3289                 connman_network_set_string(service->network, "WiFi.CACertFile",
3290                                                         service->ca_cert_file);
3291
3292         if (service->client_cert_file != NULL)
3293                 connman_network_set_string(service->network,
3294                                                 "WiFi.ClientCertFile",
3295                                                 service->client_cert_file);
3296
3297         if (service->private_key_file != NULL)
3298                 connman_network_set_string(service->network,
3299                                                 "WiFi.PrivateKeyFile",
3300                                                 service->private_key_file);
3301
3302         if (service->private_key_passphrase != NULL)
3303                 connman_network_set_string(service->network,
3304                                         "WiFi.PrivateKeyPassphrase",
3305                                         service->private_key_passphrase);
3306
3307         if (service->phase2 != NULL)
3308                 connman_network_set_string(service->network, "WiFi.Phase2",
3309                                                         service->phase2);
3310 }
3311
3312 int __connman_service_connect(struct connman_service *service)
3313 {
3314         int err;
3315
3316         DBG("service %p", service);
3317
3318         if (is_connected(service) == TRUE)
3319                 return -EISCONN;
3320
3321         if (is_connecting(service) == TRUE)
3322                 return -EALREADY;
3323
3324         switch (service->type) {
3325         case CONNMAN_SERVICE_TYPE_UNKNOWN:
3326         case CONNMAN_SERVICE_TYPE_SYSTEM:
3327         case CONNMAN_SERVICE_TYPE_GPS:
3328         case CONNMAN_SERVICE_TYPE_GADGET:
3329                 return -EINVAL;
3330         case CONNMAN_SERVICE_TYPE_ETHERNET:
3331         case CONNMAN_SERVICE_TYPE_WIMAX:
3332         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
3333         case CONNMAN_SERVICE_TYPE_VPN:
3334                 break;
3335         case CONNMAN_SERVICE_TYPE_CELLULAR:
3336                 if (service->apn == NULL)
3337                         return -EINVAL;
3338                 break;
3339         case CONNMAN_SERVICE_TYPE_WIFI:
3340                 switch (service->security) {
3341                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
3342                 case CONNMAN_SERVICE_SECURITY_NONE:
3343                         break;
3344                 case CONNMAN_SERVICE_SECURITY_WEP:
3345                 case CONNMAN_SERVICE_SECURITY_PSK:
3346                 case CONNMAN_SERVICE_SECURITY_WPA:
3347                 case CONNMAN_SERVICE_SECURITY_RSN:
3348                         if (service->passphrase == NULL)
3349                                 return -ENOKEY;
3350                         break;
3351                 case CONNMAN_SERVICE_SECURITY_8021X:
3352                         break;
3353                 }
3354                 break;
3355         }
3356
3357         if (service->network != NULL) {
3358                 if (prepare_network(service) == FALSE)
3359                         return -EINVAL;
3360
3361                 switch (service->security) {
3362                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
3363                 case CONNMAN_SERVICE_SECURITY_NONE:
3364                 case CONNMAN_SERVICE_SECURITY_WEP:
3365                 case CONNMAN_SERVICE_SECURITY_PSK:
3366                 case CONNMAN_SERVICE_SECURITY_WPA:
3367                 case CONNMAN_SERVICE_SECURITY_RSN:
3368                         break;
3369                 case CONNMAN_SERVICE_SECURITY_8021X:
3370                         prepare_8021x(service);
3371                         break;
3372                 }
3373
3374                 if (__connman_stats_service_register(service) == 0) {
3375                         __connman_stats_get(service, FALSE,
3376                                                 &service->stats.data);
3377                         __connman_stats_get(service, TRUE,
3378                                                 &service->stats_roaming.data);
3379                 }
3380
3381                 if (service->ipconfig_ipv4)
3382                         __connman_ipconfig_enable(service->ipconfig_ipv4);
3383                 if (service->ipconfig_ipv6)
3384                         __connman_ipconfig_enable(service->ipconfig_ipv6);
3385
3386                 err = __connman_network_connect(service->network);
3387         } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
3388                                         service->provider != NULL)
3389                 err = __connman_provider_connect(service->provider);
3390         else
3391                 return -EOPNOTSUPP;
3392
3393         if (err < 0) {
3394                 if (err != -EINPROGRESS) {
3395                         __connman_ipconfig_disable(service->ipconfig_ipv4);
3396                         __connman_ipconfig_disable(service->ipconfig_ipv6);
3397
3398                         __connman_stats_service_unregister(service);
3399                         if (service->userconnect == TRUE)
3400                                 return __connman_agent_report_error(service,
3401                                                 error2string(service->error),
3402                                                 report_error_cb, NULL);
3403                         else
3404                                 return err;
3405                 }
3406
3407                 service->timeout = g_timeout_add_seconds(CONNECT_TIMEOUT,
3408                                                 connect_timeout, service);
3409
3410                 return -EINPROGRESS;
3411         }
3412
3413         return 0;
3414 }
3415
3416 int __connman_service_disconnect(struct connman_service *service)
3417 {
3418         int err;
3419
3420         DBG("service %p", service);
3421
3422         if (service->network != NULL) {
3423                 err = __connman_network_disconnect(service->network);
3424         } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
3425                                         service->provider != NULL)
3426                 err = __connman_provider_disconnect(service->provider);
3427         else
3428                 return -EOPNOTSUPP;
3429
3430         if (err < 0 && err != -EINPROGRESS)
3431                 return err;
3432
3433         if (service->ipconfig_ipv4)
3434                 __connman_ipconfig_set_proxy_autoconfig(service->ipconfig_ipv4,
3435                                                         NULL);
3436         else
3437                 __connman_ipconfig_set_proxy_autoconfig(service->ipconfig_ipv6,
3438                                                         NULL);
3439
3440         __connman_ipconfig_clear_address(service->ipconfig_ipv4);
3441         __connman_ipconfig_clear_address(service->ipconfig_ipv6);
3442
3443         __connman_ipconfig_disable(service->ipconfig_ipv4);
3444         __connman_ipconfig_disable(service->ipconfig_ipv6);
3445
3446         __connman_stats_service_unregister(service);
3447
3448         return err;
3449 }
3450
3451 /**
3452  * __connman_service_lookup:
3453  * @pattern: search pattern
3454  * @path: return object path
3455  *
3456  * Look up a service path from a search pattern
3457  */
3458 int __connman_service_lookup(const char *pattern, const char **path)
3459 {
3460         GHashTableIter iter;
3461         gpointer key, value;
3462
3463         g_hash_table_iter_init(&iter, service_hash);
3464
3465         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
3466                 GSequenceIter *iter = value;
3467                 struct connman_service *service = g_sequence_get(iter);
3468
3469                 if (g_strcmp0(service->identifier, pattern) == 0 ||
3470                                 g_strcmp0(service->name, pattern) == 0) {
3471                         *path = (const char *) service->path;
3472                         return 0;
3473                 }
3474         }
3475
3476         return -ENXIO;
3477 }
3478
3479 /**
3480  * lookup_by_identifier:
3481  * @identifier: service identifier
3482  *
3483  * Look up a service by identifier (reference count will not be increased)
3484  */
3485 static struct connman_service *lookup_by_identifier(const char *identifier)
3486 {
3487         GSequenceIter *iter;
3488
3489         iter = g_hash_table_lookup(service_hash, identifier);
3490         if (iter != NULL)
3491                 return g_sequence_get(iter);
3492
3493         return NULL;
3494 }
3495
3496 static struct connman_network *create_hidden_wifi(struct connman_device *device,
3497                 const char *ssid, const char *mode, const char *security)
3498 {
3499         struct connman_network *network;
3500         char *name;
3501         int index;
3502         unsigned int i, ssid_len;
3503
3504         ssid_len = strlen(ssid);
3505         if (ssid_len < 1)
3506                 return NULL;
3507
3508         network = connman_network_create(NULL, CONNMAN_NETWORK_TYPE_WIFI);
3509         if (network == NULL)
3510                 return NULL;
3511
3512         connman_network_set_blob(network, "WiFi.SSID",
3513                                         (unsigned char *) ssid, ssid_len);
3514
3515         connman_network_set_string(network, "WiFi.Mode", mode);
3516         connman_network_set_string(network, "WiFi.Security", security);
3517
3518         name = g_try_malloc0(ssid_len + 1);
3519         if (name == NULL) {
3520                 connman_network_unref(network);
3521                 return NULL;
3522         }
3523
3524         for (i = 0; i < ssid_len; i++) {
3525                 if (g_ascii_isprint(ssid[i]))
3526                         name[i] = ssid[i];
3527                 else
3528                         name[i] = ' ';
3529         }
3530
3531         connman_network_set_name(network, name);
3532
3533         g_free(name);
3534
3535         index = connman_device_get_index(device);
3536         connman_network_set_index(network, index);
3537
3538         if (connman_device_add_network(device, network) < 0) {
3539                 connman_network_unref(network);
3540                 return NULL;
3541         }
3542
3543         connman_network_set_available(network, TRUE);
3544
3545         return network;
3546 }
3547
3548 int __connman_service_create_and_connect(DBusMessage *msg)
3549 {
3550         struct connman_service *service;
3551         struct connman_network *network;
3552         struct connman_device *device;
3553         DBusMessageIter iter, array;
3554         const char *mode = "managed", *security = "none", *group_security;
3555         const char *type = NULL, *ssid = NULL, *passphrase = NULL;
3556         unsigned int ssid_len = 0;
3557         const char *ident;
3558         char *name, *group;
3559         gboolean created = FALSE;
3560         int err;
3561
3562         dbus_message_iter_init(msg, &iter);
3563         dbus_message_iter_recurse(&iter, &array);
3564
3565         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
3566                 DBusMessageIter entry, value;
3567                 const char *key;
3568
3569                 dbus_message_iter_recurse(&array, &entry);
3570                 dbus_message_iter_get_basic(&entry, &key);
3571
3572                 dbus_message_iter_next(&entry);
3573                 dbus_message_iter_recurse(&entry, &value);
3574
3575                 switch (dbus_message_iter_get_arg_type(&value)) {
3576                 case DBUS_TYPE_STRING:
3577                         if (g_str_equal(key, "Type") == TRUE)
3578                                 dbus_message_iter_get_basic(&value, &type);
3579                         else if (g_str_equal(key, "WiFi.Mode") == TRUE ||
3580                                         g_str_equal(key, "Mode") == TRUE)
3581                                 dbus_message_iter_get_basic(&value, &mode);
3582                         else if (g_str_equal(key, "WiFi.Security") == TRUE ||
3583                                         g_str_equal(key, "Security") == TRUE)
3584                                 dbus_message_iter_get_basic(&value, &security);
3585                         else if (g_str_equal(key, "WiFi.Passphrase") == TRUE ||
3586                                         g_str_equal(key, "Passphrase") == TRUE)
3587                                 dbus_message_iter_get_basic(&value, &passphrase);
3588                         else if (g_str_equal(key, "WiFi.SSID") == TRUE ||
3589                                         g_str_equal(key, "SSID") == TRUE)
3590                                 dbus_message_iter_get_basic(&value, &ssid);
3591                 }
3592
3593                 dbus_message_iter_next(&array);
3594         }
3595
3596         if (type == NULL)
3597                 return -EINVAL;
3598
3599         if (g_strcmp0(type, "wifi") != 0 || g_strcmp0(mode, "managed") != 0)
3600                 return -EOPNOTSUPP;
3601
3602         if (ssid == NULL)
3603                 return -EINVAL;
3604
3605         ssid_len = strlen(ssid);
3606         if (ssid_len < 1)
3607                 return -EINVAL;
3608
3609         if (g_strcmp0(security, "none") != 0 &&
3610                                 g_strcmp0(security, "wep") != 0 &&
3611                                 g_strcmp0(security, "psk") != 0 &&
3612                                 g_strcmp0(security, "wpa") != 0 &&
3613                                 g_strcmp0(security, "rsn") != 0 &&
3614                                 g_strcmp0(security, "ieee8021x") != 0)
3615                 return -EINVAL;
3616
3617         device = __connman_element_find_device(CONNMAN_SERVICE_TYPE_WIFI);
3618         if (device == NULL)
3619                 return -EOPNOTSUPP;
3620
3621         ident = connman_device_get_ident(device);
3622         if (ident == NULL)
3623                 return -EOPNOTSUPP;
3624
3625
3626         if (!g_strcmp0(security, "wpa") ||
3627                 !g_strcmp0(security, "rsn"))
3628                 group_security = "psk";
3629         else
3630                 group_security = security;
3631
3632         group = connman_wifi_build_group_name((unsigned char *) ssid,
3633                                                 ssid_len, mode, group_security);
3634         if (group == NULL)
3635                 return -EINVAL;
3636
3637         name = g_strdup_printf("%s_%s_%s", type, ident, group);
3638
3639         service = lookup_by_identifier(name);
3640
3641         if (service != NULL)
3642                 goto done;
3643
3644         network = create_hidden_wifi(device, ssid, mode, security);
3645         if (network != NULL) {
3646                 connman_network_set_group(network, group);
3647                 created = TRUE;
3648         }
3649
3650         service = lookup_by_identifier(name);
3651
3652 done:
3653         g_free(name);
3654         g_free(group);
3655
3656         if (service == NULL) {
3657                 err = -EOPNOTSUPP;
3658                 goto failed;
3659         }
3660
3661         set_reconnect_state(service, FALSE);
3662
3663         __connman_device_disconnect(device);
3664
3665         if (passphrase != NULL) {
3666                 g_free(service->passphrase);
3667                 service->passphrase = g_strdup(passphrase);
3668         }
3669
3670         service->userconnect = TRUE;
3671
3672         err = __connman_service_connect(service);
3673         if (err < 0 && err != -EINPROGRESS)
3674                 goto failed;
3675
3676         g_dbus_send_reply(connection, msg,
3677                                 DBUS_TYPE_OBJECT_PATH, &service->path,
3678                                                         DBUS_TYPE_INVALID);
3679
3680         return 0;
3681
3682 failed:
3683         if (service != NULL && created == TRUE) {
3684                 struct connman_network *network = service->network;
3685
3686                 if (network != NULL) {
3687                         connman_network_set_available(network, FALSE);
3688                         __connman_device_cleanup_networks(device);
3689                 } else
3690                         __connman_service_put(service);
3691         }
3692
3693         return err;
3694 }
3695
3696 /**
3697  * __connman_service_get:
3698  * @identifier: service identifier
3699  *
3700  * Look up a service by identifier or create a new one if not found
3701  */
3702 static struct connman_service *service_get(const char *identifier)
3703 {
3704         struct connman_service *service;
3705         GSequenceIter *iter;
3706
3707         iter = g_hash_table_lookup(service_hash, identifier);
3708         if (iter != NULL) {
3709                 service = g_sequence_get(iter);
3710                 if (service != NULL)
3711                         connman_service_ref(service);
3712                 return service;
3713         }
3714
3715         service = connman_service_create();
3716         if (service == NULL)
3717                 return NULL;
3718
3719         DBG("service %p", service);
3720
3721         service->identifier = g_strdup(identifier);
3722
3723         service->profile = g_strdup(__connman_profile_active_ident());
3724
3725         iter = g_sequence_insert_sorted(service_list, service,
3726                                                 service_compare, NULL);
3727
3728         g_hash_table_insert(service_hash, service->identifier, iter);
3729
3730         return service;
3731 }
3732
3733 static int service_register(struct connman_service *service)
3734 {
3735         const char *path = __connman_profile_active_path();
3736         GSequenceIter *iter;
3737
3738         DBG("service %p", service);
3739
3740         if (service->path != NULL)
3741                 return -EALREADY;
3742
3743         service->path = g_strdup_printf("%s/%s", path, service->identifier);
3744
3745         DBG("path %s", service->path);
3746
3747         __connman_config_provision_service(service);
3748
3749         __connman_storage_load_service(service);
3750
3751         g_dbus_register_interface(connection, service->path,
3752                                         CONNMAN_SERVICE_INTERFACE,
3753                                         service_methods, service_signals,
3754                                                         NULL, service, NULL);
3755
3756         iter = g_hash_table_lookup(service_hash, service->identifier);
3757         if (iter != NULL)
3758                 g_sequence_sort_changed(iter, service_compare, NULL);
3759
3760         __connman_profile_changed(TRUE);
3761
3762         return 0;
3763 }
3764
3765 static void service_up(struct connman_ipconfig *ipconfig)
3766 {
3767         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3768
3769         connman_info("%s up", connman_ipconfig_get_ifname(ipconfig));
3770
3771         link_changed(service);
3772
3773         service->stats.valid = FALSE;
3774         service->stats_roaming.valid = FALSE;
3775 }
3776
3777 static void service_down(struct connman_ipconfig *ipconfig)
3778 {
3779         connman_info("%s down", connman_ipconfig_get_ifname(ipconfig));
3780 }
3781
3782 static void service_lower_up(struct connman_ipconfig *ipconfig)
3783 {
3784         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3785
3786         connman_info("%s lower up", connman_ipconfig_get_ifname(ipconfig));
3787
3788         stats_start(service);
3789 }
3790
3791 static void service_lower_down(struct connman_ipconfig *ipconfig)
3792 {
3793         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3794
3795         connman_info("%s lower down", connman_ipconfig_get_ifname(ipconfig));
3796
3797         stats_stop(service);
3798         __connman_storage_save_service(service);
3799 }
3800
3801 static void service_ip_bound(struct connman_ipconfig *ipconfig)
3802 {
3803         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3804
3805         connman_info("%s ip bound", connman_ipconfig_get_ifname(ipconfig));
3806
3807         settings_changed(service);
3808 }
3809
3810 static void service_ip_release(struct connman_ipconfig *ipconfig)
3811 {
3812         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3813
3814         connman_info("%s ip release", connman_ipconfig_get_ifname(ipconfig));
3815
3816         settings_changed(service);
3817 }
3818
3819 static const struct connman_ipconfig_ops service_ops = {
3820         .up             = service_up,
3821         .down           = service_down,
3822         .lower_up       = service_lower_up,
3823         .lower_down     = service_lower_down,
3824         .ip_bound       = service_ip_bound,
3825         .ip_release     = service_ip_release,
3826 };
3827
3828 static void setup_ip4config(struct connman_service *service, int index)
3829 {
3830         if (index < 0)
3831                 return;
3832
3833         service->ipconfig_ipv4 = connman_ipconfig_create(index,
3834                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
3835         if (service->ipconfig_ipv4 == NULL)
3836                 return;
3837
3838         connman_ipconfig_set_method(service->ipconfig_ipv4,
3839                                         CONNMAN_IPCONFIG_METHOD_DHCP);
3840
3841         connman_ipconfig_set_data(service->ipconfig_ipv4, service);
3842
3843         connman_ipconfig_set_ops(service->ipconfig_ipv4, &service_ops);
3844 }
3845
3846 static void setup_ip6config(struct connman_service *service, int index)
3847 {
3848         if (index < 0)
3849                 return;
3850
3851         service->ipconfig_ipv6 = connman_ipconfig_create(index,
3852                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
3853         if (service->ipconfig_ipv6 == NULL)
3854                 return;
3855
3856         connman_ipconfig_set_data(service->ipconfig_ipv6, service);
3857
3858         connman_ipconfig_set_ops(service->ipconfig_ipv6, &service_ops);
3859 }
3860
3861 void __connman_service_create_ip4config(struct connman_service *service,
3862                                                                 int index)
3863 {
3864         const char *ident = service->profile;
3865         GKeyFile *keyfile;
3866
3867         DBG("ipv4 %p", service->ipconfig_ipv4);
3868
3869         if (service->ipconfig_ipv4 != NULL)
3870                 return;
3871
3872         setup_ip4config(service, index);
3873
3874         if (ident == NULL)
3875                 return;
3876
3877         keyfile = __connman_storage_open_profile(ident);
3878         if (keyfile == NULL)
3879                 return;
3880
3881         if (service->ipconfig_ipv4)
3882                 __connman_ipconfig_load(service->ipconfig_ipv4, keyfile,
3883                                         service->identifier, "IPv4.");
3884         g_key_file_free(keyfile);
3885 }
3886
3887 void __connman_service_create_ip6config(struct connman_service *service,
3888                                                                 int index)
3889 {
3890         const char *ident = service->profile;
3891         GKeyFile *keyfile;
3892
3893         DBG("ipv6 %p", service->ipconfig_ipv6);
3894
3895         if (service->ipconfig_ipv6 != NULL)
3896                 return;
3897
3898         setup_ip6config(service, index);
3899
3900         if (ident == NULL)
3901                 return;
3902
3903         keyfile = __connman_storage_open_profile(ident);
3904         if (keyfile == NULL)
3905                 return;
3906
3907         if (service->ipconfig_ipv6 != NULL)
3908                 __connman_ipconfig_load(service->ipconfig_ipv6, keyfile,
3909                                         service->identifier, "IPv6.");
3910
3911         g_key_file_free(keyfile);
3912 }
3913
3914 /**
3915  * __connman_service_lookup_from_network:
3916  * @network: network structure
3917  *
3918  * Look up a service by network (reference count will not be increased)
3919  */
3920 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
3921 {
3922         struct connman_service *service;
3923         const char *ident, *group;
3924         char *name;
3925
3926         DBG("network %p", network);
3927
3928         ident = __connman_network_get_ident(network);
3929         if (ident == NULL)
3930                 return NULL;
3931
3932         group = connman_network_get_group(network);
3933         if (group == NULL)
3934                 return NULL;
3935
3936         name = g_strdup_printf("%s_%s_%s",
3937                         __connman_network_get_type(network), ident, group);
3938         service = lookup_by_identifier(name);
3939         g_free(name);
3940
3941         return service;
3942 }
3943
3944 struct connman_service *__connman_service_lookup_from_index(int index)
3945 {
3946         struct connman_service *service;
3947         GSequenceIter *iter;
3948
3949         iter = g_sequence_get_begin_iter(service_list);
3950
3951         while (g_sequence_iter_is_end(iter) == FALSE) {
3952                 service = g_sequence_get(iter);
3953
3954                 if (connman_ipconfig_get_index(service->ipconfig_ipv4)
3955                                                         == index)
3956                         return service;
3957
3958                 if (connman_ipconfig_get_index(service->ipconfig_ipv6)
3959                                                         == index)
3960                         return service;
3961
3962                 iter = g_sequence_iter_next(iter);
3963         }
3964
3965         return NULL;
3966 }
3967
3968 const char *__connman_service_get_ident(struct connman_service *service)
3969 {
3970         return service->identifier;
3971 }
3972
3973 const char *__connman_service_get_path(struct connman_service *service)
3974 {
3975         return service->path;
3976 }
3977
3978 unsigned int __connman_service_get_order(struct connman_service *service)
3979 {
3980         GSequenceIter *iter;
3981
3982         if (service == NULL)
3983                 return 0;
3984
3985         if (service->favorite == FALSE) {
3986                 service->order = 0;
3987                 goto done;
3988         }
3989
3990         iter = g_hash_table_lookup(service_hash, service->identifier);
3991         if (iter != NULL) {
3992                 if (g_sequence_iter_get_position(iter) == 0)
3993                         service->order = 1;
3994                 else if (service->type == CONNMAN_SERVICE_TYPE_VPN)
3995                         service->order = 10;
3996                 else
3997                         service->order = 0;
3998         }
3999
4000 done:
4001         return service->order;
4002 }
4003
4004 static enum connman_service_type convert_network_type(struct connman_network *network)
4005 {
4006         enum connman_network_type type = connman_network_get_type(network);
4007
4008         switch (type) {
4009         case CONNMAN_NETWORK_TYPE_UNKNOWN:
4010         case CONNMAN_NETWORK_TYPE_VENDOR:
4011                 break;
4012         case CONNMAN_NETWORK_TYPE_ETHERNET:
4013                 return CONNMAN_SERVICE_TYPE_ETHERNET;
4014         case CONNMAN_NETWORK_TYPE_WIFI:
4015                 return CONNMAN_SERVICE_TYPE_WIFI;
4016         case CONNMAN_NETWORK_TYPE_WIMAX:
4017                 return CONNMAN_SERVICE_TYPE_WIMAX;
4018         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
4019         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
4020                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
4021         case CONNMAN_NETWORK_TYPE_CELLULAR:
4022                 return CONNMAN_SERVICE_TYPE_CELLULAR;
4023         }
4024
4025         return CONNMAN_SERVICE_TYPE_UNKNOWN;
4026 }
4027
4028 static enum connman_service_mode convert_wifi_mode(const char *mode)
4029 {
4030         if (mode == NULL)
4031                 return CONNMAN_SERVICE_MODE_UNKNOWN;
4032         else if (g_str_equal(mode, "managed") == TRUE)
4033                 return CONNMAN_SERVICE_MODE_MANAGED;
4034         else if (g_str_equal(mode, "adhoc") == TRUE)
4035                 return CONNMAN_SERVICE_MODE_ADHOC;
4036         else
4037                 return CONNMAN_SERVICE_MODE_UNKNOWN;
4038 }
4039
4040 static enum connman_service_security convert_wifi_security(const char *security)
4041 {
4042         if (security == NULL)
4043                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
4044         else if (g_str_equal(security, "none") == TRUE)
4045                 return CONNMAN_SERVICE_SECURITY_NONE;
4046         else if (g_str_equal(security, "wep") == TRUE)
4047                 return CONNMAN_SERVICE_SECURITY_WEP;
4048         else if (g_str_equal(security, "psk") == TRUE)
4049                 return CONNMAN_SERVICE_SECURITY_PSK;
4050         else if (g_str_equal(security, "ieee8021x") == TRUE)
4051                 return CONNMAN_SERVICE_SECURITY_8021X;
4052         else if (g_str_equal(security, "wpa") == TRUE)
4053                 return CONNMAN_SERVICE_SECURITY_WPA;
4054         else if (g_str_equal(security, "rsn") == TRUE)
4055                 return CONNMAN_SERVICE_SECURITY_RSN;
4056         else
4057                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
4058 }
4059
4060 static enum connman_service_mode convert_cellular_mode(connman_uint8_t mode)
4061 {
4062         switch (mode) {
4063         case 0:
4064         case 1:
4065                 return CONNMAN_SERVICE_MODE_GPRS;
4066         case 3:
4067                 return CONNMAN_SERVICE_MODE_EDGE;
4068         case 2:
4069         case 4:
4070         case 5:
4071         case 6:
4072                 return CONNMAN_SERVICE_MODE_UMTS;
4073         }
4074
4075         return CONNMAN_SERVICE_MODE_UNKNOWN;
4076 }
4077
4078 static void update_from_network(struct connman_service *service,
4079                                         struct connman_network *network)
4080 {
4081         connman_uint8_t strength = service->strength;
4082         GSequenceIter *iter;
4083         const char *str;
4084
4085         DBG("service %p network %p", service, network);
4086
4087         if (is_connected(service) == TRUE)
4088                 return;
4089
4090         if (is_connecting(service) == TRUE)
4091                 return;
4092
4093         str = connman_network_get_string(network, "Name");
4094         if (str != NULL) {
4095                 g_free(service->name);
4096                 service->name = g_strdup(str);
4097                 service->hidden = FALSE;
4098         } else {
4099                 g_free(service->name);
4100                 service->name = NULL;
4101                 service->hidden = TRUE;
4102         }
4103
4104         service->strength = connman_network_get_uint8(network, "Strength");
4105         service->roaming = connman_network_get_bool(network, "Roaming");
4106
4107         if (service->strength == 0) {
4108                 /*
4109                  * Filter out 0-values; it's unclear what they mean
4110                  * and they cause anomalous sorting of the priority list.
4111                  */
4112                 service->strength = strength;
4113         }
4114
4115         str = connman_network_get_string(network, "WiFi.Mode");
4116         service->mode = convert_wifi_mode(str);
4117
4118         str = connman_network_get_string(network, "WiFi.Security");
4119         service->security = convert_wifi_security(str);
4120
4121         str = connman_network_get_string(network, "Cellular.MCC");
4122         g_free(service->mcc);
4123         service->mcc = g_strdup(str);
4124
4125         str = connman_network_get_string(network, "Cellular.MNC");
4126         g_free(service->mnc);
4127         service->mnc = g_strdup(str);
4128
4129         if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR) {
4130                 connman_uint8_t value = connman_network_get_uint8(network,
4131                                                         "Cellular.Mode");
4132
4133                 service->mode = convert_cellular_mode(value);
4134         }
4135
4136         if (service->strength > strength && service->network != NULL) {
4137                 connman_network_unref(service->network);
4138                 service->network = connman_network_ref(network);
4139
4140                 strength_changed(service);
4141         }
4142
4143         if (service->network == NULL)
4144                 service->network = connman_network_ref(network);
4145
4146         iter = g_hash_table_lookup(service_hash, service->identifier);
4147         if (iter != NULL)
4148                 g_sequence_sort_changed(iter, service_compare, NULL);
4149 }
4150
4151 /**
4152  * __connman_service_create_from_network:
4153  * @network: network structure
4154  *
4155  * Look up service by network and if not found, create one
4156  */
4157 struct connman_service * __connman_service_create_from_network(struct connman_network *network)
4158 {
4159         struct connman_service *service;
4160         struct connman_device *device;
4161         const char *ident, *group;
4162         char *name;
4163         int index;
4164
4165         DBG("network %p", network);
4166
4167         ident = __connman_network_get_ident(network);
4168         if (ident == NULL)
4169                 return NULL;
4170
4171         group = connman_network_get_group(network);
4172         if (group == NULL)
4173                 return NULL;
4174
4175         name = g_strdup_printf("%s_%s_%s",
4176                         __connman_network_get_type(network), ident, group);
4177         service = service_get(name);
4178         g_free(name);
4179
4180         if (service == NULL)
4181                 return NULL;
4182
4183         if (__connman_network_get_weakness(network) == TRUE)
4184                 return service;
4185
4186         if (service->path != NULL) {
4187                 update_from_network(service, network);
4188                 __connman_profile_changed(TRUE);
4189                 return service;
4190         }
4191
4192         service->type = convert_network_type(network);
4193
4194         switch (service->type) {
4195         case CONNMAN_SERVICE_TYPE_UNKNOWN:
4196         case CONNMAN_SERVICE_TYPE_SYSTEM:
4197         case CONNMAN_SERVICE_TYPE_ETHERNET:
4198         case CONNMAN_SERVICE_TYPE_WIMAX:
4199         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
4200         case CONNMAN_SERVICE_TYPE_GPS:
4201         case CONNMAN_SERVICE_TYPE_VPN:
4202         case CONNMAN_SERVICE_TYPE_GADGET:
4203                 service->autoconnect = FALSE;
4204                 break;
4205         case CONNMAN_SERVICE_TYPE_WIFI:
4206         case CONNMAN_SERVICE_TYPE_CELLULAR:
4207                 service->autoconnect = TRUE;
4208                 break;
4209         }
4210
4211         service->state = CONNMAN_SERVICE_STATE_IDLE;
4212
4213         update_from_network(service, network);
4214
4215         index = connman_network_get_index(network);
4216
4217         if (service->ipconfig_ipv4 == NULL)
4218                 setup_ip4config(service, index);
4219
4220         if (service->ipconfig_ipv6 == NULL)
4221                 setup_ip6config(service, index);
4222
4223         service_register(service);
4224
4225         if (service->favorite == TRUE) {
4226                 device = connman_network_get_device(service->network);
4227                 if (device && __connman_device_scanning(device) == FALSE)
4228                         __connman_service_auto_connect();
4229         }
4230
4231         return service;
4232 }
4233
4234 void __connman_service_update_from_network(struct connman_network *network)
4235 {
4236         struct connman_service *service;
4237         enum connman_service_mode mode;
4238         connman_uint8_t strength, value;
4239         connman_bool_t roaming;
4240         GSequenceIter *iter;
4241         const char *name;
4242         connman_bool_t stats_enable;
4243
4244         DBG("network %p", network);
4245
4246         service = __connman_service_lookup_from_network(network);
4247         if (service == NULL)
4248                 return;
4249
4250         if (service->network == NULL)
4251                 return;
4252
4253         name = connman_network_get_string(service->network, "Name");
4254         if (g_strcmp0(service->name, name) != 0) {
4255                 g_free(service->name);
4256                 service->name = g_strdup(name);
4257                 connman_dbus_property_changed_basic(service->path,
4258                                 CONNMAN_SERVICE_INTERFACE, "Name",
4259                                 DBUS_TYPE_STRING, &service->name);
4260         }
4261
4262         strength = connman_network_get_uint8(service->network, "Strength");
4263         if (strength == service->strength)
4264                 goto roaming;
4265
4266         service->strength = strength;
4267
4268         strength_changed(service);
4269
4270 roaming:
4271         roaming = connman_network_get_bool(service->network, "Roaming");
4272         if (roaming == service->roaming)
4273                 goto done;
4274
4275         stats_enable = stats_enabled(service);
4276         if (stats_enable == TRUE)
4277                 stats_stop(service);
4278
4279         service->roaming = roaming;
4280
4281         if (stats_enable == TRUE)
4282                 stats_start(service);
4283
4284         roaming_changed(service);
4285
4286         iter = g_hash_table_lookup(service_hash, service->identifier);
4287         if (iter != NULL)
4288                 g_sequence_sort_changed(iter, service_compare, NULL);
4289
4290 done:
4291         if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
4292                 return;
4293
4294         value = connman_network_get_uint8(service->network, "Cellular.Mode");
4295         mode = convert_cellular_mode(value);
4296
4297         if (mode == service->mode)
4298                 return;
4299
4300         service->mode = mode;
4301
4302         mode_changed(service);
4303 }
4304
4305 void __connman_service_remove_from_network(struct connman_network *network)
4306 {
4307         struct connman_service *service;
4308
4309         DBG("network %p", network);
4310
4311         service = __connman_service_lookup_from_network(network);
4312         if (service == NULL)
4313                 return;
4314
4315         __connman_service_put(service);
4316 }
4317
4318 /**
4319  * __connman_service_create_from_provider:
4320  * @provider: provider structure
4321  *
4322  * Look up service by provider and if not found, create one
4323  */
4324 struct connman_service *
4325 __connman_service_create_from_provider(struct connman_provider *provider)
4326 {
4327         struct connman_service *service;
4328         const char *ident, *str;
4329         char *name;
4330         int index = connman_provider_get_index(provider);
4331
4332         DBG("provider %p", provider);
4333
4334         ident = __connman_provider_get_ident(provider);
4335         if (ident == NULL)
4336                 return NULL;
4337
4338         name = g_strdup_printf("vpn_%s", ident);
4339         service = service_get(name);
4340         g_free(name);
4341
4342         if (service == NULL)
4343                 return NULL;
4344
4345         service->type = CONNMAN_SERVICE_TYPE_VPN;
4346         service->provider = connman_provider_ref(provider);
4347         service->autoconnect = FALSE;
4348
4349         service->state = CONNMAN_SERVICE_STATE_IDLE;
4350
4351         str = connman_provider_get_string(provider, "Name");
4352         if (str != NULL) {
4353                 g_free(service->name);
4354                 service->name = g_strdup(str);
4355                 service->hidden = FALSE;
4356         } else {
4357                 g_free(service->name);
4358                 service->name = NULL;
4359                 service->hidden = TRUE;
4360         }
4361
4362         service->strength = 0;
4363
4364         if (service->ipconfig_ipv4 == NULL)
4365                 service->ipconfig_ipv4 = connman_ipconfig_create(index,
4366                                                 CONNMAN_IPCONFIG_TYPE_IPV4);
4367         if (service->ipconfig_ipv4 == NULL)
4368                 return service;
4369
4370         connman_ipconfig_set_method(service->ipconfig_ipv4,
4371                                         CONNMAN_IPCONFIG_METHOD_MANUAL);
4372         connman_ipconfig_set_data(service->ipconfig_ipv4, service);
4373         connman_ipconfig_set_ops(service->ipconfig_ipv4, &service_ops);
4374
4375         if (service->ipconfig_ipv6 == NULL)
4376                 service->ipconfig_ipv6 = connman_ipconfig_create(index,
4377                                                 CONNMAN_IPCONFIG_TYPE_IPV6);
4378         if (service->ipconfig_ipv6 == NULL)
4379                 return service;
4380
4381         connman_ipconfig_set_method(service->ipconfig_ipv6,
4382                                         CONNMAN_IPCONFIG_METHOD_OFF);
4383         connman_ipconfig_set_data(service->ipconfig_ipv6, service);
4384         connman_ipconfig_set_ops(service->ipconfig_ipv6, &service_ops);
4385
4386         service_register(service);
4387
4388         return service;
4389 }
4390
4391 static int service_load(struct connman_service *service)
4392 {
4393         const char *ident = service->profile;
4394         GKeyFile *keyfile;
4395         GError *error = NULL;
4396         gchar *pathname, *data = NULL;
4397         gsize length;
4398         gchar *str;
4399         connman_bool_t autoconnect;
4400         unsigned int ssid_len;
4401         int err = 0;
4402
4403         DBG("service %p", service);
4404
4405         if (ident == NULL)
4406                 return -EINVAL;
4407
4408         pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
4409         if (pathname == NULL)
4410                 return -ENOMEM;
4411
4412         keyfile = g_key_file_new();
4413
4414         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
4415                 g_free(pathname);
4416                 return -ENOENT;
4417         }
4418
4419         g_free(pathname);
4420
4421         if (g_key_file_load_from_data(keyfile, data, length,
4422                                                         0, NULL) == FALSE) {
4423                 g_free(data);
4424                 return -EILSEQ;
4425         }
4426
4427         g_free(data);
4428
4429         switch (service->type) {
4430         case CONNMAN_SERVICE_TYPE_UNKNOWN:
4431         case CONNMAN_SERVICE_TYPE_SYSTEM:
4432         case CONNMAN_SERVICE_TYPE_ETHERNET:
4433         case CONNMAN_SERVICE_TYPE_GPS:
4434         case CONNMAN_SERVICE_TYPE_VPN:
4435         case CONNMAN_SERVICE_TYPE_GADGET:
4436                 break;
4437         case CONNMAN_SERVICE_TYPE_WIFI:
4438                 if (service->name == NULL) {
4439                         gchar *name;
4440
4441                         name = g_key_file_get_string(keyfile,
4442                                         service->identifier, "Name", NULL);
4443                         if (name != NULL) {
4444                                 g_free(service->name);
4445                                 service->name = name;
4446                         }
4447
4448                         if (service->network != NULL)
4449                                 connman_network_set_name(service->network,
4450                                                                         name);
4451                 }
4452
4453                 if (service->network &&
4454                                 connman_network_get_blob(service->network,
4455                                         "WiFi.SSID", &ssid_len) == NULL) {
4456                         gchar *hex_ssid;
4457
4458                         hex_ssid = g_key_file_get_string(keyfile,
4459                                                         service->identifier,
4460                                                                 "SSID", NULL);
4461
4462                         if (hex_ssid != NULL) {
4463                                 gchar *ssid;
4464                                 unsigned int i, j = 0, hex;
4465                                 size_t hex_ssid_len = strlen(hex_ssid);
4466
4467                                 ssid = g_try_malloc0(hex_ssid_len / 2);
4468                                 if (ssid == NULL) {
4469                                         g_free(hex_ssid);
4470                                         err = -ENOMEM;
4471                                         goto done;
4472                                 }
4473
4474                                 for (i = 0; i < hex_ssid_len; i += 2) {
4475                                         sscanf(hex_ssid + i, "%02x", &hex);
4476                                         ssid[j++] = hex;
4477                                 }
4478
4479                                 connman_network_set_blob(service->network,
4480                                         "WiFi.SSID", ssid, hex_ssid_len / 2);
4481                         }
4482
4483                         g_free(hex_ssid);
4484                 }
4485                 /* fall through */
4486
4487         case CONNMAN_SERVICE_TYPE_WIMAX:
4488         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
4489         case CONNMAN_SERVICE_TYPE_CELLULAR:
4490                 service->apn = g_key_file_get_string(keyfile,
4491                                         service->identifier, "APN", NULL);
4492
4493                 service->username = g_key_file_get_string(keyfile,
4494                                         service->identifier, "Username", NULL);
4495
4496                 service->password = g_key_file_get_string(keyfile,
4497                                         service->identifier, "Password", NULL);
4498
4499                 service->favorite = g_key_file_get_boolean(keyfile,
4500                                 service->identifier, "Favorite", NULL);
4501
4502                 autoconnect = g_key_file_get_boolean(keyfile,
4503                                 service->identifier, "AutoConnect", &error);
4504                 if (error == NULL)
4505                         service->autoconnect = autoconnect;
4506                 g_clear_error(&error);
4507
4508                 str = g_key_file_get_string(keyfile,
4509                                 service->identifier, "Failure", NULL);
4510                 if (str != NULL) {
4511                         if (service->favorite == FALSE)
4512                                 service->state = CONNMAN_SERVICE_STATE_FAILURE;
4513                         service->error = string2error(str);
4514                 }
4515                 break;
4516         }
4517
4518         str = g_key_file_get_string(keyfile,
4519                                 service->identifier, "Modified", NULL);
4520         if (str != NULL) {
4521                 g_time_val_from_iso8601(str, &service->modified);
4522                 g_free(str);
4523         }
4524
4525         str = g_key_file_get_string(keyfile,
4526                                 service->identifier, "Passphrase", NULL);
4527         if (str != NULL) {
4528                 g_free(service->passphrase);
4529                 service->passphrase = str;
4530         }
4531
4532         if (service->ipconfig_ipv4 != NULL)
4533                 __connman_ipconfig_load(service->ipconfig_ipv4, keyfile,
4534                                         service->identifier, "IPv4.");
4535
4536         if (service->ipconfig_ipv6 != NULL)
4537                 __connman_ipconfig_load(service->ipconfig_ipv6, keyfile,
4538                                         service->identifier, "IPv6.");
4539
4540         service->nameservers = g_key_file_get_string_list(keyfile,
4541                         service->identifier, "Nameservers", &length, NULL);
4542         if (service->nameservers != NULL && length == 0) {
4543                 g_strfreev(service->nameservers);
4544                 service->nameservers = NULL;
4545         }
4546
4547         service->domains = g_key_file_get_string_list(keyfile,
4548                         service->identifier, "Domains", &length, NULL);
4549         if (service->domains != NULL && length == 0) {
4550                 g_strfreev(service->domains);
4551                 service->domains = NULL;
4552         }
4553
4554         str = g_key_file_get_string(keyfile,
4555                                 service->identifier, "Proxy.Method", NULL);
4556         if (str != NULL)
4557                 service->proxy_config = string2proxymethod(str);
4558
4559         g_free(str);
4560
4561         service->proxies = g_key_file_get_string_list(keyfile,
4562                         service->identifier, "Proxy.Servers", &length, NULL);
4563         if (service->proxies != NULL && length == 0) {
4564                 g_strfreev(service->proxies);
4565                 service->proxies = NULL;
4566         }
4567
4568         service->excludes = g_key_file_get_string_list(keyfile,
4569                         service->identifier, "Proxy.Excludes", &length, NULL);
4570         if (service->excludes != NULL && length == 0) {
4571                 g_strfreev(service->excludes);
4572                 service->excludes = NULL;
4573         }
4574
4575         str = g_key_file_get_string(keyfile,
4576                                 service->identifier, "Proxy.URL", NULL);
4577         if (str != NULL) {
4578                 g_free(service->pac);
4579                 service->pac = str;
4580         }
4581
4582 done:
4583         g_key_file_free(keyfile);
4584
4585         return err;
4586 }
4587
4588 static int service_save(struct connman_service *service)
4589 {
4590         const char *ident = service->profile;
4591         GKeyFile *keyfile;
4592         gchar *pathname, *data = NULL;
4593         gsize length;
4594         gchar *str;
4595         const char *cst_str = NULL;
4596         int err = 0;
4597
4598         DBG("service %p", service);
4599
4600         if (ident == NULL)
4601                 return -EINVAL;
4602
4603         pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
4604         if (pathname == NULL)
4605                 return -ENOMEM;
4606
4607         keyfile = g_key_file_new();
4608
4609         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
4610                 goto update;
4611
4612         if (length > 0) {
4613                 if (g_key_file_load_from_data(keyfile, data, length,
4614                                                         0, NULL) == FALSE)
4615                         goto done;
4616         }
4617
4618         g_free(data);
4619
4620 update:
4621         if (service->name != NULL)
4622                 g_key_file_set_string(keyfile, service->identifier,
4623                                                 "Name", service->name);
4624
4625         switch (service->type) {
4626         case CONNMAN_SERVICE_TYPE_UNKNOWN:
4627         case CONNMAN_SERVICE_TYPE_SYSTEM:
4628         case CONNMAN_SERVICE_TYPE_ETHERNET:
4629         case CONNMAN_SERVICE_TYPE_GPS:
4630         case CONNMAN_SERVICE_TYPE_VPN:
4631         case CONNMAN_SERVICE_TYPE_GADGET:
4632                 break;
4633         case CONNMAN_SERVICE_TYPE_WIFI:
4634                 if (service->network) {
4635                         const unsigned char *ssid;
4636                         unsigned int ssid_len = 0;
4637
4638                         ssid = connman_network_get_blob(service->network,
4639                                                         "WiFi.SSID", &ssid_len);
4640
4641                         if (ssid != NULL && ssid_len > 0 && ssid[0] != '\0') {
4642                                 char *identifier = service->identifier;
4643                                 GString *str;
4644                                 unsigned int i;
4645
4646                                 str = g_string_sized_new(ssid_len * 2);
4647                                 if (str == NULL) {
4648                                         err = -ENOMEM;
4649                                         goto done;
4650                                 }
4651
4652                                 for (i = 0; i < ssid_len; i++)
4653                                         g_string_append_printf(str,
4654                                                         "%02x", ssid[i]);
4655
4656                                 g_key_file_set_string(keyfile, identifier,
4657                                                         "SSID", str->str);
4658
4659                                 g_string_free(str, TRUE);
4660                         }
4661                 }
4662                 /* fall through */
4663
4664         case CONNMAN_SERVICE_TYPE_WIMAX:
4665         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
4666         case CONNMAN_SERVICE_TYPE_CELLULAR:
4667                 if (service->apn != NULL)
4668                         g_key_file_set_string(keyfile, service->identifier,
4669                                                         "APN", service->apn);
4670
4671                 if (service->username != NULL)
4672                         g_key_file_set_string(keyfile, service->identifier,
4673                                                 "Username", service->username);
4674
4675                 if (service->password != NULL)
4676                         g_key_file_set_string(keyfile, service->identifier,
4677                                                 "Password", service->password);
4678
4679                 g_key_file_set_boolean(keyfile, service->identifier,
4680                                         "Favorite", service->favorite);
4681
4682                 if (service->favorite == TRUE)
4683                         g_key_file_set_boolean(keyfile, service->identifier,
4684                                         "AutoConnect", service->autoconnect);
4685
4686                 if (service->state == CONNMAN_SERVICE_STATE_FAILURE) {
4687                         const char *failure = error2string(service->error);
4688                         if (failure != NULL)
4689                                 g_key_file_set_string(keyfile,
4690                                                         service->identifier,
4691                                                         "Failure", failure);
4692                 } else {
4693                         g_key_file_remove_key(keyfile, service->identifier,
4694                                                         "Failure", NULL);
4695                 }
4696                 break;
4697         }
4698
4699         str = g_time_val_to_iso8601(&service->modified);
4700         if (str != NULL) {
4701                 g_key_file_set_string(keyfile, service->identifier,
4702                                                         "Modified", str);
4703                 g_free(str);
4704         }
4705
4706         if (service->passphrase != NULL && strlen(service->passphrase) > 0)
4707                 g_key_file_set_string(keyfile, service->identifier,
4708                                         "Passphrase", service->passphrase);
4709         else
4710                 g_key_file_remove_key(keyfile, service->identifier,
4711                                                         "Passphrase", NULL);
4712
4713         if (service->ipconfig_ipv4 != NULL)
4714                 __connman_ipconfig_save(service->ipconfig_ipv4, keyfile,
4715                                         service->identifier, "IPv4.");
4716
4717         if (service->ipconfig_ipv6 != NULL)
4718                 __connman_ipconfig_save(service->ipconfig_ipv6, keyfile,
4719                                                 service->identifier, "IPv6.");
4720
4721         if (service->nameservers != NULL) {
4722                 guint len = g_strv_length(service->nameservers);
4723
4724                 g_key_file_set_string_list(keyfile, service->identifier,
4725                                                                 "Nameservers",
4726                                 (const gchar **) service->nameservers, len);
4727         } else
4728                 g_key_file_remove_key(keyfile, service->identifier,
4729                                                         "Nameservers", NULL);
4730
4731         if (service->domains != NULL) {
4732                 guint len = g_strv_length(service->domains);
4733
4734                 g_key_file_set_string_list(keyfile, service->identifier,
4735                                                                 "Domains",
4736                                 (const gchar **) service->domains, len);
4737         } else
4738                 g_key_file_remove_key(keyfile, service->identifier,
4739                                                         "Domains", NULL);
4740
4741         cst_str = proxymethod2string(service->proxy_config);
4742         if (cst_str != NULL)
4743                 g_key_file_set_string(keyfile, service->identifier,
4744                                 "Proxy.Method", cst_str);
4745
4746         if (service->proxies != NULL) {
4747                 guint len = g_strv_length(service->proxies);
4748
4749                 g_key_file_set_string_list(keyfile, service->identifier,
4750                                 "Proxy.Servers",
4751                                 (const gchar **) service->proxies, len);
4752         } else
4753                 g_key_file_remove_key(keyfile, service->identifier,
4754                                                 "Proxy.Servers", NULL);
4755
4756         if (service->excludes != NULL) {
4757                 guint len = g_strv_length(service->excludes);
4758
4759                 g_key_file_set_string_list(keyfile, service->identifier,
4760                                 "Proxy.Excludes",
4761                                 (const gchar **) service->excludes, len);
4762         } else
4763                 g_key_file_remove_key(keyfile, service->identifier,
4764                                                 "Proxy.Excludes", NULL);
4765
4766         if (service->pac != NULL && strlen(service->pac) > 0)
4767                 g_key_file_set_string(keyfile, service->identifier,
4768                                         "Proxy.URL", service->pac);
4769         else
4770                 g_key_file_remove_key(keyfile, service->identifier,
4771                                                         "Proxy.URL", NULL);
4772
4773         data = g_key_file_to_data(keyfile, &length, NULL);
4774
4775         if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
4776                 connman_error("Failed to store service information");
4777
4778 done:
4779         g_free(data);
4780
4781         g_key_file_free(keyfile);
4782
4783         g_free(pathname);
4784
4785         return err;
4786 }
4787
4788 static struct connman_storage service_storage = {
4789         .name           = "service",
4790         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
4791         .service_load   = service_load,
4792         .service_save   = service_save,
4793 };
4794
4795 int __connman_service_init(void)
4796 {
4797         DBG("");
4798
4799         connection = connman_dbus_get_connection();
4800
4801         if (connman_storage_register(&service_storage) < 0)
4802                 connman_error("Failed to register service storage");
4803
4804         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
4805                                                                 NULL, NULL);
4806
4807         service_list = g_sequence_new(service_free);
4808
4809         return 0;
4810 }
4811
4812 void __connman_service_cleanup(void)
4813 {
4814         DBG("");
4815
4816         g_sequence_free(service_list);
4817         service_list = NULL;
4818
4819         g_hash_table_destroy(service_hash);
4820         service_hash = NULL;
4821
4822         g_slist_free(counter_list);
4823         counter_list = NULL;
4824
4825         connman_storage_unregister(&service_storage);
4826
4827         dbus_connection_unref(connection);
4828 }