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