src/session.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  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 <gdbus.h>
  28
  29 #include "connman.h"
  30
  31 static DBusConnection *connection;
  32 static GHashTable *session_hash;
  33 static connman_bool_t sessionmode;
  34 static struct connman_session *ecall_session;
  35
  36 enum connman_session_trigger {
  37         CONNMAN_SESSION_TRIGGER_UNKNOWN         = 0,
  38         CONNMAN_SESSION_TRIGGER_SETTING         = 1,
  39         CONNMAN_SESSION_TRIGGER_CONNECT         = 2,
  40         CONNMAN_SESSION_TRIGGER_DISCONNECT      = 3,
  41         CONNMAN_SESSION_TRIGGER_PERIODIC        = 4,
  42         CONNMAN_SESSION_TRIGGER_SERVICE         = 5,
  43         CONNMAN_SESSION_TRIGGER_ECALL           = 6,
  44 };
  45
  46 enum connman_session_reason {
  47         CONNMAN_SESSION_REASON_UNKNOWN          = 0,
  48         CONNMAN_SESSION_REASON_CONNECT          = 1,
  49         CONNMAN_SESSION_REASON_FREE_RIDE        = 2,
  50         CONNMAN_SESSION_REASON_PERIODIC         = 3,
  51 };
  52
  53 enum connman_session_roaming_policy {
  54         CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN          = 0,
  55         CONNMAN_SESSION_ROAMING_POLICY_DEFAULT          = 1,
  56         CONNMAN_SESSION_ROAMING_POLICY_ALWAYS           = 2,
  57         CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN        = 3,
  58         CONNMAN_SESSION_ROAMING_POLICY_NATIONAL         = 4,
  59         CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL    = 5,
  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         struct connman_service *service;
  67 };
  68
  69 struct session_info {
  70         char *bearer;
  71         const char *name;
  72         char *ifname;
  73         connman_bool_t online;
  74         connman_bool_t priority;
  75         GSList *allowed_bearers;
  76         connman_bool_t avoid_handover;
  77         connman_bool_t stay_connected;
  78         unsigned int periodic_connect;
  79         unsigned int idle_timeout;
  80         connman_bool_t ecall;
  81         enum connman_session_roaming_policy roaming_policy;
  82         unsigned int marker;
  83
  84         struct service_entry *entry;
  85 };
  86
  87 struct connman_session {
  88         char *owner;
  89         char *session_path;
  90         char *notify_path;
  91         guint notify_watch;
  92
  93         connman_bool_t append_all;
  94         connman_bool_t info_dirty;
  95         struct session_info info;
  96         struct session_info info_last;
  97
  98         GSequence *service_list;
  99         GHashTable *service_hash;
 100 };
 101
 102 struct bearer_info {
 103         char *name;
 104         connman_bool_t match_all;
 105         enum connman_service_type service_type;
 106 };
 107
 108 static const char *trigger2string(enum connman_session_trigger trigger)
 109 {
 110         switch (trigger) {
 111         case CONNMAN_SESSION_TRIGGER_UNKNOWN:
 112                 break;
 113         case CONNMAN_SESSION_TRIGGER_SETTING:
 114                 return "setting";
 115         case CONNMAN_SESSION_TRIGGER_CONNECT:
 116                 return "connect";
 117         case CONNMAN_SESSION_TRIGGER_DISCONNECT:
 118                 return "disconnect";
 119         case CONNMAN_SESSION_TRIGGER_PERIODIC:
 120                 return "periodic";
 121         case CONNMAN_SESSION_TRIGGER_SERVICE:
 122                 return "service";
 123         case CONNMAN_SESSION_TRIGGER_ECALL:
 124                 return "ecall";
 125         }
 126
 127         return NULL;
 128 }
 129
 130 static const char *reason2string(enum connman_session_reason reason)
 131 {
 132         switch (reason) {
 133         case CONNMAN_SESSION_REASON_UNKNOWN:
 134                 break;
 135         case CONNMAN_SESSION_REASON_CONNECT:
 136                 return "connect";
 137         case CONNMAN_SESSION_REASON_FREE_RIDE:
 138                 return "free-ride";
 139         case CONNMAN_SESSION_REASON_PERIODIC:
 140                 return "periodic";
 141         }
 142
 143         return NULL;
 144 }
 145
 146 static const char *roamingpolicy2string(enum connman_session_roaming_policy policy)
 147 {
 148         switch (policy) {
 149         case CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN:
 150                 break;
 151         case CONNMAN_SESSION_ROAMING_POLICY_DEFAULT:
 152                 return "default";
 153         case CONNMAN_SESSION_ROAMING_POLICY_ALWAYS:
 154                 return "always";
 155         case CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN:
 156                 return "forbidden";
 157         case CONNMAN_SESSION_ROAMING_POLICY_NATIONAL:
 158                 return "national";
 159         case CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL:
 160                 return "international";
 161         }
 162
 163         return NULL;
 164 }
 165
 166 static enum connman_session_roaming_policy string2roamingpolicy(const char *policy)
 167 {
 168         if (g_strcmp0(policy, "default") == 0)
 169                 return CONNMAN_SESSION_ROAMING_POLICY_DEFAULT;
 170         else if (g_strcmp0(policy, "always") == 0)
 171                 return CONNMAN_SESSION_ROAMING_POLICY_ALWAYS;
 172         else if (g_strcmp0(policy, "forbidden") == 0)
 173                 return CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
 174         else if (g_strcmp0(policy, "national") == 0)
 175                 return CONNMAN_SESSION_ROAMING_POLICY_NATIONAL;
 176         else if (g_strcmp0(policy, "international") == 0)
 177                 return CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL;
 178         else
 179                 return CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN;
 180 }
 181
 182 static enum connman_service_type bearer2service(const char *bearer)
 183 {
 184         if (bearer == NULL)
 185                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
 186
 187         if (g_strcmp0(bearer, "ethernet") == 0)
 188                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 189         else if (g_strcmp0(bearer, "wifi") == 0)
 190                 return CONNMAN_SERVICE_TYPE_WIFI;
 191         else if (g_strcmp0(bearer, "wimax") == 0)
 192                 return CONNMAN_SERVICE_TYPE_WIMAX;
 193         else if (g_strcmp0(bearer, "bluetooth") == 0)
 194                 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
 195         else if (g_strcmp0(bearer, "3g") == 0)
 196                 return CONNMAN_SERVICE_TYPE_CELLULAR;
 197         else
 198                 return CONNMAN_SERVICE_TYPE_UNKNOWN;
 199 }
 200
 201 static char *service2bearer(enum connman_service_type type)
 202 {
 203         switch (type) {
 204         case CONNMAN_SERVICE_TYPE_ETHERNET:
 205                 return "ethernet";
 206         case CONNMAN_SERVICE_TYPE_WIFI:
 207                 return "wifi";
 208         case CONNMAN_SERVICE_TYPE_WIMAX:
 209                 return "wimax";
 210         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 211                 return "bluetooth";
 212         case CONNMAN_SERVICE_TYPE_CELLULAR:
 213                 return "3g";
 214         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 215         case CONNMAN_SERVICE_TYPE_SYSTEM:
 216         case CONNMAN_SERVICE_TYPE_GPS:
 217         case CONNMAN_SERVICE_TYPE_VPN:
 218         case CONNMAN_SERVICE_TYPE_GADGET:
 219                 return "";
 220         }
 221
 222         return "";
 223 }
 224
 225 static void cleanup_bearer_info(gpointer data, gpointer user_data)
 226 {
 227         struct bearer_info *info = data;
 228
 229         g_free(info->name);
 230         g_free(info);
 231 }
 232
 233 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
 234 {
 235         struct bearer_info *info;
 236         DBusMessageIter array;
 237         GSList *list = NULL;
 238
 239         dbus_message_iter_recurse(iter, &array);
 240
 241         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
 242                 char *bearer = NULL;
 243
 244                 dbus_message_iter_get_basic(&array, &bearer);
 245
 246                 info = g_try_new0(struct bearer_info, 1);
 247                 if (info == NULL) {
 248                         g_slist_foreach(list, cleanup_bearer_info, NULL);
 249                         g_slist_free(list);
 250
 251                         return NULL;
 252                 }
 253
 254                 info->name = g_strdup(bearer);
 255                 info->service_type = bearer2service(info->name);
 256
 257                 if (info->service_type == CONNMAN_SERVICE_TYPE_UNKNOWN &&
 258                                 g_strcmp0(info->name, "*") == 0) {
 259                         info->match_all = TRUE;
 260                 } else {
 261                         info->match_all = FALSE;
 262                 }
 263
 264                 list = g_slist_append(list, info);
 265
 266                 dbus_message_iter_next(&array);
 267         }
 268
 269         return list;
 270 }
 271
 272 static GSList *session_allowed_bearers_any(void)
 273 {
 274         struct bearer_info *info;
 275         GSList *list = NULL;
 276
 277         info = g_try_new0(struct bearer_info, 1);
 278         if (info == NULL) {
 279                 g_slist_free(list);
 280
 281                 return NULL;
 282         }
 283
 284         info->name = g_strdup("");
 285         info->match_all = TRUE;
 286         info->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
 287
 288         list = g_slist_append(list, info);
 289
 290         return list;
 291 }
 292
 293 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
 294 {
 295         struct session_info *info = user_data;
 296         GSList *list;
 297
 298         for (list = info->allowed_bearers;
 299                         list != NULL; list = list->next) {
 300                 struct bearer_info *info = list->data;
 301
 302                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
 303                                                 &info->name);
 304         }
 305 }
 306
 307 static void append_ipconfig_ipv4(DBusMessageIter *iter, void *user_data)
 308 {
 309         struct connman_service *service = user_data;
 310         struct connman_ipconfig *ipconfig_ipv4;
 311
 312         if (service == NULL)
 313                 return;
 314
 315         ipconfig_ipv4 = __connman_service_get_ip4config(service);
 316         if (ipconfig_ipv4 == NULL)
 317                 return;
 318
 319         __connman_ipconfig_append_ipv4(ipconfig_ipv4, iter);
 320 }
 321
 322 static void append_ipconfig_ipv6(DBusMessageIter *iter, void *user_data)
 323 {
 324         struct connman_service *service = user_data;
 325         struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
 326
 327         if (service == NULL)
 328                 return;
 329
 330         ipconfig_ipv4 = __connman_service_get_ip4config(service);
 331         ipconfig_ipv6 = __connman_service_get_ip6config(service);
 332         if (ipconfig_ipv6 == NULL)
 333                 return;
 334
 335         __connman_ipconfig_append_ipv6(ipconfig_ipv6, iter, ipconfig_ipv4);
 336 }
 337
 338 static void append_notify(DBusMessageIter *dict,
 339                                         struct connman_session *session)
 340 {
 341         struct session_info *info = &session->info;
 342         struct session_info *info_last = &session->info_last;
 343         const char *policy;
 344         struct connman_service *service;
 345
 346         if (session->append_all == TRUE ||
 347                         info->bearer != info_last->bearer) {
 348                 connman_dbus_dict_append_basic(dict, "Bearer",
 349                                                 DBUS_TYPE_STRING,
 350                                                 &info->bearer);
 351                 info_last->bearer = info->bearer;
 352         }
 353
 354         if (session->append_all == TRUE ||
 355                         info->online != info_last->online) {
 356                 connman_dbus_dict_append_basic(dict, "Online",
 357                                                 DBUS_TYPE_BOOLEAN,
 358                                                 &info->online);
 359                 info_last->online = info->online;
 360         }
 361
 362         if (session->append_all == TRUE ||
 363                         info->name != info_last->name) {
 364                 connman_dbus_dict_append_basic(dict, "Name",
 365                                                 DBUS_TYPE_STRING,
 366                                                 &info->name);
 367                 info_last->name = info->name;
 368         }
 369
 370         if (session->append_all == TRUE ||
 371                         info->entry != info_last->entry) {
 372                 if (info->entry == NULL)
 373                         service = NULL;
 374                 else
 375                         service = info->entry->service;
 376
 377                 connman_dbus_dict_append_dict(dict, "IPv4",
 378                                                 append_ipconfig_ipv4,
 379                                                 service);
 380
 381                 connman_dbus_dict_append_dict(dict, "IPv6",
 382                                                 append_ipconfig_ipv6,
 383                                                 service);
 384
 385                 connman_dbus_dict_append_basic(dict, "Interface",
 386                                                 DBUS_TYPE_STRING,
 387                                                 &info->ifname);
 388
 389                 info_last->ifname = info->ifname;
 390                 info_last->entry = info->entry;
 391         }
 392
 393
 394         if (session->append_all == TRUE ||
 395                         info->priority != info_last->priority) {
 396                 connman_dbus_dict_append_basic(dict, "Priority",
 397                                                 DBUS_TYPE_BOOLEAN,
 398                                                 &info->priority);
 399                 info_last->priority = info->priority;
 400         }
 401
 402         if (session->append_all == TRUE ||
 403                         info->allowed_bearers != info_last->allowed_bearers) {
 404                 connman_dbus_dict_append_array(dict, "AllowedBearers",
 405                                                 DBUS_TYPE_STRING,
 406                                                 append_allowed_bearers,
 407                                                 info);
 408                 info_last->allowed_bearers = info->allowed_bearers;
 409         }
 410
 411         if (session->append_all == TRUE ||
 412                         info->avoid_handover != info_last->avoid_handover) {
 413                 connman_dbus_dict_append_basic(dict, "AvoidHandover",
 414                                                 DBUS_TYPE_BOOLEAN,
 415                                                 &info->avoid_handover);
 416                 info_last->avoid_handover = info->avoid_handover;
 417         }
 418
 419         if (session->append_all == TRUE ||
 420                         info->stay_connected != info_last->stay_connected) {
 421                 connman_dbus_dict_append_basic(dict, "StayConnected",
 422                                                 DBUS_TYPE_BOOLEAN,
 423                                                 &info->stay_connected);
 424                 info_last->stay_connected = info->stay_connected;
 425         }
 426
 427         if (session->append_all == TRUE ||
 428                         info->periodic_connect != info_last->periodic_connect) {
 429                 connman_dbus_dict_append_basic(dict, "PeriodicConnect",
 430                                                 DBUS_TYPE_UINT32,
 431                                                 &info->periodic_connect);
 432                 info_last->periodic_connect = info->periodic_connect;
 433         }
 434
 435         if (session->append_all == TRUE ||
 436                         info->idle_timeout != info_last->idle_timeout) {
 437                 connman_dbus_dict_append_basic(dict, "IdleTimeout",
 438                                                 DBUS_TYPE_UINT32,
 439                                                 &info->idle_timeout);
 440                 info_last->idle_timeout = info->idle_timeout;
 441         }
 442
 443         if (session->append_all == TRUE ||
 444                         info->ecall != info_last->ecall) {
 445                 connman_dbus_dict_append_basic(dict, "EmergencyCall",
 446                                                 DBUS_TYPE_BOOLEAN,
 447                                                 &info->ecall);
 448                 info_last->ecall = info->ecall;
 449         }
 450
 451         if (session->append_all == TRUE ||
 452                         info->roaming_policy != info_last->roaming_policy) {
 453                 policy = roamingpolicy2string(info->roaming_policy);
 454                 connman_dbus_dict_append_basic(dict, "RoamingPolicy",
 455                                                 DBUS_TYPE_STRING,
 456                                                 &policy);
 457                 info_last->roaming_policy = info->roaming_policy;
 458         }
 459
 460         if (session->append_all == TRUE ||
 461                         info->marker != info_last->marker) {
 462                 connman_dbus_dict_append_basic(dict, "SessionMarker",
 463                                                 DBUS_TYPE_UINT32,
 464                                                 &info->marker);
 465                 info_last->marker = info->marker;
 466         }
 467
 468         session->append_all = FALSE;
 469         session->info_dirty = FALSE;
 470 }
 471
 472 static gboolean session_notify(gpointer user_data)
 473 {
 474         struct connman_session *session = user_data;
 475         DBusMessage *msg;
 476         DBusMessageIter array, dict;
 477
 478         if (session->info_dirty == FALSE)
 479                 return 0;
 480
 481         DBG("session %p owner %s notify_path %s", session,
 482                 session->owner, session->notify_path);
 483
 484         msg = dbus_message_new_method_call(session->owner, session->notify_path,
 485                                                 CONNMAN_NOTIFICATION_INTERFACE,
 486                                                 "Update");
 487         if (msg == NULL)
 488                 return FALSE;
 489
 490         dbus_message_iter_init_append(msg, &array);
 491         connman_dbus_dict_open(&array, &dict);
 492
 493         append_notify(&dict, session);
 494
 495         connman_dbus_dict_close(&array, &dict);
 496
 497         g_dbus_send_message(connection, msg);
 498
 499         session->info_dirty = FALSE;
 500
 501         return FALSE;
 502 }
 503
 504 static void ipconfig_ipv4_changed(struct connman_session *session)
 505 {
 506         struct session_info *info = &session->info;
 507
 508         connman_dbus_setting_changed_dict(session->owner, session->notify_path,
 509                                                 "IPv4", append_ipconfig_ipv4,
 510                                                 info->entry->service);
 511 }
 512
 513 static void ipconfig_ipv6_changed(struct connman_session *session)
 514 {
 515         struct session_info *info = &session->info;
 516
 517         connman_dbus_setting_changed_dict(session->owner, session->notify_path,
 518                                                 "IPv6", append_ipconfig_ipv6,
 519                                                 info->entry->service);
 520 }
 521
 522 static connman_bool_t service_type_match(struct connman_session *session,
 523                                         struct connman_service *service)
 524 {
 525         struct session_info *info = &session->info;
 526         GSList *list;
 527
 528         for (list = info->allowed_bearers;
 529                         list != NULL; list = list->next) {
 530                 struct bearer_info *info = list->data;
 531                 enum connman_service_type service_type;
 532
 533                 if (info->match_all == TRUE)
 534                         return TRUE;
 535
 536                 service_type = connman_service_get_type(service);
 537                 if (info->service_type == service_type)
 538                         return TRUE;
 539         }
 540
 541         return FALSE;
 542 }
 543
 544 static connman_bool_t service_match(struct connman_session *session,
 545                                         struct connman_service *service)
 546 {
 547         if (service_type_match(session, service) == FALSE)
 548                 return FALSE;
 549
 550         return TRUE;
 551 }
 552
 553 static int service_type_weight(enum connman_service_type type)
 554 {
 555         /*
 556          * The session doesn't care which service
 557          * to use. Nevertheless we have to sort them
 558          * according their type. The ordering is
 559          *
 560          * 1. Ethernet
 561          * 2. Bluetooth
 562          * 3. WiFi/WiMAX
 563          * 4. GSM/UTMS/3G
 564          */
 565
 566         switch (type) {
 567         case CONNMAN_SERVICE_TYPE_ETHERNET:
 568                 return 4;
 569         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 570                 return 3;
 571         case CONNMAN_SERVICE_TYPE_WIFI:
 572         case CONNMAN_SERVICE_TYPE_WIMAX:
 573                 return 2;
 574         case CONNMAN_SERVICE_TYPE_CELLULAR:
 575                 return 1;
 576         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 577         case CONNMAN_SERVICE_TYPE_SYSTEM:
 578         case CONNMAN_SERVICE_TYPE_GPS:
 579         case CONNMAN_SERVICE_TYPE_VPN:
 580         case CONNMAN_SERVICE_TYPE_GADGET:
 581                 break;
 582         }
 583
 584         return 0;
 585 }
 586
 587 static gint sort_allowed_bearers(struct connman_service *service_a,
 588                                         struct connman_service *service_b,
 589                                         struct connman_session *session)
 590 {
 591         struct session_info *info = &session->info;
 592         GSList *list;
 593         enum connman_service_type type_a, type_b;
 594         int weight_a, weight_b;
 595
 596         type_a = connman_service_get_type(service_a);
 597         type_b = connman_service_get_type(service_b);
 598
 599         for (list = info->allowed_bearers;
 600                         list != NULL; list = list->next) {
 601                 struct bearer_info *info = list->data;
 602
 603                 if (info->match_all == TRUE) {
 604                         if (type_a != type_b) {
 605                                 weight_a = service_type_weight(type_a);
 606                                 weight_b = service_type_weight(type_b);
 607
 608                                 if (weight_a > weight_b)
 609                                         return -1;
 610
 611                                 if (weight_a < weight_b)
 612                                         return 1;
 613
 614                                 return 0;
 615                         }
 616                 }
 617
 618                 if (type_a == info->service_type &&
 619                                 type_b == info->service_type) {
 620                         return 0;
 621                 }
 622
 623                 if (type_a == info->service_type &&
 624                                 type_b != info->service_type) {
 625                         return -1;
 626                 }
 627
 628                 if (type_a != info->service_type &&
 629                                 type_b == info->service_type) {
 630                         return 1;
 631                 }
 632         }
 633
 634         return 0;
 635 }
 636
 637 static gint sort_services(gconstpointer a, gconstpointer b, gpointer user_data)
 638 {
 639         struct connman_service *service_a = (void *)a;
 640         struct connman_service *service_b = (void *)b;
 641         struct connman_session *session = user_data;
 642
 643         return sort_allowed_bearers(service_a, service_b, session);
 644 }
 645
 646 static void cleanup_session(gpointer user_data)
 647 {
 648         struct connman_session *session = user_data;
 649         struct session_info *info = &session->info;
 650
 651         DBG("remove %s", session->session_path);
 652
 653         g_hash_table_destroy(session->service_hash);
 654         g_sequence_free(session->service_list);
 655
 656         if (info->entry != NULL &&
 657                         info->entry->reason == CONNMAN_SESSION_REASON_CONNECT) {
 658                 __connman_service_disconnect(info->entry->service);
 659         }
 660
 661         g_slist_foreach(info->allowed_bearers, cleanup_bearer_info, NULL);
 662         g_slist_free(info->allowed_bearers);
 663
 664         g_free(session->owner);
 665         g_free(session->session_path);
 666         g_free(session->notify_path);
 667
 668         g_free(session);
 669 }
 670
 671 static void release_session(gpointer key, gpointer value, gpointer user_data)
 672 {
 673         struct connman_session *session = value;
 674         DBusMessage *message;
 675
 676         DBG("owner %s path %s", session->owner, session->notify_path);
 677
 678         if (session->notify_watch > 0)
 679                 g_dbus_remove_watch(connection, session->notify_watch);
 680
 681         g_dbus_unregister_interface(connection, session->session_path,
 682                                                 CONNMAN_SESSION_INTERFACE);
 683
 684         message = dbus_message_new_method_call(session->owner,
 685                                                 session->notify_path,
 686                                                 CONNMAN_NOTIFICATION_INTERFACE,
 687                                                 "Release");
 688         if (message == NULL)
 689                 return;
 690
 691         dbus_message_set_no_reply(message, TRUE);
 692
 693         g_dbus_send_message(connection, message);
 694 }
 695
 696 static int session_disconnect(struct connman_session *session)
 697 {
 698         DBG("session %p, %s", session, session->owner);
 699
 700         if (session->notify_watch > 0)
 701                 g_dbus_remove_watch(connection, session->notify_watch);
 702
 703         g_dbus_unregister_interface(connection, session->session_path,
 704                                                 CONNMAN_SESSION_INTERFACE);
 705
 706         g_hash_table_remove(session_hash, session->session_path);
 707
 708         return 0;
 709 }
 710
 711 static void owner_disconnect(DBusConnection *conn, void *user_data)
 712 {
 713         struct connman_session *session = user_data;
 714
 715         DBG("session %p, %s died", session, session->owner);
 716
 717         session_disconnect(session);
 718 }
 719
 720 static DBusMessage *destroy_session(DBusConnection *conn,
 721                                         DBusMessage *msg, void *user_data)
 722 {
 723         struct connman_session *session = user_data;
 724
 725         DBG("session %p", session);
 726
 727         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 728 }
 729
 730 static connman_bool_t is_connected(enum connman_service_state state)
 731 {
 732         switch (state) {
 733         case CONNMAN_SERVICE_STATE_UNKNOWN:
 734         case CONNMAN_SERVICE_STATE_IDLE:
 735         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 736         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 737         case CONNMAN_SERVICE_STATE_DISCONNECT:
 738         case CONNMAN_SERVICE_STATE_FAILURE:
 739                 break;
 740         case CONNMAN_SERVICE_STATE_READY:
 741         case CONNMAN_SERVICE_STATE_ONLINE:
 742                 return TRUE;
 743         }
 744
 745         return FALSE;
 746 }
 747
 748 static void update_info(struct session_info *info)
 749 {
 750         enum connman_service_type type;
 751         int idx;
 752
 753         if (info->entry != NULL) {
 754                 type = connman_service_get_type(info->entry->service);
 755                 info->bearer = service2bearer(type);
 756
 757                 info->online = is_connected(info->entry->state);
 758                 info->name = __connman_service_get_name(info->entry->service);
 759                 if (info->name == NULL)
 760                         info->name = "";
 761
 762                 idx = __connman_service_get_index(info->entry->service);
 763                 info->ifname = connman_inet_ifname(idx);
 764                 if (info->ifname == NULL)
 765                         info->ifname = "";
 766         } else {
 767                 info->bearer = "";
 768                 info->online = FALSE;
 769                 info->name = "";
 770                 info->ifname = "";
 771         }
 772 }
 773
 774 static connman_bool_t explicit_connect(enum connman_session_reason reason)
 775 {
 776         switch (reason) {
 777         case CONNMAN_SESSION_REASON_UNKNOWN:
 778         case CONNMAN_SESSION_REASON_FREE_RIDE:
 779                 break;
 780         case CONNMAN_SESSION_REASON_CONNECT:
 781         case CONNMAN_SESSION_REASON_PERIODIC:
 782                 return TRUE;
 783         }
 784
 785         return FALSE;
 786 }
 787
 788 static void test_and_disconnect(struct connman_session *session)
 789 {
 790         struct session_info *info = &session->info;
 791
 792         if (info->entry == NULL)
 793                 return;
 794
 795         DBG("session %p reason %s service %p state %d",
 796                 session, reason2string(info->entry->reason),
 797                 info->entry->service, info->entry->state);
 798
 799         if (explicit_connect(info->entry->reason) == FALSE)
 800                 goto out;
 801
 802         if (__connman_service_session_dec(info->entry->service) == TRUE)
 803                 goto out;
 804
 805         if (ecall_session != NULL && ecall_session != session)
 806                 goto out;
 807
 808         __connman_service_disconnect(info->entry->service);
 809
 810 out:
 811         info->entry = NULL;
 812 }
 813
 814 static void select_and_connect(struct connman_session *session,
 815                                 enum connman_session_reason reason)
 816 {
 817         struct session_info *info = &session->info;
 818         struct service_entry *entry = NULL;
 819         GSequenceIter *iter;
 820         connman_bool_t do_connect = FALSE;
 821
 822         DBG("session %p reason %s", session, reason2string(reason));
 823
 824         iter = g_sequence_get_begin_iter(session->service_list);
 825
 826         while (g_sequence_iter_is_end(iter) == FALSE) {
 827                 entry = g_sequence_get(iter);
 828
 829                 switch (entry->state) {
 830                 case CONNMAN_SERVICE_STATE_ASSOCIATION:
 831                 case CONNMAN_SERVICE_STATE_CONFIGURATION:
 832                 case CONNMAN_SERVICE_STATE_READY:
 833                 case CONNMAN_SERVICE_STATE_ONLINE:
 834                         /* connecting or connected */
 835                         break;
 836                 case CONNMAN_SERVICE_STATE_IDLE:
 837                 case CONNMAN_SERVICE_STATE_DISCONNECT:
 838                         if (explicit_connect(reason) == TRUE)
 839                                 do_connect = TRUE;
 840                         break;
 841                 case CONNMAN_SERVICE_STATE_UNKNOWN:
 842                 case CONNMAN_SERVICE_STATE_FAILURE:
 843                         entry = NULL;
 844                         break;
 845                 }
 846
 847                 if (entry != NULL)
 848                         break;
 849
 850                 iter = g_sequence_iter_next(iter);
 851         }
 852
 853         if (info->entry != NULL && info->entry != entry)
 854                 test_and_disconnect(session);
 855
 856         if (entry != NULL) {
 857                 info->entry = entry;
 858                 info->entry->reason = reason;
 859
 860                 if (explicit_connect(reason) == TRUE)
 861                         __connman_service_session_inc(info->entry->service);
 862
 863                 if (do_connect == TRUE)
 864                         __connman_service_connect(info->entry->service);
 865         }
 866 }
 867
 868 static void session_changed(struct connman_session *session,
 869                                 enum connman_session_trigger trigger)
 870 {
 871         struct session_info *info = &session->info;
 872         struct session_info *info_last = &session->info_last;
 873         GSequenceIter *iter;
 874
 875         /*
 876          * TODO: This only a placeholder for the 'real' algorithm to
 877          * play a bit around. So we are going to improve it step by step.
 878          */
 879
 880         DBG("session %p trigger %s", session, trigger2string(trigger));
 881
 882         switch (trigger) {
 883         case CONNMAN_SESSION_TRIGGER_UNKNOWN:
 884                 DBG("ignore session changed event");
 885                 return;
 886         case CONNMAN_SESSION_TRIGGER_SETTING:
 887                 if (info->entry != NULL) {
 888                         iter = g_hash_table_lookup(session->service_hash,
 889                                                         info->entry->service);
 890                         if (iter == NULL) {
 891                                 /*
 892                                  * This service is not part of this
 893                                  * session anymore.
 894                                  */
 895                                 test_and_disconnect(session);
 896                         }
 897                 }
 898
 899                 if (info->online == FALSE) {
 900                         select_and_connect(session,
 901                                         CONNMAN_SESSION_REASON_FREE_RIDE);
 902                 }
 903
 904                 break;
 905         case CONNMAN_SESSION_TRIGGER_CONNECT:
 906                 if (info->online == TRUE) {
 907                         info->entry->reason = CONNMAN_SESSION_REASON_CONNECT;
 908                         __connman_service_session_inc(info->entry->service);
 909                         break;
 910                 }
 911
 912                 select_and_connect(session,
 913                                 CONNMAN_SESSION_REASON_CONNECT);
 914
 915                 break;
 916         case CONNMAN_SESSION_TRIGGER_DISCONNECT:
 917                 test_and_disconnect(session);
 918
 919                 break;
 920         case CONNMAN_SESSION_TRIGGER_PERIODIC:
 921                 if (info->online == TRUE) {
 922                         info->entry->reason = CONNMAN_SESSION_REASON_PERIODIC;
 923                         __connman_service_session_inc(info->entry->service);
 924                         break;
 925                 }
 926
 927                 select_and_connect(session,
 928                                 CONNMAN_SESSION_REASON_PERIODIC);
 929
 930                 break;
 931         case CONNMAN_SESSION_TRIGGER_SERVICE:
 932                 if (info->online == TRUE)
 933                         break;
 934
 935                 if (info->stay_connected == TRUE) {
 936                         DBG("StayConnected");
 937                         select_and_connect(session,
 938                                         CONNMAN_SESSION_REASON_CONNECT);
 939
 940                         break;
 941                 }
 942
 943                 select_and_connect(session,
 944                                 CONNMAN_SESSION_REASON_FREE_RIDE);
 945
 946                 break;
 947         case CONNMAN_SESSION_TRIGGER_ECALL:
 948                 if (info->online == FALSE && info->entry->service != NULL)
 949                         test_and_disconnect(session);
 950
 951                 break;
 952         }
 953
 954         if (info->entry != info_last->entry) {
 955                 update_info(info);
 956                 session->info_dirty = TRUE;
 957         }
 958
 959         session_notify(session);
 960 }
 961
 962 static DBusMessage *connect_session(DBusConnection *conn,
 963                                         DBusMessage *msg, void *user_data)
 964 {
 965         struct connman_session *session = user_data;
 966
 967         DBG("session %p", session);
 968
 969         if (ecall_session != NULL && ecall_session != session)
 970                 return __connman_error_failed(msg, EBUSY);
 971
 972         session_changed(session, CONNMAN_SESSION_TRIGGER_CONNECT);
 973
 974         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 975 }
 976
 977 static DBusMessage *disconnect_session(DBusConnection *conn,
 978                                         DBusMessage *msg, void *user_data)
 979 {
 980         struct connman_session *session = user_data;
 981
 982         DBG("session %p", session);
 983
 984         if (ecall_session != NULL && ecall_session != session)
 985                 return __connman_error_failed(msg, EBUSY);
 986
 987         session_changed(session, CONNMAN_SESSION_TRIGGER_DISCONNECT);
 988
 989         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 990 }
 991
 992 static struct service_entry *create_service_entry(struct connman_service *service,
 993                                         const char *name,
 994                                         enum connman_service_state state)
 995 {
 996         struct service_entry *entry;
 997
 998         entry = g_try_new0(struct service_entry, 1);
 999         if (entry == NULL)
1000                 return entry;
1001
1002         entry->reason = CONNMAN_SESSION_REASON_UNKNOWN;
1003         entry->state = state;
1004         entry->service = service;
1005
1006         return entry;
1007 }
1008
1009 static void destroy_service_entry(gpointer data)
1010 {
1011         struct service_entry *entry = data;
1012
1013         g_free(entry);
1014 }
1015
1016 static void update_allowed_bearers(struct connman_session *session)
1017 {
1018         struct service_entry *entry;
1019         GSequenceIter *iter;
1020
1021         if (session->service_list != NULL) {
1022                 g_hash_table_remove_all(session->service_hash);
1023                 g_sequence_free(session->service_list);
1024         }
1025
1026         session->service_list = __connman_service_get_list(session,
1027                                                         service_match,
1028                                                         create_service_entry,
1029                                                         destroy_service_entry);
1030
1031         g_sequence_sort(session->service_list, sort_services, session);
1032
1033         iter = g_sequence_get_begin_iter(session->service_list);
1034
1035         while (g_sequence_iter_is_end(iter) == FALSE) {
1036                 entry = g_sequence_get(iter);
1037
1038                 DBG("service %p type %s name %s", entry->service,
1039                         service2bearer(connman_service_get_type(entry->service)),
1040                         __connman_service_get_name(entry->service));
1041
1042                 g_hash_table_replace(session->service_hash,
1043                                         entry->service, iter);
1044
1045                 iter = g_sequence_iter_next(iter);
1046         }
1047
1048         session->info_dirty = TRUE;
1049 }
1050
1051 static void update_ecall_sessions(struct connman_session *session)
1052 {
1053         struct session_info *info = &session->info;
1054         struct connman_session *session_iter;
1055         GHashTableIter iter;
1056         gpointer key, value;
1057
1058         g_hash_table_iter_init(&iter, session_hash);
1059
1060         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1061                 session_iter = value;
1062
1063                 if (session_iter == session)
1064                         continue;
1065
1066                 session_iter->info.ecall = info->ecall;
1067                 session_iter->info_dirty = TRUE;
1068
1069                 session_changed(session_iter, CONNMAN_SESSION_TRIGGER_ECALL);
1070         }
1071 }
1072
1073 static void update_ecall(struct connman_session *session)
1074 {
1075         struct session_info *info = &session->info;
1076         struct session_info *info_last = &session->info_last;
1077
1078         DBG("session %p ecall_session %p ecall %d -> %d", session,
1079                 ecall_session, info_last->ecall, info->ecall);
1080
1081         if (ecall_session == NULL) {
1082                 if (!(info_last->ecall == FALSE && info->ecall == TRUE))
1083                         goto err;
1084
1085                 ecall_session = session;
1086         } else if (ecall_session == session) {
1087                 if (!(info_last->ecall == TRUE && info->ecall == FALSE))
1088                         goto err;
1089
1090                 ecall_session = NULL;
1091         } else {
1092                 goto err;
1093         }
1094
1095         update_ecall_sessions(session);
1096
1097         session->info_dirty = TRUE;
1098         return;
1099
1100 err:
1101         /* not a valid transition */
1102         info->ecall = info_last->ecall;
1103 }
1104
1105 static DBusMessage *change_session(DBusConnection *conn,
1106                                         DBusMessage *msg, void *user_data)
1107 {
1108         struct connman_session *session = user_data;
1109         struct session_info *info = &session->info;
1110         struct session_info *info_last = &session->info_last;
1111         DBusMessageIter iter, value;
1112         const char *name;
1113         GSList *allowed_bearers;
1114
1115         DBG("session %p", session);
1116         if (dbus_message_iter_init(msg, &iter) == FALSE)
1117                 return __connman_error_invalid_arguments(msg);
1118
1119         dbus_message_iter_get_basic(&iter, &name);
1120         dbus_message_iter_next(&iter);
1121         dbus_message_iter_recurse(&iter, &value);
1122
1123         switch (dbus_message_iter_get_arg_type(&value)) {
1124         case DBUS_TYPE_ARRAY:
1125                 if (g_str_equal(name, "AllowedBearers") == TRUE) {
1126                         allowed_bearers = session_parse_allowed_bearers(&value);
1127
1128                         g_slist_foreach(info->allowed_bearers,
1129                                         cleanup_bearer_info, NULL);
1130                         g_slist_free(info->allowed_bearers);
1131
1132                         if (allowed_bearers == NULL) {
1133                                 allowed_bearers = session_allowed_bearers_any();
1134
1135                                 if (allowed_bearers == NULL)
1136                                         return __connman_error_failed(msg, ENOMEM);
1137                         }
1138
1139                         info->allowed_bearers = allowed_bearers;
1140
1141                         update_allowed_bearers(session);
1142                 } else {
1143                         goto err;
1144                 }
1145                 break;
1146         case DBUS_TYPE_BOOLEAN:
1147                 if (g_str_equal(name, "Priority") == TRUE) {
1148                         dbus_message_iter_get_basic(&value,
1149                                         &info->priority);
1150
1151                         if (info_last->priority != info->priority)
1152                                 session->info_dirty = TRUE;
1153                 } else if (g_str_equal(name, "AvoidHandover") == TRUE) {
1154                         dbus_message_iter_get_basic(&value,
1155                                         &info->avoid_handover);
1156
1157                         if (info_last->avoid_handover != info->avoid_handover)
1158                                 session->info_dirty = TRUE;
1159                 } else if (g_str_equal(name, "StayConnected") == TRUE) {
1160                         dbus_message_iter_get_basic(&value,
1161                                         &info->stay_connected);
1162
1163                         if (info_last->stay_connected != info->stay_connected)
1164                                 session->info_dirty = TRUE;
1165                 } else if (g_str_equal(name, "EmergencyCall") == TRUE) {
1166                         dbus_message_iter_get_basic(&value,
1167                                         &info->ecall);
1168
1169                         update_ecall(session);
1170                 } else {
1171                         goto err;
1172                 }
1173                 break;
1174         case DBUS_TYPE_UINT32:
1175                 if (g_str_equal(name, "PeriodicConnect") == TRUE) {
1176                         dbus_message_iter_get_basic(&value,
1177                                         &info->periodic_connect);
1178
1179                         if (info_last->periodic_connect != info->periodic_connect)
1180                                 session->info_dirty = TRUE;
1181                 } else if (g_str_equal(name, "IdleTimeout") == TRUE) {
1182                         dbus_message_iter_get_basic(&value,
1183                                         &info->idle_timeout);
1184
1185                         if (info_last->idle_timeout != info->idle_timeout)
1186                                 session->info_dirty = TRUE;
1187                 } else {
1188                         goto err;
1189                 }
1190                 break;
1191         case DBUS_TYPE_STRING:
1192                 if (g_str_equal(name, "RoamingPolicy") == TRUE) {
1193                         const char *val;
1194                         dbus_message_iter_get_basic(&value, &val);
1195                         info->roaming_policy =
1196                                         string2roamingpolicy(val);
1197
1198                         if (info_last->roaming_policy != info->roaming_policy)
1199                                 session->info_dirty = TRUE;
1200                 } else {
1201                         goto err;
1202                 }
1203                 break;
1204         default:
1205                 goto err;
1206         }
1207
1208         if (session->info_dirty == TRUE)
1209                 session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);
1210
1211         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1212
1213 err:
1214         return __connman_error_invalid_arguments(msg);
1215 }
1216
1217 static GDBusMethodTable session_methods[] = {
1218         { "Destroy",    "",   "", destroy_session    },
1219         { "Connect",    "",   "", connect_session    },
1220         { "Disconnect", "",   "", disconnect_session },
1221         { "Change",     "sv", "", change_session     },
1222         { },
1223 };
1224
1225 int __connman_session_create(DBusMessage *msg)
1226 {
1227         const char *owner, *notify_path;
1228         char *session_path = NULL;
1229         DBusMessageIter iter, array;
1230         struct connman_session *session;
1231         struct session_info *info, *info_last;
1232
1233         connman_bool_t priority = FALSE, avoid_handover = FALSE;
1234         connman_bool_t stay_connected = FALSE, ecall = FALSE;
1235         enum connman_session_roaming_policy roaming_policy =
1236                                 CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
1237         GSList *allowed_bearers = NULL;
1238         unsigned int periodic_connect = 0;
1239         unsigned int idle_timeout = 0;
1240
1241         int err;
1242
1243         owner = dbus_message_get_sender(msg);
1244
1245         DBG("owner %s", owner);
1246
1247         if (ecall_session != NULL) {
1248                 /*
1249                  * If there is an emergency call already going on,
1250                  * ignore session creation attempt
1251                  */
1252                 err = -EBUSY;
1253                 goto err;
1254         }
1255
1256         dbus_message_iter_init(msg, &iter);
1257         dbus_message_iter_recurse(&iter, &array);
1258
1259         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1260                 DBusMessageIter entry, value;
1261                 const char *key, *val;
1262
1263                 dbus_message_iter_recurse(&array, &entry);
1264                 dbus_message_iter_get_basic(&entry, &key);
1265
1266                 dbus_message_iter_next(&entry);
1267                 dbus_message_iter_recurse(&entry, &value);
1268
1269                 switch (dbus_message_iter_get_arg_type(&value)) {
1270                 case DBUS_TYPE_ARRAY:
1271                         if (g_str_equal(key, "AllowedBearers") == TRUE) {
1272                                 allowed_bearers =
1273                                         session_parse_allowed_bearers(&value);
1274                         } else {
1275                                 return -EINVAL;
1276                         }
1277                         break;
1278                 case DBUS_TYPE_BOOLEAN:
1279                         if (g_str_equal(key, "Priority") == TRUE) {
1280                                 dbus_message_iter_get_basic(&value,
1281                                                         &priority);
1282                         } else if (g_str_equal(key, "AvoidHandover") == TRUE) {
1283                                 dbus_message_iter_get_basic(&value,
1284                                                         &avoid_handover);
1285                         } else if (g_str_equal(key, "StayConnected") == TRUE) {
1286                                 dbus_message_iter_get_basic(&value,
1287                                                         &stay_connected);
1288                         } else if (g_str_equal(key, "EmergencyCall") == TRUE) {
1289                                 dbus_message_iter_get_basic(&value,
1290                                                         &ecall);
1291                         } else {
1292                                 return -EINVAL;
1293                         }
1294                         break;
1295                 case DBUS_TYPE_UINT32:
1296                         if (g_str_equal(key, "PeriodicConnect") == TRUE) {
1297                                 dbus_message_iter_get_basic(&value,
1298                                                         &periodic_connect);
1299                         } else if (g_str_equal(key, "IdleTimeout") == TRUE) {
1300                                 dbus_message_iter_get_basic(&value,
1301                                                         &idle_timeout);
1302                         } else {
1303                                 return -EINVAL;
1304                         }
1305                         break;
1306                 case DBUS_TYPE_STRING:
1307                         if (g_str_equal(key, "RoamingPolicy") == TRUE) {
1308                                 dbus_message_iter_get_basic(&value, &val);
1309                                 roaming_policy = string2roamingpolicy(val);
1310                         } else {
1311                                 return -EINVAL;
1312                         }
1313                 }
1314                 dbus_message_iter_next(&array);
1315         }
1316
1317         dbus_message_iter_next(&iter);
1318         dbus_message_iter_get_basic(&iter, &notify_path);
1319
1320         if (notify_path == NULL) {
1321                 err = -EINVAL;
1322                 goto err;
1323         }
1324
1325         session_path = g_strdup_printf("/sessions%s", notify_path);
1326         if (session_path == NULL) {
1327                 err = -ENOMEM;
1328                 goto err;
1329         }
1330
1331         session = g_hash_table_lookup(session_hash, session_path);
1332         if (session != NULL) {
1333                 err = -EEXIST;
1334                 goto err;
1335         }
1336
1337         session = g_try_new0(struct connman_session, 1);
1338         if (session == NULL) {
1339                 err = -ENOMEM;
1340                 goto err;
1341         }
1342
1343         info = &session->info;
1344         info_last = &session->info_last;
1345
1346         session->owner = g_strdup(owner);
1347         session->session_path = session_path;
1348         session->notify_path = g_strdup(notify_path);
1349         session->notify_watch =
1350                 g_dbus_add_disconnect_watch(connection, session->owner,
1351                                         owner_disconnect, session, NULL);
1352
1353         session->service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1354                                                 NULL, NULL);
1355
1356         info->bearer = "";
1357         info->online = FALSE;
1358         info->priority = priority;
1359         info->avoid_handover = avoid_handover;
1360         info->stay_connected = stay_connected;
1361         info->periodic_connect = periodic_connect;
1362         info->idle_timeout = idle_timeout;
1363         info->ecall = ecall;
1364         info->roaming_policy = roaming_policy;
1365         info->entry = NULL;
1366         info->marker = 0;
1367
1368         if (allowed_bearers == NULL) {
1369                 info->allowed_bearers =
1370                                 session_allowed_bearers_any();
1371
1372                 if (info->allowed_bearers == NULL) {
1373                         err = -ENOMEM;
1374                         goto err;
1375                 }
1376         } else {
1377                 info->allowed_bearers = allowed_bearers;
1378         }
1379
1380         g_hash_table_replace(session_hash, session->session_path, session);
1381
1382         DBG("add %s", session->session_path);
1383
1384         if (g_dbus_register_interface(connection, session->session_path,
1385                                         CONNMAN_SESSION_INTERFACE,
1386                                         session_methods, NULL,
1387                                         NULL, session, NULL) == FALSE) {
1388                 connman_error("Failed to register %s", session->session_path);
1389                 g_hash_table_remove(session_hash, session->session_path);
1390                 session = NULL;
1391
1392                 err = -EINVAL;
1393                 goto err;
1394         }
1395
1396         g_dbus_send_reply(connection, msg,
1397                                 DBUS_TYPE_OBJECT_PATH, &session->session_path,
1398                                 DBUS_TYPE_INVALID);
1399
1400
1401         update_allowed_bearers(session);
1402         update_info(info);
1403         if (info->ecall == TRUE) {
1404                 ecall_session = session;
1405                 update_ecall_sessions(session);
1406         }
1407
1408         info_last->bearer = info->bearer;
1409         info_last->online = info->online;
1410         info_last->priority = info->priority;
1411         info_last->avoid_handover = info->avoid_handover;
1412         info_last->stay_connected = info->stay_connected;
1413         info_last->periodic_connect = info->periodic_connect;
1414         info_last->idle_timeout = info->idle_timeout;
1415         info_last->ecall = info->ecall;
1416         info_last->roaming_policy = info->roaming_policy;
1417         info_last->entry = info->entry;
1418         info_last->marker = info->marker;
1419         info_last->allowed_bearers = info->allowed_bearers;
1420         update_info(info_last);
1421
1422         session->info_dirty = TRUE;
1423         session->append_all = TRUE;
1424
1425         session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);
1426
1427         return 0;
1428
1429 err:
1430         connman_error("Failed to create session");
1431         g_free(session_path);
1432
1433         g_slist_foreach(allowed_bearers, cleanup_bearer_info, NULL);
1434         g_slist_free(allowed_bearers);
1435
1436         return err;
1437 }
1438
1439 int __connman_session_destroy(DBusMessage *msg)
1440 {
1441         const char *owner, *session_path;
1442         struct connman_session *session;
1443
1444         owner = dbus_message_get_sender(msg);
1445
1446         DBG("owner %s", owner);
1447
1448         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &session_path,
1449                                                         DBUS_TYPE_INVALID);
1450         if (session_path == NULL)
1451                 return -EINVAL;
1452
1453         session = g_hash_table_lookup(session_hash, session_path);
1454         if (session == NULL)
1455                 return -EINVAL;
1456
1457         if (g_strcmp0(owner, session->owner) != 0)
1458                 return -EACCES;
1459
1460         session_disconnect(session);
1461
1462         return 0;
1463 }
1464
1465 connman_bool_t __connman_session_mode()
1466 {
1467         return sessionmode;
1468 }
1469
1470 void __connman_session_set_mode(connman_bool_t enable)
1471 {
1472         DBG("enable %d", enable);
1473
1474         if (sessionmode == enable)
1475                 return;
1476
1477         sessionmode = enable;
1478
1479         if (sessionmode == TRUE)
1480                 __connman_service_disconnect_all();
1481 }
1482
1483 static void service_add(struct connman_service *service)
1484 {
1485         GHashTableIter iter;
1486         GSequenceIter *iter_service_list;
1487         gpointer key, value;
1488         struct connman_session *session;
1489
1490         DBG("service %p", service);
1491
1492         g_hash_table_iter_init(&iter, session_hash);
1493
1494         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1495                 session = value;
1496
1497                 if (service_match(session, service) == FALSE)
1498                         continue;
1499
1500                 iter_service_list =
1501                         g_sequence_insert_sorted(session->service_list,
1502                                                         service, sort_services,
1503                                                         session);
1504
1505                 g_hash_table_replace(session->service_hash, service,
1506                                         iter_service_list);
1507
1508                 session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
1509         }
1510 }
1511
1512 static void service_remove(struct connman_service *service)
1513 {
1514
1515         GHashTableIter iter;
1516         gpointer key, value;
1517         struct connman_session *session;
1518         struct session_info *info;
1519
1520         DBG("service %p", service);
1521
1522         g_hash_table_iter_init(&iter, session_hash);
1523
1524         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1525                 GSequenceIter *iter;
1526                 session = value;
1527                 info = &session->info;
1528
1529                 iter = g_hash_table_lookup(session->service_hash, service);
1530                 if (iter == NULL)
1531                         continue;
1532
1533                 g_sequence_remove(iter);
1534
1535                 info->entry = NULL;
1536                 session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
1537         }
1538 }
1539
1540 static void service_state_changed(struct connman_service *service,
1541                                         enum connman_service_state state)
1542 {
1543         GHashTableIter iter;
1544         gpointer key, value;
1545         struct connman_session *session;
1546         struct session_info *info, *info_last;
1547
1548         DBG("service %p state %d", service, state);
1549
1550         g_hash_table_iter_init(&iter, session_hash);
1551
1552         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1553                 session = value;
1554                 info = &session->info;
1555                 info_last = &session->info_last;
1556
1557                 if (info->entry != NULL && info->entry->service == service) {
1558                         info->entry->state = state;
1559                         info->online = is_connected(info->entry->state);
1560                         if (info_last->online != info->online)
1561                                 session->info_dirty = TRUE;
1562                 }
1563
1564                 session_changed(session,
1565                                 CONNMAN_SESSION_TRIGGER_SERVICE);
1566         }
1567 }
1568
1569 static void ipconfig_changed(struct connman_service *service,
1570                                 struct connman_ipconfig *ipconfig)
1571 {
1572         GHashTableIter iter;
1573         gpointer key, value;
1574         struct connman_session *session;
1575         struct session_info *info;
1576         enum connman_ipconfig_type type;
1577
1578         DBG("service %p ipconfig %p", service, ipconfig);
1579
1580         type = __connman_ipconfig_get_config_type(ipconfig);
1581
1582         g_hash_table_iter_init(&iter, session_hash);
1583
1584         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1585                 session = value;
1586                 info = &session->info;
1587
1588                 if (info->entry != NULL && info->entry->service == service) {
1589                         if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1590                                 ipconfig_ipv4_changed(session);
1591                         else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1592                                 ipconfig_ipv6_changed(session);
1593                 }
1594         }
1595 }
1596
1597 static struct connman_notifier session_notifier = {
1598         .name                   = "session",
1599         .service_add            = service_add,
1600         .service_remove         = service_remove,
1601         .service_state_changed  = service_state_changed,
1602         .ipconfig_changed       = ipconfig_changed,
1603 };
1604
1605 int __connman_session_init(void)
1606 {
1607         int err;
1608
1609         DBG("");
1610
1611         connection = connman_dbus_get_connection();
1612         if (connection == NULL)
1613                 return -1;
1614
1615         err = connman_notifier_register(&session_notifier);
1616         if (err < 0) {
1617                 dbus_connection_unref(connection);
1618                 return err;
1619         }
1620
1621         session_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1622                                                 NULL, cleanup_session);
1623
1624         sessionmode = FALSE;
1625         return 0;
1626 }
1627
1628 void __connman_session_cleanup(void)
1629 {
1630         DBG("");
1631
1632         if (connection == NULL)
1633                 return;
1634
1635         connman_notifier_unregister(&session_notifier);
1636
1637         g_hash_table_foreach(session_hash, release_session, NULL);
1638         g_hash_table_destroy(session_hash);
1639
1640         dbus_connection_unref(connection);
1641 }