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 <stdio.h>
  27 #include <string.h>
  28 #include <gdbus.h>
  29
  30 #include "connman.h"
  31
  32 #define CONNECT_TIMEOUT         120
  33
  34 static DBusConnection *connection = NULL;
  35
  36 static GSequence *service_list = NULL;
  37 static GHashTable *service_hash = NULL;
  38
  39 struct connman_service {
  40         gint refcount;
  41         char *identifier;
  42         char *path;
  43         enum connman_service_type type;
  44         enum connman_service_mode mode;
  45         enum connman_service_security security;
  46         enum connman_service_state state;
  47         enum connman_service_error error;
  48         connman_uint8_t strength;
  49         connman_bool_t favorite;
  50         connman_bool_t hidden;
  51         connman_bool_t ignore;
  52         connman_bool_t autoconnect;
  53         connman_bool_t userconnect;
  54         GTimeVal modified;
  55         unsigned int order;
  56         char *name;
  57         char *passphrase;
  58         char *profile;
  59         char *apn;
  60         char *username;
  61         char *password;
  62         char *mcc;
  63         char *mnc;
  64         connman_bool_t roaming;
  65         struct connman_ipconfig *ipconfig;
  66         struct connman_network *network;
  67         DBusMessage *pending;
  68         guint timeout;
  69 };
  70
  71 static void append_path(gpointer value, gpointer user_data)
  72 {
  73         struct connman_service *service = value;
  74         DBusMessageIter *iter = user_data;
  75
  76         if (service->path == NULL || service->hidden == TRUE)
  77                 return;
  78
  79         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
  80                                                         &service->path);
  81 }
  82
  83 void __connman_service_list(DBusMessageIter *iter, void *user_data)
  84 {
  85         g_sequence_foreach(service_list, append_path, iter);
  86 }
  87
  88 struct find_data {
  89         const char *path;
  90         struct connman_service *service;
  91 };
  92
  93 static void compare_path(gpointer value, gpointer user_data)
  94 {
  95         struct connman_service *service = value;
  96         struct find_data *data = user_data;
  97
  98         if (data->service != NULL)
  99                 return;
 100
 101         if (g_strcmp0(service->path, data->path) == 0)
 102                 data->service = service;
 103 }
 104
 105 static struct connman_service *find_service(const char *path)
 106 {
 107         struct find_data data = { .path = path, .service = NULL };
 108
 109         DBG("path %s", path);
 110
 111         g_sequence_foreach(service_list, compare_path, &data);
 112
 113         return data.service;
 114 }
 115
 116 const char *__connman_service_type2string(enum connman_service_type type)
 117 {
 118         switch (type) {
 119         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 120                 break;
 121         case CONNMAN_SERVICE_TYPE_SYSTEM:
 122                 return "system";
 123         case CONNMAN_SERVICE_TYPE_ETHERNET:
 124                 return "ethernet";
 125         case CONNMAN_SERVICE_TYPE_WIFI:
 126                 return "wifi";
 127         case CONNMAN_SERVICE_TYPE_WIMAX:
 128                 return "wimax";
 129         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 130                 return "bluetooth";
 131         case CONNMAN_SERVICE_TYPE_CELLULAR:
 132                 return "cellular";
 133         case CONNMAN_SERVICE_TYPE_VPN:
 134                 return "vpn";
 135         }
 136
 137         return NULL;
 138 }
 139
 140 static const char *mode2string(enum connman_service_mode mode)
 141 {
 142         switch (mode) {
 143         case CONNMAN_SERVICE_MODE_UNKNOWN:
 144                 break;
 145         case CONNMAN_SERVICE_MODE_MANAGED:
 146                 return "managed";
 147         case CONNMAN_SERVICE_MODE_ADHOC:
 148                 return "adhoc";
 149         case CONNMAN_SERVICE_MODE_GPRS:
 150                 return "gprs";
 151         case CONNMAN_SERVICE_MODE_EDGE:
 152                 return "edge";
 153         case CONNMAN_SERVICE_MODE_UMTS:
 154                 return "umts";
 155         }
 156
 157         return NULL;
 158 }
 159
 160 static const char *security2string(enum connman_service_security security)
 161 {
 162         switch (security) {
 163         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 164                 break;
 165         case CONNMAN_SERVICE_SECURITY_NONE:
 166                 return "none";
 167         case CONNMAN_SERVICE_SECURITY_WEP:
 168                 return "wep";
 169         case CONNMAN_SERVICE_SECURITY_PSK:
 170                 return "psk";
 171         case CONNMAN_SERVICE_SECURITY_8021X:
 172                 return "ieee8021x";
 173         case CONNMAN_SERVICE_SECURITY_WPA:
 174                 return "wpa";
 175         case CONNMAN_SERVICE_SECURITY_RSN:
 176                 return "rsn";
 177         }
 178
 179         return NULL;
 180 }
 181
 182 static const char *state2string(enum connman_service_state state)
 183 {
 184         switch (state) {
 185         case CONNMAN_SERVICE_STATE_UNKNOWN:
 186                 break;
 187         case CONNMAN_SERVICE_STATE_IDLE:
 188                 return "idle";
 189         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 190                 return "association";
 191         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 192                 return "configuration";
 193         case CONNMAN_SERVICE_STATE_READY:
 194                 return "ready";
 195         case CONNMAN_SERVICE_STATE_DISCONNECT:
 196                 return "disconnect";
 197         case CONNMAN_SERVICE_STATE_FAILURE:
 198                 return "failure";
 199         }
 200
 201         return NULL;
 202 }
 203
 204 static const char *error2string(enum connman_service_error error)
 205 {
 206         switch (error) {
 207         case CONNMAN_SERVICE_ERROR_UNKNOWN:
 208                 break;
 209         case CONNMAN_SERVICE_ERROR_OUT_OF_RANGE:
 210                 return "out-of-range";
 211         case CONNMAN_SERVICE_ERROR_PIN_MISSING:
 212                 return "pin-missing";
 213         case CONNMAN_SERVICE_ERROR_DHCP_FAILED:
 214                 return "dhcp-failed";
 215         case CONNMAN_SERVICE_ERROR_CONNECT_FAILED:
 216                 return "connect-failed";
 217         }
 218
 219         return NULL;
 220 }
 221
 222 static enum connman_service_error string2error(const char *error)
 223 {
 224         if (g_strcmp0(error, "dhcp-failed") == 0)
 225                 return CONNMAN_SERVICE_ERROR_DHCP_FAILED;
 226         else if (g_strcmp0(error, "pin-missing") == 0)
 227                 return CONNMAN_SERVICE_ERROR_PIN_MISSING;
 228
 229         return CONNMAN_SERVICE_ERROR_UNKNOWN;
 230 }
 231
 232 static struct connman_service *get_default(void)
 233 {
 234         struct connman_service *service;
 235         GSequenceIter *iter;
 236
 237         iter = g_sequence_get_begin_iter(service_list);
 238
 239         if (g_sequence_iter_is_end(iter) == TRUE)
 240                 return NULL;
 241
 242         service = g_sequence_get(iter);
 243
 244         if (service->state != CONNMAN_SERVICE_STATE_READY)
 245                 return NULL;
 246
 247         return service;
 248 }
 249
 250 static void default_changed(void)
 251 {
 252         struct connman_service *service = get_default();
 253
 254         __connman_notifier_default_changed(service);
 255 }
 256
 257 const char *__connman_service_default(void)
 258 {
 259         struct connman_service *service;
 260
 261         service = get_default();
 262         if (service == NULL)
 263                 return "";
 264
 265         return __connman_service_type2string(service->type);
 266 }
 267
 268 static void mode_changed(struct connman_service *service)
 269 {
 270         const char *str;
 271
 272         str = mode2string(service->mode);
 273         if (str == NULL)
 274                 return;
 275
 276         connman_dbus_property_changed_basic(service->path,
 277                                 CONNMAN_SERVICE_INTERFACE, "Mode",
 278                                                 DBUS_TYPE_STRING, &str);
 279 }
 280
 281 static void state_changed(struct connman_service *service)
 282 {
 283         const char *str;
 284
 285         str = state2string(service->state);
 286         if (str == NULL)
 287                 return;
 288
 289         connman_dbus_property_changed_basic(service->path,
 290                                 CONNMAN_SERVICE_INTERFACE, "State",
 291                                                 DBUS_TYPE_STRING, &str);
 292 }
 293
 294 static void strength_changed(struct connman_service *service)
 295 {
 296         if (service->strength == 0)
 297                 return;
 298
 299         connman_dbus_property_changed_basic(service->path,
 300                                 CONNMAN_SERVICE_INTERFACE, "Strength",
 301                                         DBUS_TYPE_BYTE, &service->strength);
 302 }
 303
 304 static void favorite_changed(struct connman_service *service)
 305 {
 306         connman_dbus_property_changed_basic(service->path,
 307                                 CONNMAN_SERVICE_INTERFACE, "Favorite",
 308                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 309 }
 310
 311 static void roaming_changed(struct connman_service *service)
 312 {
 313         connman_dbus_property_changed_basic(service->path,
 314                                 CONNMAN_SERVICE_INTERFACE, "Roaming",
 315                                         DBUS_TYPE_BOOLEAN, &service->roaming);
 316 }
 317
 318 static void autoconnect_changed(struct connman_service *service)
 319 {
 320         connman_dbus_property_changed_basic(service->path,
 321                                 CONNMAN_SERVICE_INTERFACE, "AutoConnect",
 322                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
 323 }
 324
 325 static void passphrase_changed(struct connman_service *service)
 326 {
 327         dbus_bool_t required;
 328
 329         switch (service->type) {
 330         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 331         case CONNMAN_SERVICE_TYPE_SYSTEM:
 332         case CONNMAN_SERVICE_TYPE_ETHERNET:
 333         case CONNMAN_SERVICE_TYPE_WIMAX:
 334         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 335         case CONNMAN_SERVICE_TYPE_CELLULAR:
 336         case CONNMAN_SERVICE_TYPE_VPN:
 337                 return;
 338         case CONNMAN_SERVICE_TYPE_WIFI:
 339                 required = FALSE;
 340
 341                 switch (service->security) {
 342                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 343                 case CONNMAN_SERVICE_SECURITY_NONE:
 344                 case CONNMAN_SERVICE_SECURITY_8021X:
 345                         break;
 346                 case CONNMAN_SERVICE_SECURITY_WEP:
 347                 case CONNMAN_SERVICE_SECURITY_PSK:
 348                 case CONNMAN_SERVICE_SECURITY_WPA:
 349                 case CONNMAN_SERVICE_SECURITY_RSN:
 350                         if (service->passphrase == NULL)
 351                                 required = TRUE;
 352                         break;
 353                 }
 354                 break;
 355         }
 356
 357         connman_dbus_property_changed_basic(service->path,
 358                                 CONNMAN_SERVICE_INTERFACE, "PassphraseRequired",
 359                                                 DBUS_TYPE_BOOLEAN, &required);
 360 }
 361
 362 static void apn_changed(struct connman_service *service)
 363 {
 364         dbus_bool_t required;
 365
 366         switch (service->type) {
 367         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 368         case CONNMAN_SERVICE_TYPE_SYSTEM:
 369         case CONNMAN_SERVICE_TYPE_ETHERNET:
 370         case CONNMAN_SERVICE_TYPE_WIMAX:
 371         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 372         case CONNMAN_SERVICE_TYPE_WIFI:
 373         case CONNMAN_SERVICE_TYPE_VPN:
 374                 return;
 375         case CONNMAN_SERVICE_TYPE_CELLULAR:
 376                 break;
 377         }
 378
 379         required = (service->apn == NULL) ? TRUE : FALSE;
 380
 381         connman_dbus_property_changed_basic(service->path,
 382                                 CONNMAN_SERVICE_INTERFACE, "SetupRequired",
 383                                                 DBUS_TYPE_BOOLEAN, &required);
 384 }
 385
 386 static void append_ethernet(DBusMessageIter *iter, void *user_data)
 387 {
 388         struct connman_service *service = user_data;
 389
 390         switch (service->state) {
 391         case CONNMAN_SERVICE_STATE_UNKNOWN:
 392         case CONNMAN_SERVICE_STATE_IDLE:
 393         case CONNMAN_SERVICE_STATE_FAILURE:
 394         case CONNMAN_SERVICE_STATE_DISCONNECT:
 395                 return;
 396         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 397         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 398         case CONNMAN_SERVICE_STATE_READY:
 399                 break;
 400         }
 401
 402         if (service->ipconfig != NULL)
 403                 __connman_ipconfig_append_ethernet(service->ipconfig, iter);
 404 }
 405
 406 static void append_ipv4(DBusMessageIter *iter, void *user_data)
 407 {
 408         struct connman_service *service = user_data;
 409
 410         switch (service->state) {
 411         case CONNMAN_SERVICE_STATE_UNKNOWN:
 412         case CONNMAN_SERVICE_STATE_IDLE:
 413         case CONNMAN_SERVICE_STATE_FAILURE:
 414         case CONNMAN_SERVICE_STATE_DISCONNECT:
 415         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 416         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 417                 return;
 418         case CONNMAN_SERVICE_STATE_READY:
 419                 break;
 420         }
 421
 422         if (service->ipconfig != NULL)
 423                 __connman_ipconfig_append_ipv4(service->ipconfig, iter);
 424 }
 425
 426 static void settings_changed(struct connman_service *service)
 427 {
 428         connman_dbus_property_changed_dict(service->path,
 429                                         CONNMAN_SERVICE_INTERFACE, "IPv4",
 430                                                         append_ipv4, service);
 431 }
 432
 433 static DBusMessage *get_properties(DBusConnection *conn,
 434                                         DBusMessage *msg, void *user_data)
 435 {
 436         struct connman_service *service = user_data;
 437         DBusMessage *reply;
 438         DBusMessageIter array, dict;
 439         dbus_bool_t required;
 440         const char *str;
 441
 442         DBG("service %p", service);
 443
 444         reply = dbus_message_new_method_return(msg);
 445         if (reply == NULL)
 446                 return NULL;
 447
 448         dbus_message_iter_init_append(reply, &array);
 449
 450         connman_dbus_dict_open(&array, &dict);
 451
 452         str = __connman_service_type2string(service->type);
 453         if (str != NULL)
 454                 connman_dbus_dict_append_basic(&dict, "Type",
 455                                                 DBUS_TYPE_STRING, &str);
 456
 457         str = mode2string(service->mode);
 458         if (str != NULL)
 459                 connman_dbus_dict_append_basic(&dict, "Mode",
 460                                                 DBUS_TYPE_STRING, &str);
 461
 462         str = security2string(service->security);
 463         if (str != NULL)
 464                 connman_dbus_dict_append_basic(&dict, "Security",
 465                                                 DBUS_TYPE_STRING, &str);
 466
 467         str = state2string(service->state);
 468         if (str != NULL)
 469                 connman_dbus_dict_append_basic(&dict, "State",
 470                                                 DBUS_TYPE_STRING, &str);
 471
 472         str = error2string(service->error);
 473         if (str != NULL)
 474                 connman_dbus_dict_append_basic(&dict, "Error",
 475                                                 DBUS_TYPE_STRING, &str);
 476
 477         if (service->strength > 0)
 478                 connman_dbus_dict_append_basic(&dict, "Strength",
 479                                         DBUS_TYPE_BYTE, &service->strength);
 480
 481         connman_dbus_dict_append_basic(&dict, "Favorite",
 482                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 483
 484         if (service->favorite == TRUE)
 485                 connman_dbus_dict_append_basic(&dict, "AutoConnect",
 486                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
 487         else
 488                 connman_dbus_dict_append_basic(&dict, "AutoConnect",
 489                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 490
 491         if (service->name != NULL)
 492                 connman_dbus_dict_append_basic(&dict, "Name",
 493                                         DBUS_TYPE_STRING, &service->name);
 494
 495         switch (service->type) {
 496         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 497         case CONNMAN_SERVICE_TYPE_SYSTEM:
 498         case CONNMAN_SERVICE_TYPE_WIMAX:
 499         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 500         case CONNMAN_SERVICE_TYPE_VPN:
 501                 break;
 502         case CONNMAN_SERVICE_TYPE_CELLULAR:
 503                 connman_dbus_dict_append_basic(&dict, "Roaming",
 504                                         DBUS_TYPE_BOOLEAN, &service->roaming);
 505
 506                 if (service->mcc != NULL && service->mnc != NULL) {
 507                         connman_dbus_dict_append_basic(&dict, "MCC",
 508                                         DBUS_TYPE_STRING, &service->mcc);
 509                         connman_dbus_dict_append_basic(&dict, "MNC",
 510                                         DBUS_TYPE_STRING, &service->mnc);
 511                 }
 512
 513                 if (service->apn != NULL) {
 514                         connman_dbus_dict_append_basic(&dict, "APN",
 515                                         DBUS_TYPE_STRING, &service->apn);
 516
 517                         if (service->username != NULL)
 518                                 connman_dbus_dict_append_basic(&dict,
 519                                         "Username", DBUS_TYPE_STRING,
 520                                                         &service->username);
 521
 522                         if (service->password != NULL)
 523                                 connman_dbus_dict_append_basic(&dict,
 524                                         "Password", DBUS_TYPE_STRING,
 525                                                         &service->password);
 526
 527                         required = FALSE;
 528                 } else
 529                         required = TRUE;
 530
 531                 connman_dbus_dict_append_basic(&dict, "SetupRequired",
 532                                                 DBUS_TYPE_BOOLEAN, &required);
 533                 break;
 534         case CONNMAN_SERVICE_TYPE_WIFI:
 535                 if (service->passphrase != NULL &&
 536                                 __connman_security_check_privilege(msg,
 537                                         CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
 538                         connman_dbus_dict_append_basic(&dict, "Passphrase",
 539                                 DBUS_TYPE_STRING, &service->passphrase);
 540
 541                 required = FALSE;
 542
 543                 switch (service->security) {
 544                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 545                 case CONNMAN_SERVICE_SECURITY_NONE:
 546                 case CONNMAN_SERVICE_SECURITY_8021X:
 547                         break;
 548                 case CONNMAN_SERVICE_SECURITY_WEP:
 549                 case CONNMAN_SERVICE_SECURITY_PSK:
 550                 case CONNMAN_SERVICE_SECURITY_WPA:
 551                 case CONNMAN_SERVICE_SECURITY_RSN:
 552                         if (service->passphrase == NULL)
 553                                 required = TRUE;
 554                         break;
 555                 }
 556
 557                 connman_dbus_dict_append_basic(&dict, "PassphraseRequired",
 558                                                 DBUS_TYPE_BOOLEAN, &required);
 559                 /* fall through */
 560         case CONNMAN_SERVICE_TYPE_ETHERNET:
 561                 connman_dbus_dict_append_dict(&dict, "Ethernet",
 562                                                 append_ethernet, service);
 563                 break;
 564         }
 565
 566         connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4, service);
 567
 568         connman_dbus_dict_close(&array, &dict);
 569
 570         return reply;
 571 }
 572
 573 static DBusMessage *set_property(DBusConnection *conn,
 574                                         DBusMessage *msg, void *user_data)
 575 {
 576         struct connman_service *service = user_data;
 577         DBusMessageIter iter, value;
 578         const char *name;
 579         int type;
 580
 581         DBG("service %p", service);
 582
 583         if (dbus_message_iter_init(msg, &iter) == FALSE)
 584                 return __connman_error_invalid_arguments(msg);
 585
 586         dbus_message_iter_get_basic(&iter, &name);
 587         dbus_message_iter_next(&iter);
 588         dbus_message_iter_recurse(&iter, &value);
 589
 590         if (__connman_security_check_privilege(msg,
 591                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 592                 return __connman_error_permission_denied(msg);
 593
 594         type = dbus_message_iter_get_arg_type(&value);
 595
 596         if (g_str_has_prefix(name, "AutoConnect") == TRUE) {
 597                 connman_bool_t autoconnect;
 598
 599                 if (type != DBUS_TYPE_BOOLEAN)
 600                         return __connman_error_invalid_arguments(msg);
 601
 602                 if (service->favorite == FALSE)
 603                         return __connman_error_invalid_service(msg);
 604
 605                 dbus_message_iter_get_basic(&value, &autoconnect);
 606
 607                 if (service->autoconnect == autoconnect)
 608                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 609
 610                 service->autoconnect = autoconnect;
 611
 612                 autoconnect_changed(service);
 613
 614                 __connman_storage_save_service(service);
 615         } else if (g_str_equal(name, "Passphrase") == TRUE) {
 616                 const char *passphrase;
 617
 618                 if (type != DBUS_TYPE_STRING)
 619                         return __connman_error_invalid_arguments(msg);
 620
 621                 if (__connman_security_check_privilege(msg,
 622                                         CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0)
 623                         return __connman_error_permission_denied(msg);
 624
 625                 dbus_message_iter_get_basic(&value, &passphrase);
 626
 627                 g_free(service->passphrase);
 628                 service->passphrase = g_strdup(passphrase);
 629
 630                 passphrase_changed(service);
 631
 632                 if (service->network != NULL)
 633                         connman_network_set_string(service->network,
 634                                 "WiFi.Passphrase", service->passphrase);
 635
 636                 __connman_storage_save_service(service);
 637         } else if (g_str_equal(name, "APN") == TRUE) {
 638                 const char *apn;
 639
 640                 if (type != DBUS_TYPE_STRING)
 641                         return __connman_error_invalid_arguments(msg);
 642
 643                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
 644                         return __connman_error_invalid_service(msg);
 645
 646                 dbus_message_iter_get_basic(&value, &apn);
 647
 648                 g_free(service->apn);
 649                 service->apn = g_strdup(apn);
 650
 651                 apn_changed(service);
 652
 653                 if (service->network != NULL)
 654                         connman_network_set_string(service->network,
 655                                                 "Cellular.APN", service->apn);
 656
 657                 __connman_storage_save_service(service);
 658         } else if (g_str_equal(name, "Username") == TRUE) {
 659                 const char *username;
 660
 661                 if (type != DBUS_TYPE_STRING)
 662                         return __connman_error_invalid_arguments(msg);
 663
 664                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
 665                         return __connman_error_invalid_service(msg);
 666
 667                 dbus_message_iter_get_basic(&value, &username);
 668
 669                 g_free(service->username);
 670                 service->username = g_strdup(username);
 671
 672                 if (service->network != NULL)
 673                         connman_network_set_string(service->network,
 674                                         "Cellular.Username", service->username);
 675
 676                 __connman_storage_save_service(service);
 677         } else if (g_str_equal(name, "Password") == TRUE) {
 678                 const char *password;
 679
 680                 if (type != DBUS_TYPE_STRING)
 681                         return __connman_error_invalid_arguments(msg);
 682
 683                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
 684                         return __connman_error_invalid_service(msg);
 685
 686                 dbus_message_iter_get_basic(&value, &password);
 687
 688                 g_free(service->password);
 689                 service->password = g_strdup(password);
 690
 691                 if (service->network != NULL)
 692                         connman_network_set_string(service->network,
 693                                         "Cellular.Password", service->password);
 694
 695                 __connman_storage_save_service(service);
 696         } else
 697                 return __connman_error_invalid_property(msg);
 698
 699         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 700 }
 701
 702 static void set_idle(struct connman_service *service)
 703 {
 704         service->state = CONNMAN_SERVICE_STATE_IDLE;
 705         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
 706         state_changed(service);
 707 }
 708
 709 static DBusMessage *clear_property(DBusConnection *conn,
 710                                         DBusMessage *msg, void *user_data)
 711 {
 712         struct connman_service *service = user_data;
 713         const char *name;
 714
 715         DBG("service %p", service);
 716
 717         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
 718                                                         DBUS_TYPE_INVALID);
 719
 720         if (__connman_security_check_privilege(msg,
 721                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 722                 return __connman_error_permission_denied(msg);
 723
 724         if (g_str_equal(name, "Error") == TRUE) {
 725                 set_idle(service);
 726
 727                 g_get_current_time(&service->modified);
 728                 __connman_storage_save_service(service);
 729         } else if (g_str_equal(name, "Passphrase") == TRUE) {
 730                 g_free(service->passphrase);
 731                 service->passphrase = NULL;
 732
 733                 passphrase_changed(service);
 734
 735                 __connman_storage_save_service(service);
 736         } else
 737                 return __connman_error_invalid_property(msg);
 738
 739         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 740 }
 741
 742 static connman_bool_t is_connecting(struct connman_service *service)
 743 {
 744         switch (service->state) {
 745         case CONNMAN_SERVICE_STATE_UNKNOWN:
 746         case CONNMAN_SERVICE_STATE_IDLE:
 747         case CONNMAN_SERVICE_STATE_FAILURE:
 748         case CONNMAN_SERVICE_STATE_DISCONNECT:
 749         case CONNMAN_SERVICE_STATE_READY:
 750                 break;
 751         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 752         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 753                 return TRUE;
 754         }
 755
 756         return FALSE;
 757 }
 758
 759 static connman_bool_t is_ignore(struct connman_service *service)
 760 {
 761         if (service->autoconnect == FALSE)
 762                 return TRUE;
 763
 764         if (service->roaming == TRUE)
 765                 return TRUE;
 766
 767         if (service->ignore == TRUE)
 768                 return TRUE;
 769
 770         if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
 771                 return TRUE;
 772
 773         return FALSE;
 774 }
 775
 776 void __connman_service_auto_connect(void)
 777 {
 778         struct connman_service *service = NULL;
 779         GSequenceIter *iter;
 780
 781         DBG("");
 782
 783         iter = g_sequence_get_begin_iter(service_list);
 784
 785         while (g_sequence_iter_is_end(iter) == FALSE) {
 786                 service = g_sequence_get(iter);
 787
 788                 if (service->pending != NULL)
 789                         return;
 790
 791                 if (is_connecting(service) == TRUE)
 792                         return;
 793
 794                 if (service->favorite == FALSE)
 795                         return;
 796
 797                 if (service->state == CONNMAN_SERVICE_STATE_READY)
 798                         return;
 799
 800                 if (is_ignore(service) == FALSE &&
 801                                 service->state == CONNMAN_SERVICE_STATE_IDLE)
 802                         break;
 803
 804                 service = NULL;
 805
 806                 iter = g_sequence_iter_next(iter);
 807         }
 808
 809         if (service != NULL) {
 810                 service->userconnect = FALSE;
 811                 __connman_service_connect(service);
 812         }
 813 }
 814
 815 static void remove_timeout(struct connman_service *service)
 816 {
 817         if (service->timeout > 0) {
 818                 g_source_remove(service->timeout);
 819                 service->timeout = 0;
 820         }
 821 }
 822
 823 static void reply_pending(struct connman_service *service, int error)
 824 {
 825         remove_timeout(service);
 826
 827         if (service->pending != NULL) {
 828                 if (error > 0) {
 829                         DBusMessage *reply;
 830
 831                         reply = __connman_error_failed(service->pending,
 832                                                                 error);
 833                         if (reply != NULL)
 834                                 g_dbus_send_message(connection, reply);
 835                 } else
 836                         g_dbus_send_reply(connection, service->pending,
 837                                                         DBUS_TYPE_INVALID);
 838
 839                 dbus_message_unref(service->pending);
 840                 service->pending = NULL;
 841         }
 842 }
 843
 844 static gboolean connect_timeout(gpointer user_data)
 845 {
 846         struct connman_service *service = user_data;
 847         connman_bool_t autoconnect = FALSE;
 848
 849         DBG("service %p", service);
 850
 851         service->timeout = 0;
 852
 853         if (service->network != NULL)
 854                 __connman_network_disconnect(service->network);
 855
 856         __connman_ipconfig_disable(service->ipconfig);
 857
 858         if (service->pending != NULL) {
 859                 DBusMessage *reply;
 860
 861                 reply = __connman_error_operation_timeout(service->pending);
 862                 if (reply != NULL)
 863                         g_dbus_send_message(connection, reply);
 864
 865                 dbus_message_unref(service->pending);
 866                 service->pending = NULL;
 867         } else
 868                 autoconnect = TRUE;
 869
 870         __connman_service_indicate_state(service,
 871                                         CONNMAN_SERVICE_STATE_FAILURE);
 872
 873         if (autoconnect == TRUE && service->userconnect == FALSE)
 874                 __connman_service_auto_connect();
 875
 876         return FALSE;
 877 }
 878
 879 static void set_reconnect_state(struct connman_service *service,
 880                                                 connman_bool_t reconnect)
 881 {
 882         struct connman_device *device;
 883
 884         if (service->network == NULL)
 885                 return;
 886
 887         device = connman_network_get_device(service->network);
 888         if (device == NULL)
 889                 return;
 890
 891         __connman_device_set_reconnect(device, reconnect);
 892 }
 893
 894 static connman_bool_t get_reconnect_state(struct connman_service *service)
 895 {
 896         struct connman_device *device;
 897
 898         if (service->network == NULL)
 899                 return FALSE;
 900
 901         device = connman_network_get_device(service->network);
 902         if (device == NULL)
 903                 return FALSE;
 904
 905         return __connman_device_get_reconnect(device);
 906 }
 907
 908 static DBusMessage *connect_service(DBusConnection *conn,
 909                                         DBusMessage *msg, void *user_data)
 910 {
 911         struct connman_service *service = user_data;
 912         GSequenceIter *iter;
 913         int err;
 914
 915         DBG("service %p", service);
 916
 917         if (service->pending != NULL)
 918                 return __connman_error_in_progress(msg);
 919
 920         iter = g_sequence_get_begin_iter(service_list);
 921
 922         while (g_sequence_iter_is_end(iter) == FALSE) {
 923                 struct connman_service *temp = g_sequence_get(iter);
 924
 925                 if (service->type == temp->type &&
 926                                         is_connecting(temp) == TRUE)
 927                         return __connman_error_in_progress(msg);
 928
 929                 iter = g_sequence_iter_next(iter);
 930         }
 931
 932         service->ignore = FALSE;
 933
 934         service->userconnect = TRUE;
 935
 936         service->pending = dbus_message_ref(msg);
 937
 938         set_reconnect_state(service, FALSE);
 939
 940         err = __connman_service_connect(service);
 941         if (err < 0) {
 942                 if (err == -ENOKEY) {
 943                         if (__connman_agent_request_passphrase(service,
 944                                                         NULL, NULL) == 0)
 945                                 return NULL;
 946                 }
 947
 948                 if (err != -EINPROGRESS) {
 949                         dbus_message_unref(service->pending);
 950                         service->pending = NULL;
 951
 952                         return __connman_error_failed(msg, -err);
 953                 }
 954
 955                 return NULL;
 956         }
 957
 958         dbus_message_unref(service->pending);
 959         service->pending = NULL;
 960
 961         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 962 }
 963
 964 static DBusMessage *disconnect_service(DBusConnection *conn,
 965                                         DBusMessage *msg, void *user_data)
 966 {
 967         struct connman_service *service = user_data;
 968         int err;
 969
 970         DBG("service %p", service);
 971
 972         reply_pending(service, ECONNABORTED);
 973
 974         service->ignore = TRUE;
 975
 976         set_reconnect_state(service, FALSE);
 977
 978         err = __connman_service_disconnect(service);
 979         if (err < 0) {
 980                 if (err != -EINPROGRESS)
 981                         return __connman_error_failed(msg, -err);
 982
 983                 return NULL;
 984         }
 985
 986         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 987 }
 988
 989 static DBusMessage *remove_service(DBusConnection *conn,
 990                                         DBusMessage *msg, void *user_data)
 991 {
 992         struct connman_service *service = user_data;
 993
 994         DBG("service %p", service);
 995
 996         if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
 997                 return __connman_error_not_supported(msg);
 998
 999         if (service->favorite == FALSE &&
1000                         service->state != CONNMAN_SERVICE_STATE_FAILURE)
1001                 return __connman_error_not_supported(msg);
1002
1003         if (service->network != NULL) {
1004                 set_reconnect_state(service, FALSE);
1005
1006                 __connman_network_disconnect(service->network);
1007         }
1008
1009         g_free(service->passphrase);
1010         service->passphrase = NULL;
1011
1012         passphrase_changed(service);
1013
1014         g_free(service->apn);
1015         service->apn = NULL;
1016
1017         g_free(service->username);
1018         service->username = NULL;
1019
1020         g_free(service->password);
1021         service->password = NULL;
1022
1023         apn_changed(service);
1024
1025         set_idle(service);
1026
1027         connman_service_set_favorite(service, FALSE);
1028         __connman_storage_save_service(service);
1029
1030         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1031 }
1032
1033 static DBusMessage *move_before(DBusConnection *conn,
1034                                         DBusMessage *msg, void *user_data)
1035 {
1036         struct connman_service *service = user_data;
1037         struct connman_service *target;
1038         const char *path;
1039         GSequenceIter *src, *dst;
1040
1041         DBG("service %p", service);
1042
1043         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1044                                                         DBUS_TYPE_INVALID);
1045
1046         if (service->favorite == FALSE)
1047                 return __connman_error_not_supported(msg);
1048
1049         target = find_service(path);
1050         if (target == NULL || target->favorite == FALSE || target == service)
1051                 return __connman_error_invalid_service(msg);
1052
1053         DBG("target %s", target->identifier);
1054
1055         if (target->state != service->state)
1056                 return __connman_error_invalid_service(msg);
1057
1058         g_get_current_time(&service->modified);
1059         __connman_storage_save_service(service);
1060
1061         src = g_hash_table_lookup(service_hash, service->identifier);
1062         dst = g_hash_table_lookup(service_hash, target->identifier);
1063
1064         g_sequence_move(src, dst);
1065
1066         __connman_profile_changed(FALSE);
1067
1068         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1069 }
1070
1071 static DBusMessage *move_after(DBusConnection *conn,
1072                                         DBusMessage *msg, void *user_data)
1073 {
1074         struct connman_service *service = user_data;
1075         struct connman_service *target;
1076         const char *path;
1077
1078         DBG("service %p", service);
1079
1080         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1081                                                         DBUS_TYPE_INVALID);
1082
1083         if (service->favorite == FALSE)
1084                 return __connman_error_not_supported(msg);
1085
1086         target = find_service(path);
1087         if (target == NULL || target->favorite == FALSE || target == service)
1088                 return __connman_error_invalid_service(msg);
1089
1090         DBG("target %s", target->identifier);
1091
1092         if (target->state != service->state)
1093                 return __connman_error_invalid_service(msg);
1094
1095         g_get_current_time(&service->modified);
1096         __connman_storage_save_service(service);
1097
1098         return __connman_error_not_implemented(msg);
1099 }
1100
1101 static GDBusMethodTable service_methods[] = {
1102         { "GetProperties", "",   "a{sv}", get_properties     },
1103         { "SetProperty",   "sv", "",      set_property       },
1104         { "ClearProperty", "s",  "",      clear_property     },
1105         { "Connect",       "",   "",      connect_service,
1106                                                 G_DBUS_METHOD_FLAG_ASYNC },
1107         { "Disconnect",    "",   "",      disconnect_service },
1108         { "Remove",        "",   "",      remove_service     },
1109         { "MoveBefore",    "o",  "",      move_before        },
1110         { "MoveAfter",     "o",  "",      move_after         },
1111         { },
1112 };
1113
1114 static GDBusSignalTable service_signals[] = {
1115         { "PropertyChanged", "sv" },
1116         { },
1117 };
1118
1119 static void service_free(gpointer user_data)
1120 {
1121         struct connman_service *service = user_data;
1122         char *path = service->path;
1123
1124         DBG("service %p", service);
1125
1126         reply_pending(service, ENOENT);
1127
1128         g_hash_table_remove(service_hash, service->identifier);
1129
1130         service->path = NULL;
1131
1132         if (path != NULL) {
1133                 __connman_profile_changed(FALSE);
1134
1135                 g_dbus_unregister_interface(connection, path,
1136                                                 CONNMAN_SERVICE_INTERFACE);
1137                 g_free(path);
1138         }
1139
1140         if (service->network != NULL)
1141                 connman_network_unref(service->network);
1142
1143         if (service->ipconfig != NULL) {
1144                 connman_ipconfig_unref(service->ipconfig);
1145                 service->ipconfig = NULL;
1146         }
1147
1148         g_free(service->mcc);
1149         g_free(service->mnc);
1150         g_free(service->apn);
1151         g_free(service->username);
1152         g_free(service->password);
1153         g_free(service->profile);
1154         g_free(service->name);
1155         g_free(service->passphrase);
1156         g_free(service->identifier);
1157         g_free(service);
1158 }
1159
1160 /**
1161  * __connman_service_put:
1162  * @service: service structure
1163  *
1164  * Release service if no longer needed
1165  */
1166 void __connman_service_put(struct connman_service *service)
1167 {
1168         DBG("service %p", service);
1169
1170         if (g_atomic_int_dec_and_test(&service->refcount) == TRUE) {
1171                 GSequenceIter *iter;
1172
1173                 iter = g_hash_table_lookup(service_hash, service->identifier);
1174                 if (iter != NULL) {
1175                         reply_pending(service, ECONNABORTED);
1176
1177                         __connman_service_disconnect(service);
1178
1179                         g_sequence_remove(iter);
1180                 } else
1181                         service_free(service);
1182         }
1183 }
1184
1185 static void __connman_service_initialize(struct connman_service *service)
1186 {
1187         DBG("service %p", service);
1188
1189         service->refcount = 1;
1190
1191         service->type     = CONNMAN_SERVICE_TYPE_UNKNOWN;
1192         service->mode     = CONNMAN_SERVICE_MODE_UNKNOWN;
1193         service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
1194         service->state    = CONNMAN_SERVICE_STATE_UNKNOWN;
1195
1196         service->favorite = FALSE;
1197         service->hidden = FALSE;
1198
1199         service->ignore = FALSE;
1200
1201         service->userconnect = FALSE;
1202
1203         service->order = 0;
1204 }
1205
1206 /**
1207  * connman_service_create:
1208  *
1209  * Allocate a new service.
1210  *
1211  * Returns: a newly-allocated #connman_service structure
1212  */
1213 struct connman_service *connman_service_create(void)
1214 {
1215         struct connman_service *service;
1216
1217         service = g_try_new0(struct connman_service, 1);
1218         if (service == NULL)
1219                 return NULL;
1220
1221         DBG("service %p", service);
1222
1223         __connman_service_initialize(service);
1224
1225         return service;
1226 }
1227
1228 /**
1229  * connman_service_ref:
1230  * @service: service structure
1231  *
1232  * Increase reference counter of service
1233  */
1234 struct connman_service *connman_service_ref(struct connman_service *service)
1235 {
1236         g_atomic_int_inc(&service->refcount);
1237
1238         return service;
1239 }
1240
1241 /**
1242  * connman_service_unref:
1243  * @service: service structure
1244  *
1245  * Decrease reference counter of service
1246  */
1247 void connman_service_unref(struct connman_service *service)
1248 {
1249         __connman_service_put(service);
1250 }
1251
1252 static gint service_compare(gconstpointer a, gconstpointer b,
1253                                                         gpointer user_data)
1254 {
1255         struct connman_service *service_a = (void *) a;
1256         struct connman_service *service_b = (void *) b;
1257
1258         if (service_a->state != service_b->state) {
1259                 if (service_a->state == CONNMAN_SERVICE_STATE_READY)
1260                         return -1;
1261                 if (service_b->state == CONNMAN_SERVICE_STATE_READY)
1262                         return 1;
1263         }
1264
1265         if (service_a->order > service_b->order)
1266                 return -1;
1267
1268         if (service_a->order < service_b->order)
1269                 return 1;
1270
1271         if (service_a->favorite == TRUE && service_b->favorite == FALSE)
1272                 return -1;
1273
1274         if (service_a->favorite == FALSE && service_b->favorite == TRUE)
1275                 return 1;
1276
1277         if (service_a->type != service_b->type) {
1278                 switch (service_a->type) {
1279                 case CONNMAN_SERVICE_TYPE_UNKNOWN:
1280                 case CONNMAN_SERVICE_TYPE_SYSTEM:
1281                 case CONNMAN_SERVICE_TYPE_ETHERNET:
1282                 case CONNMAN_SERVICE_TYPE_VPN:
1283                         break;
1284                 case CONNMAN_SERVICE_TYPE_WIFI:
1285                         return 1;
1286                 case CONNMAN_SERVICE_TYPE_WIMAX:
1287                 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1288                 case CONNMAN_SERVICE_TYPE_CELLULAR:
1289                         return -1;
1290                 }
1291         }
1292
1293         return (gint) service_b->strength - (gint) service_a->strength;
1294 }
1295
1296 /**
1297  * connman_service_get_type:
1298  * @service: service structure
1299  *
1300  * Get the type of service
1301  */
1302 enum connman_service_type connman_service_get_type(struct connman_service *service)
1303 {
1304         if (service == NULL)
1305                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
1306
1307         return service->type;
1308 }
1309
1310 /**
1311  * connman_service_get_interface:
1312  * @service: service structure
1313  *
1314  * Get network interface of service
1315  */
1316 char *connman_service_get_interface(struct connman_service *service)
1317 {
1318         int index;
1319
1320         if (service == NULL)
1321                 return NULL;
1322
1323         if (service->network == NULL)
1324                 return NULL;
1325
1326         index = connman_network_get_index(service->network);
1327
1328         return connman_inet_ifname(index);
1329 }
1330
1331 /**
1332  * connman_service_set_favorite:
1333  * @service: service structure
1334  * @favorite: favorite value
1335  *
1336  * Change the favorite setting of service
1337  */
1338 int connman_service_set_favorite(struct connman_service *service,
1339                                                 connman_bool_t favorite)
1340 {
1341         GSequenceIter *iter;
1342
1343         iter = g_hash_table_lookup(service_hash, service->identifier);
1344         if (iter == NULL)
1345                 return -ENOENT;
1346
1347         if (service->favorite == favorite)
1348                 return -EALREADY;
1349
1350         service->favorite = favorite;
1351
1352         favorite_changed(service);
1353
1354         g_sequence_sort_changed(iter, service_compare, NULL);
1355
1356         __connman_profile_changed(FALSE);
1357
1358         return 0;
1359 }
1360
1361 int __connman_service_indicate_state(struct connman_service *service,
1362                                         enum connman_service_state state)
1363 {
1364         GSequenceIter *iter;
1365
1366         DBG("service %p state %d", service, state);
1367
1368         if (service == NULL)
1369                 return -EINVAL;
1370
1371         if (service->state == state)
1372                 return -EALREADY;
1373
1374         if (service->state == CONNMAN_SERVICE_STATE_FAILURE &&
1375                                 state == CONNMAN_SERVICE_STATE_IDLE)
1376                 return -EINVAL;
1377
1378         if (service->state == CONNMAN_SERVICE_STATE_IDLE &&
1379                                 state == CONNMAN_SERVICE_STATE_DISCONNECT)
1380                 return -EINVAL;
1381
1382         if (state == CONNMAN_SERVICE_STATE_IDLE &&
1383                         service->state != CONNMAN_SERVICE_STATE_DISCONNECT) {
1384                 service->state = CONNMAN_SERVICE_STATE_DISCONNECT;
1385                 state_changed(service);
1386
1387                 reply_pending(service, ECONNABORTED);
1388
1389                 __connman_service_disconnect(service);
1390         }
1391
1392         service->state = state;
1393         state_changed(service);
1394
1395         if (state == CONNMAN_SERVICE_STATE_IDLE) {
1396                 connman_bool_t reconnect;
1397
1398                 reconnect = get_reconnect_state(service);
1399                 if (reconnect == TRUE)
1400                         __connman_service_auto_connect();
1401         }
1402
1403         if (state == CONNMAN_SERVICE_STATE_READY) {
1404                 set_reconnect_state(service, TRUE);
1405
1406                 connman_service_set_favorite(service, TRUE);
1407
1408                 reply_pending(service, 0);
1409
1410                 service->userconnect = FALSE;
1411
1412                 g_get_current_time(&service->modified);
1413                 __connman_storage_save_service(service);
1414
1415                 settings_changed(service);
1416
1417                 __connman_notifier_connect(service->type);
1418
1419                 default_changed();
1420         } else if (state == CONNMAN_SERVICE_STATE_DISCONNECT) {
1421                 default_changed();
1422
1423                 __connman_notifier_disconnect(service->type);
1424         }
1425
1426         if (state == CONNMAN_SERVICE_STATE_FAILURE) {
1427                 reply_pending(service, EIO);
1428
1429                 if (service->userconnect == FALSE)
1430                         __connman_service_auto_connect();
1431
1432                 g_get_current_time(&service->modified);
1433                 __connman_storage_save_service(service);
1434         } else
1435                 service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
1436
1437         iter = g_hash_table_lookup(service_hash, service->identifier);
1438         if (iter != NULL)
1439                 g_sequence_sort_changed(iter, service_compare, NULL);
1440
1441         __connman_profile_changed(FALSE);
1442
1443         if (service->state == CONNMAN_SERVICE_STATE_IDLE ||
1444                         service->state == CONNMAN_SERVICE_STATE_FAILURE)
1445                 __connman_element_request_scan(CONNMAN_ELEMENT_TYPE_UNKNOWN);
1446
1447         return 0;
1448 }
1449
1450 int __connman_service_indicate_error(struct connman_service *service,
1451                                         enum connman_service_error error)
1452 {
1453         DBG("service %p error %d", service, error);
1454
1455         if (service == NULL)
1456                 return -EINVAL;
1457
1458         service->error = error;
1459
1460         return __connman_service_indicate_state(service,
1461                                         CONNMAN_SERVICE_STATE_FAILURE);
1462 }
1463
1464 int __connman_service_indicate_default(struct connman_service *service)
1465 {
1466         DBG("service %p", service);
1467
1468         default_changed();
1469
1470         return 0;
1471 }
1472
1473 static connman_bool_t prepare_network(struct connman_service *service)
1474 {
1475         enum connman_network_type type;
1476         unsigned int ssid_len;
1477
1478         type = connman_network_get_type(service->network);
1479
1480         switch (type) {
1481         case CONNMAN_NETWORK_TYPE_UNKNOWN:
1482         case CONNMAN_NETWORK_TYPE_VENDOR:
1483                 return FALSE;
1484         case CONNMAN_NETWORK_TYPE_WIFI:
1485                 if (connman_network_get_blob(service->network, "WiFi.SSID",
1486                                                         &ssid_len) == NULL)
1487                         return FALSE;
1488
1489                 connman_network_set_string(service->network,
1490                                 "WiFi.Passphrase", service->passphrase);
1491                 break;
1492         case CONNMAN_NETWORK_TYPE_ETHERNET:
1493         case CONNMAN_NETWORK_TYPE_WIMAX:
1494         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1495         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1496         case CONNMAN_NETWORK_TYPE_CELLULAR:
1497                 break;
1498         case CONNMAN_NETWORK_TYPE_MBM:
1499         case CONNMAN_NETWORK_TYPE_HSO:
1500                 connman_network_set_string(service->network,
1501                                                 "Cellular.APN", service->apn);
1502
1503                 connman_network_set_string(service->network,
1504                                         "Cellular.Username", service->username);
1505                 connman_network_set_string(service->network,
1506                                         "Cellular.Password", service->password);
1507                 break;
1508         }
1509
1510         return TRUE;
1511 }
1512
1513 int __connman_service_connect(struct connman_service *service)
1514 {
1515         int err;
1516
1517         DBG("service %p", service);
1518
1519         if (service->state == CONNMAN_SERVICE_STATE_READY)
1520                 return -EISCONN;
1521
1522         if (is_connecting(service) == TRUE)
1523                 return -EALREADY;
1524
1525         switch (service->type) {
1526         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1527         case CONNMAN_SERVICE_TYPE_SYSTEM:
1528         case CONNMAN_SERVICE_TYPE_VPN:
1529                 return -EINVAL;
1530         case CONNMAN_SERVICE_TYPE_ETHERNET:
1531         case CONNMAN_SERVICE_TYPE_WIMAX:
1532         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1533                 break;
1534         case CONNMAN_SERVICE_TYPE_CELLULAR:
1535                 if (service->apn == NULL)
1536                         return -EINVAL;
1537                 break;
1538         case CONNMAN_SERVICE_TYPE_WIFI:
1539                 switch (service->security) {
1540                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
1541                 case CONNMAN_SERVICE_SECURITY_NONE:
1542                 case CONNMAN_SERVICE_SECURITY_8021X:
1543                         break;
1544                 case CONNMAN_SERVICE_SECURITY_WEP:
1545                 case CONNMAN_SERVICE_SECURITY_PSK:
1546                 case CONNMAN_SERVICE_SECURITY_WPA:
1547                 case CONNMAN_SERVICE_SECURITY_RSN:
1548                         if (service->passphrase == NULL)
1549                                 return -ENOKEY;
1550                         break;
1551                 }
1552                 break;
1553         }
1554
1555         if (service->network != NULL) {
1556                 if (prepare_network(service) == FALSE)
1557                         return -EINVAL;
1558
1559                 __connman_ipconfig_enable(service->ipconfig);
1560
1561                 err = __connman_network_connect(service->network);
1562         } else
1563                 return -EOPNOTSUPP;
1564
1565         if (err < 0) {
1566                 if (err != -EINPROGRESS) {
1567                         __connman_ipconfig_disable(service->ipconfig);
1568                         return err;
1569                 }
1570
1571                 service->timeout = g_timeout_add_seconds(CONNECT_TIMEOUT,
1572                                                 connect_timeout, service);
1573
1574                 return -EINPROGRESS;
1575         }
1576
1577         return 0;
1578 }
1579
1580 int __connman_service_disconnect(struct connman_service *service)
1581 {
1582         int err;
1583
1584         DBG("service %p", service);
1585
1586         if (service->network != NULL) {
1587                 err = __connman_network_disconnect(service->network);
1588         } else
1589                 return -EOPNOTSUPP;
1590
1591         __connman_ipconfig_disable(service->ipconfig);
1592
1593         if (err < 0) {
1594                 if (err != -EINPROGRESS)
1595                         return err;
1596
1597                 return -EINPROGRESS;
1598         }
1599
1600         return 0;
1601 }
1602
1603 /**
1604  * __connman_service_lookup:
1605  * @identifier: service identifier
1606  *
1607  * Look up a service by identifier (reference count will not be increased)
1608  */
1609 static struct connman_service *__connman_service_lookup(const char *identifier)
1610 {
1611         GSequenceIter *iter;
1612
1613         iter = g_hash_table_lookup(service_hash, identifier);
1614         if (iter != NULL)
1615                 return g_sequence_get(iter);
1616
1617         return NULL;
1618 }
1619
1620 static struct connman_network *create_hidden_wifi(struct connman_device *device,
1621                 const char *ssid, const char *mode, const char *security)
1622 {
1623         struct connman_network *network;
1624         char *name;
1625         int index;
1626         unsigned int i, ssid_len;
1627
1628         ssid_len = strlen(ssid);
1629         if (ssid_len < 1)
1630                 return NULL;
1631
1632         network = connman_network_create(NULL, CONNMAN_NETWORK_TYPE_WIFI);
1633         if (network == NULL)
1634                 return NULL;
1635
1636         connman_network_set_blob(network, "WiFi.SSID",
1637                                         (unsigned char *) ssid, ssid_len);
1638
1639         connman_network_set_string(network, "WiFi.Mode", mode);
1640         connman_network_set_string(network, "WiFi.Security", security);
1641
1642         name = g_try_malloc0(ssid_len + 1);
1643         if (name == NULL) {
1644                 connman_network_unref(network);
1645                 return NULL;
1646         }
1647
1648         for (i = 0; i < ssid_len; i++) {
1649                 if (g_ascii_isprint(ssid[i]))
1650                         name[i] = ssid[i];
1651                 else
1652                         name[i] = ' ';
1653         }
1654
1655         connman_network_set_name(network, name);
1656
1657         g_free(name);
1658
1659         index = connman_device_get_index(device);
1660         connman_network_set_index(network, index);
1661
1662         connman_network_set_protocol(network, CONNMAN_NETWORK_PROTOCOL_IP);
1663
1664         if (connman_device_add_network(device, network) < 0) {
1665                 connman_network_unref(network);
1666                 return NULL;
1667         }
1668
1669         connman_network_set_available(network, TRUE);
1670
1671         return network;
1672 }
1673
1674 int __connman_service_create_and_connect(DBusMessage *msg)
1675 {
1676         struct connman_service *service;
1677         struct connman_network *network;
1678         struct connman_device *device;
1679         DBusMessageIter iter, array;
1680         const char *mode = "managed", *security = "none";
1681         const char *type = NULL, *ssid = NULL, *passphrase = NULL;
1682         unsigned int ssid_len = 0;
1683         const char *ident;
1684         char *name, *group;
1685         gboolean created = FALSE;
1686         int err;
1687
1688         dbus_message_iter_init(msg, &iter);
1689         dbus_message_iter_recurse(&iter, &array);
1690
1691         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1692                 DBusMessageIter entry, value;
1693                 const char *key;
1694
1695                 dbus_message_iter_recurse(&array, &entry);
1696                 dbus_message_iter_get_basic(&entry, &key);
1697
1698                 dbus_message_iter_next(&entry);
1699                 dbus_message_iter_recurse(&entry, &value);
1700
1701                 switch (dbus_message_iter_get_arg_type(&value)) {
1702                 case DBUS_TYPE_STRING:
1703                         if (g_str_equal(key, "Type") == TRUE)
1704                                 dbus_message_iter_get_basic(&value, &type);
1705                         else if (g_str_equal(key, "WiFi.Mode") == TRUE ||
1706                                         g_str_equal(key, "Mode") == TRUE)
1707                                 dbus_message_iter_get_basic(&value, &mode);
1708                         else if (g_str_equal(key, "WiFi.Security") == TRUE ||
1709                                         g_str_equal(key, "Security") == TRUE)
1710                                 dbus_message_iter_get_basic(&value, &security);
1711                         else if (g_str_equal(key, "WiFi.Passphrase") == TRUE ||
1712                                         g_str_equal(key, "Passphrase") == TRUE)
1713                                 dbus_message_iter_get_basic(&value, &passphrase);
1714                         else if (g_str_equal(key, "WiFi.SSID") == TRUE ||
1715                                         g_str_equal(key, "SSID") == TRUE)
1716                                 dbus_message_iter_get_basic(&value, &ssid);
1717                 }
1718
1719                 dbus_message_iter_next(&array);
1720         }
1721
1722         if (type == NULL)
1723                 return -EINVAL;
1724
1725         if (g_strcmp0(type, "wifi") != 0 || g_strcmp0(mode, "managed") != 0)
1726                 return -EOPNOTSUPP;
1727
1728         if (ssid == NULL)
1729                 return -EINVAL;
1730
1731         ssid_len = strlen(ssid);
1732         if (ssid_len < 1)
1733                 return -EINVAL;
1734
1735         if (g_strcmp0(security, "none") != 0 &&
1736                                 g_strcmp0(security, "wep") != 0 &&
1737                                 g_strcmp0(security, "psk") != 0 &&
1738                                 g_strcmp0(security, "wpa") != 0 &&
1739                                 g_strcmp0(security, "rsn") != 0)
1740                 return -EINVAL;
1741
1742         device = __connman_element_find_device(CONNMAN_DEVICE_TYPE_WIFI);
1743         if (device == NULL)
1744                 return -EOPNOTSUPP;
1745
1746         ident = __connman_device_get_ident(device);
1747         if (ident == NULL)
1748                 return -EOPNOTSUPP;
1749
1750         group = connman_wifi_build_group_name((unsigned char *) ssid,
1751                                                 ssid_len, mode, security);
1752         if (group == NULL)
1753                 return -EINVAL;
1754
1755         name = g_strdup_printf("%s_%s_%s", type, ident, group);
1756
1757         service = __connman_service_lookup(name);
1758
1759         if (service != NULL)
1760                 goto done;
1761
1762         network = create_hidden_wifi(device, ssid, mode, security);
1763         if (network != NULL) {
1764                 connman_network_set_group(network, group);
1765                 created = TRUE;
1766         }
1767
1768         service = __connman_service_lookup(name);
1769
1770 done:
1771         g_free(name);
1772         g_free(group);
1773
1774         if (service == NULL) {
1775                 err = -EOPNOTSUPP;
1776                 goto failed;
1777         }
1778
1779         set_reconnect_state(service, FALSE);
1780
1781         __connman_device_disconnect(device);
1782
1783         if (passphrase != NULL) {
1784                 g_free(service->passphrase);
1785                 service->passphrase = g_strdup(passphrase);
1786         }
1787
1788         service->userconnect = TRUE;
1789
1790         err = __connman_service_connect(service);
1791         if (err < 0 && err != -EINPROGRESS)
1792                 goto failed;
1793
1794         g_dbus_send_reply(connection, msg,
1795                                 DBUS_TYPE_OBJECT_PATH, &service->path,
1796                                                         DBUS_TYPE_INVALID);
1797
1798         return 0;
1799
1800 failed:
1801         if (service != NULL && created == TRUE) {
1802                 struct connman_network *network = service->network;
1803
1804                 if (network != NULL) {
1805                         connman_network_set_available(network, FALSE);
1806                         __connman_device_cleanup_networks(device);
1807                 }
1808
1809                 __connman_service_put(service);
1810         }
1811
1812         return err;
1813 }
1814
1815 /**
1816  * __connman_service_get:
1817  * @identifier: service identifier
1818  *
1819  * Look up a service by identifier or create a new one if not found
1820  */
1821 static struct connman_service *__connman_service_get(const char *identifier)
1822 {
1823         struct connman_service *service;
1824         GSequenceIter *iter;
1825
1826         iter = g_hash_table_lookup(service_hash, identifier);
1827         if (iter != NULL) {
1828                 service = g_sequence_get(iter);
1829                 if (service != NULL)
1830                         g_atomic_int_inc(&service->refcount);
1831                 return service;
1832         }
1833
1834         service = connman_service_create();
1835         if (service == NULL)
1836                 return NULL;
1837
1838         DBG("service %p", service);
1839
1840         service->identifier = g_strdup(identifier);
1841
1842         service->profile = g_strdup(__connman_profile_active_ident());
1843
1844         __connman_storage_load_service(service);
1845
1846         iter = g_sequence_insert_sorted(service_list, service,
1847                                                 service_compare, NULL);
1848
1849         g_hash_table_insert(service_hash, service->identifier, iter);
1850
1851         return service;
1852 }
1853
1854 static int service_register(struct connman_service *service)
1855 {
1856         const char *path = __connman_profile_active_path();
1857         GSequenceIter *iter;
1858
1859         DBG("service %p", service);
1860
1861         if (service->path != NULL)
1862                 return -EALREADY;
1863
1864         service->path = g_strdup_printf("%s/%s", path, service->identifier);
1865
1866         DBG("path %s", service->path);
1867
1868         g_dbus_register_interface(connection, service->path,
1869                                         CONNMAN_SERVICE_INTERFACE,
1870                                         service_methods, service_signals,
1871                                                         NULL, service, NULL);
1872
1873         __connman_storage_load_service(service);
1874
1875         iter = g_hash_table_lookup(service_hash, service->identifier);
1876         if (iter != NULL)
1877                 g_sequence_sort_changed(iter, service_compare, NULL);
1878
1879         __connman_profile_changed(TRUE);
1880
1881         return 0;
1882 }
1883
1884 static void service_up(struct connman_ipconfig *ipconfig)
1885 {
1886         connman_info("%s up", connman_ipconfig_get_ifname(ipconfig));
1887 }
1888
1889 static void service_down(struct connman_ipconfig *ipconfig)
1890 {
1891         connman_info("%s down", connman_ipconfig_get_ifname(ipconfig));
1892 }
1893
1894 static void service_lower_up(struct connman_ipconfig *ipconfig)
1895 {
1896         connman_info("%s lower up", connman_ipconfig_get_ifname(ipconfig));
1897 }
1898
1899 static void service_lower_down(struct connman_ipconfig *ipconfig)
1900 {
1901         connman_info("%s lower down", connman_ipconfig_get_ifname(ipconfig));
1902 }
1903
1904 static void service_ip_bound(struct connman_ipconfig *ipconfig)
1905 {
1906         connman_info("%s ip bound", connman_ipconfig_get_ifname(ipconfig));
1907 }
1908
1909 static void service_ip_release(struct connman_ipconfig *ipconfig)
1910 {
1911         connman_info("%s ip release", connman_ipconfig_get_ifname(ipconfig));
1912 }
1913
1914 static const struct connman_ipconfig_ops service_ops = {
1915         .up             = service_up,
1916         .down           = service_down,
1917         .lower_up       = service_lower_up,
1918         .lower_down     = service_lower_down,
1919         .ip_bound       = service_ip_bound,
1920         .ip_release     = service_ip_release,
1921 };
1922
1923 static void setup_ipconfig(struct connman_service *service, int index)
1924 {
1925         if (index < 0)
1926                 return;
1927
1928         service->ipconfig = connman_ipconfig_create(index);
1929         if (service->ipconfig == NULL)
1930                 return;
1931
1932         connman_ipconfig_set_method(service->ipconfig,
1933                                         CONNMAN_IPCONFIG_METHOD_DHCP);
1934
1935         __connman_storage_load_service(service);
1936
1937         connman_ipconfig_set_data(service->ipconfig, service);
1938
1939         connman_ipconfig_set_ops(service->ipconfig, &service_ops);
1940         connman_ipconfig_set_ops(service->ipconfig, NULL);
1941 }
1942
1943 /**
1944  * __connman_service_lookup_from_network:
1945  * @network: network structure
1946  *
1947  * Look up a service by network (reference count will not be increased)
1948  */
1949 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
1950 {
1951         struct connman_service *service;
1952         const char *ident, *group;
1953         char *name;
1954
1955         DBG("network %p", network);
1956
1957         ident = __connman_network_get_ident(network);
1958         if (ident == NULL)
1959                 return NULL;
1960
1961         group = connman_network_get_group(network);
1962         if (group == NULL)
1963                 return NULL;
1964
1965         name = g_strdup_printf("%s_%s_%s",
1966                         __connman_network_get_type(network), ident, group);
1967         service = __connman_service_lookup(name);
1968         g_free(name);
1969
1970         return service;
1971 }
1972
1973 const char *__connman_service_get_path(struct connman_service *service)
1974 {
1975         return service->path;
1976 }
1977
1978 unsigned int __connman_service_get_order(struct connman_service *service)
1979 {
1980         GSequenceIter *iter;
1981
1982         if (service == NULL)
1983                 return 0;
1984
1985         if (service->favorite == FALSE) {
1986                 service->order = 0;
1987                 goto done;
1988         }
1989
1990         iter = g_hash_table_lookup(service_hash, service->identifier);
1991         if (iter != NULL) {
1992                 if (g_sequence_iter_get_position(iter) == 0)
1993                         service->order = 1;
1994                 else
1995                         service->order = 0;
1996         }
1997
1998 done:
1999         return service->order;
2000 }
2001
2002 static enum connman_service_type convert_network_type(struct connman_network *network)
2003 {
2004         enum connman_network_type type = connman_network_get_type(network);
2005
2006         switch (type) {
2007         case CONNMAN_NETWORK_TYPE_UNKNOWN:
2008         case CONNMAN_NETWORK_TYPE_VENDOR:
2009                 break;
2010         case CONNMAN_NETWORK_TYPE_ETHERNET:
2011                 return CONNMAN_SERVICE_TYPE_ETHERNET;
2012         case CONNMAN_NETWORK_TYPE_WIFI:
2013                 return CONNMAN_SERVICE_TYPE_WIFI;
2014         case CONNMAN_NETWORK_TYPE_WIMAX:
2015                 return CONNMAN_SERVICE_TYPE_WIMAX;
2016         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
2017         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
2018                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
2019         case CONNMAN_NETWORK_TYPE_CELLULAR:
2020         case CONNMAN_NETWORK_TYPE_MBM:
2021         case CONNMAN_NETWORK_TYPE_HSO:
2022                 return CONNMAN_SERVICE_TYPE_CELLULAR;
2023         }
2024
2025         return CONNMAN_SERVICE_TYPE_UNKNOWN;
2026 }
2027
2028 static enum connman_service_mode convert_wifi_mode(const char *mode)
2029 {
2030         if (mode == NULL)
2031                 return CONNMAN_SERVICE_MODE_UNKNOWN;
2032         else if (g_str_equal(mode, "managed") == TRUE)
2033                 return CONNMAN_SERVICE_MODE_MANAGED;
2034         else if (g_str_equal(mode, "adhoc") == TRUE)
2035                 return CONNMAN_SERVICE_MODE_ADHOC;
2036         else
2037                 return CONNMAN_SERVICE_MODE_UNKNOWN;
2038 }
2039
2040 static enum connman_service_security convert_wifi_security(const char *security)
2041 {
2042         if (security == NULL)
2043                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
2044         else if (g_str_equal(security, "none") == TRUE)
2045                 return CONNMAN_SERVICE_SECURITY_NONE;
2046         else if (g_str_equal(security, "wep") == TRUE)
2047                 return CONNMAN_SERVICE_SECURITY_WEP;
2048         else if (g_str_equal(security, "wep") == TRUE)
2049                 return CONNMAN_SERVICE_SECURITY_PSK;
2050         else if (g_str_equal(security, "ieee8021x") == TRUE)
2051                 return CONNMAN_SERVICE_SECURITY_8021X;
2052         else if (g_str_equal(security, "wpa") == TRUE)
2053                 return CONNMAN_SERVICE_SECURITY_WPA;
2054         else if (g_str_equal(security, "rsn") == TRUE)
2055                 return CONNMAN_SERVICE_SECURITY_RSN;
2056         else
2057                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
2058 }
2059
2060 static enum connman_service_mode convert_cellular_mode(connman_uint8_t mode)
2061 {
2062         switch (mode) {
2063         case 0:
2064         case 1:
2065                 return CONNMAN_SERVICE_MODE_GPRS;
2066         case 3:
2067                 return CONNMAN_SERVICE_MODE_EDGE;
2068         case 2:
2069         case 4:
2070         case 5:
2071         case 6:
2072                 return CONNMAN_SERVICE_MODE_UMTS;
2073         }
2074
2075         return CONNMAN_SERVICE_MODE_UNKNOWN;
2076 }
2077
2078 static void update_from_network(struct connman_service *service,
2079                                         struct connman_network *network)
2080 {
2081         connman_uint8_t strength = service->strength;
2082         GSequenceIter *iter;
2083         const char *str;
2084
2085         DBG("service %p network %p", service, network);
2086
2087         if (service->state == CONNMAN_SERVICE_STATE_READY)
2088                 return;
2089
2090         if (is_connecting(service) == TRUE)
2091                 return;
2092
2093         str = connman_network_get_string(network, "Name");
2094         if (str != NULL) {
2095                 g_free(service->name);
2096                 service->name = g_strdup(str);
2097                 service->hidden = FALSE;
2098         } else {
2099                 g_free(service->name);
2100                 service->name = NULL;
2101                 service->hidden = TRUE;
2102         }
2103
2104         service->strength = connman_network_get_uint8(network, "Strength");
2105         service->roaming = connman_network_get_bool(network, "Roaming");
2106
2107         if (service->strength == 0) {
2108                 /*
2109                  * Filter out 0-values; it's unclear what they mean
2110                  * and they cause anomalous sorting of the priority list.
2111                  */
2112                 service->strength = strength;
2113         }
2114
2115         str = connman_network_get_string(network, "WiFi.Mode");
2116         service->mode = convert_wifi_mode(str);
2117
2118         str = connman_network_get_string(network, "WiFi.Security");
2119         service->security = convert_wifi_security(str);
2120
2121         str = connman_network_get_string(network, "Cellular.MCC");
2122         g_free(service->mcc);
2123         service->mcc = g_strdup(str);
2124
2125         str = connman_network_get_string(network, "Cellular.MNC");
2126         g_free(service->mnc);
2127         service->mnc = g_strdup(str);
2128
2129         if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR) {
2130                 connman_uint8_t value = connman_network_get_uint8(network,
2131                                                         "Cellular.Mode");
2132
2133                 service->mode = convert_cellular_mode(value);
2134         }
2135
2136         if (service->strength > strength && service->network != NULL) {
2137                 connman_network_unref(service->network);
2138                 service->network = connman_network_ref(network);
2139
2140                 strength_changed(service);
2141         }
2142
2143         if (service->network == NULL)
2144                 service->network = connman_network_ref(network);
2145
2146         iter = g_hash_table_lookup(service_hash, service->identifier);
2147         if (iter != NULL)
2148                 g_sequence_sort_changed(iter, service_compare, NULL);
2149 }
2150
2151 /**
2152  * __connman_service_create_from_network:
2153  * @network: network structure
2154  *
2155  * Look up service by network and if not found, create one
2156  */
2157 struct connman_service *__connman_service_create_from_network(struct connman_network *network)
2158 {
2159         struct connman_service *service;
2160         const char *ident, *group;
2161         char *name;
2162
2163         DBG("network %p", network);
2164
2165         ident = __connman_network_get_ident(network);
2166         if (ident == NULL)
2167                 return NULL;
2168
2169         group = connman_network_get_group(network);
2170         if (group == NULL)
2171                 return NULL;
2172
2173         name = g_strdup_printf("%s_%s_%s",
2174                         __connman_network_get_type(network), ident, group);
2175         service = __connman_service_get(name);
2176         g_free(name);
2177
2178         if (service == NULL)
2179                 return NULL;
2180
2181         if (__connman_network_get_weakness(network) == TRUE)
2182                 return service;
2183
2184         if (service->path != NULL) {
2185                 update_from_network(service, network);
2186                 __connman_profile_changed(TRUE);
2187                 return service;
2188         }
2189
2190         service->type = convert_network_type(network);
2191
2192         switch (service->type) {
2193         case CONNMAN_SERVICE_TYPE_UNKNOWN:
2194         case CONNMAN_SERVICE_TYPE_SYSTEM:
2195         case CONNMAN_SERVICE_TYPE_ETHERNET:
2196         case CONNMAN_SERVICE_TYPE_WIMAX:
2197         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2198         case CONNMAN_SERVICE_TYPE_VPN:
2199                 service->autoconnect = FALSE;
2200                 break;
2201         case CONNMAN_SERVICE_TYPE_WIFI:
2202         case CONNMAN_SERVICE_TYPE_CELLULAR:
2203                 service->autoconnect = TRUE;
2204                 break;
2205         }
2206
2207         service->state = CONNMAN_SERVICE_STATE_IDLE;
2208
2209         update_from_network(service, network);
2210
2211         setup_ipconfig(service, connman_network_get_index(network));
2212
2213         service_register(service);
2214
2215         __connman_profile_changed(TRUE);
2216
2217         if (service->favorite == TRUE)
2218                 __connman_service_auto_connect();
2219
2220         return service;
2221 }
2222
2223 void __connman_service_update_from_network(struct connman_network *network)
2224 {
2225         struct connman_service *service;
2226         enum connman_service_mode mode;
2227         connman_uint8_t strength, value;
2228         connman_bool_t roaming;
2229         GSequenceIter *iter;
2230
2231         DBG("network %p", network);
2232
2233         service = __connman_service_lookup_from_network(network);
2234         if (service == NULL)
2235                 return;
2236
2237         if (service->network == NULL)
2238                 return;
2239
2240         strength = connman_network_get_uint8(service->network, "Strength");
2241         if (strength == service->strength)
2242                 goto roaming;
2243
2244         service->strength = strength;
2245
2246         strength_changed(service);
2247
2248 roaming:
2249         roaming = connman_network_get_bool(service->network, "Roaming");
2250         if (roaming == service->roaming)
2251                 goto done;
2252
2253         service->roaming = roaming;
2254
2255         roaming_changed(service);
2256
2257         iter = g_hash_table_lookup(service_hash, service->identifier);
2258         if (iter != NULL)
2259                 g_sequence_sort_changed(iter, service_compare, NULL);
2260
2261 done:
2262         if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
2263                 return;
2264
2265         value = connman_network_get_uint8(service->network, "Cellular.Mode");
2266         mode = convert_cellular_mode(value);
2267
2268         if (mode == service->mode)
2269                 return;
2270
2271         service->mode = mode;
2272
2273         mode_changed(service);
2274 }
2275
2276 void __connman_service_remove_from_network(struct connman_network *network)
2277 {
2278         struct connman_service *service;
2279
2280         DBG("network %p", network);
2281
2282         service = __connman_service_lookup_from_network(network);
2283         if (service == NULL)
2284                 return;
2285
2286         __connman_service_put(service);
2287 }
2288
2289 static int service_load(struct connman_service *service)
2290 {
2291         const char *ident = service->profile;
2292         GKeyFile *keyfile;
2293         GError *error = NULL;
2294         gchar *pathname, *data = NULL;
2295         gsize length;
2296         gchar *str;
2297         connman_bool_t autoconnect;
2298         unsigned int ssid_len;
2299         int err = 0;
2300
2301         DBG("service %p", service);
2302
2303         if (ident == NULL)
2304                 return -EINVAL;
2305
2306         pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
2307         if (pathname == NULL)
2308                 return -ENOMEM;
2309
2310         keyfile = g_key_file_new();
2311
2312         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
2313                 g_free(pathname);
2314                 return -ENOENT;
2315         }
2316
2317         g_free(pathname);
2318
2319         if (g_key_file_load_from_data(keyfile, data, length,
2320                                                         0, NULL) == FALSE) {
2321                 g_free(data);
2322                 return -EILSEQ;
2323         }
2324
2325         g_free(data);
2326
2327         switch (service->type) {
2328         case CONNMAN_SERVICE_TYPE_UNKNOWN:
2329         case CONNMAN_SERVICE_TYPE_SYSTEM:
2330         case CONNMAN_SERVICE_TYPE_ETHERNET:
2331         case CONNMAN_SERVICE_TYPE_VPN:
2332                 break;
2333         case CONNMAN_SERVICE_TYPE_WIFI:
2334                 if (service->name == NULL) {
2335                         gchar *name;
2336
2337                         name = g_key_file_get_string(keyfile,
2338                                         service->identifier, "Name", NULL);
2339                         if (name != NULL) {
2340                                 g_free(service->name);
2341                                 service->name = name;
2342                         }
2343
2344                         if (service->network != NULL)
2345                                 connman_network_set_name(service->network,
2346                                                                         name);
2347                 }
2348
2349                 if (service->network &&
2350                                 connman_network_get_blob(service->network,
2351                                         "WiFi.SSID", &ssid_len) == NULL) {
2352                         gchar *hex_ssid;
2353
2354                         hex_ssid = g_key_file_get_string(keyfile,
2355                                                         service->identifier,
2356                                                                 "SSID", NULL);
2357
2358                         if (hex_ssid != NULL) {
2359                                 gchar *ssid;
2360                                 unsigned int i, j = 0, hex;
2361                                 size_t hex_ssid_len = strlen(hex_ssid);
2362
2363                                 ssid = g_try_malloc0(hex_ssid_len / 2);
2364                                 if (ssid == NULL) {
2365                                         g_free(hex_ssid);
2366                                         err = -ENOMEM;
2367                                         goto done;
2368                                 }
2369
2370                                 for (i = 0; i < hex_ssid_len; i += 2) {
2371                                         sscanf(hex_ssid + i, "%02x", &hex);
2372                                         ssid[j++] = hex;
2373                                 }
2374
2375                                 connman_network_set_blob(service->network,
2376                                         "WiFi.SSID", ssid, hex_ssid_len / 2);
2377                         }
2378
2379                         g_free(hex_ssid);
2380                 }
2381                 /* fall through */
2382
2383         case CONNMAN_SERVICE_TYPE_WIMAX:
2384         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2385         case CONNMAN_SERVICE_TYPE_CELLULAR:
2386                 service->apn = g_key_file_get_string(keyfile,
2387                                         service->identifier, "APN", NULL);
2388
2389                 service->username = g_key_file_get_string(keyfile,
2390                                         service->identifier, "Username", NULL);
2391
2392                 service->username = g_key_file_get_string(keyfile,
2393                                         service->identifier, "Password", NULL);
2394
2395                 service->favorite = g_key_file_get_boolean(keyfile,
2396                                 service->identifier, "Favorite", NULL);
2397
2398                 autoconnect = g_key_file_get_boolean(keyfile,
2399                                 service->identifier, "AutoConnect", &error);
2400                 if (error == NULL)
2401                         service->autoconnect = autoconnect;
2402                 g_clear_error(&error);
2403
2404                 str = g_key_file_get_string(keyfile,
2405                                 service->identifier, "Failure", NULL);
2406                 if (str != NULL) {
2407                         service->state = CONNMAN_SERVICE_STATE_FAILURE;
2408                         service->error = string2error(str);
2409                 }
2410                 break;
2411         }
2412
2413         str = g_key_file_get_string(keyfile,
2414                                 service->identifier, "Modified", NULL);
2415         if (str != NULL) {
2416                 g_time_val_from_iso8601(str, &service->modified);
2417                 g_free(str);
2418         }
2419
2420         str = g_key_file_get_string(keyfile,
2421                                 service->identifier, "Passphrase", NULL);
2422         if (str != NULL) {
2423                 g_free(service->passphrase);
2424                 service->passphrase = str;
2425         }
2426
2427         if (service->ipconfig != NULL)
2428                 __connman_ipconfig_load(service->ipconfig, keyfile,
2429                                         service->identifier, "IPv4.");
2430
2431 done:
2432         g_key_file_free(keyfile);
2433
2434         return err;
2435 }
2436
2437 static int service_save(struct connman_service *service)
2438 {
2439         const char *ident = service->profile;
2440         GKeyFile *keyfile;
2441         gchar *pathname, *data = NULL;
2442         gsize length;
2443         gchar *str;
2444         int err = 0;
2445
2446         DBG("service %p", service);
2447
2448         if (ident == NULL)
2449                 return -EINVAL;
2450
2451         pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
2452         if (pathname == NULL)
2453                 return -ENOMEM;
2454
2455         keyfile = g_key_file_new();
2456
2457         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
2458                 goto update;
2459
2460         if (length > 0) {
2461                 if (g_key_file_load_from_data(keyfile, data, length,
2462                                                         0, NULL) == FALSE)
2463                         goto done;
2464         }
2465
2466         g_free(data);
2467
2468 update:
2469         if (service->name != NULL)
2470                 g_key_file_set_string(keyfile, service->identifier,
2471                                                 "Name", service->name);
2472
2473         switch (service->type) {
2474         case CONNMAN_SERVICE_TYPE_UNKNOWN:
2475         case CONNMAN_SERVICE_TYPE_SYSTEM:
2476         case CONNMAN_SERVICE_TYPE_ETHERNET:
2477         case CONNMAN_SERVICE_TYPE_VPN:
2478                 break;
2479         case CONNMAN_SERVICE_TYPE_WIFI:
2480                 if (service->network) {
2481                         const unsigned char *ssid;
2482                         unsigned int ssid_len = 0;
2483
2484                         ssid = connman_network_get_blob(service->network,
2485                                                         "WiFi.SSID", &ssid_len);
2486
2487                         if (ssid != NULL && ssid_len > 0 && ssid[0] != '\0') {
2488                                 char *identifier = service->identifier;
2489                                 GString *str;
2490                                 unsigned int i;
2491
2492                                 str = g_string_sized_new(ssid_len * 2);
2493                                 if (str == NULL) {
2494                                         err = -ENOMEM;
2495                                         goto done;
2496                                 }
2497
2498                                 for (i = 0; i < ssid_len; i++)
2499                                         g_string_append_printf(str,
2500                                                         "%02x", ssid[i]);
2501
2502                                 g_key_file_set_string(keyfile, identifier,
2503                                                         "SSID", str->str);
2504
2505                                 g_string_free(str, TRUE);
2506                         }
2507                 }
2508                 /* fall through */
2509
2510         case CONNMAN_SERVICE_TYPE_WIMAX:
2511         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2512         case CONNMAN_SERVICE_TYPE_CELLULAR:
2513                 if (service->apn != NULL)
2514                         g_key_file_set_string(keyfile, service->identifier,
2515                                                         "APN", service->apn);
2516
2517                 if (service->username != NULL)
2518                         g_key_file_set_string(keyfile, service->identifier,
2519                                                 "Username", service->username);
2520
2521                 if (service->password != NULL)
2522                         g_key_file_set_string(keyfile, service->identifier,
2523                                                 "Password", service->password);
2524
2525                 g_key_file_set_boolean(keyfile, service->identifier,
2526                                         "Favorite", service->favorite);
2527
2528                 if (service->favorite == TRUE)
2529                         g_key_file_set_boolean(keyfile, service->identifier,
2530                                         "AutoConnect", service->autoconnect);
2531
2532                 if (service->state == CONNMAN_SERVICE_STATE_FAILURE) {
2533                         const char *failure = error2string(service->error);
2534                         if (failure != NULL)
2535                                 g_key_file_set_string(keyfile,
2536                                                         service->identifier,
2537                                                         "Failure", failure);
2538                 } else {
2539                         g_key_file_remove_key(keyfile, service->identifier,
2540                                                         "Failure", NULL);
2541                 }
2542                 break;
2543         }
2544
2545         str = g_time_val_to_iso8601(&service->modified);
2546         if (str != NULL) {
2547                 g_key_file_set_string(keyfile, service->identifier,
2548                                                         "Modified", str);
2549                 g_free(str);
2550         }
2551
2552         if (service->passphrase != NULL && strlen(service->passphrase) > 0)
2553                 g_key_file_set_string(keyfile, service->identifier,
2554                                         "Passphrase", service->passphrase);
2555         else
2556                 g_key_file_remove_key(keyfile, service->identifier,
2557                                                         "Passphrase", NULL);
2558
2559         if (service->ipconfig != NULL)
2560                 __connman_ipconfig_save(service->ipconfig, keyfile,
2561                                         service->identifier, "IPv4.");
2562
2563         data = g_key_file_to_data(keyfile, &length, NULL);
2564
2565         if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
2566                 connman_error("Failed to store service information");
2567
2568 done:
2569         g_free(data);
2570
2571         g_key_file_free(keyfile);
2572
2573         g_free(pathname);
2574
2575         return err;
2576 }
2577
2578 static struct connman_storage service_storage = {
2579         .name           = "service",
2580         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
2581         .service_load   = service_load,
2582         .service_save   = service_save,
2583 };
2584
2585 int __connman_service_init(void)
2586 {
2587         DBG("");
2588
2589         connection = connman_dbus_get_connection();
2590
2591         if (connman_storage_register(&service_storage) < 0)
2592                 connman_error("Failed to register service storage");
2593
2594         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
2595                                                                 NULL, NULL);
2596
2597         service_list = g_sequence_new(service_free);
2598
2599         return 0;
2600 }
2601
2602 void __connman_service_cleanup(void)
2603 {
2604         DBG("");
2605
2606         g_sequence_free(service_list);
2607         service_list = NULL;
2608
2609         g_hash_table_destroy(service_hash);
2610         service_hash = NULL;
2611
2612         connman_storage_unregister(&service_storage);
2613
2614         dbus_connection_unref(connection);
2615 }