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 int __connman_service_indicate_default(struct connman_service *service)
 822 {
 823         DBG("service %p", service);
 824
 825         return 0;
 826 }
 827
 828 /**
 829  * __connman_service_lookup:
 830  * @identifier: service identifier
 831  *
 832  * Look up a service by identifier (reference count will not be increased)
 833  */
 834 static struct connman_service *__connman_service_lookup(const char *identifier)
 835 {
 836         GSequenceIter *iter;
 837
 838         iter = g_hash_table_lookup(service_hash, identifier);
 839         if (iter != NULL)
 840                 return g_sequence_get(iter);
 841
 842         return NULL;
 843 }
 844
 845 /**
 846  * __connman_service_get:
 847  * @identifier: service identifier
 848  *
 849  * Look up a service by identifier or create a new one if not found
 850  */
 851 static struct connman_service *__connman_service_get(const char *identifier)
 852 {
 853         struct connman_service *service;
 854         GSequenceIter *iter;
 855
 856         iter = g_hash_table_lookup(service_hash, identifier);
 857         if (iter != NULL) {
 858                 service = g_sequence_get(iter);
 859                 if (service != NULL)
 860                         g_atomic_int_inc(&service->refcount);
 861                 return service;
 862         }
 863
 864         service = g_try_new0(struct connman_service, 1);
 865         if (service == NULL)
 866                 return NULL;
 867
 868         DBG("service %p", service);
 869
 870         __connman_service_initialize(service);
 871
 872         service->identifier = g_strdup(identifier);
 873
 874         service->profile = g_strdup(__connman_profile_active_ident());
 875
 876         __connman_storage_load_service(service);
 877
 878         iter = g_sequence_insert_sorted(service_list, service,
 879                                                 service_compare, NULL);
 880
 881         g_hash_table_insert(service_hash, service->identifier, iter);
 882
 883         return service;
 884 }
 885
 886 static int service_register(struct connman_service *service)
 887 {
 888         const char *path = __connman_profile_active_path();
 889         GSequenceIter *iter;
 890
 891         DBG("service %p", service);
 892
 893         if (service->path != NULL)
 894                 return -EALREADY;
 895
 896         service->path = g_strdup_printf("%s/%s", path, service->identifier);
 897
 898         DBG("path %s", service->path);
 899
 900         g_dbus_register_interface(connection, service->path,
 901                                         CONNMAN_SERVICE_INTERFACE,
 902                                         service_methods, service_signals,
 903                                                         NULL, service, NULL);
 904
 905         __connman_storage_load_service(service);
 906
 907         iter = g_hash_table_lookup(service_hash, service->identifier);
 908         if (iter != NULL)
 909                 g_sequence_sort_changed(iter, service_compare, NULL);
 910
 911         __connman_profile_changed();
 912
 913         return 0;
 914 }
 915
 916 /**
 917  * connman_service_lookup_from_device:
 918  * @device: device structure
 919  *
 920  * Look up a service by device (reference count will not be increased)
 921  */
 922 struct connman_service *__connman_service_lookup_from_device(struct connman_device *device)
 923 {
 924         struct connman_service *service;
 925         const char *ident;
 926         char *name;
 927
 928         ident = __connman_device_get_ident(device);
 929         if (ident == NULL)
 930                 return NULL;
 931
 932         name = g_strdup_printf("%s_%s",
 933                                 __connman_device_get_type(device), ident);
 934
 935         service = __connman_service_lookup(name);
 936
 937         g_free(name);
 938
 939         return service;
 940 }
 941
 942 static enum connman_service_type convert_device_type(struct connman_device *device)
 943 {
 944         enum connman_device_type type = connman_device_get_type(device);
 945
 946         switch (type) {
 947         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 948         case CONNMAN_DEVICE_TYPE_VENDOR:
 949         case CONNMAN_DEVICE_TYPE_WIFI:
 950         case CONNMAN_DEVICE_TYPE_WIMAX:
 951         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 952         case CONNMAN_DEVICE_TYPE_GPS:
 953         case CONNMAN_DEVICE_TYPE_HSO:
 954         case CONNMAN_DEVICE_TYPE_NOZOMI:
 955         case CONNMAN_DEVICE_TYPE_HUAWEI:
 956         case CONNMAN_DEVICE_TYPE_NOVATEL:
 957                 break;
 958         case CONNMAN_DEVICE_TYPE_ETHERNET:
 959                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 960         }
 961
 962         return CONNMAN_SERVICE_TYPE_UNKNOWN;
 963 }
 964
 965 /**
 966  * connman_service_create_from_device:
 967  * @device: device structure
 968  *
 969  * Look up service by device and if not found, create one
 970  */
 971 struct connman_service *__connman_service_create_from_device(struct connman_device *device)
 972 {
 973         struct connman_service *service;
 974         const char *ident;
 975         char *name;
 976
 977         ident = __connman_device_get_ident(device);
 978         if (ident == NULL)
 979                 return NULL;
 980
 981         name = g_strdup_printf("%s_%s",
 982                                 __connman_device_get_type(device), ident);
 983
 984         service = __connman_service_get(name);
 985         if (service == NULL)
 986                 goto done;
 987
 988         if (service->path != NULL) {
 989                 __connman_service_put(service);
 990                 service = NULL;
 991                 goto done;
 992         }
 993
 994         service->type = convert_device_type(device);
 995
 996         service->device = device;
 997
 998         service_register(service);
 999
1000 done:
1001         g_free(name);
1002
1003         return service;
1004 }
1005
1006 /**
1007  * connman_service_lookup_from_network:
1008  * @network: network structure
1009  *
1010  * Look up a service by network (reference count will not be increased)
1011  */
1012 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
1013 {
1014         struct connman_service *service;
1015         const char *ident, *group;
1016         char *name;
1017
1018         ident = __connman_network_get_ident(network);
1019         if (ident == NULL)
1020                 return NULL;
1021
1022         group = __connman_network_get_group(network);
1023         if (group == NULL)
1024                 return NULL;
1025
1026         name = g_strdup_printf("%s_%s_%s",
1027                         __connman_network_get_type(network), ident, group);
1028
1029         service = __connman_service_lookup(name);
1030
1031         g_free(name);
1032
1033         return service;
1034 }
1035
1036 static enum connman_service_type convert_network_type(struct connman_network *network)
1037 {
1038         enum connman_network_type type = connman_network_get_type(network);
1039
1040         switch (type) {
1041         case CONNMAN_NETWORK_TYPE_UNKNOWN:
1042         case CONNMAN_NETWORK_TYPE_VENDOR:
1043         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1044         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1045         case CONNMAN_NETWORK_TYPE_HSO:
1046                 break;
1047         case CONNMAN_NETWORK_TYPE_WIFI:
1048                 return CONNMAN_SERVICE_TYPE_WIFI;
1049         case CONNMAN_NETWORK_TYPE_WIMAX:
1050                 return CONNMAN_SERVICE_TYPE_WIMAX;
1051         }
1052
1053         return CONNMAN_SERVICE_TYPE_UNKNOWN;
1054 }
1055
1056 static enum connman_service_mode convert_wifi_mode(const char *mode)
1057 {
1058         if (mode == NULL)
1059                 return CONNMAN_SERVICE_MODE_UNKNOWN;
1060         else if (g_str_equal(mode, "managed") == TRUE)
1061                 return CONNMAN_SERVICE_MODE_MANAGED;
1062         else if (g_str_equal(mode, "adhoc") == TRUE)
1063                 return CONNMAN_SERVICE_MODE_ADHOC;
1064         else
1065                 return CONNMAN_SERVICE_MODE_UNKNOWN;
1066 }
1067
1068 static enum connman_service_mode convert_wifi_security(const char *security)
1069 {
1070         if (security == NULL)
1071                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
1072         else if (g_str_equal(security, "none") == TRUE)
1073                 return CONNMAN_SERVICE_SECURITY_NONE;
1074         else if (g_str_equal(security, "wep") == TRUE)
1075                 return CONNMAN_SERVICE_SECURITY_WEP;
1076         else if (g_str_equal(security, "wpa") == TRUE)
1077                 return CONNMAN_SERVICE_SECURITY_WPA;
1078         else if (g_str_equal(security, "wpa2") == TRUE)
1079                 return CONNMAN_SERVICE_SECURITY_WPA2;
1080         else
1081                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
1082 }
1083
1084 static void update_from_network(struct connman_service *service,
1085                                         struct connman_network *network)
1086 {
1087         connman_uint8_t strength = service->strength;
1088         GSequenceIter *iter;
1089         const char *str;
1090
1091         str = connman_network_get_string(network, "Name");
1092         if (str != NULL) {
1093                 g_free(service->name);
1094                 service->name = g_strdup(str);
1095         }
1096
1097         service->strength = connman_network_get_uint8(network, "Strength");
1098
1099         str = connman_network_get_string(network, "WiFi.Mode");
1100         service->mode = convert_wifi_mode(str);
1101
1102         str = connman_network_get_string(network, "WiFi.Security");
1103         service->security = convert_wifi_security(str);
1104
1105         if (service->strength > strength && service->network != NULL) {
1106                 connman_network_unref(service->network);
1107                 service->network = NULL;
1108         }
1109
1110         if (service->network == NULL) {
1111                 service->network = connman_network_ref(network);
1112
1113                 str = connman_network_get_string(network, "WiFi.Passphrase");
1114                 if (str != NULL) {
1115                         g_free(service->passphrase);
1116                         service->passphrase = g_strdup(str);
1117                 }
1118         }
1119
1120         iter = g_hash_table_lookup(service_hash, service->identifier);
1121         if (iter != NULL)
1122                 g_sequence_sort_changed(iter, service_compare, NULL);
1123 }
1124
1125 /**
1126  * connman_service_create_from_network:
1127  * @network: network structure
1128  *
1129  * Look up service by network and if not found, create one
1130  */
1131 struct connman_service *__connman_service_create_from_network(struct connman_network *network)
1132 {
1133         struct connman_service *service;
1134         const char *ident, *group;
1135         char *name;
1136
1137         ident = __connman_network_get_ident(network);
1138         if (ident == NULL)
1139                 return NULL;
1140
1141         group = __connman_network_get_group(network);
1142         if (group == NULL)
1143                 return NULL;
1144
1145         name = g_strdup_printf("%s_%s_%s",
1146                         __connman_network_get_type(network), ident, group);
1147
1148         service = __connman_service_get(name);
1149         if (service == NULL)
1150                 goto done;
1151
1152         if (service->path != NULL) {
1153                 update_from_network(service, network);
1154
1155                 __connman_profile_changed();
1156
1157                 __connman_service_put(service);
1158                 service = NULL;
1159                 goto done;
1160         }
1161
1162         service->type = convert_network_type(network);
1163
1164         service->state = CONNMAN_SERVICE_STATE_IDLE;
1165
1166         update_from_network(service, network);
1167
1168         service_register(service);
1169
1170 done:
1171         g_free(name);
1172
1173         return service;
1174 }
1175
1176 static int service_load(struct connman_service *service)
1177 {
1178         GKeyFile *keyfile;
1179         gchar *pathname, *data = NULL;
1180         gsize length;
1181         gchar *str;
1182
1183         DBG("service %p", service);
1184
1185         if (service->profile == NULL)
1186                 return -EINVAL;
1187
1188         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, service->profile);
1189         if (pathname == NULL)
1190                 return -ENOMEM;
1191
1192         keyfile = g_key_file_new();
1193
1194         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1195                 g_free(pathname);
1196                 return -ENOENT;
1197         }
1198
1199         g_free(pathname);
1200
1201         if (g_key_file_load_from_data(keyfile, data, length,
1202                                                         0, NULL) == FALSE) {
1203                 g_free(data);
1204                 return -EILSEQ;
1205         }
1206
1207         g_free(data);
1208
1209         switch (service->type) {
1210         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1211         case CONNMAN_SERVICE_TYPE_ETHERNET:
1212                 break;
1213         case CONNMAN_SERVICE_TYPE_WIFI:
1214         case CONNMAN_SERVICE_TYPE_WIMAX:
1215                 service->favorite = g_key_file_get_boolean(keyfile,
1216                                 service->identifier, "Favorite", NULL);
1217                 break;
1218         }
1219
1220         str = g_key_file_get_string(keyfile,
1221                                 service->identifier, "Modified", NULL);
1222         if (str != NULL) {
1223                 g_time_val_from_iso8601(str, &service->modified);
1224                 g_free(str);
1225         }
1226
1227         str = g_key_file_get_string(keyfile,
1228                                 service->identifier, "Passphrase", NULL);
1229         if (str != NULL) {
1230                 g_free(service->passphrase);
1231                 service->passphrase = str;
1232         }
1233
1234         g_key_file_free(keyfile);
1235
1236         return 0;
1237 }
1238
1239 static int service_save(struct connman_service *service)
1240 {
1241         GKeyFile *keyfile;
1242         gchar *pathname, *data = NULL;
1243         gsize length;
1244         gchar *str;
1245
1246         DBG("service %p", service);
1247
1248         if (service->profile == NULL)
1249                 return -EINVAL;
1250
1251         pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, service->profile);
1252         if (pathname == NULL)
1253                 return -ENOMEM;
1254
1255         keyfile = g_key_file_new();
1256
1257         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1258                 goto update;
1259
1260         if (length > 0) {
1261                 if (g_key_file_load_from_data(keyfile, data, length,
1262                                                         0, NULL) == FALSE)
1263                         goto done;
1264         }
1265
1266         g_free(data);
1267
1268 update:
1269         if (service->name != NULL)
1270                 g_key_file_set_string(keyfile, service->identifier,
1271                                                 "Name", service->name);
1272
1273         switch (service->type) {
1274         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1275         case CONNMAN_SERVICE_TYPE_ETHERNET:
1276                 break;
1277         case CONNMAN_SERVICE_TYPE_WIFI:
1278         case CONNMAN_SERVICE_TYPE_WIMAX:
1279                 g_key_file_set_boolean(keyfile, service->identifier,
1280                                         "Favorite", service->favorite);
1281                 break;
1282         }
1283
1284         str = g_time_val_to_iso8601(&service->modified);
1285         if (str != NULL) {
1286                 g_key_file_set_string(keyfile, service->identifier,
1287                                                         "Modified", str);
1288                 g_free(str);
1289         }
1290
1291         if (service->passphrase != NULL)
1292                 g_key_file_set_string(keyfile, service->identifier,
1293                                         "Passphrase", service->passphrase);
1294
1295         data = g_key_file_to_data(keyfile, &length, NULL);
1296
1297         if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
1298                 connman_error("Failed to store service information");
1299
1300 done:
1301         g_free(data);
1302
1303         g_key_file_free(keyfile);
1304
1305         g_free(pathname);
1306
1307         return 0;
1308 }
1309
1310 static struct connman_storage service_storage = {
1311         .name           = "service",
1312         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
1313         .service_load   = service_load,
1314         .service_save   = service_save,
1315 };
1316
1317 int __connman_service_init(void)
1318 {
1319         DBG("");
1320
1321         connection = connman_dbus_get_connection();
1322
1323         if (connman_storage_register(&service_storage) < 0)
1324                 connman_error("Failed to register service storage");
1325
1326         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1327                                                                 NULL, NULL);
1328
1329         service_list = g_sequence_new(service_free);
1330
1331         return 0;
1332 }
1333
1334 void __connman_service_cleanup(void)
1335 {
1336         DBG("");
1337
1338         g_sequence_free(service_list);
1339         service_list = NULL;
1340
1341         g_hash_table_destroy(service_hash);
1342         service_hash = NULL;
1343
1344         connman_storage_unregister(&service_storage);
1345
1346         dbus_connection_unref(connection);
1347 }