vcs.maemo.org Git - connman/blob - src/service.c

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