src/service.c

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