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