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