vcs.maemo.org Git - connman/blob - 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 <gdbus.h>
  27
  28 #include "connman.h"
  29
  30 static DBusConnection *connection = NULL;
  31
  32 static GSequence *service_list = NULL;
  33 static GHashTable *service_hash = NULL;
  34
  35 struct connman_service {
  36         gint refcount;
  37         char *identifier;
  38         char *path;
  39         enum connman_service_type type;
  40         enum connman_service_mode mode;
  41         enum connman_service_security security;
  42         enum connman_service_state state;
  43         connman_uint8_t strength;
  44         connman_bool_t favorite;
  45         GTimeVal modified;
  46         unsigned int order;
  47         char *name;
  48         char *passphrase;
  49         char *profile;
  50         struct connman_device *device;
  51         struct connman_network *network;
  52         DBusMessage *pending;
  53         guint timeout;
  54 };
  55
  56 static void append_path(gpointer value, gpointer user_data)
  57 {
  58         struct connman_service *service = value;
  59         DBusMessageIter *iter = user_data;
  60
  61         if (service->path == NULL)
  62                 return;
  63
  64         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
  65                                                         &service->path);
  66 }
  67
  68 void __connman_service_list(DBusMessageIter *iter)
  69 {
  70         DBG("");
  71
  72         g_sequence_foreach(service_list, append_path, iter);
  73 }
  74
  75 struct find_data {
  76         const char *path;
  77         struct connman_service *service;
  78 };
  79
  80 static void compare_path(gpointer value, gpointer user_data)
  81 {
  82         struct connman_service *service = value;
  83         struct find_data *data = user_data;
  84
  85         if (data->service != NULL)
  86                 return;
  87
  88         if (g_strcmp0(service->path, data->path) == 0)
  89                 data->service = service;
  90 }
  91
  92 static struct connman_service *find_service(const char *path)
  93 {
  94         struct find_data data = { .path = path, .service = NULL };
  95
  96         DBG("path %s", path);
  97
  98         g_sequence_foreach(service_list, compare_path, &data);
  99
 100         return data.service;
 101 }
 102
 103 static const char *type2string(enum connman_service_type type)
 104 {
 105         switch (type) {
 106         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 107                 break;
 108         case CONNMAN_SERVICE_TYPE_ETHERNET:
 109                 return "ethernet";
 110         case CONNMAN_SERVICE_TYPE_WIFI:
 111                 return "wifi";
 112         case CONNMAN_SERVICE_TYPE_WIMAX:
 113                 return "wimax";
 114         }
 115
 116         return NULL;
 117 }
 118
 119 static const char *mode2string(enum connman_service_mode mode)
 120 {
 121         switch (mode) {
 122         case CONNMAN_SERVICE_MODE_UNKNOWN:
 123                 break;
 124         case CONNMAN_SERVICE_MODE_MANAGED:
 125                 return "managed";
 126         case CONNMAN_SERVICE_MODE_ADHOC:
 127                 return "adhoc";
 128         }
 129
 130         return NULL;
 131 }
 132
 133 static const char *security2string(enum connman_service_security security)
 134 {
 135         switch (security) {
 136         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 137                 break;
 138         case CONNMAN_SERVICE_SECURITY_NONE:
 139                 return "none";
 140         case CONNMAN_SERVICE_SECURITY_WEP:
 141                 return "wep";
 142         case CONNMAN_SERVICE_SECURITY_WPA:
 143                 return "wpa";
 144         case CONNMAN_SERVICE_SECURITY_WPA2:
 145                 return "wpa2";
 146         }
 147
 148         return NULL;
 149 }
 150
 151 static const char *state2string(enum connman_service_state state)
 152 {
 153         switch (state) {
 154         case CONNMAN_SERVICE_STATE_UNKNOWN:
 155                 break;
 156         case CONNMAN_SERVICE_STATE_IDLE:
 157                 return "idle";
 158         case CONNMAN_SERVICE_STATE_CARRIER:
 159                 return "carrier";
 160         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 161                 return "association";
 162         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 163                 return "configuration";
 164         case CONNMAN_SERVICE_STATE_READY:
 165                 return "ready";
 166         case CONNMAN_SERVICE_STATE_DISCONNECT:
 167                 return "disconnect";
 168         case CONNMAN_SERVICE_STATE_FAILURE:
 169                 return "failure";
 170         }
 171
 172         return NULL;
 173 }
 174
 175 static void state_changed(struct connman_service *service)
 176 {
 177         DBusMessage *signal;
 178         DBusMessageIter entry, value;
 179         const char *str, *key = "State";
 180
 181         if (service->path == NULL)
 182                 return;
 183
 184         str = state2string(service->state);
 185         if (str == NULL)
 186                 return;
 187
 188         signal = dbus_message_new_signal(service->path,
 189                                 CONNMAN_SERVICE_INTERFACE, "PropertyChanged");
 190         if (signal == NULL)
 191                 return;
 192
 193         dbus_message_iter_init_append(signal, &entry);
 194
 195         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 196
 197         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 198                                         DBUS_TYPE_STRING_AS_STRING, &value);
 199         dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
 200         dbus_message_iter_close_container(&entry, &value);
 201
 202         g_dbus_send_message(connection, signal);
 203 }
 204
 205 static DBusMessage *get_properties(DBusConnection *conn,
 206                                         DBusMessage *msg, void *user_data)
 207 {
 208         struct connman_service *service = user_data;
 209         DBusMessage *reply;
 210         DBusMessageIter array, dict;
 211         const char *str;
 212
 213         DBG("service %p", service);
 214
 215         reply = dbus_message_new_method_return(msg);
 216         if (reply == NULL)
 217                 return NULL;
 218
 219         dbus_message_iter_init_append(reply, &array);
 220
 221         dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
 222                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 223                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 224                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 225
 226         str = type2string(service->type);
 227         if (str != NULL)
 228                 connman_dbus_dict_append_variant(&dict, "Type",
 229                                                 DBUS_TYPE_STRING, &str);
 230
 231         str = mode2string(service->mode);
 232         if (str != NULL)
 233                 connman_dbus_dict_append_variant(&dict, "Mode",
 234                                                 DBUS_TYPE_STRING, &str);
 235
 236         str = security2string(service->security);
 237         if (str != NULL)
 238                 connman_dbus_dict_append_variant(&dict, "Security",
 239                                                 DBUS_TYPE_STRING, &str);
 240
 241         str = state2string(service->state);
 242         if (str != NULL)
 243                 connman_dbus_dict_append_variant(&dict, "State",
 244                                                 DBUS_TYPE_STRING, &str);
 245
 246         if (service->strength > 0)
 247                 connman_dbus_dict_append_variant(&dict, "Strength",
 248                                         DBUS_TYPE_BYTE, &service->strength);
 249
 250         connman_dbus_dict_append_variant(&dict, "Favorite",
 251                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 252
 253         if (service->name != NULL)
 254                 connman_dbus_dict_append_variant(&dict, "Name",
 255                                         DBUS_TYPE_STRING, &service->name);
 256
 257         if (service->passphrase != NULL &&
 258                         __connman_security_check_privilege(msg,
 259                                 CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
 260                 connman_dbus_dict_append_variant(&dict, "Passphrase",
 261                                 DBUS_TYPE_STRING, &service->passphrase);
 262
 263         dbus_message_iter_close_container(&array, &dict);
 264
 265         return reply;
 266 }
 267
 268 static DBusMessage *set_property(DBusConnection *conn,
 269                                         DBusMessage *msg, void *user_data)
 270 {
 271         struct connman_service *service = user_data;
 272         DBusMessageIter iter, value;
 273         const char *name;
 274         int type;
 275
 276         DBG("service %p", service);
 277
 278         if (dbus_message_iter_init(msg, &iter) == FALSE)
 279                 return __connman_error_invalid_arguments(msg);
 280
 281         dbus_message_iter_get_basic(&iter, &name);
 282         dbus_message_iter_next(&iter);
 283         dbus_message_iter_recurse(&iter, &value);
 284
 285         if (__connman_security_check_privilege(msg,
 286                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 287                 return __connman_error_permission_denied(msg);
 288
 289         type = dbus_message_iter_get_arg_type(&value);
 290
 291         if (g_str_equal(name, "Passphrase") == TRUE) {
 292                 const char *passphrase;
 293
 294                 if (type != DBUS_TYPE_STRING)
 295                         return __connman_error_invalid_arguments(msg);
 296
 297                 if (__connman_security_check_privilege(msg,
 298                                         CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0)
 299                         return __connman_error_permission_denied(msg);
 300
 301                 dbus_message_iter_get_basic(&value, &passphrase);
 302
 303                 g_free(service->passphrase);
 304                 service->passphrase = g_strdup(passphrase);
 305
 306                 if (service->network != NULL)
 307                         connman_network_set_string(service->network,
 308                                 "WiFi.Passphrase", service->passphrase);
 309
 310                 __connman_storage_save_service(service);
 311         }
 312
 313         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 314 }
 315
 316 static gboolean connect_timeout(gpointer user_data)
 317 {
 318         struct connman_service *service = user_data;
 319
 320         DBG("service %p", service);
 321
 322         service->timeout = 0;
 323
 324         if (service->network != NULL)
 325                 __connman_network_disconnect(service->network);
 326
 327         if (service->pending != NULL) {
 328                 DBusMessage *reply;
 329
 330                 reply = __connman_error_operation_timeout(service->pending);
 331                 if (reply != NULL)
 332                         g_dbus_send_message(connection, reply);
 333
 334                 dbus_message_unref(service->pending);
 335                 service->pending = NULL;
 336
 337                 __connman_service_indicate_state(service,
 338                                         CONNMAN_SERVICE_STATE_FAILURE);
 339         }
 340
 341         return FALSE;
 342 }
 343
 344 static DBusMessage *connect_service(DBusConnection *conn,
 345                                         DBusMessage *msg, void *user_data)
 346 {
 347         struct connman_service *service = user_data;
 348
 349         DBG("service %p", service);
 350
 351         if (service->pending != NULL)
 352                 return __connman_error_in_progress(msg);
 353
 354         if (service->state == CONNMAN_SERVICE_STATE_READY)
 355                 return __connman_error_already_connected(msg);
 356
 357         if (service->network != NULL) {
 358                 int err;
 359
 360                 connman_network_set_string(service->network,
 361                                 "WiFi.Passphrase", service->passphrase);
 362
 363                 err = connman_network_connect(service->network);
 364                 if (err < 0 && err != -EINPROGRESS)
 365                         return __connman_error_failed(msg, -err);
 366
 367                 service->pending = dbus_message_ref(msg);
 368
 369                 service->timeout = g_timeout_add_seconds(45,
 370                                                 connect_timeout, service);
 371
 372                 return NULL;
 373         } else if (service->device != NULL) {
 374                 if (service->favorite == FALSE)
 375                         return __connman_error_no_carrier(msg);
 376
 377                 if (__connman_device_connect(service->device) < 0)
 378                         return __connman_error_failed(msg, EINVAL);
 379
 380                 service->pending = dbus_message_ref(msg);
 381                 service->timeout = g_timeout_add_seconds(15,
 382                                                 connect_timeout, service);
 383
 384                 return NULL;
 385         }
 386
 387         return __connman_error_not_supported(msg);
 388 }
 389
 390 static DBusMessage *disconnect_service(DBusConnection *conn,
 391                                         DBusMessage *msg, void *user_data)
 392 {
 393         struct connman_service *service = user_data;
 394
 395         DBG("service %p", service);
 396
 397         if (service->pending != NULL) {
 398                 DBusMessage *reply;
 399
 400                 reply = __connman_error_operation_aborted(service->pending);
 401                 if (reply != NULL)
 402                         g_dbus_send_message(conn, reply);
 403
 404                 dbus_message_unref(service->pending);
 405                 service->pending = NULL;
 406
 407                 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 408         }
 409
 410         if (service->network != NULL) {
 411                 int err;
 412
 413                 err = __connman_network_disconnect(service->network);
 414                 if (err < 0 && err != -EINPROGRESS)
 415                         return __connman_error_failed(msg, -err);
 416
 417                 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 418         } else if (service->device != NULL) {
 419                 int err;
 420
 421                 if (service->favorite == FALSE)
 422                         return __connman_error_no_carrier(msg);
 423
 424                 err = __connman_device_disconnect(service->device);
 425                 if (err < 0)
 426                         return __connman_error_failed(msg, -err);
 427
 428                 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 429         }
 430
 431         return __connman_error_not_supported(msg);
 432 }
 433
 434 static DBusMessage *remove_service(DBusConnection *conn,
 435                                         DBusMessage *msg, void *user_data)
 436 {
 437         struct connman_service *service = user_data;
 438
 439         DBG("service %p", service);
 440
 441         if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
 442                 return __connman_error_not_supported(msg);
 443
 444         if (service->favorite == FALSE)
 445                 return __connman_error_not_supported(msg);
 446
 447         if (service->network != NULL)
 448                 __connman_network_disconnect(service->network);
 449
 450         connman_service_set_favorite(service, FALSE);
 451         __connman_storage_save_service(service);
 452
 453         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 454 }
 455
 456 static DBusMessage *move_before(DBusConnection *conn,
 457                                         DBusMessage *msg, void *user_data)
 458 {
 459         struct connman_service *service = user_data;
 460         struct connman_service *target;
 461         const char *path;
 462         GSequenceIter *src, *dst;
 463
 464         DBG("service %p", service);
 465
 466         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 467                                                         DBUS_TYPE_INVALID);
 468
 469         if (service->favorite == FALSE)
 470                 return __connman_error_not_supported(msg);
 471
 472         target = find_service(path);
 473         if (target == NULL || target->favorite == FALSE || target == service)
 474                 return __connman_error_invalid_service(msg);
 475
 476         DBG("target %s", target->identifier);
 477
 478         g_get_current_time(&service->modified);
 479         __connman_storage_save_service(service);
 480
 481         src = g_hash_table_lookup(service_hash, service->identifier);
 482         dst = g_hash_table_lookup(service_hash, target->identifier);
 483
 484 #if 0
 485         g_sequence_move(src, dst);
 486
 487         __connman_profile_changed();
 488
 489         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 490 #endif
 491         return __connman_error_not_implemented(msg);
 492 }
 493
 494 static DBusMessage *move_after(DBusConnection *conn,
 495                                         DBusMessage *msg, void *user_data)
 496 {
 497         struct connman_service *service = user_data;
 498         struct connman_service *target;
 499         const char *path;
 500
 501         DBG("service %p", service);
 502
 503         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 504                                                         DBUS_TYPE_INVALID);
 505
 506         if (service->favorite == FALSE)
 507                 return __connman_error_not_supported(msg);
 508
 509         target = find_service(path);
 510         if (target == NULL || target->favorite == FALSE || target == service)
 511                 return __connman_error_invalid_service(msg);
 512
 513         DBG("target %s", target->identifier);
 514
 515         g_get_current_time(&service->modified);
 516         __connman_storage_save_service(service);
 517
 518         return __connman_error_not_implemented(msg);
 519 }
 520
 521 static GDBusMethodTable service_methods[] = {
 522         { "GetProperties", "",   "a{sv}", get_properties     },
 523         { "SetProperty",   "sv", "",      set_property       },
 524         { "Connect",       "",   "",      connect_service,
 525                                                 G_DBUS_METHOD_FLAG_ASYNC },
 526         { "Disconnect",    "",   "",      disconnect_service },
 527         { "Remove",        "",   "",      remove_service     },
 528         { "MoveBefore",    "o",  "",      move_before        },
 529         { "MoveAfter",     "o",  "",      move_after         },
 530         { },
 531 };
 532
 533 static GDBusSignalTable service_signals[] = {
 534         { "PropertyChanged", "sv" },
 535         { },
 536 };
 537
 538 static void service_free(gpointer user_data)
 539 {
 540         struct connman_service *service = user_data;
 541         char *path = service->path;
 542
 543         DBG("service %p", service);
 544
 545         g_hash_table_remove(service_hash, service->identifier);
 546
 547         if (service->timeout > 0)
 548                 g_source_remove(service->timeout);
 549
 550         if (service->pending != NULL) {
 551                 dbus_message_unref(service->pending);
 552                 service->pending = NULL;
 553         }
 554
 555         service->path = NULL;
 556
 557         if (path != NULL) {
 558                 __connman_profile_changed();
 559
 560                 g_dbus_unregister_interface(connection, path,
 561                                                 CONNMAN_SERVICE_INTERFACE);
 562                 g_free(path);
 563         }
 564
 565         if (service->network != NULL)
 566                 connman_network_unref(service->network);
 567
 568         g_free(service->profile);
 569         g_free(service->name);
 570         g_free(service->passphrase);
 571         g_free(service->identifier);
 572         g_free(service);
 573 }
 574
 575 /**
 576  * __connman_service_put:
 577  * @service: service structure
 578  *
 579  * Release service if no longer needed
 580  */
 581 void __connman_service_put(struct connman_service *service)
 582 {
 583         DBG("service %p", service);
 584
 585         if (g_atomic_int_dec_and_test(&service->refcount) == TRUE) {
 586                 GSequenceIter *iter;
 587
 588                 iter = g_hash_table_lookup(service_hash, service->identifier);
 589                 if (iter != NULL)
 590                         g_sequence_remove(iter);
 591                 else
 592                         service_free(service);
 593         }
 594 }
 595
 596 static void __connman_service_initialize(struct connman_service *service)
 597 {
 598         DBG("service %p", service);
 599
 600         service->refcount = 1;
 601
 602         service->type     = CONNMAN_SERVICE_TYPE_UNKNOWN;
 603         service->mode     = CONNMAN_SERVICE_MODE_UNKNOWN;
 604         service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
 605         service->state    = CONNMAN_SERVICE_STATE_UNKNOWN;
 606
 607         service->favorite = FALSE;
 608
 609         service->order = 0;
 610 }
 611
 612 /**
 613  * connman_service_create:
 614  *
 615  * Allocate a new service.
 616  *
 617  * Returns: a newly-allocated #connman_service structure
 618  */
 619 struct connman_service *connman_service_create(void)
 620 {
 621         struct connman_service *service;
 622
 623         service = g_try_new0(struct connman_service, 1);
 624         if (service == NULL)
 625                 return NULL;
 626
 627         DBG("service %p", service);
 628
 629         __connman_service_initialize(service);
 630
 631         return service;
 632 }
 633
 634 /**
 635  * connman_service_ref:
 636  * @service: service structure
 637  *
 638  * Increase reference counter of service
 639  */
 640 struct connman_service *connman_service_ref(struct connman_service *service)
 641 {
 642         g_atomic_int_inc(&service->refcount);
 643
 644         return service;
 645 }
 646
 647 /**
 648  * connman_service_unref:
 649  * @service: service structure
 650  *
 651  * Decrease reference counter of service
 652  */
 653 void connman_service_unref(struct connman_service *service)
 654 {
 655         __connman_service_put(service);
 656 }
 657
 658 static gint service_compare(gconstpointer a, gconstpointer b,
 659                                                         gpointer user_data)
 660 {
 661         struct connman_service *service_a = (void *) a;
 662         struct connman_service *service_b = (void *) b;
 663
 664         if (service_a->state != service_b->state) {
 665                 if (service_a->state == CONNMAN_SERVICE_STATE_READY)
 666                         return -1;
 667                 if (service_b->state == CONNMAN_SERVICE_STATE_READY)
 668                         return 1;
 669         }
 670
 671         if (service_a->order > service_b->order)
 672                 return -1;
 673
 674         if (service_a->order < service_b->order)
 675                 return 1;
 676
 677         if (service_a->favorite == TRUE && service_b->favorite == FALSE)
 678                 return -1;
 679
 680         if (service_a->favorite == FALSE && service_b->favorite == TRUE)
 681                 return 1;
 682
 683         return (gint) service_b->strength - (gint) service_a->strength;
 684 }
 685
 686 /**
 687  * connman_service_set_favorite:
 688  * @service: service structure
 689  * @favorite: favorite value
 690  *
 691  * Change the favorite setting of service
 692  */
 693 int connman_service_set_favorite(struct connman_service *service,
 694                                                 connman_bool_t favorite)
 695 {
 696         GSequenceIter *iter;
 697
 698         iter = g_hash_table_lookup(service_hash, service->identifier);
 699         if (iter == NULL)
 700                 return -ENOENT;
 701
 702         if (service->favorite == favorite)
 703                 return -EALREADY;
 704
 705         service->favorite = favorite;
 706
 707         g_sequence_sort_changed(iter, service_compare, NULL);
 708
 709         __connman_profile_changed();
 710
 711         return 0;
 712 }
 713
 714 int __connman_service_set_carrier(struct connman_service *service,
 715                                                 connman_bool_t carrier)
 716 {
 717         DBG("service %p carrier %d", service, carrier);
 718
 719         if (service == NULL)
 720                 return -EINVAL;
 721
 722         switch (service->type) {
 723         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 724         case CONNMAN_SERVICE_TYPE_WIFI:
 725         case CONNMAN_SERVICE_TYPE_WIMAX:
 726                 return -EINVAL;
 727         case CONNMAN_SERVICE_TYPE_ETHERNET:
 728                 break;
 729         }
 730
 731         if (carrier == FALSE) {
 732                 service->state = CONNMAN_SERVICE_STATE_DISCONNECT;
 733                 state_changed(service);
 734
 735                 service->state = CONNMAN_SERVICE_STATE_IDLE;
 736                 state_changed(service);
 737         } else {
 738                 service->state = CONNMAN_SERVICE_STATE_CARRIER;
 739                 state_changed(service);
 740         }
 741
 742         return connman_service_set_favorite(service, carrier);
 743 }
 744
 745 int __connman_service_indicate_state(struct connman_service *service,
 746                                         enum connman_service_state state)
 747 {
 748         GSequenceIter *iter;
 749
 750         DBG("service %p state %d", service, state);
 751
 752         if (service == NULL)
 753                 return -EINVAL;
 754
 755         if (state == CONNMAN_SERVICE_STATE_CARRIER)
 756                 return __connman_service_set_carrier(service, TRUE);
 757
 758         if (service->state == state)
 759                 return -EALREADY;
 760
 761         if (service->state == CONNMAN_SERVICE_STATE_IDLE &&
 762                                 state == CONNMAN_SERVICE_STATE_DISCONNECT)
 763                 return -EINVAL;
 764
 765         if (state == CONNMAN_SERVICE_STATE_IDLE &&
 766                         service->state != CONNMAN_SERVICE_STATE_DISCONNECT) {
 767                 service->state = CONNMAN_SERVICE_STATE_DISCONNECT;
 768                 state_changed(service);
 769         }
 770
 771         service->state = state;
 772         state_changed(service);
 773
 774         if (state == CONNMAN_SERVICE_STATE_READY) {
 775                 connman_service_set_favorite(service, TRUE);
 776                 __connman_storage_save_service(service);
 777
 778                 if (service->timeout > 0)
 779                         g_source_remove(service->timeout);
 780
 781                 if (service->pending != NULL) {
 782                         g_dbus_send_reply(connection, service->pending,
 783                                                         DBUS_TYPE_INVALID);
 784
 785                         dbus_message_unref(service->pending);
 786                         service->pending = NULL;
 787                 }
 788
 789                 g_get_current_time(&service->modified);
 790                 __connman_storage_save_service(service);
 791         }
 792
 793         if (state == CONNMAN_SERVICE_STATE_FAILURE) {
 794                 if (service->timeout > 0)
 795                         g_source_remove(service->timeout);
 796
 797                 if (service->pending != NULL) {
 798                         DBusMessage *reply;
 799
 800                         reply = __connman_error_failed(service->pending, EIO);
 801                         if (reply != NULL)
 802                                 g_dbus_send_message(connection, reply);
 803
 804                         dbus_message_unref(service->pending);
 805                         service->pending = NULL;
 806                 }
 807
 808                 service->state = CONNMAN_SERVICE_STATE_IDLE;
 809                 state_changed(service);
 810         }
 811
 812         iter = g_hash_table_lookup(service_hash, service->identifier);
 813         if (iter != NULL)
 814                 g_sequence_sort_changed(iter, service_compare, NULL);
 815
 816         __connman_profile_changed();
 817
 818         return 0;
 819 }
 820
 821 /**
 822  * __connman_service_lookup:
 823  * @identifier: service identifier
 824  *
 825  * Look up a service by identifier (reference count will not be increased)
 826  */
 827 static struct connman_service *__connman_service_lookup(const char *identifier)
 828 {
 829         GSequenceIter *iter;
 830
 831         iter = g_hash_table_lookup(service_hash, identifier);
 832         if (iter != NULL)
 833                 return g_sequence_get(iter);
 834
 835         return NULL;
 836 }
 837
 838 /**
 839  * __connman_service_get:
 840  * @identifier: service identifier
 841  *
 842  * Look up a service by identifier or create a new one if not found
 843  */
 844 static struct connman_service *__connman_service_get(const char *identifier)
 845 {
 846         struct connman_service *service;
 847         GSequenceIter *iter;
 848
 849         iter = g_hash_table_lookup(service_hash, identifier);
 850         if (iter != NULL) {
 851                 service = g_sequence_get(iter);
 852                 if (service != NULL)
 853                         g_atomic_int_inc(&service->refcount);
 854                 return service;
 855         }
 856
 857         service = g_try_new0(struct connman_service, 1);
 858         if (service == NULL)
 859                 return NULL;
 860
 861         DBG("service %p", service);
 862
 863         __connman_service_initialize(service);
 864
 865         service->identifier = g_strdup(identifier);
 866
 867         service->profile = g_strdup(__connman_profile_active_ident());
 868
 869         __connman_storage_load_service(service);
 870
 871         iter = g_sequence_insert_sorted(service_list, service,
 872                                                 service_compare, NULL);
 873
 874         g_hash_table_insert(service_hash, service->identifier, iter);
 875
 876         return service;
 877 }
 878
 879 static int service_register(struct connman_service *service)
 880 {
 881         const char *path = __connman_profile_active_path();
 882         GSequenceIter *iter;
 883
 884         DBG("service %p", service);
 885
 886         if (service->path != NULL)
 887                 return -EALREADY;
 888
 889         service->path = g_strdup_printf("%s/%s", path, service->identifier);
 890
 891         DBG("path %s", service->path);
 892
 893         g_dbus_register_interface(connection, service->path,
 894                                         CONNMAN_SERVICE_INTERFACE,
 895                                         service_methods, service_signals,
 896                                                         NULL, service, NULL);
 897
 898         __connman_storage_load_service(service);
 899
 900         iter = g_hash_table_lookup(service_hash, service->identifier);
 901         if (iter != NULL)
 902                 g_sequence_sort_changed(iter, service_compare, NULL);
 903
 904         __connman_profile_changed();
 905
 906         return 0;
 907 }
 908
 909 /**
 910  * connman_service_lookup_from_device:
 911  * @device: device structure
 912  *
 913  * Look up a service by device (reference count will not be increased)
 914  */
 915 struct connman_service *__connman_service_lookup_from_device(struct connman_device *device)
 916 {
 917         struct connman_service *service;
 918         const char *ident;
 919         char *name;
 920
 921         ident = __connman_device_get_ident(device);
 922         if (ident == NULL)
 923                 return NULL;
 924
 925         name = g_strdup_printf("%s_%s",
 926                                 __connman_device_get_type(device), ident);
 927
 928         service = __connman_service_lookup(name);
 929
 930         g_free(name);
 931
 932         return service;
 933 }
 934
 935 static enum connman_service_type convert_device_type(struct connman_device *device)
 936 {
 937         enum connman_device_type type = connman_device_get_type(device);
 938
 939         switch (type) {
 940         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 941         case CONNMAN_DEVICE_TYPE_VENDOR:
 942         case CONNMAN_DEVICE_TYPE_WIFI:
 943         case CONNMAN_DEVICE_TYPE_WIMAX:
 944         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 945         case CONNMAN_DEVICE_TYPE_GPS:
 946         case CONNMAN_DEVICE_TYPE_HSO:
 947         case CONNMAN_DEVICE_TYPE_NOZOMI:
 948         case CONNMAN_DEVICE_TYPE_HUAWEI:
 949         case CONNMAN_DEVICE_TYPE_NOVATEL:
 950                 break;
 951         case CONNMAN_DEVICE_TYPE_ETHERNET:
 952                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 953         }
 954
 955         return CONNMAN_SERVICE_TYPE_UNKNOWN;
 956 }
 957
 958 /**
 959  * connman_service_create_from_device:
 960  * @device: device structure
 961  *
 962  * Look up service by device and if not found, create one
 963  */
 964 struct connman_service *__connman_service_create_from_device(struct connman_device *device)
 965 {
 966         struct connman_service *service;
 967         const char *ident;
 968         char *name;
 969
 970         ident = __connman_device_get_ident(device);
 971         if (ident == NULL)
 972                 return NULL;
 973
 974         name = g_strdup_printf("%s_%s",
 975                                 __connman_device_get_type(device), ident);
 976
 977         service = __connman_service_get(name);
 978         if (service == NULL)
 979                 goto done;
 980
 981         if (service->path != NULL) {
 982                 __connman_service_put(service);
 983                 service = NULL;
 984                 goto done;
 985         }
 986
 987         service->type = convert_device_type(device);
 988
 989         service->device = device;
 990
 991         service_register(service);
 992
 993 done:
 994         g_free(name);
 995
 996         return service;
 997 }
 998
 999 /**
1000  * connman_service_lookup_from_network:
1001  * @network: network structure
1002  *
1003  * Look up a service by network (reference count will not be increased)
1004  */
1005 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
1006 {
1007         struct connman_service *service;
1008         const char *ident, *group;
1009         char *name;
1010
1011         ident = __connman_network_get_ident(network);
1012         if (ident == NULL)
1013                 return NULL;
1014
1015         group = __connman_network_get_group(network);
1016         if (group == NULL)
1017                 return NULL;
1018
1019         name = g_strdup_printf("%s_%s_%s",
1020                         __connman_network_get_type(network), ident, group);
1021
1022         service = __connman_service_lookup(name);
1023
1024         g_free(name);
1025
1026         return service;
1027 }
1028
1029 static enum connman_service_type convert_network_type(struct connman_network *network)
1030 {
1031         enum connman_network_type type = connman_network_get_type(network);
1032
1033         switch (type) {
1034         case CONNMAN_NETWORK_TYPE_UNKNOWN:
1035         case CONNMAN_NETWORK_TYPE_VENDOR:
1036         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1037         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1038         case CONNMAN_NETWORK_TYPE_HSO:
1039                 break;
1040         case CONNMAN_NETWORK_TYPE_WIFI:
1041                 return CONNMAN_SERVICE_TYPE_WIFI;
1042         case CONNMAN_NETWORK_TYPE_WIMAX:
1043                 return CONNMAN_SERVICE_TYPE_WIMAX;
1044         }
1045
1046         return CONNMAN_SERVICE_TYPE_UNKNOWN;
1047 }
1048
1049 static enum connman_service_mode convert_wifi_mode(const char *mode)
1050 {
1051         if (mode == NULL)
1052                 return CONNMAN_SERVICE_MODE_UNKNOWN;
1053         else if (g_str_equal(mode, "managed") == TRUE)
1054                 return CONNMAN_SERVICE_MODE_MANAGED;
1055         else if (g_str_equal(mode, "adhoc") == TRUE)
1056                 return CONNMAN_SERVICE_MODE_ADHOC;
1057         else
1058                 return CONNMAN_SERVICE_MODE_UNKNOWN;
1059 }
1060
1061 static enum connman_service_mode convert_wifi_security(const char *security)
1062 {
1063         if (security == NULL)
1064                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
1065         else if (g_str_equal(security, "none") == TRUE)
1066                 return CONNMAN_SERVICE_SECURITY_NONE;
1067         else if (g_str_equal(security, "wep") == TRUE)
1068                 return CONNMAN_SERVICE_SECURITY_WEP;
1069         else if (g_str_equal(security, "wpa") == TRUE)
1070                 return CONNMAN_SERVICE_SECURITY_WPA;
1071         else if (g_str_equal(security, "wpa2") == TRUE)
1072                 return CONNMAN_SERVICE_SECURITY_WPA2;
1073         else
1074                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
1075 }
1076
1077 static void update_from_network(struct connman_service *service,
1078                                         struct connman_network *network)
1079 {
1080         connman_uint8_t strength = service->strength;
1081         GSequenceIter *iter;
1082         const char *str;
1083
1084         str = connman_network_get_string(network, "Name");
1085         if (str != NULL) {
1086                 g_free(service->name);
1087                 service->name = g_strdup(str);
1088         }
1089
1090         service->strength = connman_network_get_uint8(network, "Strength");
1091
1092         str = connman_network_get_string(network, "WiFi.Mode");
1093         service->mode = convert_wifi_mode(str);
1094
1095         str = connman_network_get_string(network, "WiFi.Security");
1096         service->security = convert_wifi_security(str);
1097
1098         if (service->strength > strength && service->network != NULL) {
1099                 connman_network_unref(service->network);
1100                 service->network = NULL;
1101         }
1102
1103         if (service->network == NULL) {
1104                 service->network = connman_network_ref(network);
1105
1106                 str = connman_network_get_string(network, "WiFi.Passphrase");
1107                 if (str != NULL) {
1108                         g_free(service->passphrase);
1109                         service->passphrase = g_strdup(str);
1110                 }
1111         }
1112
1113         iter = g_hash_table_lookup(service_hash, service->identifier);
1114         if (iter != NULL)
1115                 g_sequence_sort_changed(iter, service_compare, NULL);
1116 }
1117
1118 /**
1119  * connman_service_create_from_network:
1120  * @network: network structure
1121  *
1122  * Look up service by network and if not found, create one
1123  */
1124 struct connman_service *__connman_service_create_from_network(struct connman_network *network)
1125 {
1126         struct connman_service *service;
1127         const char *ident, *group;
1128         char *name;
1129
1130         ident = __connman_network_get_ident(network);
1131         if (ident == NULL)
1132                 return NULL;
1133
1134         group = __connman_network_get_group(network);
1135         if (group == NULL)
1136                 return NULL;
1137
1138         name = g_strdup_printf("%s_%s_%s",
1139                         __connman_network_get_type(network), ident, group);
1140
1141         service = __connman_service_get(name);
1142         if (service == NULL)
1143                 goto done;
1144
1145         if (service->path != NULL) {
1146                 update_from_network(service, network);
1147
1148                 __connman_profile_changed();
1149
1150                 __connman_service_put(service);
1151                 service = NULL;
1152                 goto done;
1153         }
1154
1155         service->type = convert_network_type(network);
1156
1157         service->state = CONNMAN_SERVICE_STATE_IDLE;
1158
1159         update_from_network(service, network);
1160
1161         service_register(service);
1162
1163 done:
1164         g_free(name);
1165
1166         return service;
1167 }
1168
1169 static int service_load(struct connman_service *service)
1170 {
1171         GKeyFile *keyfile;
1172         gchar *pathname, *data = NULL;
1173         gsize length;
1174         gchar *str;
1175
1176         DBG("service %p", service);
1177
1178         if (service->profile == NULL)
1179                 return -EINVAL;
1180
1181         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, service->profile);
1182         if (pathname == NULL)
1183                 return -ENOMEM;
1184
1185         keyfile = g_key_file_new();
1186
1187         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1188                 g_free(pathname);
1189                 return -ENOENT;
1190         }
1191
1192         g_free(pathname);
1193
1194         if (g_key_file_load_from_data(keyfile, data, length,
1195                                                         0, NULL) == FALSE) {
1196                 g_free(data);
1197                 return -EILSEQ;
1198         }
1199
1200         g_free(data);
1201
1202         switch (service->type) {
1203         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1204         case CONNMAN_SERVICE_TYPE_ETHERNET:
1205                 break;
1206         case CONNMAN_SERVICE_TYPE_WIFI:
1207         case CONNMAN_SERVICE_TYPE_WIMAX:
1208                 service->favorite = g_key_file_get_boolean(keyfile,
1209                                 service->identifier, "Favorite", NULL);
1210                 break;
1211         }
1212
1213         str = g_key_file_get_string(keyfile,
1214                                 service->identifier, "Modified", NULL);
1215         if (str != NULL) {
1216                 g_time_val_from_iso8601(str, &service->modified);
1217                 g_free(str);
1218         }
1219
1220         str = g_key_file_get_string(keyfile,
1221                                 service->identifier, "Passphrase", NULL);
1222         if (str != NULL) {
1223                 g_free(service->passphrase);
1224                 service->passphrase = str;
1225         }
1226
1227         g_key_file_free(keyfile);
1228
1229         return 0;
1230 }
1231
1232 static int service_save(struct connman_service *service)
1233 {
1234         GKeyFile *keyfile;
1235         gchar *pathname, *data = NULL;
1236         gsize length;
1237         gchar *str;
1238
1239         DBG("service %p", service);
1240
1241         if (service->profile == NULL)
1242                 return -EINVAL;
1243
1244         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, service->profile);
1245         if (pathname == NULL)
1246                 return -ENOMEM;
1247
1248         keyfile = g_key_file_new();
1249
1250         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1251                 goto update;
1252
1253         if (length > 0) {
1254                 if (g_key_file_load_from_data(keyfile, data, length,
1255                                                         0, NULL) == FALSE)
1256                         goto done;
1257         }
1258
1259         g_free(data);
1260
1261 update:
1262         if (service->name != NULL)
1263                 g_key_file_set_string(keyfile, service->identifier,
1264                                                 "Name", service->name);
1265
1266         switch (service->type) {
1267         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1268         case CONNMAN_SERVICE_TYPE_ETHERNET:
1269                 break;
1270         case CONNMAN_SERVICE_TYPE_WIFI:
1271         case CONNMAN_SERVICE_TYPE_WIMAX:
1272                 g_key_file_set_boolean(keyfile, service->identifier,
1273                                         "Favorite", service->favorite);
1274                 break;
1275         }
1276
1277         str = g_time_val_to_iso8601(&service->modified);
1278         if (str != NULL) {
1279                 g_key_file_set_string(keyfile, service->identifier,
1280                                                         "Modified", str);
1281                 g_free(str);
1282         }
1283
1284         if (service->passphrase != NULL)
1285                 g_key_file_set_string(keyfile, service->identifier,
1286                                         "Passphrase", service->passphrase);
1287
1288         data = g_key_file_to_data(keyfile, &length, NULL);
1289
1290         if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
1291                 connman_error("Failed to store service information");
1292
1293 done:
1294         g_free(data);
1295
1296         g_key_file_free(keyfile);
1297
1298         g_free(pathname);
1299
1300         return 0;
1301 }
1302
1303 static struct connman_storage service_storage = {
1304         .name           = "service",
1305         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
1306         .service_load   = service_load,
1307         .service_save   = service_save,
1308 };
1309
1310 int __connman_service_init(void)
1311 {
1312         DBG("");
1313
1314         connection = connman_dbus_get_connection();
1315
1316         if (connman_storage_register(&service_storage) < 0)
1317                 connman_error("Failed to register service storage");
1318
1319         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1320                                                                 NULL, NULL);
1321
1322         service_list = g_sequence_new(service_free);
1323
1324         return 0;
1325 }
1326
1327 void __connman_service_cleanup(void)
1328 {
1329         DBG("");
1330
1331         g_sequence_free(service_list);
1332         service_list = NULL;
1333
1334         g_hash_table_destroy(service_hash);
1335         service_hash = NULL;
1336
1337         connman_storage_unregister(&service_storage);
1338
1339         dbus_connection_unref(connection);
1340 }