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