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