src/service.c

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