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