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