5 * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
6 * Copyright (C) 2011 BWM CarIT GmbH. All rights reserved.
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.
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.
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
33 static DBusConnection *connection;
34 static GHashTable *session_hash;
35 static connman_bool_t sessionmode;
36 static struct session_info *ecall_info;
38 enum connman_session_trigger {
39 CONNMAN_SESSION_TRIGGER_UNKNOWN = 0,
40 CONNMAN_SESSION_TRIGGER_SETTING = 1,
41 CONNMAN_SESSION_TRIGGER_CONNECT = 2,
42 CONNMAN_SESSION_TRIGGER_DISCONNECT = 3,
43 CONNMAN_SESSION_TRIGGER_PERIODIC = 4,
44 CONNMAN_SESSION_TRIGGER_SERVICE = 5,
45 CONNMAN_SESSION_TRIGGER_ECALL = 6,
48 enum connman_session_reason {
49 CONNMAN_SESSION_REASON_UNKNOWN = 0,
50 CONNMAN_SESSION_REASON_CONNECT = 1,
51 CONNMAN_SESSION_REASON_DISCONNECT = 2,
52 CONNMAN_SESSION_REASON_FREE_RIDE = 3,
53 CONNMAN_SESSION_REASON_PERIODIC = 4,
56 enum connman_session_state {
57 CONNMAN_SESSION_STATE_DISCONNECTED = 0,
58 CONNMAN_SESSION_STATE_CONNECTED = 1,
59 CONNMAN_SESSION_STATE_ONLINE = 2,
62 enum connman_session_type {
63 CONNMAN_SESSION_TYPE_ANY = 0,
64 CONNMAN_SESSION_TYPE_LOCAL = 1,
65 CONNMAN_SESSION_TYPE_INTERNET = 2,
68 enum connman_session_roaming_policy {
69 CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN = 0,
70 CONNMAN_SESSION_ROAMING_POLICY_DEFAULT = 1,
71 CONNMAN_SESSION_ROAMING_POLICY_ALWAYS = 2,
72 CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN = 3,
73 CONNMAN_SESSION_ROAMING_POLICY_NATIONAL = 4,
74 CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL = 5,
77 struct service_entry {
78 /* track why this service was selected */
79 enum connman_session_reason reason;
80 enum connman_service_state state;
82 struct connman_service *service;
85 GSList *pending_timeouts;
89 enum connman_session_state state;
90 enum connman_session_type type;
91 connman_bool_t priority;
92 GSList *allowed_bearers;
93 connman_bool_t avoid_handover;
94 connman_bool_t stay_connected;
95 unsigned int periodic_connect;
97 enum connman_session_roaming_policy roaming_policy;
100 struct service_entry *entry;
101 enum connman_session_reason reason;
104 struct connman_session {
110 connman_bool_t append_all;
111 struct session_info *info;
112 struct session_info *info_last;
114 GSequence *service_list;
115 GHashTable *service_hash;
120 connman_bool_t match_all;
121 enum connman_service_type service_type;
124 static const char *trigger2string(enum connman_session_trigger trigger)
127 case CONNMAN_SESSION_TRIGGER_UNKNOWN:
129 case CONNMAN_SESSION_TRIGGER_SETTING:
131 case CONNMAN_SESSION_TRIGGER_CONNECT:
133 case CONNMAN_SESSION_TRIGGER_DISCONNECT:
135 case CONNMAN_SESSION_TRIGGER_PERIODIC:
137 case CONNMAN_SESSION_TRIGGER_SERVICE:
139 case CONNMAN_SESSION_TRIGGER_ECALL:
146 static const char *reason2string(enum connman_session_reason reason)
149 case CONNMAN_SESSION_REASON_UNKNOWN:
151 case CONNMAN_SESSION_REASON_CONNECT:
153 case CONNMAN_SESSION_REASON_DISCONNECT:
155 case CONNMAN_SESSION_REASON_FREE_RIDE:
157 case CONNMAN_SESSION_REASON_PERIODIC:
164 static const char *state2string(enum connman_session_state state)
167 case CONNMAN_SESSION_STATE_DISCONNECTED:
168 return "disconnected";
169 case CONNMAN_SESSION_STATE_CONNECTED:
171 case CONNMAN_SESSION_STATE_ONLINE:
178 static const char *type2string(enum connman_session_type type)
181 case CONNMAN_SESSION_TYPE_ANY:
183 case CONNMAN_SESSION_TYPE_LOCAL:
185 case CONNMAN_SESSION_TYPE_INTERNET:
192 static enum connman_session_type string2type(const char *type)
194 if (g_strcmp0(type, "local") == 0)
195 return CONNMAN_SESSION_TYPE_LOCAL;
196 else if (g_strcmp0(type, "internet") == 0)
197 return CONNMAN_SESSION_TYPE_INTERNET;
199 return CONNMAN_SESSION_TYPE_ANY;
202 static const char *roamingpolicy2string(enum connman_session_roaming_policy policy)
205 case CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN:
207 case CONNMAN_SESSION_ROAMING_POLICY_DEFAULT:
209 case CONNMAN_SESSION_ROAMING_POLICY_ALWAYS:
211 case CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN:
213 case CONNMAN_SESSION_ROAMING_POLICY_NATIONAL:
215 case CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL:
216 return "international";
222 static enum connman_session_roaming_policy string2roamingpolicy(const char *policy)
224 if (g_strcmp0(policy, "default") == 0)
225 return CONNMAN_SESSION_ROAMING_POLICY_DEFAULT;
226 else if (g_strcmp0(policy, "always") == 0)
227 return CONNMAN_SESSION_ROAMING_POLICY_ALWAYS;
228 else if (g_strcmp0(policy, "forbidden") == 0)
229 return CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
230 else if (g_strcmp0(policy, "national") == 0)
231 return CONNMAN_SESSION_ROAMING_POLICY_NATIONAL;
232 else if (g_strcmp0(policy, "international") == 0)
233 return CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL;
235 return CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN;
238 static enum connman_service_type bearer2service(const char *bearer)
241 return CONNMAN_SERVICE_TYPE_UNKNOWN;
243 if (g_strcmp0(bearer, "ethernet") == 0)
244 return CONNMAN_SERVICE_TYPE_ETHERNET;
245 else if (g_strcmp0(bearer, "wifi") == 0)
246 return CONNMAN_SERVICE_TYPE_WIFI;
247 else if (g_strcmp0(bearer, "wimax") == 0)
248 return CONNMAN_SERVICE_TYPE_WIMAX;
249 else if (g_strcmp0(bearer, "bluetooth") == 0)
250 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
251 else if (g_strcmp0(bearer, "cellular") == 0)
252 return CONNMAN_SERVICE_TYPE_CELLULAR;
253 else if (g_strcmp0(bearer, "vpn") == 0)
254 return CONNMAN_SERVICE_TYPE_VPN;
256 return CONNMAN_SERVICE_TYPE_UNKNOWN;
259 static char *service2bearer(enum connman_service_type type)
262 case CONNMAN_SERVICE_TYPE_ETHERNET:
264 case CONNMAN_SERVICE_TYPE_WIFI:
266 case CONNMAN_SERVICE_TYPE_WIMAX:
268 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
270 case CONNMAN_SERVICE_TYPE_CELLULAR:
272 case CONNMAN_SERVICE_TYPE_VPN:
274 case CONNMAN_SERVICE_TYPE_UNKNOWN:
275 case CONNMAN_SERVICE_TYPE_SYSTEM:
276 case CONNMAN_SERVICE_TYPE_GPS:
277 case CONNMAN_SERVICE_TYPE_GADGET:
284 static void cleanup_bearer_info(gpointer data, gpointer user_data)
286 struct bearer_info *info = data;
292 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
294 struct bearer_info *info;
295 DBusMessageIter array;
298 dbus_message_iter_recurse(iter, &array);
300 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
303 dbus_message_iter_get_basic(&array, &bearer);
305 info = g_try_new0(struct bearer_info, 1);
307 g_slist_foreach(list, cleanup_bearer_info, NULL);
313 info->name = g_strdup(bearer);
314 info->service_type = bearer2service(info->name);
316 if (info->service_type == CONNMAN_SERVICE_TYPE_UNKNOWN &&
317 g_strcmp0(info->name, "*") == 0) {
318 info->match_all = TRUE;
320 info->match_all = FALSE;
323 list = g_slist_append(list, info);
325 dbus_message_iter_next(&array);
331 static GSList *session_allowed_bearers_any(void)
333 struct bearer_info *info;
336 info = g_try_new0(struct bearer_info, 1);
343 info->name = g_strdup("");
344 info->match_all = TRUE;
345 info->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
347 list = g_slist_append(list, info);
352 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
354 struct session_info *info = user_data;
357 for (list = info->allowed_bearers;
358 list != NULL; list = list->next) {
359 struct bearer_info *bearer_info = list->data;
361 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
366 static void append_ipconfig_ipv4(DBusMessageIter *iter, void *user_data)
368 struct connman_service *service = user_data;
369 struct connman_ipconfig *ipconfig_ipv4;
374 if (__connman_service_is_connected_state(service,
375 CONNMAN_IPCONFIG_TYPE_IPV4) == FALSE) {
379 ipconfig_ipv4 = __connman_service_get_ip4config(service);
380 if (ipconfig_ipv4 == NULL)
383 __connman_ipconfig_append_ipv4(ipconfig_ipv4, iter);
386 static void append_ipconfig_ipv6(DBusMessageIter *iter, void *user_data)
388 struct connman_service *service = user_data;
389 struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
394 if (__connman_service_is_connected_state(service,
395 CONNMAN_IPCONFIG_TYPE_IPV6) == FALSE) {
399 ipconfig_ipv4 = __connman_service_get_ip4config(service);
400 ipconfig_ipv6 = __connman_service_get_ip6config(service);
401 if (ipconfig_ipv6 == NULL)
404 __connman_ipconfig_append_ipv6(ipconfig_ipv6, iter, ipconfig_ipv4);
407 static void append_notify(DBusMessageIter *dict,
408 struct connman_session *session)
410 struct session_info *info = session->info;
411 struct session_info *info_last = session->info_last;
413 struct connman_service *service;
414 const char *name, *ifname, *bearer;
416 if (session->append_all == TRUE ||
417 info->state != info_last->state) {
418 const char *state = state2string(info->state);
420 connman_dbus_dict_append_basic(dict, "State",
423 info_last->state = info->state;
426 if (session->append_all == TRUE ||
427 info->entry != info_last->entry) {
428 if (info->entry == NULL) {
434 name = info->entry->name;
435 ifname = info->entry->ifname;
436 service = info->entry->service;
437 bearer = info->entry->bearer;
440 connman_dbus_dict_append_basic(dict, "Name",
444 connman_dbus_dict_append_dict(dict, "IPv4",
445 append_ipconfig_ipv4,
448 connman_dbus_dict_append_dict(dict, "IPv6",
449 append_ipconfig_ipv6,
452 connman_dbus_dict_append_basic(dict, "Interface",
456 connman_dbus_dict_append_basic(dict, "Bearer",
460 info_last->entry = info->entry;
463 if (session->append_all == TRUE || info->type != info_last->type) {
464 const char *type = type2string(info->type);
466 connman_dbus_dict_append_basic(dict, "ConnectionType",
469 info_last->type = info->type;
472 if (session->append_all == TRUE ||
473 info->priority != info_last->priority) {
474 connman_dbus_dict_append_basic(dict, "Priority",
477 info_last->priority = info->priority;
480 if (session->append_all == TRUE ||
481 info->allowed_bearers != info_last->allowed_bearers) {
482 connman_dbus_dict_append_array(dict, "AllowedBearers",
484 append_allowed_bearers,
486 info_last->allowed_bearers = info->allowed_bearers;
489 if (session->append_all == TRUE ||
490 info->avoid_handover != info_last->avoid_handover) {
491 connman_dbus_dict_append_basic(dict, "AvoidHandover",
493 &info->avoid_handover);
494 info_last->avoid_handover = info->avoid_handover;
497 if (session->append_all == TRUE ||
498 info->stay_connected != info_last->stay_connected) {
499 connman_dbus_dict_append_basic(dict, "StayConnected",
501 &info->stay_connected);
502 info_last->stay_connected = info->stay_connected;
505 if (session->append_all == TRUE ||
506 info->periodic_connect != info_last->periodic_connect) {
507 connman_dbus_dict_append_basic(dict, "PeriodicConnect",
509 &info->periodic_connect);
510 info_last->periodic_connect = info->periodic_connect;
513 if (session->append_all == TRUE ||
514 info->ecall != info_last->ecall) {
515 connman_dbus_dict_append_basic(dict, "EmergencyCall",
518 info_last->ecall = info->ecall;
521 if (session->append_all == TRUE ||
522 info->roaming_policy != info_last->roaming_policy) {
523 policy = roamingpolicy2string(info->roaming_policy);
524 connman_dbus_dict_append_basic(dict, "RoamingPolicy",
527 info_last->roaming_policy = info->roaming_policy;
530 if (session->append_all == TRUE ||
531 info->marker != info_last->marker) {
532 connman_dbus_dict_append_basic(dict, "SessionMarker",
535 info_last->marker = info->marker;
538 session->append_all = FALSE;
541 static connman_bool_t is_type_matching_state(enum connman_session_state *state,
542 enum connman_session_type type)
545 case CONNMAN_SESSION_TYPE_ANY:
547 case CONNMAN_SESSION_TYPE_LOCAL:
548 if (*state >= CONNMAN_SESSION_STATE_CONNECTED) {
549 *state = CONNMAN_SESSION_STATE_CONNECTED;
554 case CONNMAN_SESSION_TYPE_INTERNET:
555 if (*state == CONNMAN_SESSION_STATE_ONLINE)
563 static connman_bool_t compute_notifiable_changes(struct connman_session *session)
565 struct session_info *info_last = session->info_last;
566 struct session_info *info = session->info;
568 if (session->append_all == TRUE)
571 if (info->state != info_last->state)
574 if (info->entry != info_last->entry &&
575 info->state >= CONNMAN_SESSION_STATE_CONNECTED)
578 if (info->periodic_connect != info_last->periodic_connect ||
579 info->allowed_bearers != info_last->allowed_bearers ||
580 info->avoid_handover != info_last->avoid_handover ||
581 info->stay_connected != info_last->stay_connected ||
582 info->roaming_policy != info_last->roaming_policy ||
583 info->priority != info_last->priority ||
584 info->marker != info_last->marker ||
585 info->ecall != info_last->ecall ||
586 info->type != info_last->type)
592 static gboolean session_notify(gpointer user_data)
594 struct connman_session *session = user_data;
596 DBusMessageIter array, dict;
598 if (compute_notifiable_changes(session) == FALSE)
601 DBG("session %p owner %s notify_path %s", session,
602 session->owner, session->notify_path);
604 msg = dbus_message_new_method_call(session->owner, session->notify_path,
605 CONNMAN_NOTIFICATION_INTERFACE,
610 dbus_message_iter_init_append(msg, &array);
611 connman_dbus_dict_open(&array, &dict);
613 append_notify(&dict, session);
615 connman_dbus_dict_close(&array, &dict);
617 g_dbus_send_message(connection, msg);
622 static void ipconfig_ipv4_changed(struct connman_session *session)
624 struct session_info *info = session->info;
626 connman_dbus_setting_changed_dict(session->owner, session->notify_path,
627 "IPv4", append_ipconfig_ipv4,
628 info->entry->service);
631 static void ipconfig_ipv6_changed(struct connman_session *session)
633 struct session_info *info = session->info;
635 connman_dbus_setting_changed_dict(session->owner, session->notify_path,
636 "IPv6", append_ipconfig_ipv6,
637 info->entry->service);
640 static connman_bool_t service_type_match(struct connman_session *session,
641 struct connman_service *service)
643 struct session_info *info = session->info;
646 for (list = info->allowed_bearers;
647 list != NULL; list = list->next) {
648 struct bearer_info *bearer_info = list->data;
649 enum connman_service_type service_type;
651 if (bearer_info->match_all == TRUE)
654 service_type = connman_service_get_type(service);
655 if (bearer_info->service_type == service_type)
662 static connman_bool_t service_match(struct connman_session *session,
663 struct connman_service *service)
665 if (service_type_match(session, service) == FALSE)
671 static int service_type_weight(enum connman_service_type type)
674 * The session doesn't care which service
675 * to use. Nevertheless we have to sort them
676 * according their type. The ordering is
685 case CONNMAN_SERVICE_TYPE_ETHERNET:
687 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
689 case CONNMAN_SERVICE_TYPE_WIFI:
690 case CONNMAN_SERVICE_TYPE_WIMAX:
692 case CONNMAN_SERVICE_TYPE_CELLULAR:
694 case CONNMAN_SERVICE_TYPE_UNKNOWN:
695 case CONNMAN_SERVICE_TYPE_SYSTEM:
696 case CONNMAN_SERVICE_TYPE_GPS:
697 case CONNMAN_SERVICE_TYPE_VPN:
698 case CONNMAN_SERVICE_TYPE_GADGET:
705 static gint sort_allowed_bearers(struct connman_service *service_a,
706 struct connman_service *service_b,
707 struct connman_session *session)
709 struct session_info *info = session->info;
711 enum connman_service_type type_a, type_b;
712 int weight_a, weight_b;
714 type_a = connman_service_get_type(service_a);
715 type_b = connman_service_get_type(service_b);
717 for (list = info->allowed_bearers;
718 list != NULL; list = list->next) {
719 struct bearer_info *bearer_info = list->data;
721 if (bearer_info->match_all == TRUE) {
722 if (type_a != type_b) {
723 weight_a = service_type_weight(type_a);
724 weight_b = service_type_weight(type_b);
726 if (weight_a > weight_b)
729 if (weight_a < weight_b)
736 if (type_a == bearer_info->service_type &&
737 type_b == bearer_info->service_type) {
741 if (type_a == bearer_info->service_type &&
742 type_b != bearer_info->service_type) {
746 if (type_a != bearer_info->service_type &&
747 type_b == bearer_info->service_type) {
755 static gint sort_services(gconstpointer a, gconstpointer b, gpointer user_data)
757 struct service_entry *entry_a = (void *)a;
758 struct service_entry *entry_b = (void *)b;
759 struct connman_session *session = user_data;
761 return sort_allowed_bearers(entry_a->service, entry_b->service,
765 static void cleanup_session(gpointer user_data)
767 struct connman_session *session = user_data;
768 struct session_info *info = session->info;
770 DBG("remove %s", session->session_path);
772 g_hash_table_destroy(session->service_hash);
773 g_sequence_free(session->service_list);
775 if (info->entry != NULL &&
776 info->entry->reason == CONNMAN_SESSION_REASON_CONNECT) {
777 __connman_service_disconnect(info->entry->service);
780 g_slist_foreach(info->allowed_bearers, cleanup_bearer_info, NULL);
781 g_slist_free(info->allowed_bearers);
783 g_free(session->owner);
784 g_free(session->session_path);
785 g_free(session->notify_path);
786 g_free(session->info);
787 g_free(session->info_last);
792 static enum connman_session_state service_to_session_state(enum connman_service_state state)
795 case CONNMAN_SERVICE_STATE_UNKNOWN:
796 case CONNMAN_SERVICE_STATE_IDLE:
797 case CONNMAN_SERVICE_STATE_ASSOCIATION:
798 case CONNMAN_SERVICE_STATE_CONFIGURATION:
799 case CONNMAN_SERVICE_STATE_DISCONNECT:
800 case CONNMAN_SERVICE_STATE_FAILURE:
802 case CONNMAN_SERVICE_STATE_READY:
803 return CONNMAN_SESSION_STATE_CONNECTED;
804 case CONNMAN_SERVICE_STATE_ONLINE:
805 return CONNMAN_SESSION_STATE_ONLINE;
808 return CONNMAN_SESSION_STATE_DISCONNECTED;
811 static connman_bool_t is_connected(enum connman_service_state state)
814 case CONNMAN_SERVICE_STATE_UNKNOWN:
815 case CONNMAN_SERVICE_STATE_IDLE:
816 case CONNMAN_SERVICE_STATE_ASSOCIATION:
817 case CONNMAN_SERVICE_STATE_CONFIGURATION:
818 case CONNMAN_SERVICE_STATE_DISCONNECT:
819 case CONNMAN_SERVICE_STATE_FAILURE:
821 case CONNMAN_SERVICE_STATE_READY:
822 case CONNMAN_SERVICE_STATE_ONLINE:
829 static connman_bool_t is_connecting(enum connman_service_state state)
832 case CONNMAN_SERVICE_STATE_UNKNOWN:
833 case CONNMAN_SERVICE_STATE_IDLE:
835 case CONNMAN_SERVICE_STATE_ASSOCIATION:
836 case CONNMAN_SERVICE_STATE_CONFIGURATION:
838 case CONNMAN_SERVICE_STATE_DISCONNECT:
839 case CONNMAN_SERVICE_STATE_FAILURE:
840 case CONNMAN_SERVICE_STATE_READY:
841 case CONNMAN_SERVICE_STATE_ONLINE:
848 static connman_bool_t explicit_connect(enum connman_session_reason reason)
851 case CONNMAN_SESSION_REASON_UNKNOWN:
852 case CONNMAN_SESSION_REASON_FREE_RIDE:
853 case CONNMAN_SESSION_REASON_DISCONNECT:
855 case CONNMAN_SESSION_REASON_CONNECT:
856 case CONNMAN_SESSION_REASON_PERIODIC:
863 static connman_bool_t explicit_disconnect(struct session_info *info)
865 if (info->entry == NULL)
868 DBG("reason %s service %p state %d",
869 reason2string(info->entry->reason),
870 info->entry->service, info->entry->state);
872 if (info->entry->reason == CONNMAN_SESSION_REASON_UNKNOWN)
875 if (explicit_connect(info->entry->reason) == FALSE)
878 if (__connman_service_session_dec(info->entry->service) == FALSE)
881 if (ecall_info != NULL && ecall_info != info)
887 struct pending_data {
888 unsigned int timeout;
889 struct service_entry *entry;
890 gboolean (*cb)(gpointer);
893 static void pending_timeout_free(gpointer data, gpointer user_data)
895 struct pending_data *pending = data;
897 DBG("pending %p timeout %d", pending, pending->timeout);
898 g_source_remove(pending->timeout);
902 static void pending_timeout_remove_all(struct service_entry *entry)
906 g_slist_foreach(entry->pending_timeouts, pending_timeout_free, NULL);
907 g_slist_free(entry->pending_timeouts);
908 entry->pending_timeouts = NULL;
911 static gboolean pending_timeout_cb(gpointer data)
913 struct pending_data *pending = data;
914 struct service_entry *entry = pending->entry;
917 DBG("pending %p timeout %d", pending, pending->timeout);
919 ret = pending->cb(pending->entry);
921 entry->pending_timeouts =
922 g_slist_remove(entry->pending_timeouts,
929 static connman_bool_t pending_timeout_add(unsigned int seconds,
930 gboolean (*cb)(gpointer),
931 struct service_entry *entry)
933 struct pending_data *pending = g_try_new0(struct pending_data, 1);
935 if (pending == NULL || cb == NULL || entry == NULL) {
941 pending->entry = entry;
942 pending->timeout = g_timeout_add_seconds(seconds, pending_timeout_cb,
944 entry->pending_timeouts = g_slist_prepend(entry->pending_timeouts,
947 DBG("pending %p entry %p timeout id %d", pending, entry,
953 static gboolean call_disconnect(gpointer user_data)
955 struct service_entry *entry = user_data;
956 struct connman_service *service = entry->service;
959 * TODO: We should mark this entry as pending work. In case
960 * disconnect fails we just unassign this session from the
961 * service and can't do anything later on it
963 DBG("disconnect service %p", service);
964 __connman_service_disconnect(service);
969 static gboolean call_connect(gpointer user_data)
971 struct service_entry *entry = user_data;
972 struct connman_service *service = entry->service;
974 DBG("connect service %p", service);
975 __connman_service_connect(service);
980 static void deselect_service(struct session_info *info)
982 struct service_entry *entry;
983 connman_bool_t disconnect, connected;
987 if (info->entry == NULL)
990 disconnect = explicit_disconnect(info);
992 connected = is_connecting(info->entry->state) == TRUE ||
993 is_connected(info->entry->state) == TRUE;
995 info->state = CONNMAN_SESSION_STATE_DISCONNECTED;
996 info->entry->reason = CONNMAN_SESSION_REASON_UNKNOWN;
1001 DBG("disconnect %d connected %d", disconnect, connected);
1003 if (disconnect == TRUE && connected == TRUE)
1004 pending_timeout_add(0, call_disconnect, entry);
1007 static void deselect_and_disconnect(struct connman_session *session,
1008 enum connman_session_reason reason)
1010 struct session_info *info = session->info;
1012 deselect_service(info);
1014 info->reason = reason;
1017 static void select_connected_service(struct session_info *info,
1018 struct service_entry *entry)
1020 enum connman_session_state state;
1022 state = service_to_session_state(entry->state);
1023 if (is_type_matching_state(&state, info->type) == FALSE)
1026 info->state = state;
1028 info->entry = entry;
1029 info->entry->reason = info->reason;
1031 if (explicit_connect(info->reason) == FALSE)
1034 __connman_service_session_inc(info->entry->service);
1037 static void select_offline_service(struct session_info *info,
1038 struct service_entry *entry)
1040 if (explicit_connect(info->reason) == FALSE)
1043 info->state = service_to_session_state(entry->state);
1045 info->entry = entry;
1046 info->entry->reason = info->reason;
1048 __connman_service_session_inc(info->entry->service);
1049 pending_timeout_add(0, call_connect, entry);
1052 static void select_service(struct session_info *info,
1053 struct service_entry *entry)
1055 DBG("service %p", entry->service);
1057 if (is_connected(entry->state) == TRUE)
1058 select_connected_service(info, entry);
1060 select_offline_service(info, entry);
1063 static void select_and_connect(struct connman_session *session,
1064 enum connman_session_reason reason)
1066 struct session_info *info = session->info;
1067 struct service_entry *entry = NULL;
1068 GSequenceIter *iter;
1070 DBG("session %p reason %s", session, reason2string(reason));
1072 info->reason = reason;
1074 iter = g_sequence_get_begin_iter(session->service_list);
1076 while (g_sequence_iter_is_end(iter) == FALSE) {
1077 entry = g_sequence_get(iter);
1079 switch (entry->state) {
1080 case CONNMAN_SERVICE_STATE_ASSOCIATION:
1081 case CONNMAN_SERVICE_STATE_CONFIGURATION:
1082 case CONNMAN_SERVICE_STATE_READY:
1083 case CONNMAN_SERVICE_STATE_ONLINE:
1084 case CONNMAN_SERVICE_STATE_IDLE:
1085 case CONNMAN_SERVICE_STATE_DISCONNECT:
1086 select_service(info, entry);
1088 case CONNMAN_SERVICE_STATE_UNKNOWN:
1089 case CONNMAN_SERVICE_STATE_FAILURE:
1093 iter = g_sequence_iter_next(iter);
1097 static struct service_entry *create_service_entry(struct connman_service *service,
1099 enum connman_service_state state)
1101 struct service_entry *entry;
1102 enum connman_service_type type;
1105 entry = g_try_new0(struct service_entry, 1);
1109 entry->reason = CONNMAN_SESSION_REASON_UNKNOWN;
1110 entry->state = state;
1115 entry->service = service;
1117 idx = __connman_service_get_index(entry->service);
1118 entry->ifname = connman_inet_ifname(idx);
1119 if (entry->ifname == NULL)
1120 entry->ifname = g_strdup("");
1122 type = connman_service_get_type(entry->service);
1123 entry->bearer = service2bearer(type);
1128 static void destroy_service_entry(gpointer data)
1130 struct service_entry *entry = data;
1132 pending_timeout_remove_all(entry);
1133 g_free(entry->ifname);
1138 static void populate_service_list(struct connman_session *session)
1140 struct service_entry *entry;
1141 GSequenceIter *iter;
1143 session->service_hash =
1144 g_hash_table_new_full(g_direct_hash, g_direct_equal,
1146 session->service_list = __connman_service_get_list(session,
1148 create_service_entry,
1149 destroy_service_entry);
1151 g_sequence_sort(session->service_list, sort_services, session);
1153 iter = g_sequence_get_begin_iter(session->service_list);
1155 while (g_sequence_iter_is_end(iter) == FALSE) {
1156 entry = g_sequence_get(iter);
1158 DBG("service %p type %s name %s", entry->service,
1159 service2bearer(connman_service_get_type(entry->service)),
1162 g_hash_table_replace(session->service_hash,
1163 entry->service, iter);
1165 iter = g_sequence_iter_next(iter);
1169 static void session_changed(struct connman_session *session,
1170 enum connman_session_trigger trigger)
1172 struct session_info *info = session->info;
1173 struct session_info *info_last = session->info_last;
1174 GSequenceIter *service_iter = NULL, *service_iter_last = NULL;
1175 GSequence *service_list_last;
1176 GHashTable *service_hash_last;
1179 * TODO: This only a placeholder for the 'real' algorithm to
1180 * play a bit around. So we are going to improve it step by step.
1183 DBG("session %p trigger %s reason %s", session, trigger2string(trigger),
1184 reason2string(info->reason));
1186 if (info->entry != NULL) {
1187 enum connman_session_state state;
1189 state = service_to_session_state(info->entry->state);
1191 if (is_type_matching_state(&state, info->type) == TRUE)
1192 info->state = state;
1196 case CONNMAN_SESSION_TRIGGER_UNKNOWN:
1197 DBG("ignore session changed event");
1199 case CONNMAN_SESSION_TRIGGER_SETTING:
1200 if (info->allowed_bearers != info_last->allowed_bearers) {
1202 service_hash_last = session->service_hash;
1203 service_list_last = session->service_list;
1205 populate_service_list(session);
1207 if (info->entry != NULL) {
1208 service_iter_last = g_hash_table_lookup(
1210 info->entry->service);
1211 service_iter = g_hash_table_lookup(
1212 session->service_hash,
1213 info->entry->service);
1216 if (service_iter == NULL && service_iter_last != NULL) {
1218 * The currently selected service is
1219 * not part of this session anymore.
1221 deselect_and_disconnect(session, info->reason);
1224 g_hash_table_remove_all(service_hash_last);
1225 g_sequence_free(service_list_last);
1228 if (info->type != info_last->type) {
1229 if (info->state >= CONNMAN_SESSION_STATE_CONNECTED &&
1230 is_type_matching_state(&info->state,
1231 info->type) == FALSE)
1232 deselect_and_disconnect(session, info->reason);
1235 if (info->state == CONNMAN_SESSION_STATE_DISCONNECTED) {
1236 select_and_connect(session,
1237 CONNMAN_SESSION_REASON_FREE_RIDE);
1241 case CONNMAN_SESSION_TRIGGER_CONNECT:
1242 if (info->state >= CONNMAN_SESSION_STATE_CONNECTED) {
1243 if (info->entry->reason == CONNMAN_SESSION_REASON_CONNECT)
1245 info->entry->reason = CONNMAN_SESSION_REASON_CONNECT;
1246 __connman_service_session_inc(info->entry->service);
1250 if (info->entry != NULL &&
1251 is_connecting(info->entry->state) == TRUE) {
1255 select_and_connect(session,
1256 CONNMAN_SESSION_REASON_CONNECT);
1259 case CONNMAN_SESSION_TRIGGER_DISCONNECT:
1260 deselect_and_disconnect(session,
1261 CONNMAN_SESSION_REASON_DISCONNECT);
1264 case CONNMAN_SESSION_TRIGGER_PERIODIC:
1265 if (info->state >= CONNMAN_SESSION_STATE_CONNECTED) {
1266 info->entry->reason = CONNMAN_SESSION_REASON_PERIODIC;
1267 __connman_service_session_inc(info->entry->service);
1271 select_and_connect(session,
1272 CONNMAN_SESSION_REASON_PERIODIC);
1275 case CONNMAN_SESSION_TRIGGER_SERVICE:
1276 if (info->entry != NULL &&
1277 (is_connecting(info->entry->state) == TRUE ||
1278 is_connected(info->entry->state) == TRUE)) {
1282 deselect_and_disconnect(session, info->reason);
1284 if (info->reason == CONNMAN_SESSION_REASON_FREE_RIDE ||
1285 info->stay_connected == TRUE) {
1286 select_and_connect(session, info->reason);
1290 case CONNMAN_SESSION_TRIGGER_ECALL:
1291 if (info->state == CONNMAN_SESSION_STATE_DISCONNECTED &&
1292 info->entry != NULL &&
1293 info->entry->service != NULL) {
1294 deselect_and_disconnect(session, info->reason);
1300 session_notify(session);
1303 static DBusMessage *connect_session(DBusConnection *conn,
1304 DBusMessage *msg, void *user_data)
1306 struct connman_session *session = user_data;
1307 struct session_info *info = session->info;
1309 DBG("session %p", session);
1311 if (ecall_info != NULL && ecall_info != info)
1312 return __connman_error_failed(msg, EBUSY);
1314 session_changed(session, CONNMAN_SESSION_TRIGGER_CONNECT);
1316 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1319 static DBusMessage *disconnect_session(DBusConnection *conn,
1320 DBusMessage *msg, void *user_data)
1322 struct connman_session *session = user_data;
1323 struct session_info *info = session->info;
1325 DBG("session %p", session);
1327 if (ecall_info != NULL && ecall_info != info)
1328 return __connman_error_failed(msg, EBUSY);
1330 session_changed(session, CONNMAN_SESSION_TRIGGER_DISCONNECT);
1332 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1335 static void update_ecall_sessions(struct connman_session *session)
1337 struct session_info *info = session->info;
1338 struct connman_session *session_iter;
1339 GHashTableIter iter;
1340 gpointer key, value;
1342 g_hash_table_iter_init(&iter, session_hash);
1344 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1345 session_iter = value;
1347 if (session_iter == session)
1350 session_iter->info->ecall = info->ecall;
1352 session_changed(session_iter, CONNMAN_SESSION_TRIGGER_ECALL);
1356 static void update_ecall(struct connman_session *session)
1358 struct session_info *info = session->info;
1359 struct session_info *info_last = session->info_last;
1361 DBG("session %p ecall_info %p ecall %d -> %d", session,
1362 ecall_info, info_last->ecall, info->ecall);
1364 if (ecall_info == NULL) {
1365 if (!(info_last->ecall == FALSE && info->ecall == TRUE))
1369 } else if (ecall_info == info) {
1370 if (!(info_last->ecall == TRUE && info->ecall == FALSE))
1378 update_ecall_sessions(session);
1383 /* not a valid transition */
1384 info->ecall = info_last->ecall;
1387 static DBusMessage *change_session(DBusConnection *conn,
1388 DBusMessage *msg, void *user_data)
1390 struct connman_session *session = user_data;
1391 struct session_info *info = session->info;
1392 DBusMessageIter iter, value;
1395 GSList *allowed_bearers;
1397 DBG("session %p", session);
1398 if (dbus_message_iter_init(msg, &iter) == FALSE)
1399 return __connman_error_invalid_arguments(msg);
1401 dbus_message_iter_get_basic(&iter, &name);
1402 dbus_message_iter_next(&iter);
1403 dbus_message_iter_recurse(&iter, &value);
1405 switch (dbus_message_iter_get_arg_type(&value)) {
1406 case DBUS_TYPE_ARRAY:
1407 if (g_str_equal(name, "AllowedBearers") == TRUE) {
1408 allowed_bearers = session_parse_allowed_bearers(&value);
1410 g_slist_foreach(info->allowed_bearers,
1411 cleanup_bearer_info, NULL);
1412 g_slist_free(info->allowed_bearers);
1414 if (allowed_bearers == NULL) {
1415 allowed_bearers = session_allowed_bearers_any();
1417 if (allowed_bearers == NULL)
1418 return __connman_error_failed(msg, ENOMEM);
1421 info->allowed_bearers = allowed_bearers;
1426 case DBUS_TYPE_BOOLEAN:
1427 if (g_str_equal(name, "Priority") == TRUE) {
1428 dbus_message_iter_get_basic(&value,
1430 } else if (g_str_equal(name, "AvoidHandover") == TRUE) {
1431 dbus_message_iter_get_basic(&value,
1432 &info->avoid_handover);
1433 } else if (g_str_equal(name, "StayConnected") == TRUE) {
1434 dbus_message_iter_get_basic(&value,
1435 &info->stay_connected);
1436 } else if (g_str_equal(name, "EmergencyCall") == TRUE) {
1437 dbus_message_iter_get_basic(&value,
1440 update_ecall(session);
1445 case DBUS_TYPE_UINT32:
1446 if (g_str_equal(name, "PeriodicConnect") == TRUE) {
1447 dbus_message_iter_get_basic(&value,
1448 &info->periodic_connect);
1453 case DBUS_TYPE_STRING:
1454 if (g_str_equal(name, "ConnectionType") == TRUE) {
1455 dbus_message_iter_get_basic(&value, &val);
1456 info->type = string2type(val);
1457 } else if (g_str_equal(name, "RoamingPolicy") == TRUE) {
1458 dbus_message_iter_get_basic(&value, &val);
1459 info->roaming_policy =
1460 string2roamingpolicy(val);
1469 session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);
1471 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1474 return __connman_error_invalid_arguments(msg);
1477 static void release_session(gpointer key, gpointer value, gpointer user_data)
1479 struct connman_session *session = value;
1480 DBusMessage *message;
1482 DBG("owner %s path %s", session->owner, session->notify_path);
1484 if (session->notify_watch > 0)
1485 g_dbus_remove_watch(connection, session->notify_watch);
1487 g_dbus_unregister_interface(connection, session->session_path,
1488 CONNMAN_SESSION_INTERFACE);
1490 message = dbus_message_new_method_call(session->owner,
1491 session->notify_path,
1492 CONNMAN_NOTIFICATION_INTERFACE,
1494 if (message == NULL)
1497 dbus_message_set_no_reply(message, TRUE);
1499 g_dbus_send_message(connection, message);
1502 static int session_disconnect(struct connman_session *session)
1504 DBG("session %p, %s", session, session->owner);
1506 if (session->notify_watch > 0)
1507 g_dbus_remove_watch(connection, session->notify_watch);
1509 g_dbus_unregister_interface(connection, session->session_path,
1510 CONNMAN_SESSION_INTERFACE);
1512 deselect_and_disconnect(session,
1513 CONNMAN_SESSION_REASON_DISCONNECT);
1515 g_hash_table_remove(session_hash, session->session_path);
1520 static void owner_disconnect(DBusConnection *conn, void *user_data)
1522 struct connman_session *session = user_data;
1524 DBG("session %p, %s died", session, session->owner);
1526 session_disconnect(session);
1529 static DBusMessage *destroy_session(DBusConnection *conn,
1530 DBusMessage *msg, void *user_data)
1532 struct connman_session *session = user_data;
1533 struct session_info *info = session->info;
1535 DBG("session %p", session);
1537 if (ecall_info != NULL && ecall_info != info)
1538 return __connman_error_failed(msg, EBUSY);
1540 session_disconnect(session);
1542 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1545 static const GDBusMethodTable session_methods[] = {
1546 { GDBUS_METHOD("Destroy", NULL, NULL, destroy_session) },
1547 { GDBUS_METHOD("Connect", NULL, NULL, connect_session) },
1548 { GDBUS_METHOD("Disconnect", NULL, NULL,
1549 disconnect_session ) },
1550 { GDBUS_METHOD("Change",
1551 GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
1552 NULL, change_session) },
1556 int __connman_session_create(DBusMessage *msg)
1558 const char *owner, *notify_path;
1559 char *session_path = NULL;
1560 DBusMessageIter iter, array;
1561 struct connman_session *session = NULL;
1562 struct session_info *info, *info_last;
1564 enum connman_session_type type = CONNMAN_SESSION_TYPE_ANY;
1565 connman_bool_t priority = FALSE, avoid_handover = FALSE;
1566 connman_bool_t stay_connected = FALSE, ecall = FALSE;
1567 enum connman_session_roaming_policy roaming_policy =
1568 CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
1569 GSList *allowed_bearers = NULL;
1570 unsigned int periodic_connect = 0;
1574 owner = dbus_message_get_sender(msg);
1576 DBG("owner %s", owner);
1578 if (ecall_info != NULL) {
1580 * If there is an emergency call already going on,
1581 * ignore session creation attempt
1587 dbus_message_iter_init(msg, &iter);
1588 dbus_message_iter_recurse(&iter, &array);
1590 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1591 DBusMessageIter entry, value;
1592 const char *key, *val;
1594 dbus_message_iter_recurse(&array, &entry);
1595 dbus_message_iter_get_basic(&entry, &key);
1597 dbus_message_iter_next(&entry);
1598 dbus_message_iter_recurse(&entry, &value);
1600 switch (dbus_message_iter_get_arg_type(&value)) {
1601 case DBUS_TYPE_ARRAY:
1602 if (g_str_equal(key, "AllowedBearers") == TRUE) {
1604 session_parse_allowed_bearers(&value);
1609 case DBUS_TYPE_BOOLEAN:
1610 if (g_str_equal(key, "Priority") == TRUE) {
1611 dbus_message_iter_get_basic(&value,
1613 } else if (g_str_equal(key, "AvoidHandover") == TRUE) {
1614 dbus_message_iter_get_basic(&value,
1616 } else if (g_str_equal(key, "StayConnected") == TRUE) {
1617 dbus_message_iter_get_basic(&value,
1619 } else if (g_str_equal(key, "EmergencyCall") == TRUE) {
1620 dbus_message_iter_get_basic(&value,
1626 case DBUS_TYPE_UINT32:
1627 if (g_str_equal(key, "PeriodicConnect") == TRUE) {
1628 dbus_message_iter_get_basic(&value,
1634 case DBUS_TYPE_STRING:
1635 if (g_str_equal(key, "ConnectionType") == TRUE) {
1636 dbus_message_iter_get_basic(&value, &val);
1637 type = string2type(val);
1638 } else if (g_str_equal(key, "RoamingPolicy") == TRUE) {
1639 dbus_message_iter_get_basic(&value, &val);
1640 roaming_policy = string2roamingpolicy(val);
1645 dbus_message_iter_next(&array);
1648 dbus_message_iter_next(&iter);
1649 dbus_message_iter_get_basic(&iter, ¬ify_path);
1651 if (notify_path == NULL) {
1656 session_path = g_strdup_printf("/sessions%s", notify_path);
1657 if (session_path == NULL) {
1662 session = g_hash_table_lookup(session_hash, session_path);
1663 if (session != NULL) {
1669 session = g_try_new0(struct connman_session, 1);
1670 if (session == NULL) {
1675 session->info = g_try_new0(struct session_info, 1);
1676 if (session->info == NULL) {
1681 session->info_last = g_try_new0(struct session_info, 1);
1682 if (session->info_last == NULL) {
1687 info = session->info;
1688 info_last = session->info_last;
1690 session->owner = g_strdup(owner);
1691 session->session_path = session_path;
1692 session->notify_path = g_strdup(notify_path);
1693 session->notify_watch =
1694 g_dbus_add_disconnect_watch(connection, session->owner,
1695 owner_disconnect, session, NULL);
1697 info->state = CONNMAN_SESSION_STATE_DISCONNECTED;
1699 info->priority = priority;
1700 info->avoid_handover = avoid_handover;
1701 info->stay_connected = stay_connected;
1702 info->periodic_connect = periodic_connect;
1703 info->ecall = ecall;
1704 info->roaming_policy = roaming_policy;
1708 if (allowed_bearers == NULL) {
1709 info->allowed_bearers =
1710 session_allowed_bearers_any();
1712 if (info->allowed_bearers == NULL) {
1717 info->allowed_bearers = allowed_bearers;
1720 g_hash_table_replace(session_hash, session->session_path, session);
1722 DBG("add %s", session->session_path);
1724 if (g_dbus_register_interface(connection, session->session_path,
1725 CONNMAN_SESSION_INTERFACE,
1726 session_methods, NULL,
1727 NULL, session, NULL) == FALSE) {
1728 connman_error("Failed to register %s", session->session_path);
1729 g_hash_table_remove(session_hash, session->session_path);
1736 g_dbus_send_reply(connection, msg,
1737 DBUS_TYPE_OBJECT_PATH, &session->session_path,
1741 populate_service_list(session);
1742 if (info->ecall == TRUE) {
1744 update_ecall_sessions(session);
1747 info_last->state = info->state;
1748 info_last->priority = info->priority;
1749 info_last->avoid_handover = info->avoid_handover;
1750 info_last->stay_connected = info->stay_connected;
1751 info_last->periodic_connect = info->periodic_connect;
1752 info_last->ecall = info->ecall;
1753 info_last->roaming_policy = info->roaming_policy;
1754 info_last->entry = info->entry;
1755 info_last->marker = info->marker;
1756 info_last->allowed_bearers = info->allowed_bearers;
1758 session->append_all = TRUE;
1760 session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);
1765 connman_error("Failed to create session");
1767 if (session != NULL) {
1768 if (session->info_last != NULL)
1769 g_free(session->info_last);
1770 if (session->info != NULL)
1771 g_free(session->info);
1775 g_free(session_path);
1777 g_slist_foreach(allowed_bearers, cleanup_bearer_info, NULL);
1778 g_slist_free(allowed_bearers);
1783 int __connman_session_destroy(DBusMessage *msg)
1785 const char *owner, *session_path;
1786 struct connman_session *session;
1788 owner = dbus_message_get_sender(msg);
1790 DBG("owner %s", owner);
1792 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &session_path,
1794 if (session_path == NULL)
1797 session = g_hash_table_lookup(session_hash, session_path);
1798 if (session == NULL)
1801 if (g_strcmp0(owner, session->owner) != 0)
1804 session_disconnect(session);
1809 connman_bool_t __connman_session_mode()
1814 void __connman_session_set_mode(connman_bool_t enable)
1816 DBG("enable %d", enable);
1818 if (sessionmode != enable) {
1819 sessionmode = enable;
1821 connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
1822 CONNMAN_MANAGER_INTERFACE, "SessionMode",
1823 DBUS_TYPE_BOOLEAN, &sessionmode);
1826 if (sessionmode == TRUE)
1827 __connman_service_disconnect_all();
1830 static void service_add(struct connman_service *service,
1833 GHashTableIter iter;
1834 GSequenceIter *iter_service_list;
1835 gpointer key, value;
1836 struct connman_session *session;
1837 struct service_entry *entry;
1839 DBG("service %p", service);
1841 g_hash_table_iter_init(&iter, session_hash);
1843 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1846 if (service_match(session, service) == FALSE)
1849 entry = create_service_entry(service, name,
1850 CONNMAN_SERVICE_STATE_IDLE);
1855 g_sequence_insert_sorted(session->service_list,
1856 entry, sort_services,
1859 g_hash_table_replace(session->service_hash, service,
1862 session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
1866 static void service_remove(struct connman_service *service)
1869 GHashTableIter iter;
1870 gpointer key, value;
1871 struct connman_session *session;
1872 struct session_info *info;
1874 DBG("service %p", service);
1876 g_hash_table_iter_init(&iter, session_hash);
1878 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1879 GSequenceIter *seq_iter;
1881 info = session->info;
1883 seq_iter = g_hash_table_lookup(session->service_hash, service);
1884 if (seq_iter == NULL)
1887 g_sequence_remove(seq_iter);
1889 if (info->entry != NULL && info->entry->service == service)
1891 session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
1895 static void service_state_changed(struct connman_service *service,
1896 enum connman_service_state state)
1898 GHashTableIter iter;
1899 gpointer key, value;
1901 DBG("service %p state %d", service, state);
1903 g_hash_table_iter_init(&iter, session_hash);
1905 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1906 struct connman_session *session = value;
1907 GSequenceIter *service_iter;
1909 service_iter = g_hash_table_lookup(session->service_hash, service);
1910 if (service_iter != NULL) {
1911 struct service_entry *entry;
1913 entry = g_sequence_get(service_iter);
1914 entry->state = state;
1917 session_changed(session,
1918 CONNMAN_SESSION_TRIGGER_SERVICE);
1922 static void ipconfig_changed(struct connman_service *service,
1923 struct connman_ipconfig *ipconfig)
1925 GHashTableIter iter;
1926 gpointer key, value;
1927 struct connman_session *session;
1928 struct session_info *info;
1929 enum connman_ipconfig_type type;
1931 DBG("service %p ipconfig %p", service, ipconfig);
1933 type = __connman_ipconfig_get_config_type(ipconfig);
1935 g_hash_table_iter_init(&iter, session_hash);
1937 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1939 info = session->info;
1941 if (info->state == CONNMAN_SESSION_STATE_DISCONNECTED)
1944 if (info->entry != NULL && info->entry->service == service) {
1945 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1946 ipconfig_ipv4_changed(session);
1947 else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1948 ipconfig_ipv6_changed(session);
1953 static struct connman_notifier session_notifier = {
1955 .service_add = service_add,
1956 .service_remove = service_remove,
1957 .service_state_changed = service_state_changed,
1958 .ipconfig_changed = ipconfig_changed,
1961 int __connman_session_init(void)
1967 connection = connman_dbus_get_connection();
1968 if (connection == NULL)
1971 err = connman_notifier_register(&session_notifier);
1973 dbus_connection_unref(connection);
1977 session_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1978 NULL, cleanup_session);
1980 sessionmode = FALSE;
1984 void __connman_session_cleanup(void)
1988 if (connection == NULL)
1991 connman_notifier_unregister(&session_notifier);
1993 g_hash_table_foreach(session_hash, release_session, NULL);
1994 g_hash_table_destroy(session_hash);
1995 session_hash = NULL;
1997 dbus_connection_unref(connection);