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