src/session.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
   6  *  Copyright (C) 2011  BWM CarIT GmbH. All rights reserved.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2 as
  10  *  published by the Free Software Foundation.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <errno.h>
  28
  29 #include <gdbus.h>
  30
  31 #include <connman/session.h>
  32
  33 #include "connman.h"
  34
  35 static DBusConnection *connection;
  36 static GHashTable *session_hash;
  37 static connman_bool_t sessionmode;
  38 static struct connman_session *ecall_session;
  39 static GSList *policy_list;
  40
  41 enum connman_session_trigger {
  42         CONNMAN_SESSION_TRIGGER_UNKNOWN         = 0,
  43         CONNMAN_SESSION_TRIGGER_SETTING         = 1,
  44         CONNMAN_SESSION_TRIGGER_CONNECT         = 2,
  45         CONNMAN_SESSION_TRIGGER_DISCONNECT      = 3,
  46         CONNMAN_SESSION_TRIGGER_SERVICE         = 4,
  47         CONNMAN_SESSION_TRIGGER_ECALL           = 5,
  48 };
  49
  50 enum connman_session_reason {
  51         CONNMAN_SESSION_REASON_UNKNOWN          = 0,
  52         CONNMAN_SESSION_REASON_CONNECT          = 1,
  53         CONNMAN_SESSION_REASON_FREE_RIDE        = 2,
  54 };
  55
  56 enum connman_session_state {
  57         CONNMAN_SESSION_STATE_DISCONNECTED   = 0,
  58         CONNMAN_SESSION_STATE_CONNECTED      = 1,
  59         CONNMAN_SESSION_STATE_ONLINE         = 2,
  60 };
  61
  62 struct service_entry {
  63         /* track why this service was selected */
  64         enum connman_session_reason reason;
  65         enum connman_service_state state;
  66         const char *name;
  67         struct connman_service *service;
  68         char *ifname;
  69         const char *bearer;
  70         GSList *pending_timeouts;
  71 };
  72
  73 struct session_info {
  74         struct connman_session_config config;
  75         enum connman_session_state state;
  76         struct service_entry *entry;
  77         enum connman_session_reason reason;
  78 };
  79
  80 struct connman_session {
  81         char *owner;
  82         char *session_path;
  83         char *notify_path;
  84         guint notify_watch;
  85
  86         struct connman_session_policy *policy;
  87
  88         connman_bool_t append_all;
  89         struct session_info *info;
  90         struct session_info *info_last;
  91         struct connman_session_config *policy_config;
  92
  93         connman_bool_t ecall;
  94
  95         GSequence *service_list;
  96         GHashTable *service_hash;
  97 };
  98
  99 static const char *trigger2string(enum connman_session_trigger trigger)
 100 {
 101         switch (trigger) {
 102         case CONNMAN_SESSION_TRIGGER_UNKNOWN:
 103                 break;
 104         case CONNMAN_SESSION_TRIGGER_SETTING:
 105                 return "setting";
 106         case CONNMAN_SESSION_TRIGGER_CONNECT:
 107                 return "connect";
 108         case CONNMAN_SESSION_TRIGGER_DISCONNECT:
 109                 return "disconnect";
 110         case CONNMAN_SESSION_TRIGGER_SERVICE:
 111                 return "service";
 112         case CONNMAN_SESSION_TRIGGER_ECALL:
 113                 return "ecall";
 114         }
 115
 116         return NULL;
 117 }
 118
 119 static const char *reason2string(enum connman_session_reason reason)
 120 {
 121         switch (reason) {
 122         case CONNMAN_SESSION_REASON_UNKNOWN:
 123                 return "unknown";
 124         case CONNMAN_SESSION_REASON_CONNECT:
 125                 return "connect";
 126         case CONNMAN_SESSION_REASON_FREE_RIDE:
 127                 return "free-ride";
 128         }
 129
 130         return NULL;
 131 }
 132
 133 static const char *state2string(enum connman_session_state state)
 134 {
 135         switch (state) {
 136         case CONNMAN_SESSION_STATE_DISCONNECTED:
 137                 return "disconnected";
 138         case CONNMAN_SESSION_STATE_CONNECTED:
 139                 return "connected";
 140         case CONNMAN_SESSION_STATE_ONLINE:
 141                 return "online";
 142         }
 143
 144         return NULL;
 145 }
 146
 147 static const char *type2string(enum connman_session_type type)
 148 {
 149         switch (type) {
 150         case CONNMAN_SESSION_TYPE_UNKNOWN:
 151                 return "";
 152         case CONNMAN_SESSION_TYPE_ANY:
 153                 return "any";
 154         case CONNMAN_SESSION_TYPE_LOCAL:
 155                 return "local";
 156         case CONNMAN_SESSION_TYPE_INTERNET:
 157                 return "internet";
 158         }
 159
 160         return NULL;
 161 }
 162
 163 static enum connman_session_type string2type(const char *type)
 164 {
 165         if (g_strcmp0(type, "any") == 0)
 166                 return CONNMAN_SESSION_TYPE_ANY;
 167         if (g_strcmp0(type, "local") == 0)
 168                 return CONNMAN_SESSION_TYPE_LOCAL;
 169         else if (g_strcmp0(type, "internet") == 0)
 170                 return CONNMAN_SESSION_TYPE_INTERNET;
 171
 172         return CONNMAN_SESSION_TYPE_UNKNOWN;
 173 }
 174
 175 static enum connman_service_type bearer2service(const char *bearer)
 176 {
 177         if (bearer == NULL)
 178                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
 179
 180         if (g_strcmp0(bearer, "ethernet") == 0)
 181                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 182         else if (g_strcmp0(bearer, "wifi") == 0)
 183                 return CONNMAN_SERVICE_TYPE_WIFI;
 184         else if (g_strcmp0(bearer, "wimax") == 0)
 185                 return CONNMAN_SERVICE_TYPE_WIMAX;
 186         else if (g_strcmp0(bearer, "bluetooth") == 0)
 187                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
 188         else if (g_strcmp0(bearer, "cellular") == 0)
 189                 return CONNMAN_SERVICE_TYPE_CELLULAR;
 190         else if (g_strcmp0(bearer, "vpn") == 0)
 191                 return CONNMAN_SERVICE_TYPE_VPN;
 192         else
 193                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
 194 }
 195
 196 static char *service2bearer(enum connman_service_type type)
 197 {
 198         switch (type) {
 199         case CONNMAN_SERVICE_TYPE_ETHERNET:
 200                 return "ethernet";
 201         case CONNMAN_SERVICE_TYPE_WIFI:
 202                 return "wifi";
 203         case CONNMAN_SERVICE_TYPE_WIMAX:
 204                 return "wimax";
 205         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 206                 return "bluetooth";
 207         case CONNMAN_SERVICE_TYPE_CELLULAR:
 208                 return "cellular";
 209         case CONNMAN_SERVICE_TYPE_VPN:
 210                 return "vpn";
 211         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 212         case CONNMAN_SERVICE_TYPE_SYSTEM:
 213         case CONNMAN_SERVICE_TYPE_GPS:
 214         case CONNMAN_SERVICE_TYPE_GADGET:
 215                 return "";
 216         }
 217
 218         return "";
 219 }
 220
 221 static int assign_policy_plugin(struct connman_session *session)
 222 {
 223         GSList *list;
 224         struct connman_session_policy *policy;
 225
 226         if (session->policy != NULL)
 227                 return -EALREADY;
 228
 229         for (list = policy_list; list != NULL; list = list->next) {
 230                 policy = list->data;
 231
 232                 session->policy = policy;
 233                 break;
 234         }
 235
 236         return 0;
 237 }
 238
 239 static int create_policy_config(struct connman_session *session)
 240 {
 241         struct connman_session_config *config;
 242
 243         config = (*session->policy->create)(session);
 244         if (config == NULL)
 245                 return -ENOMEM;
 246
 247         session->policy_config = config;
 248
 249         return 0;
 250 }
 251
 252 static void destroy_policy_config(struct connman_session *session)
 253 {
 254         (*session->policy->destroy)(session);
 255 }
 256
 257 static void probe_policy(struct connman_session_policy *policy)
 258 {
 259
 260         GHashTableIter iter;
 261         gpointer key, value;
 262         struct connman_session *session;
 263
 264         DBG("policy %p name %s", policy, policy->name);
 265
 266         g_hash_table_iter_init(&iter, session_hash);
 267
 268         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 269                 session = value;
 270
 271                 if (session->policy != NULL)
 272                         continue;
 273
 274                 assign_policy_plugin(session);
 275         }
 276 }
 277
 278 static void remove_policy(struct connman_session_policy *policy)
 279 {
 280         GHashTableIter iter;
 281         gpointer key, value;
 282         struct connman_session *session;
 283
 284         DBG("policy %p name %s", policy, policy->name);
 285
 286         g_hash_table_iter_init(&iter, session_hash);
 287
 288         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 289                 session = value;
 290
 291                 if (session->policy != policy)
 292                         continue;
 293
 294                 session->policy = NULL;
 295                 assign_policy_plugin(session);
 296         }
 297 }
 298
 299 static gint compare_priority(gconstpointer a, gconstpointer b)
 300 {
 301         const struct connman_session_policy *policy1 = a;
 302         const struct connman_session_policy *policy2 = b;
 303
 304         return policy2->priority - policy1->priority;
 305 }
 306
 307
 308 int connman_session_policy_register(struct connman_session_policy *policy)
 309 {
 310         DBG("name %s", policy->name);
 311
 312         policy_list = g_slist_insert_sorted(policy_list, policy,
 313                                                 compare_priority);
 314
 315         probe_policy(policy);
 316
 317         return 0;
 318 }
 319
 320 void connman_session_policy_unregister(struct connman_session_policy *policy)
 321 {
 322         DBG("name %s", policy->name);
 323
 324         policy_list = g_slist_remove(policy_list, policy);
 325
 326         remove_policy(policy);
 327 }
 328
 329 static enum connman_session_type apply_policy_on_type(
 330                         enum connman_session_type policy,
 331                         enum connman_session_type type)
 332 {
 333         if (type == CONNMAN_SESSION_TYPE_UNKNOWN)
 334                 return CONNMAN_SESSION_TYPE_UNKNOWN;
 335
 336         if (policy == CONNMAN_SESSION_TYPE_ANY)
 337                 return type;
 338
 339         if (policy == CONNMAN_SESSION_TYPE_LOCAL)
 340                 return CONNMAN_SESSION_TYPE_LOCAL;
 341
 342         return CONNMAN_SESSION_TYPE_INTERNET;
 343 }
 344
 345 static void cleanup_bearer(gpointer data)
 346 {
 347         struct connman_session_bearer *bearer = data;
 348
 349         g_free(bearer->name);
 350         g_free(bearer);
 351 }
 352
 353 void connman_session_free_bearers(GSList *bearers)
 354 {
 355         g_slist_free_full(bearers, cleanup_bearer);
 356 }
 357
 358 static int session_parse_allowed_bearers(DBusMessageIter *iter, GSList **list)
 359 {
 360         struct connman_session_bearer *bearer;
 361         DBusMessageIter array;
 362
 363         dbus_message_iter_recurse(iter, &array);
 364
 365         *list = NULL;
 366
 367         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
 368                 char *bearer_name = NULL;
 369
 370                 dbus_message_iter_get_basic(&array, &bearer_name);
 371
 372                 bearer = g_try_new0(struct connman_session_bearer, 1);
 373                 if (bearer == NULL) {
 374                         connman_session_free_bearers(*list);
 375                         *list = NULL;
 376                         return -ENOMEM;
 377                 }
 378
 379                 bearer->name = g_strdup(bearer_name);
 380                 bearer->service_type = bearer2service(bearer->name);
 381
 382                 if (bearer->service_type == CONNMAN_SERVICE_TYPE_UNKNOWN &&
 383                                 g_strcmp0(bearer->name, "*") == 0) {
 384                         bearer->match_all = TRUE;
 385                 } else {
 386                         bearer->match_all = FALSE;
 387                 }
 388
 389                 *list = g_slist_append(*list, bearer);
 390
 391                 dbus_message_iter_next(&array);
 392         }
 393
 394         return 0;
 395 }
 396
 397 GSList *connman_session_allowed_bearers_any(void)
 398 {
 399         struct connman_session_bearer *bearer;
 400         GSList *list = NULL;
 401
 402         bearer = g_try_new0(struct connman_session_bearer, 1);
 403         if (bearer == NULL)
 404                 return NULL;
 405
 406         bearer->name = g_strdup("");
 407         bearer->match_all = TRUE;
 408         bearer->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
 409
 410         list = g_slist_append(list, bearer);
 411
 412         return list;
 413 }
 414
 415 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
 416 {
 417         struct session_info *info = user_data;
 418         GSList *list;
 419
 420         for (list = info->config.allowed_bearers;
 421                         list != NULL; list = list->next) {
 422                 struct connman_session_bearer *bearer = list->data;
 423
 424                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
 425                                                 &bearer->name);
 426         }
 427 }
 428
 429 static void append_ipconfig_ipv4(DBusMessageIter *iter, void *user_data)
 430 {
 431         struct connman_service *service = user_data;
 432         struct connman_ipconfig *ipconfig_ipv4;
 433
 434         if (service == NULL)
 435                 return;
 436
 437         if (__connman_service_is_connected_state(service,
 438                                 CONNMAN_IPCONFIG_TYPE_IPV4) == FALSE) {
 439                 return;
 440         }
 441
 442         ipconfig_ipv4 = __connman_service_get_ip4config(service);
 443         if (ipconfig_ipv4 == NULL)
 444                 return;
 445
 446         __connman_ipconfig_append_ipv4(ipconfig_ipv4, iter);
 447 }
 448
 449 static void append_ipconfig_ipv6(DBusMessageIter *iter, void *user_data)
 450 {
 451         struct connman_service *service = user_data;
 452         struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
 453
 454         if (service == NULL)
 455                 return;
 456
 457         if (__connman_service_is_connected_state(service,
 458                                 CONNMAN_IPCONFIG_TYPE_IPV6) == FALSE) {
 459                 return;
 460         }
 461
 462         ipconfig_ipv4 = __connman_service_get_ip4config(service);
 463         ipconfig_ipv6 = __connman_service_get_ip6config(service);
 464         if (ipconfig_ipv6 == NULL)
 465                 return;
 466
 467         __connman_ipconfig_append_ipv6(ipconfig_ipv6, iter, ipconfig_ipv4);
 468 }
 469
 470 static void append_notify(DBusMessageIter *dict,
 471                                         struct connman_session *session)
 472 {
 473         struct session_info *info = session->info;
 474         struct session_info *info_last = session->info_last;
 475         struct connman_service *service;
 476         const char *name, *ifname, *bearer;
 477
 478         if (session->append_all == TRUE ||
 479                         info->state != info_last->state) {
 480                 const char *state = state2string(info->state);
 481
 482                 connman_dbus_dict_append_basic(dict, "State",
 483                                                 DBUS_TYPE_STRING,
 484                                                 &state);
 485                 info_last->state = info->state;
 486         }
 487
 488         if (session->append_all == TRUE ||
 489                         info->entry != info_last->entry) {
 490                 if (info->entry == NULL) {
 491                         name = "";
 492                         ifname = "";
 493                         service = NULL;
 494                         bearer = "";
 495                 } else {
 496                         name = info->entry->name;
 497                         ifname = info->entry->ifname;
 498                         service = info->entry->service;
 499                         bearer = info->entry->bearer;
 500                 }
 501
 502                 connman_dbus_dict_append_basic(dict, "Name",
 503                                                 DBUS_TYPE_STRING,
 504                                                 &name);
 505
 506                 connman_dbus_dict_append_dict(dict, "IPv4",
 507                                                 append_ipconfig_ipv4,
 508                                                 service);
 509
 510                 connman_dbus_dict_append_dict(dict, "IPv6",
 511                                                 append_ipconfig_ipv6,
 512                                                 service);
 513
 514                 connman_dbus_dict_append_basic(dict, "Interface",
 515                                                 DBUS_TYPE_STRING,
 516                                                 &ifname);
 517
 518                 connman_dbus_dict_append_basic(dict, "Bearer",
 519                                                 DBUS_TYPE_STRING,
 520                                                 &bearer);
 521
 522                 info_last->entry = info->entry;
 523         }
 524
 525         if (session->append_all == TRUE ||
 526                         info->config.type != info_last->config.type) {
 527                 const char *type = type2string(info->config.type);
 528
 529                 connman_dbus_dict_append_basic(dict, "ConnectionType",
 530                                                 DBUS_TYPE_STRING,
 531                                                 &type);
 532                 info_last->config.type = info->config.type;
 533         }
 534
 535         if (session->append_all == TRUE ||
 536                         info->config.allowed_bearers != info_last->config.allowed_bearers) {
 537                 connman_dbus_dict_append_array(dict, "AllowedBearers",
 538                                                 DBUS_TYPE_STRING,
 539                                                 append_allowed_bearers,
 540                                                 info);
 541                 info_last->config.allowed_bearers = info->config.allowed_bearers;
 542         }
 543
 544         session->append_all = FALSE;
 545 }
 546
 547 static connman_bool_t is_type_matching_state(enum connman_session_state *state,
 548                                                 enum connman_session_type type)
 549 {
 550         switch (type) {
 551         case CONNMAN_SESSION_TYPE_UNKNOWN:
 552                 return FALSE;
 553         case CONNMAN_SESSION_TYPE_ANY:
 554                 return TRUE;
 555         case CONNMAN_SESSION_TYPE_LOCAL:
 556                 if (*state >= CONNMAN_SESSION_STATE_CONNECTED) {
 557                         *state = CONNMAN_SESSION_STATE_CONNECTED;
 558                         return TRUE;
 559                 }
 560
 561                 break;
 562         case CONNMAN_SESSION_TYPE_INTERNET:
 563                 if (*state == CONNMAN_SESSION_STATE_ONLINE)
 564                         return TRUE;
 565                 break;
 566         }
 567
 568         return FALSE;
 569 }
 570
 571 static connman_bool_t compute_notifiable_changes(struct connman_session *session)
 572 {
 573         struct session_info *info_last = session->info_last;
 574         struct session_info *info = session->info;
 575
 576         if (session->append_all == TRUE)
 577                 return TRUE;
 578
 579         if (info->state != info_last->state)
 580                 return TRUE;
 581
 582         if (info->entry != info_last->entry &&
 583                         info->state >= CONNMAN_SESSION_STATE_CONNECTED)
 584                 return TRUE;
 585
 586         if (info->config.allowed_bearers != info_last->config.allowed_bearers ||
 587                         info->config.type != info_last->config.type)
 588                 return TRUE;
 589
 590         return FALSE;
 591 }
 592
 593 static gboolean session_notify(gpointer user_data)
 594 {
 595         struct connman_session *session = user_data;
 596         DBusMessage *msg;
 597         DBusMessageIter array, dict;
 598
 599         if (compute_notifiable_changes(session) == FALSE)
 600                 return FALSE;
 601
 602         DBG("session %p owner %s notify_path %s", session,
 603                 session->owner, session->notify_path);
 604
 605         msg = dbus_message_new_method_call(session->owner, session->notify_path,
 606                                                 CONNMAN_NOTIFICATION_INTERFACE,
 607                                                 "Update");
 608         if (msg == NULL)
 609                 return FALSE;
 610
 611         dbus_message_iter_init_append(msg, &array);
 612         connman_dbus_dict_open(&array, &dict);
 613
 614         append_notify(&dict, session);
 615
 616         connman_dbus_dict_close(&array, &dict);
 617
 618         g_dbus_send_message(connection, msg);
 619
 620         return FALSE;
 621 }
 622
 623 static void ipconfig_ipv4_changed(struct connman_session *session)
 624 {
 625         struct session_info *info = session->info;
 626
 627         connman_dbus_setting_changed_dict(session->owner, session->notify_path,
 628                                                 "IPv4", append_ipconfig_ipv4,
 629                                                 info->entry->service);
 630 }
 631
 632 static void ipconfig_ipv6_changed(struct connman_session *session)
 633 {
 634         struct session_info *info = session->info;
 635
 636         connman_dbus_setting_changed_dict(session->owner, session->notify_path,
 637                                                 "IPv6", append_ipconfig_ipv6,
 638                                                 info->entry->service);
 639 }
 640
 641 static connman_bool_t service_type_match(struct connman_session *session,
 642                                         struct connman_service *service)
 643 {
 644         struct session_info *info = session->info;
 645         GSList *list;
 646
 647         for (list = info->config.allowed_bearers;
 648                         list != NULL; list = list->next) {
 649                 struct connman_session_bearer *bearer = list->data;
 650                 enum connman_service_type service_type;
 651
 652                 if (bearer->match_all == TRUE)
 653                         return TRUE;
 654
 655                 service_type = connman_service_get_type(service);
 656                 if (bearer->service_type == service_type)
 657                         return TRUE;
 658         }
 659
 660         return FALSE;
 661 }
 662
 663 static connman_bool_t service_match(struct connman_session *session,
 664                                         struct connman_service *service)
 665 {
 666         if (service_type_match(session, service) == FALSE)
 667                 return FALSE;
 668
 669         return TRUE;
 670 }
 671
 672 static int service_type_weight(enum connman_service_type type)
 673 {
 674         /*
 675          * The session doesn't care which service
 676          * to use. Nevertheless we have to sort them
 677          * according their type. The ordering is
 678          *
 679          * 1. Ethernet
 680          * 2. Bluetooth
 681          * 3. WiFi/WiMAX
 682          * 4. Cellular
 683          */
 684
 685         switch (type) {
 686         case CONNMAN_SERVICE_TYPE_ETHERNET:
 687                 return 4;
 688         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 689                 return 3;
 690         case CONNMAN_SERVICE_TYPE_WIFI:
 691         case CONNMAN_SERVICE_TYPE_WIMAX:
 692                 return 2;
 693         case CONNMAN_SERVICE_TYPE_CELLULAR:
 694                 return 1;
 695         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 696         case CONNMAN_SERVICE_TYPE_SYSTEM:
 697         case CONNMAN_SERVICE_TYPE_GPS:
 698         case CONNMAN_SERVICE_TYPE_VPN:
 699         case CONNMAN_SERVICE_TYPE_GADGET:
 700                 break;
 701         }
 702
 703         return 0;
 704 }
 705
 706 static gint sort_allowed_bearers(struct connman_service *service_a,
 707                                         struct connman_service *service_b,
 708                                         struct connman_session *session)
 709 {
 710         struct session_info *info = session->info;
 711         GSList *list;
 712         enum connman_service_type type_a, type_b;
 713         int weight_a, weight_b;
 714
 715         type_a = connman_service_get_type(service_a);
 716         type_b = connman_service_get_type(service_b);
 717
 718         for (list = info->config.allowed_bearers;
 719                         list != NULL; list = list->next) {
 720                 struct connman_session_bearer *bearer = list->data;
 721
 722                 if (bearer->match_all == TRUE) {
 723                         if (type_a != type_b) {
 724                                 weight_a = service_type_weight(type_a);
 725                                 weight_b = service_type_weight(type_b);
 726
 727                                 if (weight_a > weight_b)
 728                                         return -1;
 729
 730                                 if (weight_a < weight_b)
 731                                         return 1;
 732
 733                                 return 0;
 734                         }
 735                 }
 736
 737                 if (type_a == bearer->service_type &&
 738                                 type_b == bearer->service_type) {
 739                         return 0;
 740                 }
 741
 742                 if (type_a == bearer->service_type &&
 743                                 type_b != bearer->service_type) {
 744                         return -1;
 745                 }
 746
 747                 if (type_a != bearer->service_type &&
 748                                 type_b == bearer->service_type) {
 749                         return 1;
 750                 }
 751         }
 752
 753         return 0;
 754 }
 755
 756 static gint sort_services(gconstpointer a, gconstpointer b, gpointer user_data)
 757 {
 758         struct service_entry *entry_a = (void *)a;
 759         struct service_entry *entry_b = (void *)b;
 760         struct connman_session *session = user_data;
 761
 762         return sort_allowed_bearers(entry_a->service, entry_b->service,
 763                                 session);
 764 }
 765
 766 static void cleanup_session(gpointer user_data)
 767 {
 768         struct connman_session *session = user_data;
 769         struct session_info *info = session->info;
 770
 771         DBG("remove %s", session->session_path);
 772
 773         g_hash_table_destroy(session->service_hash);
 774         g_sequence_free(session->service_list);
 775
 776         if (info->entry != NULL &&
 777                         info->entry->reason == CONNMAN_SESSION_REASON_CONNECT) {
 778                 __connman_service_disconnect(info->entry->service);
 779         }
 780
 781         destroy_policy_config(session);
 782         connman_session_free_bearers(session->info->config.allowed_bearers);
 783         g_free(session->owner);
 784         g_free(session->session_path);
 785         g_free(session->notify_path);
 786         g_free(session->info);
 787         g_free(session->info_last);
 788
 789         g_free(session);
 790 }
 791
 792 static enum connman_session_state service_to_session_state(enum connman_service_state state)
 793 {
 794         switch (state) {
 795         case CONNMAN_SERVICE_STATE_UNKNOWN:
 796         case CONNMAN_SERVICE_STATE_IDLE:
 797         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 798         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 799         case CONNMAN_SERVICE_STATE_DISCONNECT:
 800         case CONNMAN_SERVICE_STATE_FAILURE:
 801                 break;
 802         case CONNMAN_SERVICE_STATE_READY:
 803                 return CONNMAN_SESSION_STATE_CONNECTED;
 804         case CONNMAN_SERVICE_STATE_ONLINE:
 805                 return CONNMAN_SESSION_STATE_ONLINE;
 806         }
 807
 808         return CONNMAN_SESSION_STATE_DISCONNECTED;
 809 }
 810
 811 static connman_bool_t is_connected(enum connman_service_state state)
 812 {
 813         switch (state) {
 814         case CONNMAN_SERVICE_STATE_UNKNOWN:
 815         case CONNMAN_SERVICE_STATE_IDLE:
 816         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 817         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 818         case CONNMAN_SERVICE_STATE_DISCONNECT:
 819         case CONNMAN_SERVICE_STATE_FAILURE:
 820                 break;
 821         case CONNMAN_SERVICE_STATE_READY:
 822         case CONNMAN_SERVICE_STATE_ONLINE:
 823                 return TRUE;
 824         }
 825
 826         return FALSE;
 827 }
 828
 829 static connman_bool_t is_connecting(enum connman_service_state state)
 830 {
 831         switch (state) {
 832         case CONNMAN_SERVICE_STATE_UNKNOWN:
 833         case CONNMAN_SERVICE_STATE_IDLE:
 834                 break;
 835         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 836         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 837                 return TRUE;
 838         case CONNMAN_SERVICE_STATE_DISCONNECT:
 839         case CONNMAN_SERVICE_STATE_FAILURE:
 840         case CONNMAN_SERVICE_STATE_READY:
 841         case CONNMAN_SERVICE_STATE_ONLINE:
 842                 break;
 843         }
 844
 845         return FALSE;
 846 }
 847
 848 static connman_bool_t explicit_connect(enum connman_session_reason reason)
 849 {
 850         switch (reason) {
 851         case CONNMAN_SESSION_REASON_UNKNOWN:
 852         case CONNMAN_SESSION_REASON_FREE_RIDE:
 853                 break;
 854         case CONNMAN_SESSION_REASON_CONNECT:
 855                 return TRUE;
 856         }
 857
 858         return FALSE;
 859 }
 860
 861 static connman_bool_t explicit_disconnect(struct session_info *info)
 862 {
 863         if (info->entry == NULL)
 864                 return FALSE;
 865
 866         DBG("reason %s service %p state %d",
 867                 reason2string(info->entry->reason),
 868                 info->entry->service, info->entry->state);
 869
 870         if (info->entry->reason == CONNMAN_SESSION_REASON_UNKNOWN)
 871                 return FALSE;
 872
 873         if (explicit_connect(info->entry->reason) == FALSE)
 874                 return FALSE;
 875
 876         if (__connman_service_session_dec(info->entry->service) == FALSE)
 877                 return FALSE;
 878
 879         return TRUE;
 880 }
 881
 882 struct pending_data {
 883         unsigned int timeout;
 884         struct service_entry *entry;
 885         gboolean (*cb)(gpointer);
 886 };
 887
 888 static void pending_timeout_free(gpointer data, gpointer user_data)
 889 {
 890         struct pending_data *pending = data;
 891
 892         DBG("pending %p timeout %d", pending, pending->timeout);
 893         g_source_remove(pending->timeout);
 894         g_free(pending);
 895 }
 896
 897 static void pending_timeout_remove_all(struct service_entry *entry)
 898 {
 899         DBG("");
 900
 901         g_slist_foreach(entry->pending_timeouts, pending_timeout_free, NULL);
 902         g_slist_free(entry->pending_timeouts);
 903         entry->pending_timeouts = NULL;
 904 }
 905
 906 static gboolean pending_timeout_cb(gpointer data)
 907 {
 908         struct pending_data *pending = data;
 909         struct service_entry *entry = pending->entry;
 910         gboolean ret;
 911
 912         DBG("pending %p timeout %d", pending, pending->timeout);
 913
 914         ret = pending->cb(pending->entry);
 915         if (ret == FALSE) {
 916                 entry->pending_timeouts =
 917                         g_slist_remove(entry->pending_timeouts,
 918                                         pending);
 919                 g_free(pending);
 920         }
 921         return ret;
 922 }
 923
 924 static connman_bool_t pending_timeout_add(unsigned int seconds,
 925                                         gboolean (*cb)(gpointer),
 926                                         struct service_entry *entry)
 927 {
 928         struct pending_data *pending = g_try_new0(struct pending_data, 1);
 929
 930         if (pending == NULL || cb == NULL || entry == NULL) {
 931                 g_free(pending);
 932                 return FALSE;
 933         }
 934
 935         pending->cb = cb;
 936         pending->entry = entry;
 937         pending->timeout = g_timeout_add_seconds(seconds, pending_timeout_cb,
 938                                                 pending);
 939         entry->pending_timeouts = g_slist_prepend(entry->pending_timeouts,
 940                                                 pending);
 941
 942         DBG("pending %p entry %p timeout id %d", pending, entry,
 943                 pending->timeout);
 944
 945         return TRUE;
 946 }
 947
 948 static gboolean call_disconnect(gpointer user_data)
 949 {
 950         struct service_entry *entry = user_data;
 951         struct connman_service *service = entry->service;
 952
 953         /*
 954          * TODO: We should mark this entry as pending work. In case
 955          * disconnect fails we just unassign this session from the
 956          * service and can't do anything later on it
 957          */
 958         DBG("disconnect service %p", service);
 959         __connman_service_disconnect(service);
 960
 961         return FALSE;
 962 }
 963
 964 static gboolean call_connect(gpointer user_data)
 965 {
 966         struct service_entry *entry = user_data;
 967         struct connman_service *service = entry->service;
 968
 969         DBG("connect service %p", service);
 970         __connman_service_connect(service);
 971
 972         return FALSE;
 973 }
 974
 975 static void deselect_service(struct session_info *info)
 976 {
 977         struct service_entry *entry;
 978         connman_bool_t disconnect, connected;
 979
 980         DBG("");
 981
 982         if (info->entry == NULL)
 983                 return;
 984
 985         disconnect = explicit_disconnect(info);
 986
 987         connected = is_connecting(info->entry->state) == TRUE ||
 988                         is_connected(info->entry->state) == TRUE;
 989
 990         info->state = CONNMAN_SESSION_STATE_DISCONNECTED;
 991         info->entry->reason = CONNMAN_SESSION_REASON_UNKNOWN;
 992
 993         entry = info->entry;
 994         info->entry = NULL;
 995
 996         DBG("disconnect %d connected %d", disconnect, connected);
 997
 998         if (disconnect == TRUE && connected == TRUE)
 999                 pending_timeout_add(0, call_disconnect, entry);
1000 }
1001
1002 static void deselect_and_disconnect(struct connman_session *session)
1003 {
1004         struct session_info *info = session->info;
1005
1006         deselect_service(info);
1007
1008         info->reason = CONNMAN_SESSION_REASON_FREE_RIDE;
1009 }
1010
1011 static void select_connected_service(struct session_info *info,
1012                                         struct service_entry *entry)
1013 {
1014         enum connman_session_state state;
1015
1016         state = service_to_session_state(entry->state);
1017         if (is_type_matching_state(&state, info->config.type) == FALSE)
1018                 return;
1019
1020         info->state = state;
1021
1022         info->entry = entry;
1023         info->entry->reason = info->reason;
1024
1025         if (explicit_connect(info->reason) == FALSE)
1026                 return;
1027
1028         __connman_service_session_inc(info->entry->service);
1029 }
1030
1031 static void select_offline_service(struct session_info *info,
1032                                         struct service_entry *entry)
1033 {
1034         if (explicit_connect(info->reason) == FALSE)
1035                 return;
1036
1037         info->state = service_to_session_state(entry->state);
1038
1039         info->entry = entry;
1040         info->entry->reason = info->reason;
1041
1042         __connman_service_session_inc(info->entry->service);
1043         pending_timeout_add(0, call_connect, entry);
1044 }
1045
1046 static void select_service(struct session_info *info,
1047                                 struct service_entry *entry)
1048 {
1049         DBG("service %p", entry->service);
1050
1051         if (is_connected(entry->state) == TRUE)
1052                 select_connected_service(info, entry);
1053         else
1054                 select_offline_service(info, entry);
1055 }
1056
1057 static void select_and_connect(struct connman_session *session,
1058                                 enum connman_session_reason reason)
1059 {
1060         struct session_info *info = session->info;
1061         struct service_entry *entry = NULL;
1062         GSequenceIter *iter;
1063
1064         DBG("session %p reason %s", session, reason2string(reason));
1065
1066         info->reason = reason;
1067
1068         iter = g_sequence_get_begin_iter(session->service_list);
1069
1070         while (g_sequence_iter_is_end(iter) == FALSE) {
1071                 entry = g_sequence_get(iter);
1072
1073                 switch (entry->state) {
1074                 case CONNMAN_SERVICE_STATE_ASSOCIATION:
1075                 case CONNMAN_SERVICE_STATE_CONFIGURATION:
1076                 case CONNMAN_SERVICE_STATE_READY:
1077                 case CONNMAN_SERVICE_STATE_ONLINE:
1078                 case CONNMAN_SERVICE_STATE_IDLE:
1079                 case CONNMAN_SERVICE_STATE_DISCONNECT:
1080                         select_service(info, entry);
1081                         return;
1082                 case CONNMAN_SERVICE_STATE_UNKNOWN:
1083                 case CONNMAN_SERVICE_STATE_FAILURE:
1084                         break;
1085                 }
1086
1087                 iter = g_sequence_iter_next(iter);
1088         }
1089 }
1090
1091 static struct service_entry *create_service_entry(struct connman_service *service,
1092                                         const char *name,
1093                                         enum connman_service_state state)
1094 {
1095         struct service_entry *entry;
1096         enum connman_service_type type;
1097         int idx;
1098
1099         entry = g_try_new0(struct service_entry, 1);
1100         if (entry == NULL)
1101                 return entry;
1102
1103         entry->reason = CONNMAN_SESSION_REASON_UNKNOWN;
1104         entry->state = state;
1105         if (name != NULL)
1106                 entry->name = name;
1107         else
1108                 entry->name = "";
1109         entry->service = service;
1110
1111         idx = __connman_service_get_index(entry->service);
1112         entry->ifname = connman_inet_ifname(idx);
1113         if (entry->ifname == NULL)
1114                 entry->ifname = g_strdup("");
1115
1116         type = connman_service_get_type(entry->service);
1117         entry->bearer = service2bearer(type);
1118
1119         return entry;
1120 }
1121
1122 static void destroy_service_entry(gpointer data)
1123 {
1124         struct service_entry *entry = data;
1125
1126         pending_timeout_remove_all(entry);
1127         g_free(entry->ifname);
1128
1129         g_free(entry);
1130 }
1131
1132 static void populate_service_list(struct connman_session *session)
1133 {
1134         struct service_entry *entry;
1135         GSequenceIter *iter;
1136
1137         session->service_hash =
1138                 g_hash_table_new_full(g_direct_hash, g_direct_equal,
1139                                         NULL, NULL);
1140         session->service_list = __connman_service_get_list(session,
1141                                                         service_match,
1142                                                         create_service_entry,
1143                                                         destroy_service_entry);
1144
1145         g_sequence_sort(session->service_list, sort_services, session);
1146
1147         iter = g_sequence_get_begin_iter(session->service_list);
1148
1149         while (g_sequence_iter_is_end(iter) == FALSE) {
1150                 entry = g_sequence_get(iter);
1151
1152                 DBG("service %p type %s name %s", entry->service,
1153                         service2bearer(connman_service_get_type(entry->service)),
1154                         entry->name);
1155
1156                 g_hash_table_replace(session->service_hash,
1157                                         entry->service, iter);
1158
1159                 iter = g_sequence_iter_next(iter);
1160         }
1161 }
1162
1163 static void session_changed(struct connman_session *session,
1164                                 enum connman_session_trigger trigger)
1165 {
1166         struct session_info *info = session->info;
1167         struct session_info *info_last = session->info_last;
1168         GSequenceIter *service_iter = NULL, *service_iter_last = NULL;
1169         GSequence *service_list_last;
1170         GHashTable *service_hash_last;
1171
1172         /*
1173          * TODO: This only a placeholder for the 'real' algorithm to
1174          * play a bit around. So we are going to improve it step by step.
1175          */
1176
1177         DBG("session %p trigger %s reason %s", session, trigger2string(trigger),
1178                                                 reason2string(info->reason));
1179
1180         if (info->entry != NULL) {
1181                 enum connman_session_state state;
1182
1183                 state = service_to_session_state(info->entry->state);
1184
1185                 if (is_type_matching_state(&state, info->config.type) == TRUE)
1186                         info->state = state;
1187         }
1188
1189         switch (trigger) {
1190         case CONNMAN_SESSION_TRIGGER_UNKNOWN:
1191                 DBG("ignore session changed event");
1192                 return;
1193         case CONNMAN_SESSION_TRIGGER_SETTING:
1194                 if (info->config.allowed_bearers != info_last->config.allowed_bearers) {
1195
1196                         service_hash_last = session->service_hash;
1197                         service_list_last = session->service_list;
1198
1199                         populate_service_list(session);
1200
1201                         if (info->entry != NULL) {
1202                                 service_iter_last = g_hash_table_lookup(
1203                                                         service_hash_last,
1204                                                         info->entry->service);
1205                                 service_iter = g_hash_table_lookup(
1206                                                         session->service_hash,
1207                                                         info->entry->service);
1208                         }
1209
1210                         if (service_iter == NULL && service_iter_last != NULL) {
1211                                 /*
1212                                  * The currently selected service is
1213                                  * not part of this session anymore.
1214                                  */
1215                                 deselect_and_disconnect(session);
1216                         }
1217
1218                         g_hash_table_remove_all(service_hash_last);
1219                         g_sequence_free(service_list_last);
1220                 }
1221
1222                 if (info->config.type != info_last->config.type) {
1223                         if (info->state >= CONNMAN_SESSION_STATE_CONNECTED &&
1224                                         is_type_matching_state(&info->state,
1225                                                         info->config.type) == FALSE)
1226                                 deselect_and_disconnect(session);
1227                 }
1228
1229                 if (info->state == CONNMAN_SESSION_STATE_DISCONNECTED) {
1230                         select_and_connect(session,
1231                                         CONNMAN_SESSION_REASON_FREE_RIDE);
1232                 }
1233
1234                 break;
1235         case CONNMAN_SESSION_TRIGGER_ECALL:
1236                 /*
1237                  * For the time beeing we fallback to normal connect
1238                  * strategy.
1239                  */
1240         case CONNMAN_SESSION_TRIGGER_CONNECT:
1241                 if (info->state >= CONNMAN_SESSION_STATE_CONNECTED) {
1242                         if (info->entry->reason == CONNMAN_SESSION_REASON_CONNECT)
1243                                 break;
1244                         info->entry->reason = CONNMAN_SESSION_REASON_CONNECT;
1245                         __connman_service_session_inc(info->entry->service);
1246                         break;
1247                 }
1248
1249                 if (info->entry != NULL &&
1250                                 is_connecting(info->entry->state) == TRUE) {
1251                         break;
1252                 }
1253
1254                 select_and_connect(session,
1255                                 CONNMAN_SESSION_REASON_CONNECT);
1256
1257                 break;
1258         case CONNMAN_SESSION_TRIGGER_DISCONNECT:
1259                 deselect_and_disconnect(session);
1260
1261                 break;
1262         case CONNMAN_SESSION_TRIGGER_SERVICE:
1263                 if (info->entry != NULL &&
1264                         (is_connecting(info->entry->state) == TRUE ||
1265                                 is_connected(info->entry->state) == TRUE)) {
1266                         break;
1267                 }
1268
1269                 deselect_and_disconnect(session);
1270
1271                 if (info->reason == CONNMAN_SESSION_REASON_FREE_RIDE) {
1272                         select_and_connect(session, info->reason);
1273                 }
1274
1275                 break;
1276         }
1277
1278         session_notify(session);
1279 }
1280
1281 static DBusMessage *connect_session(DBusConnection *conn,
1282                                         DBusMessage *msg, void *user_data)
1283 {
1284         struct connman_session *session = user_data;
1285
1286         DBG("session %p", session);
1287
1288         if (ecall_session != NULL) {
1289                 if (ecall_session->ecall == TRUE && ecall_session != session)
1290                         return __connman_error_failed(msg, EBUSY);
1291
1292                 session->ecall = TRUE;
1293                 session_changed(session, CONNMAN_SESSION_TRIGGER_ECALL);
1294         } else
1295                 session_changed(session, CONNMAN_SESSION_TRIGGER_CONNECT);
1296
1297         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1298 }
1299
1300 static DBusMessage *disconnect_session(DBusConnection *conn,
1301                                         DBusMessage *msg, void *user_data)
1302 {
1303         struct connman_session *session = user_data;
1304
1305         DBG("session %p", session);
1306
1307         if (ecall_session != NULL) {
1308                 if (ecall_session->ecall == TRUE && ecall_session != session)
1309                         return __connman_error_failed(msg, EBUSY);
1310
1311                 session->ecall = FALSE;
1312         }
1313
1314         session_changed(session, CONNMAN_SESSION_TRIGGER_DISCONNECT);
1315
1316         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1317 }
1318
1319 static DBusMessage *change_session(DBusConnection *conn,
1320                                         DBusMessage *msg, void *user_data)
1321 {
1322         struct connman_session *session = user_data;
1323         struct session_info *info = session->info;
1324         DBusMessageIter iter, value;
1325         const char *name;
1326         const char *val;
1327         GSList *allowed_bearers;
1328         int err;
1329
1330         DBG("session %p", session);
1331         if (dbus_message_iter_init(msg, &iter) == FALSE)
1332                 return __connman_error_invalid_arguments(msg);
1333
1334         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
1335                 return __connman_error_invalid_arguments(msg);
1336
1337         dbus_message_iter_get_basic(&iter, &name);
1338         dbus_message_iter_next(&iter);
1339
1340         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
1341                 return __connman_error_invalid_arguments(msg);
1342
1343         dbus_message_iter_recurse(&iter, &value);
1344
1345         switch (dbus_message_iter_get_arg_type(&value)) {
1346         case DBUS_TYPE_ARRAY:
1347                 if (g_str_equal(name, "AllowedBearers") == TRUE) {
1348                         err = session_parse_allowed_bearers(&value,
1349                                                         &allowed_bearers);
1350                         if (err < 0)
1351                                 return __connman_error_failed(msg, err);
1352
1353                         connman_session_free_bearers(info->config.allowed_bearers);
1354                         info->config.allowed_bearers = allowed_bearers;
1355                 } else {
1356                         goto err;
1357                 }
1358                 break;
1359         case DBUS_TYPE_STRING:
1360                 if (g_str_equal(name, "ConnectionType") == TRUE) {
1361                         dbus_message_iter_get_basic(&value, &val);
1362                         info->config.type = apply_policy_on_type(
1363                                 session->policy_config->type,
1364                                 string2type(val));
1365                 } else {
1366                         goto err;
1367                 }
1368                 break;
1369         default:
1370                 goto err;
1371         }
1372
1373         session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);
1374
1375         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1376
1377 err:
1378         return __connman_error_invalid_arguments(msg);
1379 }
1380
1381 static void release_session(gpointer key, gpointer value, gpointer user_data)
1382 {
1383         struct connman_session *session = value;
1384         DBusMessage *message;
1385
1386         DBG("owner %s path %s", session->owner, session->notify_path);
1387
1388         if (session->notify_watch > 0)
1389                 g_dbus_remove_watch(connection, session->notify_watch);
1390
1391         g_dbus_unregister_interface(connection, session->session_path,
1392                                                 CONNMAN_SESSION_INTERFACE);
1393
1394         message = dbus_message_new_method_call(session->owner,
1395                                                 session->notify_path,
1396                                                 CONNMAN_NOTIFICATION_INTERFACE,
1397                                                 "Release");
1398         if (message == NULL)
1399                 return;
1400
1401         dbus_message_set_no_reply(message, TRUE);
1402
1403         g_dbus_send_message(connection, message);
1404 }
1405
1406 static int session_disconnect(struct connman_session *session)
1407 {
1408         DBG("session %p, %s", session, session->owner);
1409
1410         if (session->notify_watch > 0)
1411                 g_dbus_remove_watch(connection, session->notify_watch);
1412
1413         g_dbus_unregister_interface(connection, session->session_path,
1414                                                 CONNMAN_SESSION_INTERFACE);
1415
1416         deselect_and_disconnect(session);
1417
1418         g_hash_table_remove(session_hash, session->session_path);
1419
1420         return 0;
1421 }
1422
1423 static void owner_disconnect(DBusConnection *conn, void *user_data)
1424 {
1425         struct connman_session *session = user_data;
1426
1427         DBG("session %p, %s died", session, session->owner);
1428
1429         session_disconnect(session);
1430 }
1431
1432 static DBusMessage *destroy_session(DBusConnection *conn,
1433                                         DBusMessage *msg, void *user_data)
1434 {
1435         struct connman_session *session = user_data;
1436
1437         DBG("session %p", session);
1438
1439         if (ecall_session != NULL && ecall_session != session)
1440                 return __connman_error_failed(msg, EBUSY);
1441
1442         session_disconnect(session);
1443
1444         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1445 }
1446
1447 static const GDBusMethodTable session_methods[] = {
1448         { GDBUS_METHOD("Destroy", NULL, NULL, destroy_session) },
1449         { GDBUS_METHOD("Connect", NULL, NULL, connect_session) },
1450         { GDBUS_METHOD("Disconnect", NULL, NULL,
1451                         disconnect_session ) },
1452         { GDBUS_METHOD("Change",
1453                         GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
1454                         NULL, change_session) },
1455         { },
1456 };
1457
1458 int __connman_session_create(DBusMessage *msg)
1459 {
1460         const char *owner, *notify_path;
1461         char *session_path = NULL;
1462         DBusMessageIter iter, array;
1463         struct connman_session *session = NULL;
1464         struct session_info *info, *info_last;
1465         enum connman_session_type type = CONNMAN_SESSION_TYPE_ANY;
1466         GSList *allowed_bearers;
1467         connman_bool_t allowed_bearers_valid = FALSE;
1468         connman_bool_t type_valid = FALSE;
1469         int err;
1470
1471         owner = dbus_message_get_sender(msg);
1472
1473         DBG("owner %s", owner);
1474
1475         if (ecall_session != NULL && ecall_session->ecall == TRUE) {
1476                 /*
1477                  * If there is an emergency call already going on,
1478                  * ignore session creation attempt
1479                  */
1480                 err = -EBUSY;
1481                 goto err;
1482         }
1483
1484         dbus_message_iter_init(msg, &iter);
1485         dbus_message_iter_recurse(&iter, &array);
1486
1487         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1488                 DBusMessageIter entry, value;
1489                 const char *key, *val;
1490
1491                 dbus_message_iter_recurse(&array, &entry);
1492                 dbus_message_iter_get_basic(&entry, &key);
1493
1494                 dbus_message_iter_next(&entry);
1495                 dbus_message_iter_recurse(&entry, &value);
1496
1497                 switch (dbus_message_iter_get_arg_type(&value)) {
1498                 case DBUS_TYPE_ARRAY:
1499                         if (g_str_equal(key, "AllowedBearers") == TRUE) {
1500                                 err = session_parse_allowed_bearers(&value,
1501                                                         &allowed_bearers);
1502                                 if (err < 0)
1503                                         goto err;
1504
1505                                 allowed_bearers_valid = TRUE;
1506                         } else {
1507                                 return -EINVAL;
1508                         }
1509                         break;
1510                 case DBUS_TYPE_STRING:
1511                         if (g_str_equal(key, "ConnectionType") == TRUE) {
1512                                 dbus_message_iter_get_basic(&value, &val);
1513                                 type = string2type(val);
1514                                 type_valid = TRUE;
1515                         } else {
1516                                 return -EINVAL;
1517                         }
1518                 }
1519                 dbus_message_iter_next(&array);
1520         }
1521
1522         dbus_message_iter_next(&iter);
1523         dbus_message_iter_get_basic(&iter, &notify_path);
1524
1525         if (notify_path == NULL) {
1526                 err = -EINVAL;
1527                 goto err;
1528         }
1529
1530         session_path = g_strdup_printf("/sessions%s", notify_path);
1531         if (session_path == NULL) {
1532                 err = -ENOMEM;
1533                 goto err;
1534         }
1535
1536         session = g_hash_table_lookup(session_hash, session_path);
1537         if (session != NULL) {
1538                 session = NULL;
1539                 err = -EEXIST;
1540                 goto err;
1541         }
1542
1543         session = g_try_new0(struct connman_session, 1);
1544         if (session == NULL) {
1545                 err = -ENOMEM;
1546                 goto err;
1547         }
1548
1549         session->info = g_try_new0(struct session_info, 1);
1550         if (session->info == NULL) {
1551                 err = -ENOMEM;
1552                 goto err;
1553         }
1554
1555         session->info_last = g_try_new0(struct session_info, 1);
1556         if (session->info_last == NULL) {
1557                 err = -ENOMEM;
1558                 goto err;
1559         }
1560
1561         info = session->info;
1562         info_last = session->info_last;
1563
1564         session->owner = g_strdup(owner);
1565         session->session_path = session_path;
1566         session->notify_path = g_strdup(notify_path);
1567         session->notify_watch =
1568                 g_dbus_add_disconnect_watch(connection, session->owner,
1569                                         owner_disconnect, session, NULL);
1570
1571         err = assign_policy_plugin(session);
1572         if (err < 0)
1573                 goto err;
1574         err = create_policy_config(session);
1575         if (err < 0)
1576                 goto err;
1577
1578         if (session->policy_config->ecall == TRUE)
1579                 ecall_session = session;
1580
1581         info->state = CONNMAN_SESSION_STATE_DISCONNECTED;
1582         if (type_valid == FALSE)
1583                 type = CONNMAN_SESSION_TYPE_ANY;
1584         info->config.type = apply_policy_on_type(
1585                                 session->policy_config->type,
1586                                 type);
1587         info->config.priority = session->policy_config->priority;
1588         info->config.roaming_policy = session->policy_config->roaming_policy;
1589         info->entry = NULL;
1590
1591         if (allowed_bearers_valid == FALSE) {
1592                 allowed_bearers = connman_session_allowed_bearers_any();
1593                 if (allowed_bearers == NULL) {
1594                         err = -ENOMEM;
1595                         goto err;
1596                 }
1597         }
1598         info->config.allowed_bearers = allowed_bearers;
1599
1600         g_hash_table_replace(session_hash, session->session_path, session);
1601
1602         DBG("add %s", session->session_path);
1603
1604         if (g_dbus_register_interface(connection, session->session_path,
1605                                         CONNMAN_SESSION_INTERFACE,
1606                                         session_methods, NULL,
1607                                         NULL, session, NULL) == FALSE) {
1608                 connman_error("Failed to register %s", session->session_path);
1609                 g_hash_table_remove(session_hash, session->session_path);
1610                 session = NULL;
1611
1612                 err = -EINVAL;
1613                 goto err;
1614         }
1615
1616         g_dbus_send_reply(connection, msg,
1617                                 DBUS_TYPE_OBJECT_PATH, &session->session_path,
1618                                 DBUS_TYPE_INVALID);
1619
1620
1621         populate_service_list(session);
1622
1623         info_last->state = info->state;
1624         info_last->config.priority = info->config.priority;
1625         info_last->config.roaming_policy = info->config.roaming_policy;
1626         info_last->entry = info->entry;
1627         info_last->config.allowed_bearers = info->config.allowed_bearers;
1628
1629         session->append_all = TRUE;
1630
1631         session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);
1632
1633         return 0;
1634
1635 err:
1636         connman_error("Failed to create session");
1637
1638         if (session != NULL) {
1639                 if (session->info_last != NULL)
1640                         g_free(session->info_last);
1641                 if (session->info != NULL)
1642                         g_free(session->info);
1643                 g_free(session);
1644         }
1645
1646         g_free(session_path);
1647
1648         connman_session_free_bearers(allowed_bearers);
1649
1650         return err;
1651 }
1652
1653 int __connman_session_destroy(DBusMessage *msg)
1654 {
1655         const char *owner, *session_path;
1656         struct connman_session *session;
1657
1658         owner = dbus_message_get_sender(msg);
1659
1660         DBG("owner %s", owner);
1661
1662         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &session_path,
1663                                                         DBUS_TYPE_INVALID);
1664         if (session_path == NULL)
1665                 return -EINVAL;
1666
1667         session = g_hash_table_lookup(session_hash, session_path);
1668         if (session == NULL)
1669                 return -EINVAL;
1670
1671         if (g_strcmp0(owner, session->owner) != 0)
1672                 return -EACCES;
1673
1674         session_disconnect(session);
1675
1676         return 0;
1677 }
1678
1679 connman_bool_t __connman_session_mode()
1680 {
1681         return sessionmode;
1682 }
1683
1684 void __connman_session_set_mode(connman_bool_t enable)
1685 {
1686         DBG("enable %d", enable);
1687
1688         if (sessionmode != enable) {
1689                 sessionmode = enable;
1690
1691                 connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
1692                                 CONNMAN_MANAGER_INTERFACE, "SessionMode",
1693                                 DBUS_TYPE_BOOLEAN, &sessionmode);
1694         }
1695
1696         if (sessionmode == TRUE)
1697                 __connman_service_disconnect_all();
1698 }
1699
1700 static void service_add(struct connman_service *service,
1701                         const char *name)
1702 {
1703         GHashTableIter iter;
1704         GSequenceIter *iter_service_list;
1705         gpointer key, value;
1706         struct connman_session *session;
1707         struct service_entry *entry;
1708
1709         DBG("service %p", service);
1710
1711         g_hash_table_iter_init(&iter, session_hash);
1712
1713         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1714                 session = value;
1715
1716                 if (service_match(session, service) == FALSE)
1717                         continue;
1718
1719                 entry = create_service_entry(service, name,
1720                                                 CONNMAN_SERVICE_STATE_IDLE);
1721                 if (entry == NULL)
1722                         continue;
1723
1724                 iter_service_list =
1725                         g_sequence_insert_sorted(session->service_list,
1726                                                         entry, sort_services,
1727                                                         session);
1728
1729                 g_hash_table_replace(session->service_hash, service,
1730                                         iter_service_list);
1731
1732                 session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
1733         }
1734 }
1735
1736 static void service_remove(struct connman_service *service)
1737 {
1738
1739         GHashTableIter iter;
1740         gpointer key, value;
1741         struct connman_session *session;
1742         struct session_info *info;
1743
1744         DBG("service %p", service);
1745
1746         g_hash_table_iter_init(&iter, session_hash);
1747
1748         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1749                 GSequenceIter *seq_iter;
1750                 session = value;
1751                 info = session->info;
1752
1753                 seq_iter = g_hash_table_lookup(session->service_hash, service);
1754                 if (seq_iter == NULL)
1755                         continue;
1756
1757                 g_sequence_remove(seq_iter);
1758
1759                 if (info->entry != NULL && info->entry->service == service)
1760                         info->entry = NULL;
1761                 session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
1762         }
1763 }
1764
1765 static void service_state_changed(struct connman_service *service,
1766                                         enum connman_service_state state)
1767 {
1768         GHashTableIter iter;
1769         gpointer key, value;
1770
1771         DBG("service %p state %d", service, state);
1772
1773         g_hash_table_iter_init(&iter, session_hash);
1774
1775         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1776                 struct connman_session *session = value;
1777                 GSequenceIter *service_iter;
1778
1779                 service_iter = g_hash_table_lookup(session->service_hash, service);
1780                 if (service_iter != NULL) {
1781                         struct service_entry *entry;
1782
1783                         entry = g_sequence_get(service_iter);
1784                         entry->state = state;
1785                 }
1786
1787                 session_changed(session,
1788                                 CONNMAN_SESSION_TRIGGER_SERVICE);
1789         }
1790 }
1791
1792 static void ipconfig_changed(struct connman_service *service,
1793                                 struct connman_ipconfig *ipconfig)
1794 {
1795         GHashTableIter iter;
1796         gpointer key, value;
1797         struct connman_session *session;
1798         struct session_info *info;
1799         enum connman_ipconfig_type type;
1800
1801         DBG("service %p ipconfig %p", service, ipconfig);
1802
1803         type = __connman_ipconfig_get_config_type(ipconfig);
1804
1805         g_hash_table_iter_init(&iter, session_hash);
1806
1807         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1808                 session = value;
1809                 info = session->info;
1810
1811                 if (info->state == CONNMAN_SESSION_STATE_DISCONNECTED)
1812                         continue;
1813
1814                 if (info->entry != NULL && info->entry->service == service) {
1815                         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1816                                 ipconfig_ipv4_changed(session);
1817                         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1818                                 ipconfig_ipv6_changed(session);
1819                 }
1820         }
1821 }
1822
1823 static struct connman_notifier session_notifier = {
1824         .name                   = "session",
1825         .service_add            = service_add,
1826         .service_remove         = service_remove,
1827         .service_state_changed  = service_state_changed,
1828         .ipconfig_changed       = ipconfig_changed,
1829 };
1830
1831 int __connman_session_init(void)
1832 {
1833         int err;
1834
1835         DBG("");
1836
1837         connection = connman_dbus_get_connection();
1838         if (connection == NULL)
1839                 return -1;
1840
1841         err = connman_notifier_register(&session_notifier);
1842         if (err < 0) {
1843                 dbus_connection_unref(connection);
1844                 return err;
1845         }
1846
1847         session_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1848                                                 NULL, cleanup_session);
1849
1850         sessionmode = FALSE;
1851         return 0;
1852 }
1853
1854 void __connman_session_cleanup(void)
1855 {
1856         DBG("");
1857
1858         if (connection == NULL)
1859                 return;
1860
1861         connman_notifier_unregister(&session_notifier);
1862
1863         g_hash_table_foreach(session_hash, release_session, NULL);
1864         g_hash_table_destroy(session_hash);
1865         session_hash = NULL;
1866
1867         dbus_connection_unref(connection);
1868 }