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