src/service.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <gdbus.h>
  29
  30 #include "connman.h"
  31
  32 #define CONNECT_TIMEOUT         120
  33
  34 static DBusConnection *connection = NULL;
  35
  36 static GSequence *service_list = NULL;
  37 static GHashTable *service_hash = NULL;
  38 static GSList *counter_list = NULL;
  39
  40 struct connman_stats {
  41         connman_bool_t valid;
  42         connman_bool_t enabled;
  43         unsigned int rx_packets_last;
  44         unsigned int tx_packets_last;
  45         unsigned int rx_packets;
  46         unsigned int tx_packets;
  47         unsigned int rx_bytes_last;
  48         unsigned int tx_bytes_last;
  49         unsigned int rx_bytes;
  50         unsigned int tx_bytes;
  51         unsigned int rx_errors_last;
  52         unsigned int tx_errors_last;
  53         unsigned int rx_errors;
  54         unsigned int tx_errors;
  55         unsigned int rx_dropped_last;
  56         unsigned int tx_dropped_last;
  57         unsigned int rx_dropped;
  58         unsigned int tx_dropped;
  59         unsigned int time_start;
  60         unsigned int time;
  61         GTimer *timer;
  62 };
  63
  64 struct connman_stats_update {
  65         unsigned int rx_packets;
  66         unsigned int tx_packets;
  67         unsigned int rx_bytes;
  68         unsigned int tx_bytes;
  69         unsigned int rx_errors;
  70         unsigned int tx_errors;
  71         unsigned int rx_dropped;
  72         unsigned int tx_dropped;
  73         unsigned int time;
  74 };
  75
  76 struct connman_stats_counter {
  77         connman_bool_t append_all;
  78         struct connman_stats_update stats;
  79         struct connman_stats_update stats_roaming;
  80 };
  81
  82 struct connman_service {
  83         gint refcount;
  84         char *identifier;
  85         char *path;
  86         enum connman_service_type type;
  87         enum connman_service_mode mode;
  88         enum connman_service_security security;
  89         enum connman_service_state state;
  90         enum connman_service_error error;
  91         connman_uint8_t strength;
  92         connman_bool_t favorite;
  93         connman_bool_t immutable;
  94         connman_bool_t hidden;
  95         connman_bool_t ignore;
  96         connman_bool_t autoconnect;
  97         connman_bool_t userconnect;
  98         GTimeVal modified;
  99         unsigned int order;
 100         char *name;
 101         char *passphrase;
 102         char *profile;
 103         char *apn;
 104         char *username;
 105         char *password;
 106         char *mcc;
 107         char *mnc;
 108         connman_bool_t roaming;
 109         connman_bool_t login_required;
 110         struct connman_ipconfig *ipconfig;
 111         struct connman_network *network;
 112         struct connman_provider *provider;
 113         char **nameservers;
 114         char *nameserver;
 115         char **domains;
 116         char *domainname;
 117         /* 802.1x settings from the config files */
 118         char *eap;
 119         char *identity;
 120         char *ca_cert_file;
 121         char *client_cert_file;
 122         char *private_key_file;
 123         char *private_key_passphrase;
 124         char *phase2;
 125         DBusMessage *pending;
 126         guint timeout;
 127         struct connman_location *location;
 128         struct connman_stats stats;
 129         struct connman_stats stats_roaming;
 130         GHashTable *counter_table;
 131 };
 132
 133 static void append_path(gpointer value, gpointer user_data)
 134 {
 135         struct connman_service *service = value;
 136         DBusMessageIter *iter = user_data;
 137
 138         if (service->path == NULL || service->hidden == TRUE)
 139                 return;
 140
 141         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
 142                                                         &service->path);
 143 }
 144
 145 void __connman_service_list(DBusMessageIter *iter, void *user_data)
 146 {
 147         g_sequence_foreach(service_list, append_path, iter);
 148 }
 149
 150 struct find_data {
 151         const char *path;
 152         struct connman_service *service;
 153 };
 154
 155 static void compare_path(gpointer value, gpointer user_data)
 156 {
 157         struct connman_service *service = value;
 158         struct find_data *data = user_data;
 159
 160         if (data->service != NULL)
 161                 return;
 162
 163         if (g_strcmp0(service->path, data->path) == 0)
 164                 data->service = service;
 165 }
 166
 167 static struct connman_service *find_service(const char *path)
 168 {
 169         struct find_data data = { .path = path, .service = NULL };
 170
 171         DBG("path %s", path);
 172
 173         g_sequence_foreach(service_list, compare_path, &data);
 174
 175         return data.service;
 176 }
 177
 178 const char *__connman_service_type2string(enum connman_service_type type)
 179 {
 180         switch (type) {
 181         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 182                 break;
 183         case CONNMAN_SERVICE_TYPE_SYSTEM:
 184                 return "system";
 185         case CONNMAN_SERVICE_TYPE_ETHERNET:
 186                 return "ethernet";
 187         case CONNMAN_SERVICE_TYPE_WIFI:
 188                 return "wifi";
 189         case CONNMAN_SERVICE_TYPE_WIMAX:
 190                 return "wimax";
 191         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 192                 return "bluetooth";
 193         case CONNMAN_SERVICE_TYPE_CELLULAR:
 194                 return "cellular";
 195         case CONNMAN_SERVICE_TYPE_GPS:
 196                 return "gps";
 197         case CONNMAN_SERVICE_TYPE_VPN:
 198                 return "vpn";
 199         }
 200
 201         return NULL;
 202 }
 203
 204 static const char *mode2string(enum connman_service_mode mode)
 205 {
 206         switch (mode) {
 207         case CONNMAN_SERVICE_MODE_UNKNOWN:
 208                 break;
 209         case CONNMAN_SERVICE_MODE_MANAGED:
 210                 return "managed";
 211         case CONNMAN_SERVICE_MODE_ADHOC:
 212                 return "adhoc";
 213         case CONNMAN_SERVICE_MODE_GPRS:
 214                 return "gprs";
 215         case CONNMAN_SERVICE_MODE_EDGE:
 216                 return "edge";
 217         case CONNMAN_SERVICE_MODE_UMTS:
 218                 return "umts";
 219         }
 220
 221         return NULL;
 222 }
 223
 224 static const char *security2string(enum connman_service_security security)
 225 {
 226         switch (security) {
 227         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 228                 break;
 229         case CONNMAN_SERVICE_SECURITY_NONE:
 230                 return "none";
 231         case CONNMAN_SERVICE_SECURITY_WEP:
 232                 return "wep";
 233         case CONNMAN_SERVICE_SECURITY_PSK:
 234                 return "psk";
 235         case CONNMAN_SERVICE_SECURITY_8021X:
 236                 return "ieee8021x";
 237         case CONNMAN_SERVICE_SECURITY_WPA:
 238                 return "wpa";
 239         case CONNMAN_SERVICE_SECURITY_RSN:
 240                 return "rsn";
 241         }
 242
 243         return NULL;
 244 }
 245
 246 static const char *state2string(enum connman_service_state state)
 247 {
 248         switch (state) {
 249         case CONNMAN_SERVICE_STATE_UNKNOWN:
 250                 break;
 251         case CONNMAN_SERVICE_STATE_IDLE:
 252                 return "idle";
 253         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 254                 return "association";
 255         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 256                 return "configuration";
 257         case CONNMAN_SERVICE_STATE_READY:
 258                 return "ready";
 259         case CONNMAN_SERVICE_STATE_ONLINE:
 260                 return "online";
 261         case CONNMAN_SERVICE_STATE_DISCONNECT:
 262                 return "disconnect";
 263         case CONNMAN_SERVICE_STATE_FAILURE:
 264                 return "failure";
 265         }
 266
 267         return NULL;
 268 }
 269
 270 static const char *error2string(enum connman_service_error error)
 271 {
 272         switch (error) {
 273         case CONNMAN_SERVICE_ERROR_UNKNOWN:
 274                 break;
 275         case CONNMAN_SERVICE_ERROR_OUT_OF_RANGE:
 276                 return "out-of-range";
 277         case CONNMAN_SERVICE_ERROR_PIN_MISSING:
 278                 return "pin-missing";
 279         case CONNMAN_SERVICE_ERROR_DHCP_FAILED:
 280                 return "dhcp-failed";
 281         case CONNMAN_SERVICE_ERROR_CONNECT_FAILED:
 282                 return "connect-failed";
 283         }
 284
 285         return NULL;
 286 }
 287
 288 static enum connman_service_error string2error(const char *error)
 289 {
 290         if (g_strcmp0(error, "dhcp-failed") == 0)
 291                 return CONNMAN_SERVICE_ERROR_DHCP_FAILED;
 292         else if (g_strcmp0(error, "pin-missing") == 0)
 293                 return CONNMAN_SERVICE_ERROR_PIN_MISSING;
 294
 295         return CONNMAN_SERVICE_ERROR_UNKNOWN;
 296 }
 297
 298 static connman_bool_t is_connecting(struct connman_service *service)
 299 {
 300         switch (service->state) {
 301         case CONNMAN_SERVICE_STATE_UNKNOWN:
 302         case CONNMAN_SERVICE_STATE_IDLE:
 303         case CONNMAN_SERVICE_STATE_FAILURE:
 304         case CONNMAN_SERVICE_STATE_DISCONNECT:
 305         case CONNMAN_SERVICE_STATE_READY:
 306         case CONNMAN_SERVICE_STATE_ONLINE:
 307                 break;
 308         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 309         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 310                 return TRUE;
 311         }
 312
 313         return FALSE;
 314 }
 315
 316 static connman_bool_t is_connected(const struct connman_service *service)
 317 {
 318         switch (service->state) {
 319         case CONNMAN_SERVICE_STATE_UNKNOWN:
 320         case CONNMAN_SERVICE_STATE_IDLE:
 321         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 322         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 323         case CONNMAN_SERVICE_STATE_DISCONNECT:
 324         case CONNMAN_SERVICE_STATE_FAILURE:
 325                 break;
 326         case CONNMAN_SERVICE_STATE_READY:
 327         case CONNMAN_SERVICE_STATE_ONLINE:
 328                 return TRUE;
 329         }
 330
 331         return FALSE;
 332 }
 333
 334 static void update_nameservers(struct connman_service *service)
 335 {
 336         const char *ifname = connman_ipconfig_get_ifname(service->ipconfig);
 337
 338         if (ifname == NULL)
 339                 return;
 340
 341         switch (service->state) {
 342         case CONNMAN_SERVICE_STATE_UNKNOWN:
 343         case CONNMAN_SERVICE_STATE_IDLE:
 344         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 345         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 346                 return;
 347         case CONNMAN_SERVICE_STATE_FAILURE:
 348         case CONNMAN_SERVICE_STATE_DISCONNECT:
 349                 connman_resolver_remove_all(ifname);
 350                 return;
 351         case CONNMAN_SERVICE_STATE_READY:
 352         case CONNMAN_SERVICE_STATE_ONLINE:
 353                 break;
 354         }
 355
 356         connman_resolver_remove_all(ifname);
 357
 358         if (service->nameservers != NULL) {
 359                 int i;
 360
 361                 for (i = 0; service->nameservers[i]; i++)
 362                         connman_resolver_append(ifname, NULL,
 363                                                 service->nameservers[i]);
 364         } else if (service->nameserver != NULL)
 365                 connman_resolver_append(ifname, NULL, service->nameserver);
 366
 367         connman_resolver_flush();
 368 }
 369
 370 void __connman_service_append_nameserver(struct connman_service *service,
 371                                                 const char *nameserver)
 372 {
 373         DBG("service %p nameserver %s", service, nameserver);
 374
 375         if (nameserver == NULL)
 376                 return;
 377
 378         g_free(service->nameserver);
 379         service->nameserver = g_strdup(nameserver);
 380
 381         update_nameservers(service);
 382 }
 383
 384 void __connman_service_remove_nameserver(struct connman_service *service,
 385                                                 const char *nameserver)
 386 {
 387         DBG("service %p nameserver %s", service, nameserver);
 388
 389         if (nameserver == NULL)
 390                 return;
 391
 392         g_free(service->nameserver);
 393         service->nameserver = NULL;
 394
 395         update_nameservers(service);
 396 }
 397
 398 void __connman_service_nameserver_add_routes(struct connman_service *service,
 399                                                 const char *gw)
 400 {
 401         int index;
 402
 403         if (service == NULL)
 404                 return;
 405
 406         index = connman_network_get_index(service->network);
 407
 408         if (service->nameservers != NULL) {
 409                 int i;
 410
 411                 /*
 412                  * We add nameservers host routes for nameservers that
 413                  * are not on our subnet. For those who are, the subnet
 414                  * route will be installed by the time the dns proxy code
 415                  * tries to reach them. The subnet route is installed
 416                  * when setting the interface IP address.
 417                  */
 418                 for (i = 0; service->nameservers[i]; i++) {
 419                         if (connman_inet_compare_subnet(index,
 420                                                         service->nameservers[i]))
 421                                 continue;
 422
 423                         connman_inet_add_host_route(index,
 424                                                 service->nameservers[i], gw);
 425                 }
 426         } else if (service->nameserver != NULL) {
 427                 if (connman_inet_compare_subnet(index, service->nameserver))
 428                         return;
 429
 430                 connman_inet_add_host_route(index, service->nameserver, gw);
 431         }
 432 }
 433
 434 void __connman_service_nameserver_del_routes(struct connman_service *service)
 435 {
 436         int index;
 437
 438         if (service == NULL)
 439                 return;
 440
 441         index = connman_network_get_index(service->network);
 442
 443         if (service->nameservers != NULL) {
 444                 int i;
 445
 446                 for (i = 0; service->nameservers[i]; i++)
 447                         connman_inet_del_host_route(index,
 448                                                 service->nameservers[i]);
 449         } else if (service->nameserver != NULL) {
 450                 connman_inet_del_host_route(index, service->nameserver);
 451         }
 452 }
 453
 454 static struct connman_stats *stats_get(struct connman_service *service)
 455 {
 456         if (service->roaming == TRUE)
 457                 return &service->stats_roaming;
 458         else
 459                 return &service->stats;
 460 }
 461
 462 static connman_bool_t stats_enabled(struct connman_service *service)
 463 {
 464         struct connman_stats *stats = stats_get(service);
 465
 466         return stats->enabled;
 467 }
 468
 469 static void stats_start(struct connman_service *service)
 470 {
 471         struct connman_stats *stats = stats_get(service);
 472
 473         DBG("service %p", service);
 474
 475         if (stats->timer == NULL)
 476                 return;
 477
 478         stats->enabled = TRUE;
 479         stats->time_start = stats->time;
 480
 481         g_timer_start(stats->timer);
 482 }
 483
 484 static void stats_stop(struct connman_service *service)
 485 {
 486         struct connman_stats *stats = stats_get(service);
 487         unsigned int seconds;
 488
 489         DBG("service %p", service);
 490
 491         if (stats->timer == NULL)
 492                 return;
 493
 494         if (stats->enabled == FALSE)
 495                 return;
 496
 497         g_timer_stop(stats->timer);
 498
 499         seconds = g_timer_elapsed(stats->timer, NULL);
 500         stats->time = stats->time_start + seconds;
 501
 502         stats->enabled = FALSE;
 503 }
 504
 505 static int stats_load(struct connman_service *service, GKeyFile *keyfile)
 506 {
 507         /* home */
 508         service->stats.rx_packets = g_key_file_get_integer(keyfile,
 509                         service->identifier, "Home.rx_packets", NULL);
 510         service->stats.tx_packets = g_key_file_get_integer(keyfile,
 511                         service->identifier, "Home.tx_packets", NULL);
 512         service->stats.rx_bytes = g_key_file_get_integer(keyfile,
 513                         service->identifier, "Home.rx_bytes", NULL);
 514         service->stats.tx_bytes = g_key_file_get_integer(keyfile,
 515                         service->identifier, "Home.tx_bytes", NULL);
 516         service->stats.rx_errors = g_key_file_get_integer(keyfile,
 517                         service->identifier, "Home.rx_errors", NULL);
 518         service->stats.tx_errors = g_key_file_get_integer(keyfile,
 519                         service->identifier, "Home.tx_errors", NULL);
 520         service->stats.rx_dropped = g_key_file_get_integer(keyfile,
 521                         service->identifier, "Home.rx_dropped", NULL);
 522         service->stats.tx_dropped = g_key_file_get_integer(keyfile,
 523                         service->identifier, "Home.tx_dropped", NULL);
 524         service->stats.time = g_key_file_get_integer(keyfile,
 525                         service->identifier, "Home.time", NULL);
 526
 527         /* roaming */
 528         service->stats_roaming.rx_packets = g_key_file_get_integer(keyfile,
 529                         service->identifier, "Roaming.rx_packets", NULL);
 530         service->stats_roaming.tx_packets = g_key_file_get_integer(keyfile,
 531                         service->identifier, "Roaming.tx_packets", NULL);
 532         service->stats_roaming.rx_bytes = g_key_file_get_integer(keyfile,
 533                         service->identifier, "Roaming.rx_bytes", NULL);
 534         service->stats_roaming.tx_bytes = g_key_file_get_integer(keyfile,
 535                         service->identifier, "Roaming.tx_bytes", NULL);
 536         service->stats_roaming.rx_errors = g_key_file_get_integer(keyfile,
 537                         service->identifier, "Roaming.rx_errors", NULL);
 538         service->stats_roaming.tx_errors = g_key_file_get_integer(keyfile,
 539                         service->identifier, "Roaming.tx_errors", NULL);
 540         service->stats_roaming.rx_dropped = g_key_file_get_integer(keyfile,
 541                         service->identifier, "Roaming.rx_dropped", NULL);
 542         service->stats_roaming.tx_dropped = g_key_file_get_integer(keyfile,
 543                         service->identifier, "Roaming.tx_dropped", NULL);
 544         service->stats_roaming.time = g_key_file_get_integer(keyfile,
 545                         service->identifier, "Roaming.time", NULL);
 546
 547         return 0;
 548 }
 549
 550 static int stats_save(struct connman_service *service, GKeyFile *keyfile)
 551 {
 552         /* home */
 553         g_key_file_set_integer(keyfile, service->identifier,
 554                 "Home.rx_packets", service->stats.rx_packets);
 555         g_key_file_set_integer(keyfile, service->identifier,
 556                 "Home.tx_packets", service->stats.tx_packets);
 557         g_key_file_set_integer(keyfile, service->identifier,
 558                 "Home.rx_bytes", service->stats.rx_bytes);
 559         g_key_file_set_integer(keyfile, service->identifier,
 560                 "Home.tx_bytes", service->stats.tx_bytes);
 561         g_key_file_set_integer(keyfile, service->identifier,
 562                 "Home.rx_errors", service->stats.rx_errors);
 563         g_key_file_set_integer(keyfile, service->identifier,
 564                 "Home.tx_errors", service->stats.tx_errors);
 565         g_key_file_set_integer(keyfile, service->identifier,
 566                 "Home.rx_dropped", service->stats.rx_dropped);
 567         g_key_file_set_integer(keyfile, service->identifier,
 568                 "Home.tx_dropped", service->stats.tx_dropped);
 569         g_key_file_set_integer(keyfile, service->identifier,
 570                 "Home.time", service->stats.time);
 571
 572         /* roaming */
 573         g_key_file_set_integer(keyfile, service->identifier,
 574                 "Roaming.rx_packets", service->stats_roaming.rx_packets);
 575         g_key_file_set_integer(keyfile, service->identifier,
 576                 "Roaming.tx_packets", service->stats_roaming.tx_packets);
 577         g_key_file_set_integer(keyfile, service->identifier,
 578                 "Roaming.rx_bytes", service->stats_roaming.rx_bytes);
 579         g_key_file_set_integer(keyfile, service->identifier,
 580                 "Roaming.tx_bytes", service->stats_roaming.tx_bytes);
 581         g_key_file_set_integer(keyfile, service->identifier,
 582                 "Roaming.rx_errors", service->stats_roaming.rx_errors);
 583         g_key_file_set_integer(keyfile, service->identifier,
 584                 "Roaming.tx_errors", service->stats_roaming.tx_errors);
 585         g_key_file_set_integer(keyfile, service->identifier,
 586                 "Roaming.rx_dropped", service->stats_roaming.rx_dropped);
 587         g_key_file_set_integer(keyfile, service->identifier,
 588                 "Roaming.tx_dropped", service->stats_roaming.tx_dropped);
 589         g_key_file_set_integer(keyfile, service->identifier,
 590                 "Roaming.time", service->stats_roaming.time);
 591
 592         return 0;
 593 }
 594
 595 static void reset_stats(struct connman_service *service)
 596 {
 597         DBG("service %p", service);
 598
 599         /* home */
 600         service->stats.valid = FALSE;
 601
 602         service->stats.rx_packets = 0;
 603         service->stats.tx_packets = 0;
 604         service->stats.rx_bytes = 0;
 605         service->stats.tx_bytes = 0;
 606         service->stats.rx_errors = 0;
 607         service->stats.tx_errors = 0;
 608         service->stats.rx_dropped = 0;
 609         service->stats.tx_dropped = 0;
 610         service->stats.time = 0;
 611         service->stats.time_start = 0;
 612
 613         g_timer_reset(service->stats.timer);
 614
 615         /* roaming */
 616         service->stats_roaming.valid = FALSE;
 617
 618         service->stats_roaming.rx_packets = 0;
 619         service->stats_roaming.tx_packets = 0;
 620         service->stats_roaming.rx_bytes = 0;
 621         service->stats_roaming.tx_bytes = 0;
 622         service->stats_roaming.rx_errors = 0;
 623         service->stats_roaming.tx_errors = 0;
 624         service->stats_roaming.rx_dropped = 0;
 625         service->stats_roaming.tx_dropped = 0;
 626         service->stats_roaming.time = 0;
 627         service->stats_roaming.time_start = 0;
 628
 629         g_timer_reset(service->stats_roaming.timer);
 630 }
 631
 632 static struct connman_service *get_default(void)
 633 {
 634         struct connman_service *service;
 635         GSequenceIter *iter;
 636
 637         iter = g_sequence_get_begin_iter(service_list);
 638
 639         if (g_sequence_iter_is_end(iter) == TRUE)
 640                 return NULL;
 641
 642         service = g_sequence_get(iter);
 643
 644         if (is_connected(service) == FALSE)
 645                 return NULL;
 646
 647         return service;
 648 }
 649
 650 static void default_changed(void)
 651 {
 652         struct connman_service *service = get_default();
 653
 654         __connman_notifier_default_changed(service);
 655 }
 656
 657 const char *__connman_service_default(void)
 658 {
 659         struct connman_service *service;
 660
 661         service = get_default();
 662         if (service == NULL)
 663                 return "";
 664
 665         return __connman_service_type2string(service->type);
 666 }
 667
 668 static void mode_changed(struct connman_service *service)
 669 {
 670         const char *str;
 671
 672         str = mode2string(service->mode);
 673         if (str == NULL)
 674                 return;
 675
 676         connman_dbus_property_changed_basic(service->path,
 677                                 CONNMAN_SERVICE_INTERFACE, "Mode",
 678                                                 DBUS_TYPE_STRING, &str);
 679 }
 680
 681 static void state_changed(struct connman_service *service)
 682 {
 683         const char *str;
 684
 685         str = state2string(service->state);
 686         if (str == NULL)
 687                 return;
 688
 689         connman_dbus_property_changed_basic(service->path,
 690                                 CONNMAN_SERVICE_INTERFACE, "State",
 691                                                 DBUS_TYPE_STRING, &str);
 692 }
 693
 694 static void strength_changed(struct connman_service *service)
 695 {
 696         if (service->strength == 0)
 697                 return;
 698
 699         connman_dbus_property_changed_basic(service->path,
 700                                 CONNMAN_SERVICE_INTERFACE, "Strength",
 701                                         DBUS_TYPE_BYTE, &service->strength);
 702 }
 703
 704 static void favorite_changed(struct connman_service *service)
 705 {
 706         if (service->path == NULL)
 707                 return;
 708
 709         connman_dbus_property_changed_basic(service->path,
 710                                 CONNMAN_SERVICE_INTERFACE, "Favorite",
 711                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 712 }
 713
 714 static void immutable_changed(struct connman_service *service)
 715 {
 716         if (service->path == NULL)
 717                 return;
 718
 719         connman_dbus_property_changed_basic(service->path,
 720                                 CONNMAN_SERVICE_INTERFACE, "Immutable",
 721                                         DBUS_TYPE_BOOLEAN, &service->immutable);
 722 }
 723
 724 static void roaming_changed(struct connman_service *service)
 725 {
 726         if (service->path == NULL)
 727                 return;
 728
 729         connman_dbus_property_changed_basic(service->path,
 730                                 CONNMAN_SERVICE_INTERFACE, "Roaming",
 731                                         DBUS_TYPE_BOOLEAN, &service->roaming);
 732 }
 733
 734 static void autoconnect_changed(struct connman_service *service)
 735 {
 736         if (service->path == NULL)
 737                 return;
 738
 739         connman_dbus_property_changed_basic(service->path,
 740                                 CONNMAN_SERVICE_INTERFACE, "AutoConnect",
 741                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
 742 }
 743
 744 static void passphrase_changed(struct connman_service *service)
 745 {
 746         dbus_bool_t required;
 747
 748         switch (service->type) {
 749         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 750         case CONNMAN_SERVICE_TYPE_SYSTEM:
 751         case CONNMAN_SERVICE_TYPE_ETHERNET:
 752         case CONNMAN_SERVICE_TYPE_WIMAX:
 753         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 754         case CONNMAN_SERVICE_TYPE_CELLULAR:
 755         case CONNMAN_SERVICE_TYPE_GPS:
 756         case CONNMAN_SERVICE_TYPE_VPN:
 757                 return;
 758         case CONNMAN_SERVICE_TYPE_WIFI:
 759                 required = FALSE;
 760
 761                 switch (service->security) {
 762                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 763                 case CONNMAN_SERVICE_SECURITY_NONE:
 764                         break;
 765                 case CONNMAN_SERVICE_SECURITY_WEP:
 766                 case CONNMAN_SERVICE_SECURITY_PSK:
 767                 case CONNMAN_SERVICE_SECURITY_WPA:
 768                 case CONNMAN_SERVICE_SECURITY_RSN:
 769                         if (service->passphrase == NULL)
 770                                 required = TRUE;
 771                         break;
 772                 case CONNMAN_SERVICE_SECURITY_8021X:
 773                         break;
 774                 }
 775                 break;
 776         }
 777
 778         connman_dbus_property_changed_basic(service->path,
 779                                 CONNMAN_SERVICE_INTERFACE, "PassphraseRequired",
 780                                                 DBUS_TYPE_BOOLEAN, &required);
 781 }
 782
 783 static void login_changed(struct connman_service *service)
 784 {
 785         dbus_bool_t required = service->login_required;
 786
 787         if (service->path == NULL)
 788                 return;
 789
 790         connman_dbus_property_changed_basic(service->path,
 791                                 CONNMAN_SERVICE_INTERFACE, "LoginRequired",
 792                                                 DBUS_TYPE_BOOLEAN, &required);
 793 }
 794
 795 static void apn_changed(struct connman_service *service)
 796 {
 797         dbus_bool_t required;
 798
 799         switch (service->type) {
 800         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 801         case CONNMAN_SERVICE_TYPE_SYSTEM:
 802         case CONNMAN_SERVICE_TYPE_ETHERNET:
 803         case CONNMAN_SERVICE_TYPE_WIMAX:
 804         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 805         case CONNMAN_SERVICE_TYPE_WIFI:
 806         case CONNMAN_SERVICE_TYPE_GPS:
 807         case CONNMAN_SERVICE_TYPE_VPN:
 808                 return;
 809         case CONNMAN_SERVICE_TYPE_CELLULAR:
 810                 break;
 811         }
 812
 813         required = (service->apn == NULL) ? TRUE : FALSE;
 814
 815         connman_dbus_property_changed_basic(service->path,
 816                                 CONNMAN_SERVICE_INTERFACE, "SetupRequired",
 817                                                 DBUS_TYPE_BOOLEAN, &required);
 818 }
 819
 820 static void append_ethernet(DBusMessageIter *iter, void *user_data)
 821 {
 822         struct connman_service *service = user_data;
 823
 824         if (service->ipconfig != NULL)
 825                 __connman_ipconfig_append_ethernet(service->ipconfig, iter);
 826 }
 827
 828 static void append_ipv4(DBusMessageIter *iter, void *user_data)
 829 {
 830         struct connman_service *service = user_data;
 831
 832         if (is_connected(service) == FALSE)
 833                 return;
 834
 835         if (service->ipconfig != NULL)
 836                 __connman_ipconfig_append_ipv4(service->ipconfig, iter);
 837 }
 838
 839 static void append_ipv6(DBusMessageIter *iter, void *user_data)
 840 {
 841         struct connman_service *service = user_data;
 842         struct connman_ipconfig *ipv6config;
 843
 844         if (is_connected(service) == FALSE)
 845                 return;
 846
 847         if (service->ipconfig == NULL)
 848                 return;
 849
 850         ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
 851         if (ipv6config == NULL)
 852                 return;
 853
 854         __connman_ipconfig_append_ipv6(ipv6config, iter);
 855 }
 856
 857 static void append_ipv4config(DBusMessageIter *iter, void *user_data)
 858 {
 859         struct connman_service *service = user_data;
 860
 861         if (service->ipconfig != NULL)
 862                 __connman_ipconfig_append_ipv4config(service->ipconfig, iter);
 863 }
 864
 865 static void append_ipv6config(DBusMessageIter *iter, void *user_data)
 866 {
 867         struct connman_service *service = user_data;
 868         struct connman_ipconfig *ipv6config;
 869
 870         if (service->ipconfig == NULL)
 871                 return;
 872
 873         ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
 874         if (ipv6config == NULL)
 875                 return;
 876
 877         __connman_ipconfig_append_ipv6config(ipv6config, iter);
 878 }
 879
 880 static void append_dns(DBusMessageIter *iter, void *user_data)
 881 {
 882         struct connman_service *service = user_data;
 883
 884         if (is_connected(service) == FALSE)
 885                 return;
 886
 887         if (service->nameservers != NULL) {
 888                 int i;
 889
 890                 for (i = 0; service->nameservers[i]; i++)
 891                         dbus_message_iter_append_basic(iter,
 892                                 DBUS_TYPE_STRING, &service->nameservers[i]);
 893
 894                 return;
 895         }
 896
 897         if (service->nameserver == NULL)
 898                 return;
 899
 900         dbus_message_iter_append_basic(iter,
 901                                 DBUS_TYPE_STRING, &service->nameserver);
 902 }
 903
 904 static void append_dnsconfig(DBusMessageIter *iter, void *user_data)
 905 {
 906         struct connman_service *service = user_data;
 907         int i;
 908
 909         if (service->nameservers == NULL)
 910                 return;
 911
 912         for (i = 0; service->nameservers[i]; i++)
 913                 dbus_message_iter_append_basic(iter,
 914                                 DBUS_TYPE_STRING, &service->nameservers[i]);
 915 }
 916
 917 static void append_domain(DBusMessageIter *iter, void *user_data)
 918 {
 919         struct connman_service *service = user_data;
 920
 921         if (is_connected(service) == FALSE && is_connecting(service) == FALSE)
 922                 return;
 923
 924         if (service->domainname == NULL)
 925                 return;
 926
 927         dbus_message_iter_append_basic(iter,
 928                                 DBUS_TYPE_STRING, &service->domainname);
 929 }
 930
 931 static void append_domainconfig(DBusMessageIter *iter, void *user_data)
 932 {
 933         struct connman_service *service = user_data;
 934         int i;
 935
 936         if (service->domains == NULL)
 937                 return;
 938
 939         for (i = 0; service->domains[i]; i++)
 940                 dbus_message_iter_append_basic(iter,
 941                                 DBUS_TYPE_STRING, &service->domains[i]);
 942 }
 943
 944 static void append_proxy(DBusMessageIter *iter, void *user_data)
 945 {
 946         struct connman_service *service = user_data;
 947
 948         if (is_connected(service) == FALSE)
 949                 return;
 950
 951         if (service->ipconfig != NULL)
 952                 __connman_ipconfig_append_proxy(service->ipconfig, iter);
 953 }
 954
 955 static void append_provider(DBusMessageIter *iter, void *user_data)
 956 {
 957         struct connman_service *service = user_data;
 958
 959         DBG("%p %p", service, service->provider);
 960
 961         if (is_connected(service) == FALSE)
 962                 return;
 963
 964         if (service->provider != NULL)
 965                 __connman_provider_append_properties(service->provider, iter);
 966 }
 967
 968
 969 static void settings_changed(struct connman_service *service)
 970 {
 971         connman_dbus_property_changed_dict(service->path,
 972                                         CONNMAN_SERVICE_INTERFACE, "IPv4",
 973                                                         append_ipv4, service);
 974
 975         connman_dbus_property_changed_dict(service->path,
 976                                         CONNMAN_SERVICE_INTERFACE, "IPv6",
 977                                                         append_ipv6, service);
 978 }
 979
 980 static void ipv4_configuration_changed(struct connman_service *service)
 981 {
 982         connman_dbus_property_changed_dict(service->path,
 983                                         CONNMAN_SERVICE_INTERFACE,
 984                                                         "IPv4.Configuration",
 985                                                         append_ipv4config,
 986                                                         service);
 987 }
 988
 989 static void ipv6_configuration_changed(struct connman_service *service)
 990 {
 991         connman_dbus_property_changed_dict(service->path,
 992                                         CONNMAN_SERVICE_INTERFACE,
 993                                                         "IPv6.Configuration",
 994                                                         append_ipv6config,
 995                                                         service);
 996 }
 997
 998 static void dns_changed(struct connman_service *service)
 999 {
1000         connman_dbus_property_changed_array(service->path,
1001                                 CONNMAN_SERVICE_INTERFACE, "Nameservers",
1002                                         DBUS_TYPE_STRING, append_dns, service);
1003 }
1004
1005 static void dns_configuration_changed(struct connman_service *service)
1006 {
1007         connman_dbus_property_changed_array(service->path,
1008                                 CONNMAN_SERVICE_INTERFACE,
1009                                 "Nameservers.Configuration",
1010                                 DBUS_TYPE_STRING, append_dnsconfig, service);
1011
1012         dns_changed(service);
1013 }
1014
1015 static void domain_changed(struct connman_service *service)
1016 {
1017         connman_dbus_property_changed_array(service->path,
1018                                 CONNMAN_SERVICE_INTERFACE, "Domains",
1019                                 DBUS_TYPE_STRING, append_domain, service);
1020 }
1021
1022 static void domain_configuration_changed(struct connman_service *service)
1023 {
1024         connman_dbus_property_changed_array(service->path,
1025                                 CONNMAN_SERVICE_INTERFACE,
1026                                 "Domains.Configuration",
1027                                 DBUS_TYPE_STRING, append_domainconfig, service);
1028 }
1029
1030 static void proxy_changed(struct connman_service *service)
1031 {
1032         connman_dbus_property_changed_dict(service->path,
1033                                         CONNMAN_SERVICE_INTERFACE, "Proxy",
1034                                                         append_proxy, service);
1035 }
1036
1037 static void link_changed(struct connman_service *service)
1038 {
1039         connman_dbus_property_changed_dict(service->path,
1040                                         CONNMAN_SERVICE_INTERFACE, "Ethernet",
1041                                                 append_ethernet, service);
1042 }
1043
1044 static void stats_append_counters(DBusMessageIter *dict,
1045                         struct connman_stats *stats,
1046                         struct connman_stats_update *counters,
1047                         connman_bool_t append_all)
1048 {
1049         if (counters->rx_packets != stats->rx_packets || append_all) {
1050                 counters->rx_packets = stats->rx_packets;
1051                 connman_dbus_dict_append_basic(dict, "RX.Packets",
1052                                         DBUS_TYPE_UINT32, &stats->rx_packets);
1053         }
1054
1055         if (counters->tx_packets != stats->tx_packets || append_all) {
1056                 counters->tx_packets = stats->tx_packets;
1057                 connman_dbus_dict_append_basic(dict, "TX.Packets",
1058                                         DBUS_TYPE_UINT32, &stats->tx_packets);
1059         }
1060
1061         if (counters->rx_bytes != stats->rx_bytes || append_all) {
1062                 counters->rx_bytes = stats->rx_bytes;
1063                 connman_dbus_dict_append_basic(dict, "RX.Bytes",
1064                                         DBUS_TYPE_UINT32, &stats->rx_bytes);
1065         }
1066
1067         if (counters->tx_bytes != stats->tx_bytes || append_all) {
1068                 counters->tx_bytes = stats->tx_bytes;
1069                 connman_dbus_dict_append_basic(dict, "TX.Bytes",
1070                                         DBUS_TYPE_UINT32, &stats->tx_bytes);
1071         }
1072
1073         if (counters->rx_errors != stats->rx_errors || append_all) {
1074                 counters->rx_errors = stats->rx_errors;
1075                 connman_dbus_dict_append_basic(dict, "RX.Errors",
1076                                         DBUS_TYPE_UINT32, &stats->rx_errors);
1077         }
1078
1079         if (counters->tx_errors != stats->tx_errors || append_all) {
1080                 counters->tx_errors = stats->tx_errors;
1081                 connman_dbus_dict_append_basic(dict, "TX.Errors",
1082                                         DBUS_TYPE_UINT32, &stats->tx_errors);
1083         }
1084
1085         if (counters->rx_dropped != stats->rx_dropped || append_all) {
1086                 counters->rx_dropped = stats->rx_dropped;
1087                 connman_dbus_dict_append_basic(dict, "RX.Dropped",
1088                                         DBUS_TYPE_UINT32, &stats->rx_dropped);
1089         }
1090
1091         if (counters->tx_dropped != stats->tx_dropped || append_all) {
1092                 counters->tx_dropped = stats->tx_dropped;
1093                 connman_dbus_dict_append_basic(dict, "TX.Dropped",
1094                                         DBUS_TYPE_UINT32, &stats->tx_dropped);
1095         }
1096
1097         if (counters->time != stats->time || append_all) {
1098                 counters->time = stats->time;
1099                 connman_dbus_dict_append_basic(dict, "Time",
1100                                         DBUS_TYPE_UINT32, &stats->time);
1101         }
1102 }
1103
1104 static void stats_append(struct connman_service *service,
1105                                 const char *counter,
1106                                 struct connman_stats_counter *counters,
1107                                 connman_bool_t append_all)
1108 {
1109         DBusMessageIter array, dict;
1110         DBusMessage *msg;
1111
1112         DBG("service %p counter %s", service, counter);
1113
1114         msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
1115         if (msg == NULL)
1116                 return;
1117
1118         dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH,
1119                                 &service->path, DBUS_TYPE_INVALID);
1120
1121         dbus_message_iter_init_append(msg, &array);
1122
1123         /* home counter */
1124         connman_dbus_dict_open(&array, &dict);
1125
1126         stats_append_counters(&dict, &service->stats,
1127                                 &counters->stats, append_all);
1128
1129         connman_dbus_dict_close(&array, &dict);
1130
1131         /* roaming counter */
1132         connman_dbus_dict_open(&array, &dict);
1133
1134         stats_append_counters(&dict, &service->stats_roaming,
1135                                 &counters->stats_roaming, append_all);
1136
1137         connman_dbus_dict_close(&array, &dict);
1138
1139         __connman_counter_send_usage(counter, msg);
1140 }
1141
1142 static void stats_update(struct connman_service *service,
1143                                 unsigned int rx_packets, unsigned int tx_packets,
1144                                 unsigned int rx_bytes, unsigned int tx_bytes,
1145                                 unsigned int rx_errors, unsigned int tx_errors,
1146                                 unsigned int rx_dropped, unsigned int tx_dropped)
1147 {
1148         struct connman_stats *stats = stats_get(service);
1149         unsigned int seconds;
1150
1151         DBG("service %p", service);
1152
1153         if (stats->valid == TRUE) {
1154                 stats->rx_packets +=
1155                         rx_packets - stats->rx_packets_last;
1156                 stats->tx_packets +=
1157                         tx_packets - stats->tx_packets_last;
1158                 stats->rx_bytes +=
1159                         rx_bytes - stats->rx_bytes_last;
1160                 stats->tx_bytes +=
1161                         tx_bytes - stats->tx_bytes_last;
1162                 stats->rx_errors +=
1163                         rx_errors - stats->rx_errors_last;
1164                 stats->tx_errors +=
1165                         tx_errors - stats->tx_errors_last;
1166                 stats->rx_dropped +=
1167                         rx_dropped - stats->rx_dropped_last;
1168                 stats->tx_dropped +=
1169                         tx_dropped - stats->tx_dropped_last;
1170         } else {
1171                 stats->valid = TRUE;
1172         }
1173
1174         stats->rx_packets_last = rx_packets;
1175         stats->tx_packets_last = tx_packets;
1176         stats->rx_bytes_last = rx_bytes;
1177         stats->tx_bytes_last = tx_bytes;
1178         stats->rx_errors_last = rx_errors;
1179         stats->tx_errors_last = tx_errors;
1180         stats->rx_dropped_last = rx_dropped;
1181         stats->tx_dropped_last = tx_dropped;
1182
1183         seconds = g_timer_elapsed(stats->timer, NULL);
1184         stats->time = stats->time_start + seconds;
1185 }
1186
1187 void __connman_service_notify(struct connman_ipconfig *ipconfig,
1188                         unsigned int rx_packets, unsigned int tx_packets,
1189                         unsigned int rx_bytes, unsigned int tx_bytes,
1190                         unsigned int rx_errors, unsigned int tx_errors,
1191                         unsigned int rx_dropped, unsigned int tx_dropped)
1192 {
1193         struct connman_service *service;
1194         GHashTableIter iter;
1195         gpointer key, value;
1196         const char *counter;
1197         struct connman_stats_counter *counters;
1198
1199         service = connman_ipconfig_get_data(ipconfig);
1200         if (service == NULL)
1201                 return;
1202
1203         if (is_connected(service) == FALSE)
1204                 return;
1205
1206         stats_update(service,
1207                 rx_packets, tx_packets,
1208                 rx_bytes, tx_bytes,
1209                 rx_errors, tx_errors,
1210                 rx_dropped, tx_dropped);
1211
1212         g_hash_table_iter_init(&iter, service->counter_table);
1213         while (g_hash_table_iter_next(&iter, &key, &value)) {
1214                 counter = key;
1215                 counters = value;
1216
1217                 stats_append(service, counter, counters, counters->append_all);
1218                 counters->append_all = FALSE;
1219         }
1220 }
1221
1222 int __connman_service_counter_register(const char *counter)
1223 {
1224         struct connman_service *service = NULL;
1225         GSequenceIter *iter;
1226         struct connman_stats_counter *counters;
1227
1228         DBG("counter %s", counter);
1229
1230         counter_list = g_slist_append(counter_list, (gpointer)counter);
1231
1232         iter = g_sequence_get_begin_iter(service_list);
1233
1234         while (g_sequence_iter_is_end(iter) == FALSE) {
1235                 service = g_sequence_get(iter);
1236
1237                 counters = g_try_new0(struct connman_stats_counter, 1);
1238                 if (counters == NULL)
1239                         return -ENOMEM;
1240
1241                 counters->append_all = TRUE;
1242
1243                 g_hash_table_replace(service->counter_table, (gpointer)counter,
1244                                         counters);
1245
1246                 iter = g_sequence_iter_next(iter);
1247         }
1248
1249         return 0;
1250 }
1251
1252 void __connman_service_counter_unregister(const char *counter)
1253 {
1254         struct connman_service *service = NULL;
1255         GSequenceIter *iter;
1256
1257         DBG("counter %s", counter);
1258
1259         iter = g_sequence_get_begin_iter(service_list);
1260
1261         while (g_sequence_iter_is_end(iter) == FALSE) {
1262                 service = g_sequence_get(iter);
1263
1264                 g_hash_table_remove(service->counter_table, counter);
1265
1266                 iter = g_sequence_iter_next(iter);
1267         }
1268
1269         counter_list = g_slist_remove(counter_list, counter);
1270 }
1271
1272 static void append_properties(DBusMessageIter *dict, dbus_bool_t limited,
1273                                         struct connman_service *service)
1274 {
1275         dbus_bool_t required;
1276         const char *str;
1277
1278         str = __connman_service_type2string(service->type);
1279         if (str != NULL)
1280                 connman_dbus_dict_append_basic(dict, "Type",
1281                                                 DBUS_TYPE_STRING, &str);
1282
1283         str = mode2string(service->mode);
1284         if (str != NULL)
1285                 connman_dbus_dict_append_basic(dict, "Mode",
1286                                                 DBUS_TYPE_STRING, &str);
1287
1288         str = security2string(service->security);
1289         if (str != NULL)
1290                 connman_dbus_dict_append_basic(dict, "Security",
1291                                                 DBUS_TYPE_STRING, &str);
1292
1293         str = state2string(service->state);
1294         if (str != NULL)
1295                 connman_dbus_dict_append_basic(dict, "State",
1296                                                 DBUS_TYPE_STRING, &str);
1297
1298         str = error2string(service->error);
1299         if (str != NULL)
1300                 connman_dbus_dict_append_basic(dict, "Error",
1301                                                 DBUS_TYPE_STRING, &str);
1302
1303         if (service->strength > 0)
1304                 connman_dbus_dict_append_basic(dict, "Strength",
1305                                         DBUS_TYPE_BYTE, &service->strength);
1306
1307         connman_dbus_dict_append_basic(dict, "Favorite",
1308                                         DBUS_TYPE_BOOLEAN, &service->favorite);
1309
1310         connman_dbus_dict_append_basic(dict, "Immutable",
1311                                         DBUS_TYPE_BOOLEAN, &service->immutable);
1312
1313         if (service->favorite == TRUE)
1314                 connman_dbus_dict_append_basic(dict, "AutoConnect",
1315                                 DBUS_TYPE_BOOLEAN, &service->autoconnect);
1316         else
1317                 connman_dbus_dict_append_basic(dict, "AutoConnect",
1318                                         DBUS_TYPE_BOOLEAN, &service->favorite);
1319
1320         if (service->name != NULL)
1321                 connman_dbus_dict_append_basic(dict, "Name",
1322                                         DBUS_TYPE_STRING, &service->name);
1323
1324         connman_dbus_dict_append_basic(dict, "LoginRequired",
1325                                 DBUS_TYPE_BOOLEAN, &service->login_required);
1326
1327         switch (service->type) {
1328         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1329         case CONNMAN_SERVICE_TYPE_SYSTEM:
1330         case CONNMAN_SERVICE_TYPE_GPS:
1331         case CONNMAN_SERVICE_TYPE_VPN:
1332                 break;
1333         case CONNMAN_SERVICE_TYPE_CELLULAR:
1334                 connman_dbus_dict_append_basic(dict, "Roaming",
1335                                         DBUS_TYPE_BOOLEAN, &service->roaming);
1336
1337                 if (service->mcc != NULL && service->mnc != NULL) {
1338                         connman_dbus_dict_append_basic(dict, "MCC",
1339                                         DBUS_TYPE_STRING, &service->mcc);
1340                         connman_dbus_dict_append_basic(dict, "MNC",
1341                                         DBUS_TYPE_STRING, &service->mnc);
1342                 }
1343
1344                 if (service->apn != NULL) {
1345                         connman_dbus_dict_append_basic(dict, "APN",
1346                                         DBUS_TYPE_STRING, &service->apn);
1347
1348                         if (service->username != NULL)
1349                                 connman_dbus_dict_append_basic(dict,
1350                                         "Username", DBUS_TYPE_STRING,
1351                                                         &service->username);
1352
1353                         if (service->password != NULL)
1354                                 connman_dbus_dict_append_basic(dict,
1355                                         "Password", DBUS_TYPE_STRING,
1356                                                         &service->password);
1357
1358                         required = FALSE;
1359                 } else
1360                         required = TRUE;
1361
1362                 connman_dbus_dict_append_basic(dict, "SetupRequired",
1363                                                 DBUS_TYPE_BOOLEAN, &required);
1364                 connman_dbus_dict_append_dict(dict, "Ethernet",
1365                                                 append_ethernet, service);
1366                 break;
1367         case CONNMAN_SERVICE_TYPE_WIFI:
1368                 if (service->passphrase != NULL && limited == FALSE)
1369                         connman_dbus_dict_append_basic(dict, "Passphrase",
1370                                 DBUS_TYPE_STRING, &service->passphrase);
1371
1372                 required = FALSE;
1373
1374                 switch (service->security) {
1375                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
1376                 case CONNMAN_SERVICE_SECURITY_NONE:
1377                         break;
1378                 case CONNMAN_SERVICE_SECURITY_WEP:
1379                 case CONNMAN_SERVICE_SECURITY_PSK:
1380                 case CONNMAN_SERVICE_SECURITY_WPA:
1381                 case CONNMAN_SERVICE_SECURITY_RSN:
1382                         if (service->passphrase == NULL)
1383                                 required = TRUE;
1384                         break;
1385                 case CONNMAN_SERVICE_SECURITY_8021X:
1386                         break;
1387                 }
1388
1389                 connman_dbus_dict_append_basic(dict, "PassphraseRequired",
1390                                                 DBUS_TYPE_BOOLEAN, &required);
1391                 /* fall through */
1392         case CONNMAN_SERVICE_TYPE_ETHERNET:
1393         case CONNMAN_SERVICE_TYPE_WIMAX:
1394         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1395                 connman_dbus_dict_append_dict(dict, "Ethernet",
1396                                                 append_ethernet, service);
1397                 break;
1398         }
1399
1400         connman_dbus_dict_append_dict(dict, "IPv4", append_ipv4, service);
1401
1402         connman_dbus_dict_append_dict(dict, "IPv4.Configuration",
1403                                                 append_ipv4config, service);
1404
1405         connman_dbus_dict_append_dict(dict, "IPv6", append_ipv6, service);
1406
1407         connman_dbus_dict_append_dict(dict, "IPv6.Configuration",
1408                                                 append_ipv6config, service);
1409
1410         connman_dbus_dict_append_array(dict, "Nameservers",
1411                                 DBUS_TYPE_STRING, append_dns, service);
1412
1413         connman_dbus_dict_append_array(dict, "Nameservers.Configuration",
1414                                 DBUS_TYPE_STRING, append_dnsconfig, service);
1415
1416         connman_dbus_dict_append_array(dict, "Domains",
1417                                 DBUS_TYPE_STRING, append_domain, service);
1418
1419         connman_dbus_dict_append_array(dict, "Domains.Configuration",
1420                                 DBUS_TYPE_STRING, append_domainconfig, service);
1421
1422         connman_dbus_dict_append_dict(dict, "Proxy", append_proxy, service);
1423
1424         connman_dbus_dict_append_dict(dict, "Provider", append_provider, service);
1425 }
1426
1427 static void append_struct(gpointer value, gpointer user_data)
1428 {
1429         struct connman_service *service = value;
1430         DBusMessageIter *iter = user_data;
1431         DBusMessageIter entry, dict;
1432
1433         if (service->path == NULL || service->hidden == TRUE)
1434                 return;
1435
1436         dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &entry);
1437
1438         dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
1439                                                         &service->path);
1440
1441         connman_dbus_dict_open(&entry, &dict);
1442         append_properties(&dict, TRUE, service);
1443         connman_dbus_dict_close(&entry, &dict);
1444
1445         dbus_message_iter_close_container(iter, &entry);
1446 }
1447
1448 void __connman_service_list_struct(DBusMessageIter *iter)
1449 {
1450         g_sequence_foreach(service_list, append_struct, iter);
1451 }
1452
1453 int __connman_service_get_index(struct connman_service *service)
1454 {
1455         if (service == NULL)
1456                 return -1;
1457
1458         if (service->network == NULL)
1459                 return -1;
1460
1461         return connman_network_get_index(service->network);
1462 }
1463
1464 void __connman_service_set_domainname(struct connman_service *service,
1465                                                 const char *domainname)
1466 {
1467         if (service == NULL)
1468                 return;
1469
1470         g_free(service->domainname);
1471         service->domainname = g_strdup(domainname);
1472
1473         domain_changed(service);
1474 }
1475
1476 const char *__connman_service_get_domainname(struct connman_service *service)
1477 {
1478         if (service == NULL)
1479                 return NULL;
1480
1481         return service->domainname;
1482 }
1483
1484 const char *__connman_service_get_nameserver(struct connman_service *service)
1485 {
1486         if (service == NULL)
1487                 return NULL;
1488
1489         return service->nameserver;
1490 }
1491
1492 void __connman_service_set_proxy_autoconfig(struct connman_service *service,
1493                                                         const char *url)
1494 {
1495         if (service == NULL)
1496                 return;
1497
1498         if (__connman_ipconfig_set_proxy_autoconfig(service->ipconfig,
1499                                                                 url) < 0)
1500                 return;
1501
1502         proxy_changed(service);
1503 }
1504
1505 const char *connman_service_get_proxy_autoconfig(struct connman_service *service)
1506 {
1507         if (service == NULL)
1508                 return NULL;
1509
1510         return __connman_ipconfig_get_proxy_autoconfig(service->ipconfig);
1511 }
1512
1513 static DBusMessage *get_properties(DBusConnection *conn,
1514                                         DBusMessage *msg, void *user_data)
1515 {
1516         struct connman_service *service = user_data;
1517         DBusMessage *reply;
1518         DBusMessageIter array, dict;
1519
1520         DBG("service %p", service);
1521
1522         reply = dbus_message_new_method_return(msg);
1523         if (reply == NULL)
1524                 return NULL;
1525
1526         dbus_message_iter_init_append(reply, &array);
1527
1528         connman_dbus_dict_open(&array, &dict);
1529         append_properties(&dict, FALSE, service);
1530         connman_dbus_dict_close(&array, &dict);
1531
1532         return reply;
1533 }
1534
1535 static DBusMessage *set_property(DBusConnection *conn,
1536                                         DBusMessage *msg, void *user_data)
1537 {
1538         struct connman_service *service = user_data;
1539         DBusMessageIter iter, value;
1540         const char *name;
1541         int type;
1542
1543         DBG("service %p", service);
1544
1545         if (dbus_message_iter_init(msg, &iter) == FALSE)
1546                 return __connman_error_invalid_arguments(msg);
1547
1548         dbus_message_iter_get_basic(&iter, &name);
1549         dbus_message_iter_next(&iter);
1550         dbus_message_iter_recurse(&iter, &value);
1551
1552         type = dbus_message_iter_get_arg_type(&value);
1553
1554         if (g_str_has_prefix(name, "AutoConnect") == TRUE) {
1555                 connman_bool_t autoconnect;
1556
1557                 if (type != DBUS_TYPE_BOOLEAN)
1558                         return __connman_error_invalid_arguments(msg);
1559
1560                 if (service->favorite == FALSE)
1561                         return __connman_error_invalid_service(msg);
1562
1563                 dbus_message_iter_get_basic(&value, &autoconnect);
1564
1565                 if (service->autoconnect == autoconnect)
1566                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1567
1568                 service->autoconnect = autoconnect;
1569
1570                 autoconnect_changed(service);
1571
1572                 __connman_storage_save_service(service);
1573         } else if (g_str_equal(name, "Passphrase") == TRUE) {
1574                 const char *passphrase;
1575
1576                 if (type != DBUS_TYPE_STRING)
1577                         return __connman_error_invalid_arguments(msg);
1578
1579                 if (service->immutable == TRUE)
1580                         return __connman_error_not_supported(msg);
1581
1582                 dbus_message_iter_get_basic(&value, &passphrase);
1583
1584                 g_free(service->passphrase);
1585                 service->passphrase = g_strdup(passphrase);
1586
1587                 passphrase_changed(service);
1588
1589                 if (service->network != NULL)
1590                         connman_network_set_string(service->network,
1591                                 "WiFi.Passphrase", service->passphrase);
1592
1593                 __connman_storage_save_service(service);
1594         } else if (g_str_equal(name, "APN") == TRUE) {
1595                 const char *apn;
1596
1597                 if (type != DBUS_TYPE_STRING)
1598                         return __connman_error_invalid_arguments(msg);
1599
1600                 if (service->immutable == TRUE)
1601                         return __connman_error_not_supported(msg);
1602
1603                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1604                         return __connman_error_invalid_service(msg);
1605
1606                 dbus_message_iter_get_basic(&value, &apn);
1607
1608                 g_free(service->apn);
1609                 service->apn = g_strdup(apn);
1610
1611                 apn_changed(service);
1612
1613                 if (service->network != NULL)
1614                         connman_network_set_string(service->network,
1615                                                 "Cellular.APN", service->apn);
1616
1617                 __connman_storage_save_service(service);
1618         } else if (g_str_equal(name, "Username") == TRUE) {
1619                 const char *username;
1620
1621                 if (type != DBUS_TYPE_STRING)
1622                         return __connman_error_invalid_arguments(msg);
1623
1624                 if (service->immutable == TRUE)
1625                         return __connman_error_not_supported(msg);
1626
1627                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1628                         return __connman_error_invalid_service(msg);
1629
1630                 dbus_message_iter_get_basic(&value, &username);
1631
1632                 g_free(service->username);
1633                 service->username = g_strdup(username);
1634
1635                 if (service->network != NULL)
1636                         connman_network_set_string(service->network,
1637                                         "Cellular.Username", service->username);
1638
1639                 __connman_storage_save_service(service);
1640         } else if (g_str_equal(name, "Password") == TRUE) {
1641                 const char *password;
1642
1643                 if (type != DBUS_TYPE_STRING)
1644                         return __connman_error_invalid_arguments(msg);
1645
1646                 if (service->immutable == TRUE)
1647                         return __connman_error_not_supported(msg);
1648
1649                 if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
1650                         return __connman_error_invalid_service(msg);
1651
1652                 dbus_message_iter_get_basic(&value, &password);
1653
1654                 g_free(service->password);
1655                 service->password = g_strdup(password);
1656
1657                 if (service->network != NULL)
1658                         connman_network_set_string(service->network,
1659                                         "Cellular.Password", service->password);
1660
1661                 __connman_storage_save_service(service);
1662         } else if (g_str_equal(name, "Nameservers.Configuration") == TRUE) {
1663                 DBusMessageIter entry;
1664                 GString *str;
1665                 int index;
1666                 const char *gw;
1667
1668                 if (type != DBUS_TYPE_ARRAY)
1669                         return __connman_error_invalid_arguments(msg);
1670
1671                 str = g_string_new(NULL);
1672                 if (str == NULL)
1673                         return __connman_error_invalid_arguments(msg);
1674
1675                 index = connman_network_get_index(service->network);
1676                 gw = __connman_ipconfig_get_gateway(index);
1677
1678                 if (gw && strlen(gw))
1679                         __connman_service_nameserver_del_routes(service);
1680
1681                 dbus_message_iter_recurse(&value, &entry);
1682
1683                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
1684                         const char *val;
1685                         dbus_message_iter_get_basic(&entry, &val);
1686                         dbus_message_iter_next(&entry);
1687                         if (str->len > 0)
1688                                 g_string_append_printf(str, " %s", val);
1689                         else
1690                                 g_string_append(str, val);
1691                 }
1692
1693                 g_strfreev(service->nameservers);
1694
1695                 if (str->len > 0)
1696                         service->nameservers = g_strsplit_set(str->str, " ", 0);
1697                 else
1698                         service->nameservers = NULL;
1699
1700                 g_string_free(str, TRUE);
1701
1702                 if (gw && strlen(gw))
1703                         __connman_service_nameserver_add_routes(service, gw);
1704
1705                 update_nameservers(service);
1706                 dns_configuration_changed(service);
1707
1708                 __connman_storage_save_service(service);
1709         } else if (g_str_equal(name, "Domains.Configuration") == TRUE) {
1710                 DBusMessageIter entry;
1711                 GString *str;
1712
1713                 if (type != DBUS_TYPE_ARRAY)
1714                         return __connman_error_invalid_arguments(msg);
1715
1716                 str = g_string_new(NULL);
1717                 if (str == NULL)
1718                         return __connman_error_invalid_arguments(msg);
1719
1720                 dbus_message_iter_recurse(&value, &entry);
1721
1722                 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
1723                         const char *val;
1724                         dbus_message_iter_get_basic(&entry, &val);
1725                         dbus_message_iter_next(&entry);
1726                         if (str->len > 0)
1727                                 g_string_append_printf(str, " %s", val);
1728                         else
1729                                 g_string_append(str, val);
1730                 }
1731
1732                 g_strfreev(service->domains);
1733
1734                 if (str->len > 0)
1735                         service->domains = g_strsplit_set(str->str, " ", 0);
1736                 else
1737                         service->domains = NULL;
1738
1739                 g_string_free(str, TRUE);
1740
1741                 //update_domains(service);
1742                 domain_configuration_changed(service);
1743
1744                 __connman_storage_save_service(service);
1745         } else if (g_str_equal(name, "IPv4.Configuration") == TRUE ||
1746                         g_str_equal(name, "IPv6.Configuration")) {
1747
1748                 enum connman_ipconfig_type type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
1749                 int err = 0;
1750                 struct connman_ipconfig *ipv6config;
1751
1752                 DBG("%s", name);
1753
1754                 ipv6config = connman_ipconfig_get_ipv6config(
1755                                                 service->ipconfig);
1756                 if (service->ipconfig == NULL)
1757                         return __connman_error_invalid_property(msg);
1758
1759                 if (is_connecting(service) ||
1760                                 is_connected(service)) {
1761                         __connman_network_clear_ipconfig(service->network,
1762                                                         service->ipconfig);
1763                         __connman_network_clear_ipconfig(service->network,
1764                                                                 ipv6config);
1765                 }
1766
1767                 if (g_str_equal(name, "IPv4.Configuration") == TRUE) {
1768                         type = CONNMAN_IPCONFIG_TYPE_IPV4;
1769                         err = __connman_ipconfig_set_config(
1770                                         service->ipconfig, type, &value);
1771                 } else if (g_str_equal(name, "IPv6.Configuration") == TRUE) {
1772                         type = CONNMAN_IPCONFIG_TYPE_IPV6;
1773                         err = __connman_ipconfig_set_config(
1774                                                 ipv6config, type, &value);
1775                 }
1776
1777                 if (err < 0) {
1778                         if (is_connected(service) ||
1779                                         is_connecting(service))
1780                                 __connman_network_set_ipconfig(
1781                                                         service->network,
1782                                                         service->ipconfig);
1783                         return __connman_error_failed(msg, -err);
1784                 }
1785
1786                 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1787                         ipv4_configuration_changed(service);
1788                 else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1789                         ipv6_configuration_changed(service);
1790
1791                 if (is_connecting(service) ||
1792                                 is_connected(service))
1793                         __connman_network_set_ipconfig(service->network,
1794                                                         service->ipconfig);
1795
1796                 __connman_storage_save_service(service);
1797         } else
1798                 return __connman_error_invalid_property(msg);
1799
1800         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1801 }
1802
1803 static void set_idle(struct connman_service *service)
1804 {
1805         service->state = CONNMAN_SERVICE_STATE_IDLE;
1806         service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
1807         state_changed(service);
1808 }
1809
1810 static DBusMessage *clear_property(DBusConnection *conn,
1811                                         DBusMessage *msg, void *user_data)
1812 {
1813         struct connman_service *service = user_data;
1814         const char *name;
1815
1816         DBG("service %p", service);
1817
1818         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
1819                                                         DBUS_TYPE_INVALID);
1820
1821         if (g_str_equal(name, "Error") == TRUE) {
1822                 set_idle(service);
1823
1824                 g_get_current_time(&service->modified);
1825                 __connman_storage_save_service(service);
1826         } else if (g_str_equal(name, "Passphrase") == TRUE) {
1827                 if (service->immutable == TRUE)
1828                         return __connman_error_not_supported(msg);
1829
1830                 g_free(service->passphrase);
1831                 service->passphrase = NULL;
1832
1833                 passphrase_changed(service);
1834
1835                 __connman_storage_save_service(service);
1836         } else
1837                 return __connman_error_invalid_property(msg);
1838
1839         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1840 }
1841
1842 static connman_bool_t is_ignore(struct connman_service *service)
1843 {
1844         if (service->autoconnect == FALSE)
1845                 return TRUE;
1846
1847         if (service->roaming == TRUE)
1848                 return TRUE;
1849
1850         if (service->ignore == TRUE)
1851                 return TRUE;
1852
1853         if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
1854                 return TRUE;
1855
1856         return FALSE;
1857 }
1858
1859 void __connman_service_auto_connect(void)
1860 {
1861         struct connman_service *service = NULL;
1862         GSequenceIter *iter;
1863
1864         DBG("");
1865
1866         iter = g_sequence_get_begin_iter(service_list);
1867
1868         while (g_sequence_iter_is_end(iter) == FALSE) {
1869                 service = g_sequence_get(iter);
1870
1871                 if (service->pending != NULL)
1872                         return;
1873
1874                 if (is_connecting(service) == TRUE)
1875                         return;
1876
1877                 if (service->favorite == FALSE)
1878                         return;
1879
1880                 if (is_connected(service) == TRUE)
1881                         return;
1882
1883                 if (is_ignore(service) == FALSE &&
1884                                 service->state == CONNMAN_SERVICE_STATE_IDLE)
1885                         break;
1886
1887                 service = NULL;
1888
1889                 iter = g_sequence_iter_next(iter);
1890         }
1891
1892         if (service != NULL) {
1893                 service->userconnect = FALSE;
1894                 __connman_service_connect(service);
1895         }
1896 }
1897
1898 static void remove_timeout(struct connman_service *service)
1899 {
1900         if (service->timeout > 0) {
1901                 g_source_remove(service->timeout);
1902                 service->timeout = 0;
1903         }
1904 }
1905
1906 static void reply_pending(struct connman_service *service, int error)
1907 {
1908         remove_timeout(service);
1909
1910         if (service->pending != NULL) {
1911                 if (error > 0) {
1912                         DBusMessage *reply;
1913
1914                         reply = __connman_error_failed(service->pending,
1915                                                                 error);
1916                         if (reply != NULL)
1917                                 g_dbus_send_message(connection, reply);
1918                 } else
1919                         g_dbus_send_reply(connection, service->pending,
1920                                                         DBUS_TYPE_INVALID);
1921
1922                 dbus_message_unref(service->pending);
1923                 service->pending = NULL;
1924         }
1925 }
1926
1927 static gboolean connect_timeout(gpointer user_data)
1928 {
1929         struct connman_service *service = user_data;
1930         connman_bool_t autoconnect = FALSE;
1931
1932         DBG("service %p", service);
1933
1934         service->timeout = 0;
1935
1936         if (service->network != NULL)
1937                 __connman_network_disconnect(service->network);
1938
1939         __connman_ipconfig_disable(service->ipconfig);
1940
1941         if (service->pending != NULL) {
1942                 DBusMessage *reply;
1943
1944                 reply = __connman_error_operation_timeout(service->pending);
1945                 if (reply != NULL)
1946                         g_dbus_send_message(connection, reply);
1947
1948                 dbus_message_unref(service->pending);
1949                 service->pending = NULL;
1950         } else
1951                 autoconnect = TRUE;
1952
1953         __connman_service_indicate_state(service,
1954                                         CONNMAN_SERVICE_STATE_FAILURE);
1955
1956         if (autoconnect == TRUE && service->userconnect == FALSE)
1957                 __connman_service_auto_connect();
1958
1959         return FALSE;
1960 }
1961
1962 static void set_reconnect_state(struct connman_service *service,
1963                                                 connman_bool_t reconnect)
1964 {
1965         struct connman_device *device;
1966
1967         if (service->network == NULL)
1968                 return;
1969
1970         device = connman_network_get_device(service->network);
1971         if (device == NULL)
1972                 return;
1973
1974         __connman_device_set_reconnect(device, reconnect);
1975 }
1976
1977 static connman_bool_t get_reconnect_state(struct connman_service *service)
1978 {
1979         struct connman_device *device;
1980
1981         if (service->network == NULL)
1982                 return FALSE;
1983
1984         device = connman_network_get_device(service->network);
1985         if (device == NULL)
1986                 return FALSE;
1987
1988         return __connman_device_get_reconnect(device);
1989 }
1990
1991 struct connman_service *
1992 __connman_service_connect_type(enum connman_service_type type)
1993 {
1994         struct connman_service *service;
1995         GSequenceIter *iter;
1996         int err;
1997
1998         DBG("type %d", type);
1999
2000         /*
2001          * We go through the already sorted service list.
2002          * We pick the first one matching our type, or just
2003          * the first available one if we have no type.
2004          */
2005         iter = g_sequence_get_begin_iter(service_list);
2006         if (g_sequence_iter_is_end(iter))
2007                 return NULL;
2008         service = g_sequence_get(iter);
2009
2010         /*
2011          * If the first service is connected or about to be
2012          * connected, we return it, regardless of the type.
2013          */
2014         if ((g_sequence_iter_is_end(iter) == FALSE) &&
2015                 (is_connecting(service) == TRUE ||
2016                         is_connected(service) == TRUE))
2017                 return service;
2018
2019         while (g_sequence_iter_is_end(iter) == FALSE) {
2020                 if (service->type == type ||
2021                         type == CONNMAN_SERVICE_TYPE_UNKNOWN)
2022                         break;
2023
2024                 iter = g_sequence_iter_next(iter);
2025                 service = g_sequence_get(iter);
2026         }
2027
2028         if (g_sequence_iter_is_end(iter))
2029                 return NULL;
2030
2031         service->ignore = FALSE;
2032
2033         service->userconnect = TRUE;
2034
2035         set_reconnect_state(service, FALSE);
2036
2037         err = __connman_service_connect(service);
2038         if (err < 0) {
2039                 if (err == -ENOKEY)
2040                         if (__connman_agent_request_passphrase(service,
2041                                                                 NULL, NULL))
2042                                 return service;
2043
2044                 if (err != -EINPROGRESS)
2045                         return NULL;
2046         }
2047
2048         return service;
2049 }
2050
2051 static DBusMessage *connect_service(DBusConnection *conn,
2052                                         DBusMessage *msg, void *user_data)
2053 {
2054         struct connman_service *service = user_data;
2055         GSequenceIter *iter;
2056         int err;
2057
2058         DBG("service %p", service);
2059
2060         if (service->pending != NULL)
2061                 return __connman_error_in_progress(msg);
2062
2063         iter = g_sequence_get_begin_iter(service_list);
2064
2065         while (g_sequence_iter_is_end(iter) == FALSE) {
2066                 struct connman_service *temp = g_sequence_get(iter);
2067
2068                 if (service->type == temp->type &&
2069                                         is_connecting(temp) == TRUE)
2070                         return __connman_error_in_progress(msg);
2071
2072                 iter = g_sequence_iter_next(iter);
2073         }
2074
2075         service->ignore = FALSE;
2076
2077         service->userconnect = TRUE;
2078
2079         service->pending = dbus_message_ref(msg);
2080
2081         set_reconnect_state(service, FALSE);
2082
2083         err = __connman_service_connect(service);
2084         if (err < 0) {
2085                 if (err == -ENOKEY) {
2086                         if (__connman_agent_request_passphrase(service,
2087                                                         NULL, NULL) == 0)
2088                                 return NULL;
2089                 }
2090
2091                 if (err != -EINPROGRESS) {
2092                         dbus_message_unref(service->pending);
2093                         service->pending = NULL;
2094
2095                         return __connman_error_failed(msg, -err);
2096                 }
2097
2098                 return NULL;
2099         }
2100
2101         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2102 }
2103
2104 static DBusMessage *disconnect_service(DBusConnection *conn,
2105                                         DBusMessage *msg, void *user_data)
2106 {
2107         struct connman_service *service = user_data;
2108         int err;
2109
2110         DBG("service %p", service);
2111
2112         reply_pending(service, ECONNABORTED);
2113
2114         service->ignore = TRUE;
2115
2116         set_reconnect_state(service, FALSE);
2117
2118         err = __connman_service_disconnect(service);
2119         if (err < 0) {
2120                 if (err != -EINPROGRESS)
2121                         return __connman_error_failed(msg, -err);
2122
2123                 return NULL;
2124         }
2125
2126         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2127 }
2128
2129 static DBusMessage *remove_service(DBusConnection *conn,
2130                                         DBusMessage *msg, void *user_data)
2131 {
2132         struct connman_service *service = user_data;
2133
2134         DBG("service %p", service);
2135
2136         if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
2137                 return __connman_error_not_supported(msg);
2138
2139         if (service->immutable == TRUE)
2140                 return __connman_error_not_supported(msg);
2141
2142         if (service->favorite == FALSE &&
2143                         service->state != CONNMAN_SERVICE_STATE_FAILURE)
2144                 return __connman_error_not_supported(msg);
2145
2146         if (service->network != NULL) {
2147                 set_reconnect_state(service, FALSE);
2148
2149                 __connman_network_disconnect(service->network);
2150         }
2151
2152         g_hash_table_destroy(service->counter_table);
2153
2154         g_free(service->passphrase);
2155         service->passphrase = NULL;
2156
2157         passphrase_changed(service);
2158
2159         g_free(service->apn);
2160         service->apn = NULL;
2161
2162         g_free(service->username);
2163         service->username = NULL;
2164
2165         g_free(service->password);
2166         service->password = NULL;
2167
2168         apn_changed(service);
2169
2170         set_idle(service);
2171
2172         __connman_service_set_favorite(service, FALSE);
2173         __connman_storage_save_service(service);
2174
2175         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2176 }
2177
2178 static DBusMessage *move_service(DBusConnection *conn,
2179                                         DBusMessage *msg, void *user_data,
2180                                                                 gboolean before)
2181 {
2182         struct connman_service *service = user_data;
2183         struct connman_service *target;
2184         const char *path;
2185         GSequenceIter *src, *dst;
2186
2187         DBG("service %p", service);
2188
2189         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
2190                                                         DBUS_TYPE_INVALID);
2191
2192         if (service->favorite == FALSE)
2193                 return __connman_error_not_supported(msg);
2194
2195         target = find_service(path);
2196         if (target == NULL || target->favorite == FALSE || target == service)
2197                 return __connman_error_invalid_service(msg);
2198
2199         DBG("target %s", target->identifier);
2200
2201         if (target->state != service->state)
2202                 return __connman_error_invalid_service(msg);
2203
2204         g_get_current_time(&service->modified);
2205         __connman_storage_save_service(service);
2206
2207         src = g_hash_table_lookup(service_hash, service->identifier);
2208         dst = g_hash_table_lookup(service_hash, target->identifier);
2209
2210         before ? g_sequence_move(src, dst) : g_sequence_move(dst, src);
2211
2212         __connman_profile_changed(FALSE);
2213
2214         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2215 }
2216
2217 static DBusMessage *move_before(DBusConnection *conn,
2218                                         DBusMessage *msg, void *user_data)
2219 {
2220         return move_service(conn, msg, user_data, TRUE);
2221 }
2222
2223 static DBusMessage *move_after(DBusConnection *conn,
2224                                         DBusMessage *msg, void *user_data)
2225 {
2226         return move_service(conn, msg, user_data, FALSE);
2227 }
2228
2229 static DBusMessage *reset_counters(DBusConnection *conn,
2230                                         DBusMessage *msg, void *user_data)
2231 {
2232         struct connman_service *service = user_data;
2233
2234         reset_stats(service);
2235
2236         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2237 }
2238
2239 static GDBusMethodTable service_methods[] = {
2240         { "GetProperties", "",   "a{sv}", get_properties     },
2241         { "SetProperty",   "sv", "",      set_property       },
2242         { "ClearProperty", "s",  "",      clear_property     },
2243         { "Connect",       "",   "",      connect_service,
2244                                                 G_DBUS_METHOD_FLAG_ASYNC },
2245         { "Disconnect",    "",   "",      disconnect_service },
2246         { "Remove",        "",   "",      remove_service     },
2247         { "MoveBefore",    "o",  "",      move_before        },
2248         { "MoveAfter",     "o",  "",      move_after         },
2249         { "ResetCounters", "",   "",      reset_counters     },
2250         { },
2251 };
2252
2253 static GDBusSignalTable service_signals[] = {
2254         { "PropertyChanged", "sv" },
2255         { },
2256 };
2257
2258 static void service_free(gpointer user_data)
2259 {
2260         struct connman_service *service = user_data;
2261         char *path = service->path;
2262
2263         DBG("service %p", service);
2264
2265         reply_pending(service, ENOENT);
2266
2267         g_hash_table_remove(service_hash, service->identifier);
2268
2269         stats_stop(service);
2270         __connman_storage_save_service(service);
2271
2272         service->path = NULL;
2273
2274         if (path != NULL) {
2275                 __connman_profile_changed(FALSE);
2276
2277                 g_dbus_unregister_interface(connection, path,
2278                                                 CONNMAN_SERVICE_INTERFACE);
2279                 g_free(path);
2280         }
2281
2282         if (service->network != NULL)
2283                 connman_network_unref(service->network);
2284
2285         if (service->provider != NULL)
2286                 connman_provider_unref(service->provider);
2287
2288         if (service->ipconfig != NULL) {
2289                 connman_ipconfig_unref(service->ipconfig);
2290                 service->ipconfig = NULL;
2291         }
2292
2293         if (service->location != NULL)
2294                 connman_location_unref(service->location);
2295
2296         g_strfreev(service->nameservers);
2297         g_strfreev(service->domains);
2298
2299         g_free(service->nameserver);
2300         g_free(service->domainname);
2301         g_free(service->mcc);
2302         g_free(service->mnc);
2303         g_free(service->apn);
2304         g_free(service->username);
2305         g_free(service->password);
2306         g_free(service->profile);
2307         g_free(service->name);
2308         g_free(service->passphrase);
2309         g_free(service->identifier);
2310         g_free(service->eap);
2311         g_free(service->identity);
2312         g_free(service->ca_cert_file);
2313         g_free(service->client_cert_file);
2314         g_free(service->private_key_file);
2315         g_free(service->private_key_passphrase);
2316         g_free(service->phase2);
2317
2318         if (service->stats.timer != NULL)
2319                 g_timer_destroy(service->stats.timer);
2320         if (service->stats_roaming.timer != NULL)
2321                 g_timer_destroy(service->stats_roaming.timer);
2322
2323         g_free(service);
2324 }
2325
2326 /**
2327  * __connman_service_put:
2328  * @service: service structure
2329  *
2330  * Release service if no longer needed
2331  */
2332 void __connman_service_put(struct connman_service *service)
2333 {
2334         DBG("service %p", service);
2335
2336         if (g_atomic_int_dec_and_test(&service->refcount) == TRUE) {
2337                 GSequenceIter *iter;
2338
2339                 iter = g_hash_table_lookup(service_hash, service->identifier);
2340                 if (iter != NULL) {
2341                         reply_pending(service, ECONNABORTED);
2342
2343                         __connman_service_disconnect(service);
2344
2345                         g_sequence_remove(iter);
2346                 } else
2347                         service_free(service);
2348         }
2349 }
2350
2351 static void stats_init(struct connman_service *service)
2352 {
2353         /* home */
2354         service->stats.valid = FALSE;
2355         service->stats.enabled = FALSE;
2356         service->stats.timer = g_timer_new();
2357
2358         /* roaming */
2359         service->stats_roaming.valid = FALSE;
2360         service->stats_roaming.enabled = FALSE;
2361         service->stats_roaming.timer = g_timer_new();
2362 }
2363
2364 static void service_initialize(struct connman_service *service)
2365 {
2366         DBG("service %p", service);
2367
2368         service->refcount = 1;
2369
2370         service->type     = CONNMAN_SERVICE_TYPE_UNKNOWN;
2371         service->mode     = CONNMAN_SERVICE_MODE_UNKNOWN;
2372         service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
2373         service->state    = CONNMAN_SERVICE_STATE_UNKNOWN;
2374
2375         service->favorite  = FALSE;
2376         service->immutable = FALSE;
2377         service->hidden = FALSE;
2378
2379         service->ignore = FALSE;
2380
2381         service->userconnect = FALSE;
2382
2383         service->order = 0;
2384
2385         stats_init(service);
2386
2387         service->provider = NULL;
2388 }
2389
2390 /**
2391  * connman_service_create:
2392  *
2393  * Allocate a new service.
2394  *
2395  * Returns: a newly-allocated #connman_service structure
2396  */
2397 struct connman_service *connman_service_create(void)
2398 {
2399         GSList *list;
2400         struct connman_stats_counter *counters;
2401         const char *counter;
2402
2403         struct connman_service *service;
2404
2405         service = g_try_new0(struct connman_service, 1);
2406         if (service == NULL)
2407                 return NULL;
2408
2409         DBG("service %p", service);
2410
2411         service->counter_table = g_hash_table_new_full(g_str_hash,
2412                                                 g_str_equal, NULL, g_free);
2413
2414         for (list = counter_list; list; list = list->next) {
2415                 counter = list->data;
2416
2417                 counters = g_try_new0(struct connman_stats_counter, 1);
2418                 if (counters == NULL) {
2419                         g_hash_table_destroy(service->counter_table);
2420                         g_free(service);
2421                         return NULL;
2422                 }
2423
2424                 counters->append_all = TRUE;
2425
2426                 g_hash_table_replace(service->counter_table, (gpointer)counter,
2427                                 counters);
2428         }
2429
2430         service_initialize(service);
2431
2432         service->location = __connman_location_create(service);
2433
2434         return service;
2435 }
2436
2437 struct connman_location *__connman_service_get_location(struct connman_service *service)
2438 {
2439         return service->location;
2440 }
2441
2442 /**
2443  * connman_service_ref:
2444  * @service: service structure
2445  *
2446  * Increase reference counter of service
2447  */
2448 struct connman_service *connman_service_ref(struct connman_service *service)
2449 {
2450         DBG("%p", service);
2451
2452         g_atomic_int_inc(&service->refcount);
2453
2454         return service;
2455 }
2456
2457 /**
2458  * connman_service_unref:
2459  * @service: service structure
2460  *
2461  * Decrease reference counter of service
2462  */
2463 void connman_service_unref(struct connman_service *service)
2464 {
2465         __connman_service_put(service);
2466 }
2467
2468 static gint service_compare(gconstpointer a, gconstpointer b,
2469                                                         gpointer user_data)
2470 {
2471         struct connman_service *service_a = (void *) a;
2472         struct connman_service *service_b = (void *) b;
2473
2474         if (service_a->state != service_b->state) {
2475                 if (is_connected(service_a) == TRUE)
2476                         return -1;
2477                 if (is_connected(service_b) == TRUE)
2478                         return 1;
2479         }
2480
2481         if (service_a->order > service_b->order)
2482                 return -1;
2483
2484         if (service_a->order < service_b->order)
2485                 return 1;
2486
2487         if (service_a->favorite == TRUE && service_b->favorite == FALSE)
2488                 return -1;
2489
2490         if (service_a->favorite == FALSE && service_b->favorite == TRUE)
2491                 return 1;
2492
2493         if (service_a->type != service_b->type) {
2494                 switch (service_a->type) {
2495                 case CONNMAN_SERVICE_TYPE_UNKNOWN:
2496                 case CONNMAN_SERVICE_TYPE_SYSTEM:
2497                 case CONNMAN_SERVICE_TYPE_ETHERNET:
2498                 case CONNMAN_SERVICE_TYPE_GPS:
2499                 case CONNMAN_SERVICE_TYPE_VPN:
2500                         break;
2501                 case CONNMAN_SERVICE_TYPE_WIFI:
2502                         return 1;
2503                 case CONNMAN_SERVICE_TYPE_WIMAX:
2504                 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2505                 case CONNMAN_SERVICE_TYPE_CELLULAR:
2506                         return -1;
2507                 }
2508         }
2509
2510         return (gint) service_b->strength - (gint) service_a->strength;
2511 }
2512
2513 /**
2514  * connman_service_get_type:
2515  * @service: service structure
2516  *
2517  * Get the type of service
2518  */
2519 enum connman_service_type connman_service_get_type(struct connman_service *service)
2520 {
2521         if (service == NULL)
2522                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
2523
2524         return service->type;
2525 }
2526
2527 /**
2528  * connman_service_get_interface:
2529  * @service: service structure
2530  *
2531  * Get network interface of service
2532  */
2533 char *connman_service_get_interface(struct connman_service *service)
2534 {
2535         int index;
2536
2537         if (service == NULL)
2538                 return NULL;
2539
2540         if (service->type == CONNMAN_SERVICE_TYPE_VPN) {
2541                 index = connman_ipconfig_get_index(service->ipconfig);
2542
2543                 return connman_inet_ifname(index);
2544         }
2545
2546         if (service->network == NULL)
2547                 return NULL;
2548
2549         index = connman_network_get_index(service->network);
2550
2551         return connman_inet_ifname(index);
2552 }
2553
2554 /**
2555  * connman_service_get_network:
2556  * @service: service structure
2557  *
2558  * Get the service network
2559  */
2560 struct connman_network *
2561 __connman_service_get_network(struct connman_service *service)
2562 {
2563         if (service == NULL)
2564                 return NULL;
2565
2566         return service->network;
2567 }
2568
2569 struct connman_ipconfig *__connman_service_get_ipconfig(struct connman_service *service)
2570 {
2571         if (service == NULL)
2572                 return NULL;
2573
2574         return service->ipconfig;
2575 }
2576
2577 enum connman_service_security __connman_service_get_security(struct connman_service *service)
2578 {
2579         if (service == NULL)
2580                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
2581
2582         return service->security;
2583 }
2584
2585 /**
2586  * __connman_service_set_favorite:
2587  * @service: service structure
2588  * @favorite: favorite value
2589  *
2590  * Change the favorite setting of service
2591  */
2592 int __connman_service_set_favorite(struct connman_service *service,
2593                                                 connman_bool_t favorite)
2594 {
2595         GSequenceIter *iter;
2596
2597         iter = g_hash_table_lookup(service_hash, service->identifier);
2598         if (iter == NULL)
2599                 return -ENOENT;
2600
2601         if (service->favorite == favorite)
2602                 return -EALREADY;
2603
2604         service->favorite = favorite;
2605
2606         favorite_changed(service);
2607
2608         g_sequence_sort_changed(iter, service_compare, NULL);
2609
2610         __connman_profile_changed(FALSE);
2611
2612         return 0;
2613 }
2614
2615 int __connman_service_set_immutable(struct connman_service *service,
2616                                                 connman_bool_t immutable)
2617 {
2618         service->immutable = immutable;
2619
2620         immutable_changed(service);
2621
2622         return 0;
2623 }
2624
2625 void __connman_service_set_string(struct connman_service *service,
2626                                   const char *key, const char *value)
2627 {
2628         if (g_str_equal(key, "EAP") == TRUE) {
2629                 g_free(service->eap);
2630                 service->eap = g_strdup(value);
2631         } else if (g_str_equal(key, "Identity") == TRUE) {
2632                 g_free(service->identity);
2633                 service->identity = g_strdup(value);
2634         } else if (g_str_equal(key, "CACertFile") == TRUE) {
2635                 g_free(service->ca_cert_file);
2636                 service->ca_cert_file = g_strdup(value);
2637         } else if (g_str_equal(key, "ClientCertFile") == TRUE) {
2638                 g_free(service->client_cert_file);
2639                 service->client_cert_file = g_strdup(value);
2640         } else if (g_str_equal(key, "PrivateKeyFile") == TRUE) {
2641                 g_free(service->private_key_file);
2642                 service->private_key_file = g_strdup(value);
2643         } else if (g_str_equal(key, "PrivateKeyPassphrase") == TRUE) {
2644                 g_free(service->private_key_passphrase);
2645                 service->private_key_passphrase = g_strdup(value);
2646         } else if (g_str_equal(key, "Phase2") == TRUE) {
2647                 g_free(service->phase2);
2648                 service->phase2 = g_strdup(value);
2649         } else if (g_str_equal(key, "Passphrase") == TRUE) {
2650                 g_free(service->passphrase);
2651                 service->passphrase = g_strdup(value);
2652         }
2653 }
2654
2655 int __connman_service_indicate_state(struct connman_service *service,
2656                                         enum connman_service_state state)
2657 {
2658         GSequenceIter *iter;
2659
2660         DBG("service %p state %d", service, state);
2661
2662         if (service == NULL)
2663                 return -EINVAL;
2664
2665         if (service->state == state)
2666                 return -EALREADY;
2667
2668         if (service->state == CONNMAN_SERVICE_STATE_FAILURE &&
2669                                 state == CONNMAN_SERVICE_STATE_IDLE)
2670                 return -EINVAL;
2671
2672         if (service->state == CONNMAN_SERVICE_STATE_IDLE &&
2673                                 state == CONNMAN_SERVICE_STATE_DISCONNECT)
2674                 return -EINVAL;
2675
2676         if (state == CONNMAN_SERVICE_STATE_IDLE &&
2677                         service->state != CONNMAN_SERVICE_STATE_DISCONNECT) {
2678                 service->state = CONNMAN_SERVICE_STATE_DISCONNECT;
2679                 state_changed(service);
2680
2681                 reply_pending(service, ECONNABORTED);
2682
2683                 __connman_service_disconnect(service);
2684         }
2685
2686         if (state == CONNMAN_SERVICE_STATE_CONFIGURATION)
2687                 __connman_ipconfig_enable(service->ipconfig);
2688
2689         service->state = state;
2690         state_changed(service);
2691
2692         if (state == CONNMAN_SERVICE_STATE_ONLINE) {
2693                 if (service->login_required == TRUE) {
2694                         service->login_required = FALSE;
2695                         login_changed(service);
2696                 }
2697
2698                 connman_timeserver_sync();
2699         }
2700
2701         if (state == CONNMAN_SERVICE_STATE_IDLE) {
2702                 connman_bool_t reconnect;
2703
2704                 reconnect = get_reconnect_state(service);
2705                 if (reconnect == TRUE)
2706                         __connman_service_auto_connect();
2707         }
2708
2709         if (state == CONNMAN_SERVICE_STATE_READY) {
2710                 set_reconnect_state(service, TRUE);
2711
2712                 __connman_service_set_favorite(service, TRUE);
2713
2714                 reply_pending(service, 0);
2715
2716                 service->userconnect = FALSE;
2717
2718                 g_get_current_time(&service->modified);
2719                 __connman_storage_save_service(service);
2720
2721                 update_nameservers(service);
2722                 dns_changed(service);
2723
2724                 __connman_wpad_start(service);
2725
2726                 __connman_notifier_connect(service->type);
2727
2728                 default_changed();
2729         } else if (state == CONNMAN_SERVICE_STATE_DISCONNECT) {
2730                 __connman_location_finish(service);
2731
2732                 default_changed();
2733
2734                 __connman_wpad_stop(service);
2735
2736                 update_nameservers(service);
2737                 dns_changed(service);
2738
2739                 __connman_notifier_disconnect(service->type);
2740         }
2741
2742         if (state == CONNMAN_SERVICE_STATE_FAILURE) {
2743                 reply_pending(service, EIO);
2744
2745                 if (service->userconnect == FALSE)
2746                         __connman_service_auto_connect();
2747
2748                 g_get_current_time(&service->modified);
2749                 __connman_storage_save_service(service);
2750         } else
2751                 service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
2752
2753         iter = g_hash_table_lookup(service_hash, service->identifier);
2754         if (iter != NULL)
2755                 g_sequence_sort_changed(iter, service_compare, NULL);
2756
2757         __connman_profile_changed(FALSE);
2758
2759         if (service->state == CONNMAN_SERVICE_STATE_ONLINE)
2760                 default_changed();
2761
2762         if (service->state == CONNMAN_SERVICE_STATE_DISCONNECT) {
2763                 struct connman_service *def_service = get_default();
2764
2765                 if (__connman_notifier_count_connected() == 0 &&
2766                         def_service != NULL &&
2767                                 def_service->provider != NULL)
2768                         __connman_provider_disconnect(def_service->provider);
2769         }
2770
2771         if (service->state == CONNMAN_SERVICE_STATE_IDLE ||
2772                         service->state == CONNMAN_SERVICE_STATE_FAILURE)
2773                 __connman_element_request_scan(CONNMAN_ELEMENT_TYPE_UNKNOWN);
2774
2775         return 0;
2776 }
2777
2778 int __connman_service_indicate_error(struct connman_service *service,
2779                                         enum connman_service_error error)
2780 {
2781         DBG("service %p error %d", service, error);
2782
2783         if (service == NULL)
2784                 return -EINVAL;
2785
2786         service->error = error;
2787
2788         return __connman_service_indicate_state(service,
2789                                         CONNMAN_SERVICE_STATE_FAILURE);
2790 }
2791
2792 int __connman_service_indicate_default(struct connman_service *service)
2793 {
2794         DBG("service %p", service);
2795
2796         default_changed();
2797
2798         __connman_location_detect(service);
2799
2800         return 0;
2801 }
2802
2803 int __connman_service_request_login(struct connman_service *service)
2804 {
2805         DBG("service %p", service);
2806
2807         if (service == NULL)
2808                 return -EINVAL;
2809
2810         service->login_required = TRUE;
2811         login_changed(service);
2812
2813         return 0;
2814 }
2815
2816 static connman_bool_t prepare_network(struct connman_service *service)
2817 {
2818         enum connman_network_type type;
2819         unsigned int ssid_len;
2820
2821         type = connman_network_get_type(service->network);
2822
2823         switch (type) {
2824         case CONNMAN_NETWORK_TYPE_UNKNOWN:
2825         case CONNMAN_NETWORK_TYPE_VENDOR:
2826                 return FALSE;
2827         case CONNMAN_NETWORK_TYPE_WIFI:
2828                 if (connman_network_get_blob(service->network, "WiFi.SSID",
2829                                                         &ssid_len) == NULL)
2830                         return FALSE;
2831
2832                 connman_network_set_string(service->network,
2833                                 "WiFi.Passphrase", service->passphrase);
2834                 break;
2835         case CONNMAN_NETWORK_TYPE_ETHERNET:
2836         case CONNMAN_NETWORK_TYPE_WIMAX:
2837         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
2838         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
2839                 break;
2840         case CONNMAN_NETWORK_TYPE_CELLULAR:
2841                 connman_network_set_string(service->network,
2842                                                 "Cellular.APN", service->apn);
2843
2844                 connman_network_set_string(service->network,
2845                                         "Cellular.Username", service->username);
2846                 connman_network_set_string(service->network,
2847                                         "Cellular.Password", service->password);
2848                 break;
2849         }
2850
2851         return TRUE;
2852 }
2853
2854 static void prepare_8021x(struct connman_service *service)
2855 {
2856         if (service->eap != NULL)
2857                 connman_network_set_string(service->network, "WiFi.EAP",
2858                                                                 service->eap);
2859
2860         if (service->identity != NULL)
2861                 connman_network_set_string(service->network, "WiFi.Identity",
2862                                                         service->identity);
2863
2864         if (service->ca_cert_file != NULL)
2865                 connman_network_set_string(service->network, "WiFi.CACertFile",
2866                                                         service->ca_cert_file);
2867
2868         if (service->client_cert_file != NULL)
2869                 connman_network_set_string(service->network,
2870                                                 "WiFi.ClientCertFile",
2871                                                 service->client_cert_file);
2872
2873         if (service->private_key_file != NULL)
2874                 connman_network_set_string(service->network,
2875                                                 "WiFi.PrivateKeyFile",
2876                                                 service->private_key_file);
2877
2878         if (service->private_key_passphrase != NULL)
2879                 connman_network_set_string(service->network,
2880                                         "WiFi.PrivateKeyPassphrase",
2881                                         service->private_key_passphrase);
2882
2883         if (service->phase2 != NULL)
2884                 connman_network_set_string(service->network, "WiFi.Phase2",
2885                                                         service->phase2);
2886 }
2887
2888 int __connman_service_connect(struct connman_service *service)
2889 {
2890         int err;
2891
2892         DBG("service %p", service);
2893
2894         if (is_connected(service) == TRUE)
2895                 return -EISCONN;
2896
2897         if (is_connecting(service) == TRUE)
2898                 return -EALREADY;
2899
2900         switch (service->type) {
2901         case CONNMAN_SERVICE_TYPE_UNKNOWN:
2902         case CONNMAN_SERVICE_TYPE_SYSTEM:
2903         case CONNMAN_SERVICE_TYPE_GPS:
2904                 return -EINVAL;
2905         case CONNMAN_SERVICE_TYPE_ETHERNET:
2906         case CONNMAN_SERVICE_TYPE_WIMAX:
2907         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
2908         case CONNMAN_SERVICE_TYPE_VPN:
2909                 break;
2910         case CONNMAN_SERVICE_TYPE_CELLULAR:
2911                 if (service->apn == NULL)
2912                         return -EINVAL;
2913                 break;
2914         case CONNMAN_SERVICE_TYPE_WIFI:
2915                 switch (service->security) {
2916                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
2917                 case CONNMAN_SERVICE_SECURITY_NONE:
2918                         break;
2919                 case CONNMAN_SERVICE_SECURITY_WEP:
2920                 case CONNMAN_SERVICE_SECURITY_PSK:
2921                 case CONNMAN_SERVICE_SECURITY_WPA:
2922                 case CONNMAN_SERVICE_SECURITY_RSN:
2923                         if (service->passphrase == NULL)
2924                                 return -ENOKEY;
2925                         break;
2926                 case CONNMAN_SERVICE_SECURITY_8021X:
2927                         break;
2928                 }
2929                 break;
2930         }
2931
2932         if (service->network != NULL) {
2933                 if (prepare_network(service) == FALSE)
2934                         return -EINVAL;
2935
2936                 switch (service->security) {
2937                 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
2938                 case CONNMAN_SERVICE_SECURITY_NONE:
2939                 case CONNMAN_SERVICE_SECURITY_WEP:
2940                 case CONNMAN_SERVICE_SECURITY_PSK:
2941                 case CONNMAN_SERVICE_SECURITY_WPA:
2942                 case CONNMAN_SERVICE_SECURITY_RSN:
2943                         break;
2944                 case CONNMAN_SERVICE_SECURITY_8021X:
2945                         prepare_8021x(service);
2946                         break;
2947                 }
2948
2949                 __connman_ipconfig_enable(service->ipconfig);
2950
2951                 err = __connman_network_connect(service->network);
2952         } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
2953                                         service->provider != NULL)
2954                 err = __connman_provider_connect(service->provider);
2955         else
2956                 return -EOPNOTSUPP;
2957
2958         if (err < 0) {
2959                 if (err != -EINPROGRESS) {
2960                         __connman_ipconfig_disable(service->ipconfig);
2961                         return err;
2962                 }
2963
2964                 service->timeout = g_timeout_add_seconds(CONNECT_TIMEOUT,
2965                                                 connect_timeout, service);
2966
2967                 return -EINPROGRESS;
2968         }
2969
2970         return 0;
2971 }
2972
2973 int __connman_service_disconnect(struct connman_service *service)
2974 {
2975         struct connman_ipconfig *ipv6config;
2976         int err;
2977
2978         DBG("service %p", service);
2979
2980         if (service->network != NULL) {
2981                 err = __connman_network_disconnect(service->network);
2982         } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
2983                                         service->provider != NULL)
2984                 err = __connman_provider_disconnect(service->provider);
2985         else
2986                 return -EOPNOTSUPP;
2987
2988         __connman_ipconfig_set_proxy_autoconfig(service->ipconfig, NULL);
2989
2990         __connman_ipconfig_clear_address(service->ipconfig);
2991
2992         ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
2993
2994         __connman_ipconfig_clear_address(ipv6config);
2995
2996         __connman_ipconfig_disable(service->ipconfig);
2997
2998         if (err < 0) {
2999                 if (err != -EINPROGRESS)
3000                         return err;
3001
3002                 return -EINPROGRESS;
3003         }
3004
3005         return 0;
3006 }
3007
3008 /**
3009  * __connman_service_lookup:
3010  * @pattern: search pattern
3011  * @path: return object path
3012  *
3013  * Look up a service path from a search pattern
3014  */
3015 int __connman_service_lookup(const char *pattern, const char **path)
3016 {
3017         GHashTableIter iter;
3018         gpointer key, value;
3019
3020         g_hash_table_iter_init(&iter, service_hash);
3021
3022         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
3023                 GSequenceIter *iter = value;
3024                 struct connman_service *service = g_sequence_get(iter);
3025
3026                 if (g_strcmp0(service->identifier, pattern) == 0 ||
3027                                 g_strcmp0(service->name, pattern) == 0) {
3028                         *path = (const char *) service->path;
3029                         return 0;
3030                 }
3031         }
3032
3033         return -ENXIO;
3034 }
3035
3036 /**
3037  * lookup_by_identifier:
3038  * @identifier: service identifier
3039  *
3040  * Look up a service by identifier (reference count will not be increased)
3041  */
3042 static struct connman_service *lookup_by_identifier(const char *identifier)
3043 {
3044         GSequenceIter *iter;
3045
3046         iter = g_hash_table_lookup(service_hash, identifier);
3047         if (iter != NULL)
3048                 return g_sequence_get(iter);
3049
3050         return NULL;
3051 }
3052
3053 static struct connman_network *create_hidden_wifi(struct connman_device *device,
3054                 const char *ssid, const char *mode, const char *security)
3055 {
3056         struct connman_network *network;
3057         char *name;
3058         int index;
3059         unsigned int i, ssid_len;
3060
3061         ssid_len = strlen(ssid);
3062         if (ssid_len < 1)
3063                 return NULL;
3064
3065         network = connman_network_create(NULL, CONNMAN_NETWORK_TYPE_WIFI);
3066         if (network == NULL)
3067                 return NULL;
3068
3069         connman_network_set_blob(network, "WiFi.SSID",
3070                                         (unsigned char *) ssid, ssid_len);
3071
3072         connman_network_set_string(network, "WiFi.Mode", mode);
3073         connman_network_set_string(network, "WiFi.Security", security);
3074
3075         name = g_try_malloc0(ssid_len + 1);
3076         if (name == NULL) {
3077                 connman_network_unref(network);
3078                 return NULL;
3079         }
3080
3081         for (i = 0; i < ssid_len; i++) {
3082                 if (g_ascii_isprint(ssid[i]))
3083                         name[i] = ssid[i];
3084                 else
3085                         name[i] = ' ';
3086         }
3087
3088         connman_network_set_name(network, name);
3089
3090         g_free(name);
3091
3092         index = connman_device_get_index(device);
3093         connman_network_set_index(network, index);
3094
3095         connman_network_set_protocol(network, CONNMAN_NETWORK_PROTOCOL_IP);
3096
3097         if (connman_device_add_network(device, network) < 0) {
3098                 connman_network_unref(network);
3099                 return NULL;
3100         }
3101
3102         connman_network_set_available(network, TRUE);
3103
3104         return network;
3105 }
3106
3107 int __connman_service_create_and_connect(DBusMessage *msg)
3108 {
3109         struct connman_service *service;
3110         struct connman_network *network;
3111         struct connman_device *device;
3112         DBusMessageIter iter, array;
3113         const char *mode = "managed", *security = "none", *group_security;
3114         const char *type = NULL, *ssid = NULL, *passphrase = NULL;
3115         unsigned int ssid_len = 0;
3116         const char *ident;
3117         char *name, *group;
3118         gboolean created = FALSE;
3119         int err;
3120
3121         dbus_message_iter_init(msg, &iter);
3122         dbus_message_iter_recurse(&iter, &array);
3123
3124         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
3125                 DBusMessageIter entry, value;
3126                 const char *key;
3127
3128                 dbus_message_iter_recurse(&array, &entry);
3129                 dbus_message_iter_get_basic(&entry, &key);
3130
3131                 dbus_message_iter_next(&entry);
3132                 dbus_message_iter_recurse(&entry, &value);
3133
3134                 switch (dbus_message_iter_get_arg_type(&value)) {
3135                 case DBUS_TYPE_STRING:
3136                         if (g_str_equal(key, "Type") == TRUE)
3137                                 dbus_message_iter_get_basic(&value, &type);
3138                         else if (g_str_equal(key, "WiFi.Mode") == TRUE ||
3139                                         g_str_equal(key, "Mode") == TRUE)
3140                                 dbus_message_iter_get_basic(&value, &mode);
3141                         else if (g_str_equal(key, "WiFi.Security") == TRUE ||
3142                                         g_str_equal(key, "Security") == TRUE)
3143                                 dbus_message_iter_get_basic(&value, &security);
3144                         else if (g_str_equal(key, "WiFi.Passphrase") == TRUE ||
3145                                         g_str_equal(key, "Passphrase") == TRUE)
3146                                 dbus_message_iter_get_basic(&value, &passphrase);
3147                         else if (g_str_equal(key, "WiFi.SSID") == TRUE ||
3148                                         g_str_equal(key, "SSID") == TRUE)
3149                                 dbus_message_iter_get_basic(&value, &ssid);
3150                 }
3151
3152                 dbus_message_iter_next(&array);
3153         }
3154
3155         if (type == NULL)
3156                 return -EINVAL;
3157
3158         if (g_strcmp0(type, "wifi") != 0 || g_strcmp0(mode, "managed") != 0)
3159                 return -EOPNOTSUPP;
3160
3161         if (ssid == NULL)
3162                 return -EINVAL;
3163
3164         ssid_len = strlen(ssid);
3165         if (ssid_len < 1)
3166                 return -EINVAL;
3167
3168         if (g_strcmp0(security, "none") != 0 &&
3169                                 g_strcmp0(security, "wep") != 0 &&
3170                                 g_strcmp0(security, "psk") != 0 &&
3171                                 g_strcmp0(security, "wpa") != 0 &&
3172                                 g_strcmp0(security, "rsn") != 0 &&
3173                                 g_strcmp0(security, "ieee8021x") != 0)
3174                 return -EINVAL;
3175
3176         device = __connman_element_find_device(CONNMAN_DEVICE_TYPE_WIFI);
3177         if (device == NULL)
3178                 return -EOPNOTSUPP;
3179
3180         ident = connman_device_get_ident(device);
3181         if (ident == NULL)
3182                 return -EOPNOTSUPP;
3183
3184
3185         if (!g_strcmp0(security, "wpa") ||
3186                 !g_strcmp0(security, "rsn"))
3187                 group_security = "psk";
3188         else
3189                 group_security = security;
3190
3191         group = connman_wifi_build_group_name((unsigned char *) ssid,
3192                                                 ssid_len, mode, group_security);
3193         if (group == NULL)
3194                 return -EINVAL;
3195
3196         name = g_strdup_printf("%s_%s_%s", type, ident, group);
3197
3198         service = lookup_by_identifier(name);
3199
3200         if (service != NULL)
3201                 goto done;
3202
3203         network = create_hidden_wifi(device, ssid, mode, security);
3204         if (network != NULL) {
3205                 connman_network_set_group(network, group);
3206                 created = TRUE;
3207         }
3208
3209         service = lookup_by_identifier(name);
3210
3211 done:
3212         g_free(name);
3213         g_free(group);
3214
3215         if (service == NULL) {
3216                 err = -EOPNOTSUPP;
3217                 goto failed;
3218         }
3219
3220         set_reconnect_state(service, FALSE);
3221
3222         __connman_device_disconnect(device);
3223
3224         if (passphrase != NULL) {
3225                 g_free(service->passphrase);
3226                 service->passphrase = g_strdup(passphrase);
3227         }
3228
3229         service->userconnect = TRUE;
3230
3231         err = __connman_service_connect(service);
3232         if (err < 0 && err != -EINPROGRESS)
3233                 goto failed;
3234
3235         g_dbus_send_reply(connection, msg,
3236                                 DBUS_TYPE_OBJECT_PATH, &service->path,
3237                                                         DBUS_TYPE_INVALID);
3238
3239         return 0;
3240
3241 failed:
3242         if (service != NULL && created == TRUE) {
3243                 struct connman_network *network = service->network;
3244
3245                 if (network != NULL) {
3246                         connman_network_set_available(network, FALSE);
3247                         __connman_device_cleanup_networks(device);
3248                 } else
3249                         __connman_service_put(service);
3250         }
3251
3252         return err;
3253 }
3254
3255 /**
3256  * __connman_service_get:
3257  * @identifier: service identifier
3258  *
3259  * Look up a service by identifier or create a new one if not found
3260  */
3261 static struct connman_service *service_get(const char *identifier)
3262 {
3263         struct connman_service *service;
3264         GSequenceIter *iter;
3265
3266         iter = g_hash_table_lookup(service_hash, identifier);
3267         if (iter != NULL) {
3268                 service = g_sequence_get(iter);
3269                 if (service != NULL)
3270                         connman_service_ref(service);
3271                 return service;
3272         }
3273
3274         service = connman_service_create();
3275         if (service == NULL)
3276                 return NULL;
3277
3278         DBG("service %p", service);
3279
3280         service->identifier = g_strdup(identifier);
3281
3282         service->profile = g_strdup(__connman_profile_active_ident());
3283
3284         iter = g_sequence_insert_sorted(service_list, service,
3285                                                 service_compare, NULL);
3286
3287         g_hash_table_insert(service_hash, service->identifier, iter);
3288
3289         return service;
3290 }
3291
3292 static int service_register(struct connman_service *service)
3293 {
3294         const char *path = __connman_profile_active_path();
3295         GSequenceIter *iter;
3296
3297         DBG("service %p", service);
3298
3299         if (service->path != NULL)
3300                 return -EALREADY;
3301
3302         service->path = g_strdup_printf("%s/%s", path, service->identifier);
3303
3304         DBG("path %s", service->path);
3305
3306         __connman_config_provision_service(service);
3307
3308         __connman_storage_load_service(service);
3309
3310         g_dbus_register_interface(connection, service->path,
3311                                         CONNMAN_SERVICE_INTERFACE,
3312                                         service_methods, service_signals,
3313                                                         NULL, service, NULL);
3314
3315         iter = g_hash_table_lookup(service_hash, service->identifier);
3316         if (iter != NULL)
3317                 g_sequence_sort_changed(iter, service_compare, NULL);
3318
3319         __connman_profile_changed(TRUE);
3320
3321         return 0;
3322 }
3323
3324 static void service_up(struct connman_ipconfig *ipconfig)
3325 {
3326         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3327
3328         connman_info("%s up", connman_ipconfig_get_ifname(ipconfig));
3329
3330         link_changed(service);
3331
3332         service->stats.valid = FALSE;
3333         service->stats_roaming.valid = FALSE;
3334 }
3335
3336 static void service_down(struct connman_ipconfig *ipconfig)
3337 {
3338         connman_info("%s down", connman_ipconfig_get_ifname(ipconfig));
3339 }
3340
3341 static void service_lower_up(struct connman_ipconfig *ipconfig)
3342 {
3343         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3344
3345         connman_info("%s lower up", connman_ipconfig_get_ifname(ipconfig));
3346
3347         stats_start(service);
3348 }
3349
3350 static void service_lower_down(struct connman_ipconfig *ipconfig)
3351 {
3352         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3353
3354         connman_info("%s lower down", connman_ipconfig_get_ifname(ipconfig));
3355
3356         stats_stop(service);
3357         __connman_storage_save_service(service);
3358 }
3359
3360 static void service_ip_bound(struct connman_ipconfig *ipconfig)
3361 {
3362         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3363
3364         connman_info("%s ip bound", connman_ipconfig_get_ifname(ipconfig));
3365
3366         settings_changed(service);
3367 }
3368
3369 static void service_ip_release(struct connman_ipconfig *ipconfig)
3370 {
3371         struct connman_service *service = connman_ipconfig_get_data(ipconfig);
3372
3373         connman_info("%s ip release", connman_ipconfig_get_ifname(ipconfig));
3374
3375         settings_changed(service);
3376 }
3377
3378 static const struct connman_ipconfig_ops service_ops = {
3379         .up             = service_up,
3380         .down           = service_down,
3381         .lower_up       = service_lower_up,
3382         .lower_down     = service_lower_down,
3383         .ip_bound       = service_ip_bound,
3384         .ip_release     = service_ip_release,
3385 };
3386
3387 static void setup_ipconfig(struct connman_service *service, int index)
3388 {
3389         if (index < 0)
3390                 return;
3391
3392         service->ipconfig = connman_ipconfig_create(index);
3393         if (service->ipconfig == NULL)
3394                 return;
3395
3396         connman_ipconfig_set_method(service->ipconfig,
3397                                         CONNMAN_IPCONFIG_METHOD_DHCP);
3398
3399         connman_ipconfig_set_data(service->ipconfig, service);
3400
3401         connman_ipconfig_set_ops(service->ipconfig, &service_ops);
3402 }
3403
3404 void __connman_service_create_ipconfig(struct connman_service *service,
3405                                                                 int index)
3406 {
3407         struct connman_ipconfig *ipv6config;
3408         const char *ident = service->profile;
3409         GKeyFile *keyfile;
3410
3411         if (service->ipconfig != NULL)
3412                 return;
3413
3414         setup_ipconfig(service, index);
3415
3416         if (ident == NULL)
3417                 return;
3418
3419         keyfile = __connman_storage_open_profile(ident);
3420         if (keyfile == NULL)
3421                 return;
3422
3423
3424         ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
3425         if (ipv6config != NULL)
3426                 __connman_ipconfig_load(ipv6config, keyfile,
3427                                         service->identifier, "IPv6.");
3428
3429         __connman_ipconfig_load(service->ipconfig, keyfile,
3430                                         service->identifier, "IPv4.");
3431         g_key_file_free(keyfile);
3432 }
3433
3434 /**
3435  * __connman_service_lookup_from_network:
3436  * @network: network structure
3437  *
3438  * Look up a service by network (reference count will not be increased)
3439  */
3440 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
3441 {
3442         struct connman_service *service;
3443         const char *ident, *group;
3444         char *name;
3445
3446         DBG("network %p", network);
3447
3448         ident = __connman_network_get_ident(network);
3449         if (ident == NULL)
3450                 return NULL;
3451
3452         group = connman_network_get_group(network);
3453         if (group == NULL)
3454                 return NULL;
3455
3456         name = g_strdup_printf("%s_%s_%s",
3457                         __connman_network_get_type(network), ident, group);
3458         service = lookup_by_identifier(name);
3459         g_free(name);
3460
3461         return service;
3462 }
3463
3464 struct connman_service *__connman_service_lookup_from_index(int index)
3465 {
3466         struct connman_service *service;
3467         GSequenceIter *iter;
3468
3469         iter = g_sequence_get_begin_iter(service_list);
3470
3471         while (g_sequence_iter_is_end(iter) == FALSE) {
3472                 service = g_sequence_get(iter);
3473
3474                 if (connman_ipconfig_get_index(service->ipconfig) == index)
3475                         return service;
3476
3477                 iter = g_sequence_iter_next(iter);
3478         }
3479
3480         return NULL;
3481 }
3482
3483 const char *__connman_service_get_path(struct connman_service *service)
3484 {
3485         return service->path;
3486 }
3487
3488 unsigned int __connman_service_get_order(struct connman_service *service)
3489 {
3490         GSequenceIter *iter;
3491
3492         if (service == NULL)
3493                 return 0;
3494
3495         if (service->favorite == FALSE) {
3496                 service->order = 0;
3497                 goto done;
3498         }
3499
3500         iter = g_hash_table_lookup(service_hash, service->identifier);
3501         if (iter != NULL) {
3502                 if (g_sequence_iter_get_position(iter) == 0)
3503                         service->order = 1;
3504                 else if (service->type == CONNMAN_SERVICE_TYPE_VPN)
3505                         service->order = 10;
3506                 else
3507                         service->order = 0;
3508         }
3509
3510 done:
3511         return service->order;
3512 }
3513
3514 static enum connman_service_type convert_network_type(struct connman_network *network)
3515 {
3516         enum connman_network_type type = connman_network_get_type(network);
3517
3518         switch (type) {
3519         case CONNMAN_NETWORK_TYPE_UNKNOWN:
3520         case CONNMAN_NETWORK_TYPE_VENDOR:
3521                 break;
3522         case CONNMAN_NETWORK_TYPE_ETHERNET:
3523                 return CONNMAN_SERVICE_TYPE_ETHERNET;
3524         case CONNMAN_NETWORK_TYPE_WIFI:
3525                 return CONNMAN_SERVICE_TYPE_WIFI;
3526         case CONNMAN_NETWORK_TYPE_WIMAX:
3527                 return CONNMAN_SERVICE_TYPE_WIMAX;
3528         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
3529         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
3530                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
3531         case CONNMAN_NETWORK_TYPE_CELLULAR:
3532                 return CONNMAN_SERVICE_TYPE_CELLULAR;
3533         }
3534
3535         return CONNMAN_SERVICE_TYPE_UNKNOWN;
3536 }
3537
3538 static enum connman_service_mode convert_wifi_mode(const char *mode)
3539 {
3540         if (mode == NULL)
3541                 return CONNMAN_SERVICE_MODE_UNKNOWN;
3542         else if (g_str_equal(mode, "managed") == TRUE)
3543                 return CONNMAN_SERVICE_MODE_MANAGED;
3544         else if (g_str_equal(mode, "adhoc") == TRUE)
3545                 return CONNMAN_SERVICE_MODE_ADHOC;
3546         else
3547                 return CONNMAN_SERVICE_MODE_UNKNOWN;
3548 }
3549
3550 static enum connman_service_security convert_wifi_security(const char *security)
3551 {
3552         if (security == NULL)
3553                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
3554         else if (g_str_equal(security, "none") == TRUE)
3555                 return CONNMAN_SERVICE_SECURITY_NONE;
3556         else if (g_str_equal(security, "wep") == TRUE)
3557                 return CONNMAN_SERVICE_SECURITY_WEP;
3558         else if (g_str_equal(security, "psk") == TRUE)
3559                 return CONNMAN_SERVICE_SECURITY_PSK;
3560         else if (g_str_equal(security, "ieee8021x") == TRUE)
3561                 return CONNMAN_SERVICE_SECURITY_8021X;
3562         else if (g_str_equal(security, "wpa") == TRUE)
3563                 return CONNMAN_SERVICE_SECURITY_WPA;
3564         else if (g_str_equal(security, "rsn") == TRUE)
3565                 return CONNMAN_SERVICE_SECURITY_RSN;
3566         else
3567                 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
3568 }
3569
3570 static enum connman_service_mode convert_cellular_mode(connman_uint8_t mode)
3571 {
3572         switch (mode) {
3573         case 0:
3574         case 1:
3575                 return CONNMAN_SERVICE_MODE_GPRS;
3576         case 3:
3577                 return CONNMAN_SERVICE_MODE_EDGE;
3578         case 2:
3579         case 4:
3580         case 5:
3581         case 6:
3582                 return CONNMAN_SERVICE_MODE_UMTS;
3583         }
3584
3585         return CONNMAN_SERVICE_MODE_UNKNOWN;
3586 }
3587
3588 static void update_from_network(struct connman_service *service,
3589                                         struct connman_network *network)
3590 {
3591         connman_uint8_t strength = service->strength;
3592         GSequenceIter *iter;
3593         const char *str;
3594
3595         DBG("service %p network %p", service, network);
3596
3597         if (is_connected(service) == TRUE)
3598                 return;
3599
3600         if (is_connecting(service) == TRUE)
3601                 return;
3602
3603         str = connman_network_get_string(network, "Name");
3604         if (str != NULL) {
3605                 g_free(service->name);
3606                 service->name = g_strdup(str);
3607                 service->hidden = FALSE;
3608         } else {
3609                 g_free(service->name);
3610                 service->name = NULL;
3611                 service->hidden = TRUE;
3612         }
3613
3614         service->strength = connman_network_get_uint8(network, "Strength");
3615         service->roaming = connman_network_get_bool(network, "Roaming");
3616
3617         if (service->strength == 0) {
3618                 /*
3619                  * Filter out 0-values; it's unclear what they mean
3620                  * and they cause anomalous sorting of the priority list.
3621                  */
3622                 service->strength = strength;
3623         }
3624
3625         str = connman_network_get_string(network, "WiFi.Mode");
3626         service->mode = convert_wifi_mode(str);
3627
3628         str = connman_network_get_string(network, "WiFi.Security");
3629         service->security = convert_wifi_security(str);
3630
3631         str = connman_network_get_string(network, "Cellular.MCC");
3632         g_free(service->mcc);
3633         service->mcc = g_strdup(str);
3634
3635         str = connman_network_get_string(network, "Cellular.MNC");
3636         g_free(service->mnc);
3637         service->mnc = g_strdup(str);
3638
3639         if (service->type == CONNMAN_SERVICE_TYPE_CELLULAR) {
3640                 connman_uint8_t value = connman_network_get_uint8(network,
3641                                                         "Cellular.Mode");
3642
3643                 service->mode = convert_cellular_mode(value);
3644         }
3645
3646         if (service->strength > strength && service->network != NULL) {
3647                 connman_network_unref(service->network);
3648                 service->network = connman_network_ref(network);
3649
3650                 strength_changed(service);
3651         }
3652
3653         if (service->network == NULL)
3654                 service->network = connman_network_ref(network);
3655
3656         iter = g_hash_table_lookup(service_hash, service->identifier);
3657         if (iter != NULL)
3658                 g_sequence_sort_changed(iter, service_compare, NULL);
3659 }
3660
3661 /**
3662  * __connman_service_create_from_network:
3663  * @network: network structure
3664  *
3665  * Look up service by network and if not found, create one
3666  */
3667 struct connman_service * __connman_service_create_from_network(struct connman_network *network)
3668 {
3669         struct connman_service *service;
3670         const char *ident, *group;
3671         char *name;
3672
3673         DBG("network %p", network);
3674
3675         ident = __connman_network_get_ident(network);
3676         if (ident == NULL)
3677                 return NULL;
3678
3679         group = connman_network_get_group(network);
3680         if (group == NULL)
3681                 return NULL;
3682
3683         name = g_strdup_printf("%s_%s_%s",
3684                         __connman_network_get_type(network), ident, group);
3685         service = service_get(name);
3686         g_free(name);
3687
3688         if (service == NULL)
3689                 return NULL;
3690
3691         if (__connman_network_get_weakness(network) == TRUE)
3692                 return service;
3693
3694         if (service->path != NULL) {
3695                 update_from_network(service, network);
3696                 __connman_profile_changed(TRUE);
3697                 return service;
3698         }
3699
3700         service->type = convert_network_type(network);
3701
3702         switch (service->type) {
3703         case CONNMAN_SERVICE_TYPE_UNKNOWN:
3704         case CONNMAN_SERVICE_TYPE_SYSTEM:
3705         case CONNMAN_SERVICE_TYPE_ETHERNET:
3706         case CONNMAN_SERVICE_TYPE_WIMAX:
3707         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
3708         case CONNMAN_SERVICE_TYPE_GPS:
3709         case CONNMAN_SERVICE_TYPE_VPN:
3710                 service->autoconnect = FALSE;
3711                 break;
3712         case CONNMAN_SERVICE_TYPE_WIFI:
3713         case CONNMAN_SERVICE_TYPE_CELLULAR:
3714                 service->autoconnect = TRUE;
3715                 break;
3716         }
3717
3718         service->state = CONNMAN_SERVICE_STATE_IDLE;
3719
3720         update_from_network(service, network);
3721
3722         setup_ipconfig(service, connman_network_get_index(network));
3723
3724         service_register(service);
3725
3726         if (service->favorite == TRUE)
3727                 __connman_service_auto_connect();
3728
3729         return service;
3730 }
3731
3732 void __connman_service_update_from_network(struct connman_network *network)
3733 {
3734         struct connman_service *service;
3735         enum connman_service_mode mode;
3736         connman_uint8_t strength, value;
3737         connman_bool_t roaming;
3738         GSequenceIter *iter;
3739         const char *name;
3740         connman_bool_t stats_enable;
3741
3742         DBG("network %p", network);
3743
3744         service = __connman_service_lookup_from_network(network);
3745         if (service == NULL)
3746                 return;
3747
3748         if (service->network == NULL)
3749                 return;
3750
3751         name = connman_network_get_string(service->network, "Name");
3752         if (g_strcmp0(service->name, name) != 0) {
3753                 g_free(service->name);
3754                 service->name = g_strdup(name);
3755                 connman_dbus_property_changed_basic(service->path,
3756                                 CONNMAN_SERVICE_INTERFACE, "Name",
3757                                 DBUS_TYPE_STRING, &service->name);
3758         }
3759
3760         strength = connman_network_get_uint8(service->network, "Strength");
3761         if (strength == service->strength)
3762                 goto roaming;
3763
3764         service->strength = strength;
3765
3766         strength_changed(service);
3767
3768 roaming:
3769         roaming = connman_network_get_bool(service->network, "Roaming");
3770         if (roaming == service->roaming)
3771                 goto done;
3772
3773         stats_enable = stats_enabled(service);
3774         if (stats_enable == TRUE)
3775                 stats_stop(service);
3776
3777         service->roaming = roaming;
3778
3779         if (stats_enable == TRUE)
3780                 stats_start(service);
3781
3782         roaming_changed(service);
3783
3784         iter = g_hash_table_lookup(service_hash, service->identifier);
3785         if (iter != NULL)
3786                 g_sequence_sort_changed(iter, service_compare, NULL);
3787
3788 done:
3789         if (service->type != CONNMAN_SERVICE_TYPE_CELLULAR)
3790                 return;
3791
3792         value = connman_network_get_uint8(service->network, "Cellular.Mode");
3793         mode = convert_cellular_mode(value);
3794
3795         if (mode == service->mode)
3796                 return;
3797
3798         service->mode = mode;
3799
3800         mode_changed(service);
3801 }
3802
3803 void __connman_service_remove_from_network(struct connman_network *network)
3804 {
3805         struct connman_service *service;
3806
3807         DBG("network %p", network);
3808
3809         service = __connman_service_lookup_from_network(network);
3810         if (service == NULL)
3811                 return;
3812
3813         __connman_service_put(service);
3814 }
3815
3816 /**
3817  * __connman_service_create_from_provider:
3818  * @provider: provider structure
3819  *
3820  * Look up service by provider and if not found, create one
3821  */
3822 struct connman_service *
3823 __connman_service_create_from_provider(struct connman_provider *provider)
3824 {
3825         struct connman_service *service;
3826         const char *ident, *str;
3827         char *name;
3828         int index = connman_provider_get_index(provider);
3829
3830         DBG("provider %p", provider);
3831
3832         ident = __connman_provider_get_ident(provider);
3833         if (ident == NULL)
3834                 return NULL;
3835
3836         name = g_strdup_printf("vpn_%s", ident);
3837         service = service_get(name);
3838         g_free(name);
3839
3840         if (service == NULL)
3841                 return NULL;
3842
3843         service->type = CONNMAN_SERVICE_TYPE_VPN;
3844         service->provider = connman_provider_ref(provider);
3845         service->autoconnect = FALSE;
3846
3847         service->state = CONNMAN_SERVICE_STATE_IDLE;
3848
3849         str = connman_provider_get_string(provider, "Name");
3850         if (str != NULL) {
3851                 g_free(service->name);
3852                 service->name = g_strdup(str);
3853                 service->hidden = FALSE;
3854         } else {
3855                 g_free(service->name);
3856                 service->name = NULL;
3857                 service->hidden = TRUE;
3858         }
3859
3860         service->strength = 0;
3861
3862         service->ipconfig = connman_ipconfig_create(index);
3863         if (service->ipconfig == NULL)
3864                 return service;
3865
3866         connman_ipconfig_set_method(service->ipconfig,
3867                                         CONNMAN_IPCONFIG_METHOD_MANUAL);
3868
3869         connman_ipconfig_set_data(service->ipconfig, service);
3870
3871         connman_ipconfig_set_ops(service->ipconfig, &service_ops);
3872
3873         service_register(service);
3874
3875         return service;
3876 }
3877
3878 static int service_load(struct connman_service *service)
3879 {
3880         const char *ident = service->profile;
3881         GKeyFile *keyfile;
3882         GError *error = NULL;
3883         gchar *pathname, *data = NULL;
3884         gsize length;
3885         gchar *str;
3886         connman_bool_t autoconnect;
3887         unsigned int ssid_len;
3888         int err = 0;
3889
3890         DBG("service %p", service);
3891
3892         if (ident == NULL)
3893                 return -EINVAL;
3894
3895         pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
3896         if (pathname == NULL)
3897                 return -ENOMEM;
3898
3899         keyfile = g_key_file_new();
3900
3901         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
3902                 g_free(pathname);
3903                 return -ENOENT;
3904         }
3905
3906         g_free(pathname);
3907
3908         if (g_key_file_load_from_data(keyfile, data, length,
3909                                                         0, NULL) == FALSE) {
3910                 g_free(data);
3911                 return -EILSEQ;
3912         }
3913
3914         g_free(data);
3915
3916         switch (service->type) {
3917         case CONNMAN_SERVICE_TYPE_UNKNOWN:
3918         case CONNMAN_SERVICE_TYPE_SYSTEM:
3919         case CONNMAN_SERVICE_TYPE_ETHERNET:
3920         case CONNMAN_SERVICE_TYPE_GPS:
3921         case CONNMAN_SERVICE_TYPE_VPN:
3922                 break;
3923         case CONNMAN_SERVICE_TYPE_WIFI:
3924                 if (service->name == NULL) {
3925                         gchar *name;
3926
3927                         name = g_key_file_get_string(keyfile,
3928                                         service->identifier, "Name", NULL);
3929                         if (name != NULL) {
3930                                 g_free(service->name);
3931                                 service->name = name;
3932                         }
3933
3934                         if (service->network != NULL)
3935                                 connman_network_set_name(service->network,
3936                                                                         name);
3937                 }
3938
3939                 if (service->network &&
3940                                 connman_network_get_blob(service->network,
3941                                         "WiFi.SSID", &ssid_len) == NULL) {
3942                         gchar *hex_ssid;
3943
3944                         hex_ssid = g_key_file_get_string(keyfile,
3945                                                         service->identifier,
3946                                                                 "SSID", NULL);
3947
3948                         if (hex_ssid != NULL) {
3949                                 gchar *ssid;
3950                                 unsigned int i, j = 0, hex;
3951                                 size_t hex_ssid_len = strlen(hex_ssid);
3952
3953                                 ssid = g_try_malloc0(hex_ssid_len / 2);
3954                                 if (ssid == NULL) {
3955                                         g_free(hex_ssid);
3956                                         err = -ENOMEM;
3957                                         goto done;
3958                                 }
3959
3960                                 for (i = 0; i < hex_ssid_len; i += 2) {
3961                                         sscanf(hex_ssid + i, "%02x", &hex);
3962                                         ssid[j++] = hex;
3963                                 }
3964
3965                                 connman_network_set_blob(service->network,
3966                                         "WiFi.SSID", ssid, hex_ssid_len / 2);
3967                         }
3968
3969                         g_free(hex_ssid);
3970                 }
3971                 /* fall through */
3972
3973         case CONNMAN_SERVICE_TYPE_WIMAX:
3974         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
3975         case CONNMAN_SERVICE_TYPE_CELLULAR:
3976                 service->apn = g_key_file_get_string(keyfile,
3977                                         service->identifier, "APN", NULL);
3978
3979                 service->username = g_key_file_get_string(keyfile,
3980                                         service->identifier, "Username", NULL);
3981
3982                 service->password = g_key_file_get_string(keyfile,
3983                                         service->identifier, "Password", NULL);
3984
3985                 service->favorite = g_key_file_get_boolean(keyfile,
3986                                 service->identifier, "Favorite", NULL);
3987
3988                 autoconnect = g_key_file_get_boolean(keyfile,
3989                                 service->identifier, "AutoConnect", &error);
3990                 if (error == NULL)
3991                         service->autoconnect = autoconnect;
3992                 g_clear_error(&error);
3993
3994                 str = g_key_file_get_string(keyfile,
3995                                 service->identifier, "Failure", NULL);
3996                 if (str != NULL) {
3997                         service->state = CONNMAN_SERVICE_STATE_FAILURE;
3998                         service->error = string2error(str);
3999                 }
4000                 break;
4001         }
4002
4003         str = g_key_file_get_string(keyfile,
4004                                 service->identifier, "Modified", NULL);
4005         if (str != NULL) {
4006                 g_time_val_from_iso8601(str, &service->modified);
4007                 g_free(str);
4008         }
4009
4010         str = g_key_file_get_string(keyfile,
4011                                 service->identifier, "Passphrase", NULL);
4012         if (str != NULL) {
4013                 g_free(service->passphrase);
4014                 service->passphrase = str;
4015         }
4016
4017         if (service->ipconfig != NULL) {
4018                 struct connman_ipconfig *ipv6config;
4019
4020                 ipv6config = connman_ipconfig_get_ipv6config(
4021                                                 service->ipconfig);
4022                 if (ipv6config != NULL)
4023                         __connman_ipconfig_load(ipv6config, keyfile,
4024                                         service->identifier, "IPv6.");
4025
4026                 __connman_ipconfig_load(service->ipconfig, keyfile,
4027                                         service->identifier, "IPv4.");
4028         }
4029
4030         service->nameservers = g_key_file_get_string_list(keyfile,
4031                         service->identifier, "Nameservers", &length, NULL);
4032         if (service->nameservers != NULL && length == 0) {
4033                 g_strfreev(service->nameservers);
4034                 service->nameservers = NULL;
4035         }
4036
4037         service->domains = g_key_file_get_string_list(keyfile,
4038                         service->identifier, "Domains", &length, NULL);
4039         if (service->domains != NULL && length == 0) {
4040                 g_strfreev(service->domains);
4041                 service->domains = NULL;
4042         }
4043
4044         stats_load(service, keyfile);
4045 done:
4046         g_key_file_free(keyfile);
4047
4048         return err;
4049 }
4050
4051 static int service_save(struct connman_service *service)
4052 {
4053         const char *ident = service->profile;
4054         GKeyFile *keyfile;
4055         gchar *pathname, *data = NULL;
4056         gsize length;
4057         gchar *str;
4058         int err = 0;
4059
4060         DBG("service %p", service);
4061
4062         if (ident == NULL)
4063                 return -EINVAL;
4064
4065         pathname = g_strdup_printf("%s/%s.profile", STORAGEDIR, ident);
4066         if (pathname == NULL)
4067                 return -ENOMEM;
4068
4069         keyfile = g_key_file_new();
4070
4071         if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
4072                 goto update;
4073
4074         if (length > 0) {
4075                 if (g_key_file_load_from_data(keyfile, data, length,
4076                                                         0, NULL) == FALSE)
4077                         goto done;
4078         }
4079
4080         g_free(data);
4081
4082 update:
4083         if (service->name != NULL)
4084                 g_key_file_set_string(keyfile, service->identifier,
4085                                                 "Name", service->name);
4086
4087         switch (service->type) {
4088         case CONNMAN_SERVICE_TYPE_UNKNOWN:
4089         case CONNMAN_SERVICE_TYPE_SYSTEM:
4090         case CONNMAN_SERVICE_TYPE_ETHERNET:
4091         case CONNMAN_SERVICE_TYPE_GPS:
4092         case CONNMAN_SERVICE_TYPE_VPN:
4093                 break;
4094         case CONNMAN_SERVICE_TYPE_WIFI:
4095                 if (service->network) {
4096                         const unsigned char *ssid;
4097                         unsigned int ssid_len = 0;
4098
4099                         ssid = connman_network_get_blob(service->network,
4100                                                         "WiFi.SSID", &ssid_len);
4101
4102                         if (ssid != NULL && ssid_len > 0 && ssid[0] != '\0') {
4103                                 char *identifier = service->identifier;
4104                                 GString *str;
4105                                 unsigned int i;
4106
4107                                 str = g_string_sized_new(ssid_len * 2);
4108                                 if (str == NULL) {
4109                                         err = -ENOMEM;
4110                                         goto done;
4111                                 }
4112
4113                                 for (i = 0; i < ssid_len; i++)
4114                                         g_string_append_printf(str,
4115                                                         "%02x", ssid[i]);
4116
4117                                 g_key_file_set_string(keyfile, identifier,
4118                                                         "SSID", str->str);
4119
4120                                 g_string_free(str, TRUE);
4121                         }
4122                 }
4123                 /* fall through */
4124
4125         case CONNMAN_SERVICE_TYPE_WIMAX:
4126         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
4127         case CONNMAN_SERVICE_TYPE_CELLULAR:
4128                 if (service->apn != NULL)
4129                         g_key_file_set_string(keyfile, service->identifier,
4130                                                         "APN", service->apn);
4131
4132                 if (service->username != NULL)
4133                         g_key_file_set_string(keyfile, service->identifier,
4134                                                 "Username", service->username);
4135
4136                 if (service->password != NULL)
4137                         g_key_file_set_string(keyfile, service->identifier,
4138                                                 "Password", service->password);
4139
4140                 g_key_file_set_boolean(keyfile, service->identifier,
4141                                         "Favorite", service->favorite);
4142
4143                 if (service->favorite == TRUE)
4144                         g_key_file_set_boolean(keyfile, service->identifier,
4145                                         "AutoConnect", service->autoconnect);
4146
4147                 if (service->state == CONNMAN_SERVICE_STATE_FAILURE) {
4148                         const char *failure = error2string(service->error);
4149                         if (failure != NULL)
4150                                 g_key_file_set_string(keyfile,
4151                                                         service->identifier,
4152                                                         "Failure", failure);
4153                 } else {
4154                         g_key_file_remove_key(keyfile, service->identifier,
4155                                                         "Failure", NULL);
4156                 }
4157                 break;
4158         }
4159
4160         str = g_time_val_to_iso8601(&service->modified);
4161         if (str != NULL) {
4162                 g_key_file_set_string(keyfile, service->identifier,
4163                                                         "Modified", str);
4164                 g_free(str);
4165         }
4166
4167         if (service->passphrase != NULL && strlen(service->passphrase) > 0)
4168                 g_key_file_set_string(keyfile, service->identifier,
4169                                         "Passphrase", service->passphrase);
4170         else
4171                 g_key_file_remove_key(keyfile, service->identifier,
4172                                                         "Passphrase", NULL);
4173
4174         if (service->ipconfig != NULL) {
4175                 struct connman_ipconfig *ipv6config;
4176
4177                 ipv6config = connman_ipconfig_get_ipv6config(service->ipconfig);
4178                 if (ipv6config != NULL)
4179                         __connman_ipconfig_save(ipv6config, keyfile,
4180                                                 service->identifier, "IPv6.");
4181
4182                 __connman_ipconfig_save(service->ipconfig, keyfile,
4183                                         service->identifier, "IPv4.");
4184         }
4185
4186         if (service->nameservers != NULL) {
4187                 guint len = g_strv_length(service->nameservers);
4188
4189                 g_key_file_set_string_list(keyfile, service->identifier,
4190                                                                 "Nameservers",
4191                                 (const gchar **) service->nameservers, len);
4192         } else
4193                 g_key_file_remove_key(keyfile, service->identifier,
4194                                                         "Nameservers", NULL);
4195
4196         if (service->domains != NULL) {
4197                 guint len = g_strv_length(service->domains);
4198
4199                 g_key_file_set_string_list(keyfile, service->identifier,
4200                                                                 "Domains",
4201                                 (const gchar **) service->domains, len);
4202         } else
4203                 g_key_file_remove_key(keyfile, service->identifier,
4204                                                         "Domains", NULL);
4205
4206         stats_save(service, keyfile);
4207
4208         data = g_key_file_to_data(keyfile, &length, NULL);
4209
4210         if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
4211                 connman_error("Failed to store service information");
4212
4213 done:
4214         g_free(data);
4215
4216         g_key_file_free(keyfile);
4217
4218         g_free(pathname);
4219
4220         return err;
4221 }
4222
4223 static struct connman_storage service_storage = {
4224         .name           = "service",
4225         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
4226         .service_load   = service_load,
4227         .service_save   = service_save,
4228 };
4229
4230 int __connman_service_init(void)
4231 {
4232         DBG("");
4233
4234         connection = connman_dbus_get_connection();
4235
4236         if (connman_storage_register(&service_storage) < 0)
4237                 connman_error("Failed to register service storage");
4238
4239         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
4240                                                                 NULL, NULL);
4241
4242         service_list = g_sequence_new(service_free);
4243
4244         return 0;
4245 }
4246
4247 void __connman_service_cleanup(void)
4248 {
4249         DBG("");
4250
4251         g_sequence_free(service_list);
4252         service_list = NULL;
4253
4254         g_hash_table_destroy(service_hash);
4255         service_hash = NULL;
4256
4257         g_slist_free(counter_list);
4258         counter_list = NULL;
4259
4260         connman_storage_unregister(&service_storage);
4261
4262         dbus_connection_unref(connection);
4263 }