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