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