5 * Copyright (C) 2007-2010 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
31 static DBusConnection *connection;
32 static GHashTable *session_hash;
33 static connman_bool_t sessionmode;
34 static struct connman_session *ecall_session;
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,
46 enum connman_session_roaming_policy {
47 CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN = 0,
48 CONNMAN_SESSION_ROAMING_POLICY_DEFAULT = 1,
49 CONNMAN_SESSION_ROAMING_POLICY_ALWAYS = 2,
50 CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN = 3,
51 CONNMAN_SESSION_ROAMING_POLICY_NATIONAL = 4,
52 CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL = 5,
59 connman_bool_t online;
60 connman_bool_t priority;
61 GSList *allowed_bearers;
62 connman_bool_t avoid_handover;
63 connman_bool_t stay_connected;
64 unsigned int periodic_connect;
65 unsigned int idle_timeout;
67 enum connman_session_roaming_policy roaming_policy;
70 struct connman_service *service;
73 struct connman_session {
79 connman_bool_t append_all;
80 connman_bool_t info_dirty;
81 struct session_info info;
82 struct session_info info_last;
84 GSequence *service_list;
89 connman_bool_t match_all;
90 enum connman_service_type service_type;
93 static const char *trigger2string(enum connman_session_trigger trigger)
96 case CONNMAN_SESSION_TRIGGER_UNKNOWN:
98 case CONNMAN_SESSION_TRIGGER_SETTING:
100 case CONNMAN_SESSION_TRIGGER_CONNECT:
102 case CONNMAN_SESSION_TRIGGER_DISCONNECT:
104 case CONNMAN_SESSION_TRIGGER_PERIODIC:
106 case CONNMAN_SESSION_TRIGGER_SERVICE:
108 case CONNMAN_SESSION_TRIGGER_ECALL:
115 static const char *roamingpolicy2string(enum connman_session_roaming_policy policy)
118 case CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN:
120 case CONNMAN_SESSION_ROAMING_POLICY_DEFAULT:
122 case CONNMAN_SESSION_ROAMING_POLICY_ALWAYS:
124 case CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN:
126 case CONNMAN_SESSION_ROAMING_POLICY_NATIONAL:
128 case CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL:
129 return "international";
135 static enum connman_session_roaming_policy string2roamingpolicy(const char *policy)
137 if (g_strcmp0(policy, "default") == 0)
138 return CONNMAN_SESSION_ROAMING_POLICY_DEFAULT;
139 else if (g_strcmp0(policy, "always") == 0)
140 return CONNMAN_SESSION_ROAMING_POLICY_ALWAYS;
141 else if (g_strcmp0(policy, "forbidden") == 0)
142 return CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
143 else if (g_strcmp0(policy, "national") == 0)
144 return CONNMAN_SESSION_ROAMING_POLICY_NATIONAL;
145 else if (g_strcmp0(policy, "international") == 0)
146 return CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL;
148 return CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN;
151 static enum connman_service_type bearer2service(const char *bearer)
154 return CONNMAN_SERVICE_TYPE_UNKNOWN;
156 if (g_strcmp0(bearer, "ethernet") == 0)
157 return CONNMAN_SERVICE_TYPE_ETHERNET;
158 else if (g_strcmp0(bearer, "wifi") == 0)
159 return CONNMAN_SERVICE_TYPE_WIFI;
160 else if (g_strcmp0(bearer, "wimax") == 0)
161 return CONNMAN_SERVICE_TYPE_WIMAX;
162 else if (g_strcmp0(bearer, "bluetooth") == 0)
163 return CONNMAN_SERVICE_TYPE_BLUETOOTH;
164 else if (g_strcmp0(bearer, "3g") == 0)
165 return CONNMAN_SERVICE_TYPE_CELLULAR;
167 return CONNMAN_SERVICE_TYPE_UNKNOWN;
170 static char *service2bearer(enum connman_service_type type)
173 case CONNMAN_SERVICE_TYPE_ETHERNET:
175 case CONNMAN_SERVICE_TYPE_WIFI:
177 case CONNMAN_SERVICE_TYPE_WIMAX:
179 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
181 case CONNMAN_SERVICE_TYPE_CELLULAR:
183 case CONNMAN_SERVICE_TYPE_UNKNOWN:
184 case CONNMAN_SERVICE_TYPE_SYSTEM:
185 case CONNMAN_SERVICE_TYPE_GPS:
186 case CONNMAN_SERVICE_TYPE_VPN:
187 case CONNMAN_SERVICE_TYPE_GADGET:
194 static void cleanup_bearer_info(gpointer data, gpointer user_data)
196 struct bearer_info *info = data;
202 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
204 struct bearer_info *info;
205 DBusMessageIter array;
208 dbus_message_iter_recurse(iter, &array);
210 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
213 dbus_message_iter_get_basic(&array, &bearer);
215 info = g_try_new0(struct bearer_info, 1);
217 g_slist_foreach(list, cleanup_bearer_info, NULL);
223 info->name = g_strdup(bearer);
224 info->service_type = bearer2service(info->name);
226 if (info->service_type == CONNMAN_SERVICE_TYPE_UNKNOWN &&
227 g_strcmp0(info->name, "*") == 0) {
228 info->match_all = TRUE;
230 info->match_all = FALSE;
233 list = g_slist_append(list, info);
235 dbus_message_iter_next(&array);
241 static GSList *session_allowed_bearers_any(void)
243 struct bearer_info *info;
246 info = g_try_new0(struct bearer_info, 1);
253 info->name = g_strdup("");
254 info->match_all = TRUE;
255 info->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
257 list = g_slist_append(list, info);
262 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
264 struct session_info *info = user_data;
267 for (list = info->allowed_bearers;
268 list != NULL; list = list->next) {
269 struct bearer_info *info = list->data;
271 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
276 static void append_ipconfig_ipv4(DBusMessageIter *iter, void *user_data)
278 struct connman_service *service = user_data;
279 struct connman_ipconfig *ipconfig_ipv4;
284 ipconfig_ipv4 = __connman_service_get_ip4config(service);
285 if (ipconfig_ipv4 == NULL)
288 __connman_ipconfig_append_ipv4(ipconfig_ipv4, iter);
291 static void append_ipconfig_ipv6(DBusMessageIter *iter, void *user_data)
293 struct connman_service *service = user_data;
294 struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
299 ipconfig_ipv4 = __connman_service_get_ip4config(service);
300 ipconfig_ipv6 = __connman_service_get_ip6config(service);
301 if (ipconfig_ipv6 == NULL)
304 __connman_ipconfig_append_ipv6(ipconfig_ipv6, iter, ipconfig_ipv4);
307 static void append_notify(DBusMessageIter *dict,
308 struct connman_session *session)
310 struct session_info *info = &session->info;
311 struct session_info *info_last = &session->info_last;
314 if (session->append_all == TRUE ||
315 info->bearer != info_last->bearer) {
316 connman_dbus_dict_append_basic(dict, "Bearer",
319 info_last->bearer = info->bearer;
322 if (session->append_all == TRUE ||
323 info->online != info_last->online) {
324 connman_dbus_dict_append_basic(dict, "Online",
327 info_last->online = info->online;
330 if (session->append_all == TRUE ||
331 info->name != info_last->name) {
332 connman_dbus_dict_append_basic(dict, "Name",
335 info_last->name = info->name;
338 if (session->append_all == TRUE ||
339 info->service != info_last->service) {
340 connman_dbus_dict_append_dict(dict, "IPv4",
341 append_ipconfig_ipv4,
344 connman_dbus_dict_append_dict(dict, "IPv6",
345 append_ipconfig_ipv6,
348 connman_dbus_dict_append_basic(dict, "Interface",
352 info_last->ifname = info->ifname;
353 info_last->service = info->service;
357 if (session->append_all == TRUE ||
358 info->priority != info_last->priority) {
359 connman_dbus_dict_append_basic(dict, "Priority",
362 info_last->priority = info->priority;
365 if (session->append_all == TRUE ||
366 info->allowed_bearers != info_last->allowed_bearers) {
367 connman_dbus_dict_append_array(dict, "AllowedBearers",
369 append_allowed_bearers,
371 info_last->allowed_bearers = info->allowed_bearers;
374 if (session->append_all == TRUE ||
375 info->avoid_handover != info_last->avoid_handover) {
376 connman_dbus_dict_append_basic(dict, "AvoidHandover",
378 &info->avoid_handover);
379 info_last->avoid_handover = info->avoid_handover;
382 if (session->append_all == TRUE ||
383 info->stay_connected != info_last->stay_connected) {
384 connman_dbus_dict_append_basic(dict, "StayConnected",
386 &info->stay_connected);
387 info_last->stay_connected = info->stay_connected;
390 if (session->append_all == TRUE ||
391 info->periodic_connect != info_last->periodic_connect) {
392 connman_dbus_dict_append_basic(dict, "PeriodicConnect",
394 &info->periodic_connect);
395 info_last->periodic_connect = info->periodic_connect;
398 if (session->append_all == TRUE ||
399 info->idle_timeout != info_last->idle_timeout) {
400 connman_dbus_dict_append_basic(dict, "IdleTimeout",
402 &info->idle_timeout);
403 info_last->idle_timeout = info->idle_timeout;
406 if (session->append_all == TRUE ||
407 info->ecall != info_last->ecall) {
408 connman_dbus_dict_append_basic(dict, "EmergencyCall",
411 info_last->ecall = info->ecall;
414 if (session->append_all == TRUE ||
415 info->roaming_policy != info_last->roaming_policy) {
416 policy = roamingpolicy2string(info->roaming_policy);
417 connman_dbus_dict_append_basic(dict, "RoamingPolicy",
420 info_last->roaming_policy = info->roaming_policy;
423 if (session->append_all == TRUE ||
424 info->marker != info_last->marker) {
425 connman_dbus_dict_append_basic(dict, "SessionMarker",
428 info_last->marker = info->marker;
431 session->append_all = FALSE;
432 session->info_dirty = FALSE;
435 static gboolean session_notify(gpointer user_data)
437 struct connman_session *session = user_data;
439 DBusMessageIter array, dict;
441 if (session->info_dirty == FALSE)
444 DBG("session %p owner %s notify_path %s", session,
445 session->owner, session->notify_path);
447 msg = dbus_message_new_method_call(session->owner, session->notify_path,
448 CONNMAN_NOTIFICATION_INTERFACE,
453 dbus_message_iter_init_append(msg, &array);
454 connman_dbus_dict_open(&array, &dict);
456 append_notify(&dict, session);
458 connman_dbus_dict_close(&array, &dict);
460 g_dbus_send_message(connection, msg);
462 session->info_dirty = FALSE;
467 static void ipconfig_ipv4_changed(struct connman_session *session)
469 struct session_info *info = &session->info;
471 connman_dbus_setting_changed_dict(session->owner, session->notify_path,
472 "IPv4", append_ipconfig_ipv4,
476 static void ipconfig_ipv6_changed(struct connman_session *session)
478 struct session_info *info = &session->info;
480 connman_dbus_setting_changed_dict(session->owner, session->notify_path,
481 "IPv6", append_ipconfig_ipv6,
485 static GSequenceIter *lookup_service(struct connman_session *session,
486 struct connman_service *service)
493 iter = g_sequence_get_begin_iter(session->service_list);
495 while (g_sequence_iter_is_end(iter) == FALSE) {
496 struct connman_service *service_iter = g_sequence_get(iter);
498 if (service_iter == service)
501 iter = g_sequence_iter_next(iter);
507 static connman_bool_t service_type_match(struct connman_session *session,
508 struct connman_service *service)
510 struct session_info *info = &session->info;
513 for (list = info->allowed_bearers;
514 list != NULL; list = list->next) {
515 struct bearer_info *info = list->data;
516 enum connman_service_type service_type;
518 if (info->match_all == TRUE)
521 service_type = connman_service_get_type(service);
522 if (info->service_type == service_type)
529 static connman_bool_t service_match(struct connman_session *session,
530 struct connman_service *service)
532 if (service_type_match(session, service) == FALSE)
538 static int service_type_weight(enum connman_service_type type)
541 * The session doesn't care which service
542 * to use. Nevertheless we have to sort them
543 * according their type. The ordering is
552 case CONNMAN_SERVICE_TYPE_ETHERNET:
554 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
556 case CONNMAN_SERVICE_TYPE_WIFI:
557 case CONNMAN_SERVICE_TYPE_WIMAX:
559 case CONNMAN_SERVICE_TYPE_CELLULAR:
561 case CONNMAN_SERVICE_TYPE_UNKNOWN:
562 case CONNMAN_SERVICE_TYPE_SYSTEM:
563 case CONNMAN_SERVICE_TYPE_GPS:
564 case CONNMAN_SERVICE_TYPE_VPN:
565 case CONNMAN_SERVICE_TYPE_GADGET:
572 static gint sort_allowed_bearers(struct connman_service *service_a,
573 struct connman_service *service_b,
574 struct connman_session *session)
576 struct session_info *info = &session->info;
578 enum connman_service_type type_a, type_b;
579 int weight_a, weight_b;
581 type_a = connman_service_get_type(service_a);
582 type_b = connman_service_get_type(service_b);
584 for (list = info->allowed_bearers;
585 list != NULL; list = list->next) {
586 struct bearer_info *info = list->data;
588 if (info->match_all == TRUE) {
589 if (type_a != type_b) {
590 weight_a = service_type_weight(type_a);
591 weight_b = service_type_weight(type_b);
593 if (weight_a > weight_b)
596 if (weight_a < weight_b)
603 if (type_a == info->service_type &&
604 type_b == info->service_type) {
608 if (type_a == info->service_type &&
609 type_b != info->service_type) {
613 if (type_a != info->service_type &&
614 type_b == info->service_type) {
622 static gint sort_services(gconstpointer a, gconstpointer b, gpointer user_data)
624 struct connman_service *service_a = (void *)a;
625 struct connman_service *service_b = (void *)b;
626 struct connman_session *session = user_data;
628 return sort_allowed_bearers(service_a, service_b, session);
631 static void cleanup_session(gpointer user_data)
633 struct connman_session *session = user_data;
634 struct session_info *info = &session->info;
636 DBG("remove %s", session->session_path);
638 g_sequence_free(session->service_list);
640 g_slist_foreach(info->allowed_bearers, cleanup_bearer_info, NULL);
641 g_slist_free(info->allowed_bearers);
643 g_free(session->owner);
644 g_free(session->session_path);
645 g_free(session->notify_path);
650 static void release_session(gpointer key, gpointer value, gpointer user_data)
652 struct connman_session *session = value;
653 DBusMessage *message;
655 DBG("owner %s path %s", session->owner, session->notify_path);
657 if (session->notify_watch > 0)
658 g_dbus_remove_watch(connection, session->notify_watch);
660 g_dbus_unregister_interface(connection, session->session_path,
661 CONNMAN_SESSION_INTERFACE);
663 message = dbus_message_new_method_call(session->owner,
664 session->notify_path,
665 CONNMAN_NOTIFICATION_INTERFACE,
670 dbus_message_set_no_reply(message, TRUE);
672 g_dbus_send_message(connection, message);
675 static int session_disconnect(struct connman_session *session)
677 DBG("session %p, %s", session, session->owner);
679 if (session->notify_watch > 0)
680 g_dbus_remove_watch(connection, session->notify_watch);
682 g_dbus_unregister_interface(connection, session->session_path,
683 CONNMAN_SESSION_INTERFACE);
685 g_hash_table_remove(session_hash, session->session_path);
690 static void owner_disconnect(DBusConnection *conn, void *user_data)
692 struct connman_session *session = user_data;
694 DBG("session %p, %s died", session, session->owner);
696 session_disconnect(session);
699 static DBusMessage *destroy_session(DBusConnection *conn,
700 DBusMessage *msg, void *user_data)
702 struct connman_session *session = user_data;
704 DBG("session %p", session);
706 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
709 static void update_info(struct session_info *info)
711 enum connman_service_type type;
714 if (info->service != NULL) {
715 type = connman_service_get_type(info->service);
716 info->bearer = service2bearer(type);
718 info->online = __connman_service_is_connected(info->service);
719 info->name = __connman_service_get_name(info->service);
721 idx = __connman_service_get_index(info->service);
722 info->ifname = connman_inet_ifname(idx);
723 if (info->ifname == NULL)
727 info->online = FALSE;
733 static void notify_service_changes(struct connman_session *session)
735 struct session_info *info = &session->info;
736 struct session_info *info_last = &session->info_last;
738 if (info->service == info_last->service)
742 session->info_dirty = TRUE;
745 static void select_and_connect(struct connman_session *session,
746 connman_bool_t do_connect)
748 struct session_info *info = &session->info;
749 struct connman_service *service = NULL;
752 DBG("session %p connect %d", session, do_connect);
754 iter = g_sequence_get_begin_iter(session->service_list);
756 while (g_sequence_iter_is_end(iter) == FALSE) {
757 service = g_sequence_get(iter);
759 if (__connman_service_is_connecting(service) == TRUE ||
760 __connman_service_is_connected(service) == TRUE) {
764 if (__connman_service_is_idle(service) == TRUE &&
765 do_connect == TRUE) {
771 iter = g_sequence_iter_next(iter);
774 if (info->service != NULL && info->service != service) {
775 __connman_service_disconnect(info->service);
776 info->service = NULL;
779 if (service != NULL) {
780 info->service = service;
782 if (do_connect == TRUE)
783 __connman_service_connect(info->service);
786 notify_service_changes(session);
789 static void session_changed(struct connman_session *session,
790 enum connman_session_trigger trigger)
792 struct session_info *info = &session->info;
796 * TODO: This only a placeholder for the 'real' algorithm to
797 * play a bit around. So we are going to improve it step by step.
800 DBG("session %p trigger %s", session, trigger2string(trigger));
803 case CONNMAN_SESSION_TRIGGER_UNKNOWN:
804 DBG("ignore session changed event");
806 case CONNMAN_SESSION_TRIGGER_SETTING:
807 if (info->service != NULL) {
808 iter = lookup_service(session, info->service);
811 * This service is not part of this
815 __connman_service_disconnect(info->service);
816 info->service = NULL;
819 notify_service_changes(session);
822 /* Try to free ride */
823 if (info->online == FALSE)
824 select_and_connect(session, FALSE);
827 case CONNMAN_SESSION_TRIGGER_CONNECT:
828 if (info->online == TRUE)
831 select_and_connect(session, TRUE);
834 case CONNMAN_SESSION_TRIGGER_DISCONNECT:
835 if (info->online == FALSE)
838 if (info->service != NULL)
839 __connman_service_disconnect(info->service);
841 info->service = NULL;
842 notify_service_changes(session);
845 case CONNMAN_SESSION_TRIGGER_PERIODIC:
846 select_and_connect(session, TRUE);
849 case CONNMAN_SESSION_TRIGGER_SERVICE:
850 if (info->online == TRUE)
853 if (info->stay_connected == TRUE) {
854 DBG("StayConnected");
855 select_and_connect(session, TRUE);
860 /* Try to free ride */
861 select_and_connect(session, FALSE);
864 case CONNMAN_SESSION_TRIGGER_ECALL:
865 if (info->online == FALSE && info->service != NULL)
866 info->service = NULL;
868 notify_service_changes(session);
874 case CONNMAN_SESSION_TRIGGER_UNKNOWN:
876 case CONNMAN_SESSION_TRIGGER_CONNECT:
877 case CONNMAN_SESSION_TRIGGER_DISCONNECT:
878 case CONNMAN_SESSION_TRIGGER_ECALL:
879 g_timeout_add_seconds(0, session_notify, session);
881 case CONNMAN_SESSION_TRIGGER_SETTING:
882 case CONNMAN_SESSION_TRIGGER_PERIODIC:
883 case CONNMAN_SESSION_TRIGGER_SERVICE:
884 session_notify(session);
889 static DBusMessage *connect_session(DBusConnection *conn,
890 DBusMessage *msg, void *user_data)
892 struct connman_session *session = user_data;
894 DBG("session %p", session);
896 if (ecall_session != NULL && ecall_session != session)
897 return __connman_error_failed(msg, EBUSY);
899 session_changed(session, CONNMAN_SESSION_TRIGGER_CONNECT);
901 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
904 static DBusMessage *disconnect_session(DBusConnection *conn,
905 DBusMessage *msg, void *user_data)
907 struct connman_session *session = user_data;
909 DBG("session %p", session);
911 if (ecall_session != NULL && ecall_session != session)
912 return __connman_error_failed(msg, EBUSY);
914 session_changed(session, CONNMAN_SESSION_TRIGGER_DISCONNECT);
916 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
919 static void print_name(gpointer data, gpointer user_data)
921 struct connman_service *service = data;
923 DBG("service %p type %s name %s", service,
924 service2bearer(connman_service_get_type(service)),
925 __connman_service_get_name(service));
928 static void update_allowed_bearers(struct connman_session *session)
930 if (session->service_list != NULL)
931 g_sequence_free(session->service_list);
933 session->service_list = __connman_service_get_list(session,
935 g_sequence_sort(session->service_list, sort_services, session);
936 g_sequence_foreach(session->service_list, print_name, NULL);
938 session->info_dirty = TRUE;
941 static void update_ecall_sessions(struct connman_session *session)
943 struct session_info *info = &session->info;
944 struct connman_session *session_iter;
948 g_hash_table_iter_init(&iter, session_hash);
950 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
951 session_iter = value;
953 if (session_iter == session)
956 session_iter->info.ecall = info->ecall;
957 session_iter->info_dirty = TRUE;
959 session_changed(session_iter, CONNMAN_SESSION_TRIGGER_ECALL);
963 static void update_ecall(struct connman_session *session)
965 struct session_info *info = &session->info;
966 struct session_info *info_last = &session->info_last;
968 DBG("session %p ecall_session %p ecall %d -> %d", session,
969 ecall_session, info_last->ecall, info->ecall);
971 if (ecall_session == NULL) {
972 if (!(info_last->ecall == FALSE && info->ecall == TRUE))
975 ecall_session = session;
976 } else if (ecall_session == session) {
977 if (!(info_last->ecall == TRUE && info->ecall == FALSE))
980 ecall_session = NULL;
985 update_ecall_sessions(session);
987 session->info_dirty = TRUE;
991 /* not a valid transition */
992 info->ecall = info_last->ecall;
995 static DBusMessage *change_session(DBusConnection *conn,
996 DBusMessage *msg, void *user_data)
998 struct connman_session *session = user_data;
999 struct session_info *info = &session->info;
1000 struct session_info *info_last = &session->info_last;
1001 DBusMessageIter iter, value;
1003 GSList *allowed_bearers;
1005 DBG("session %p", session);
1006 if (dbus_message_iter_init(msg, &iter) == FALSE)
1007 return __connman_error_invalid_arguments(msg);
1009 dbus_message_iter_get_basic(&iter, &name);
1010 dbus_message_iter_next(&iter);
1011 dbus_message_iter_recurse(&iter, &value);
1013 switch (dbus_message_iter_get_arg_type(&value)) {
1014 case DBUS_TYPE_ARRAY:
1015 if (g_str_equal(name, "AllowedBearers") == TRUE) {
1016 allowed_bearers = session_parse_allowed_bearers(&value);
1018 g_slist_foreach(info->allowed_bearers,
1019 cleanup_bearer_info, NULL);
1020 g_slist_free(info->allowed_bearers);
1022 if (allowed_bearers == NULL) {
1023 allowed_bearers = session_allowed_bearers_any();
1025 if (allowed_bearers == NULL)
1026 return __connman_error_failed(msg, ENOMEM);
1029 info->allowed_bearers = allowed_bearers;
1031 update_allowed_bearers(session);
1036 case DBUS_TYPE_BOOLEAN:
1037 if (g_str_equal(name, "Priority") == TRUE) {
1038 dbus_message_iter_get_basic(&value,
1041 if (info_last->priority != info->priority)
1042 session->info_dirty = TRUE;
1043 } else if (g_str_equal(name, "AvoidHandover") == TRUE) {
1044 dbus_message_iter_get_basic(&value,
1045 &info->avoid_handover);
1047 if (info_last->avoid_handover != info->avoid_handover)
1048 session->info_dirty = TRUE;
1049 } else if (g_str_equal(name, "StayConnected") == TRUE) {
1050 dbus_message_iter_get_basic(&value,
1051 &info->stay_connected);
1053 if (info_last->stay_connected != info->stay_connected)
1054 session->info_dirty = TRUE;
1055 } else if (g_str_equal(name, "EmergencyCall") == TRUE) {
1056 dbus_message_iter_get_basic(&value,
1059 update_ecall(session);
1064 case DBUS_TYPE_UINT32:
1065 if (g_str_equal(name, "PeriodicConnect") == TRUE) {
1066 dbus_message_iter_get_basic(&value,
1067 &info->periodic_connect);
1069 if (info_last->periodic_connect != info->periodic_connect)
1070 session->info_dirty = TRUE;
1071 } else if (g_str_equal(name, "IdleTimeout") == TRUE) {
1072 dbus_message_iter_get_basic(&value,
1073 &info->idle_timeout);
1075 if (info_last->idle_timeout != info->idle_timeout)
1076 session->info_dirty = TRUE;
1081 case DBUS_TYPE_STRING:
1082 if (g_str_equal(name, "RoamingPolicy") == TRUE) {
1084 dbus_message_iter_get_basic(&value, &val);
1085 info->roaming_policy =
1086 string2roamingpolicy(val);
1088 if (info_last->roaming_policy != info->roaming_policy)
1089 session->info_dirty = TRUE;
1098 if (session->info_dirty == TRUE)
1099 session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);
1101 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
1104 return __connman_error_invalid_arguments(msg);
1107 static GDBusMethodTable session_methods[] = {
1108 { "Destroy", "", "", destroy_session },
1109 { "Connect", "", "", connect_session },
1110 { "Disconnect", "", "", disconnect_session },
1111 { "Change", "sv", "", change_session },
1115 int __connman_session_create(DBusMessage *msg)
1117 const char *owner, *notify_path;
1118 char *session_path = NULL;
1119 DBusMessageIter iter, array;
1120 struct connman_session *session;
1121 struct session_info *info, *info_last;
1123 connman_bool_t priority = FALSE, avoid_handover = FALSE;
1124 connman_bool_t stay_connected = FALSE, ecall = FALSE;
1125 enum connman_session_roaming_policy roaming_policy =
1126 CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
1127 GSList *allowed_bearers = NULL;
1128 unsigned int periodic_connect = 0;
1129 unsigned int idle_timeout = 0;
1133 owner = dbus_message_get_sender(msg);
1135 DBG("owner %s", owner);
1137 if (ecall_session != NULL) {
1139 * If there is an emergency call already going on,
1140 * ignore session creation attempt
1146 dbus_message_iter_init(msg, &iter);
1147 dbus_message_iter_recurse(&iter, &array);
1149 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
1150 DBusMessageIter entry, value;
1151 const char *key, *val;
1153 dbus_message_iter_recurse(&array, &entry);
1154 dbus_message_iter_get_basic(&entry, &key);
1156 dbus_message_iter_next(&entry);
1157 dbus_message_iter_recurse(&entry, &value);
1159 switch (dbus_message_iter_get_arg_type(&value)) {
1160 case DBUS_TYPE_ARRAY:
1161 if (g_str_equal(key, "AllowedBearers") == TRUE) {
1163 session_parse_allowed_bearers(&value);
1168 case DBUS_TYPE_BOOLEAN:
1169 if (g_str_equal(key, "Priority") == TRUE) {
1170 dbus_message_iter_get_basic(&value,
1172 } else if (g_str_equal(key, "AvoidHandover") == TRUE) {
1173 dbus_message_iter_get_basic(&value,
1175 } else if (g_str_equal(key, "StayConnected") == TRUE) {
1176 dbus_message_iter_get_basic(&value,
1178 } else if (g_str_equal(key, "EmergencyCall") == TRUE) {
1179 dbus_message_iter_get_basic(&value,
1185 case DBUS_TYPE_UINT32:
1186 if (g_str_equal(key, "PeriodicConnect") == TRUE) {
1187 dbus_message_iter_get_basic(&value,
1189 } else if (g_str_equal(key, "IdleTimeout") == TRUE) {
1190 dbus_message_iter_get_basic(&value,
1196 case DBUS_TYPE_STRING:
1197 if (g_str_equal(key, "RoamingPolicy") == TRUE) {
1198 dbus_message_iter_get_basic(&value, &val);
1199 roaming_policy = string2roamingpolicy(val);
1204 dbus_message_iter_next(&array);
1207 dbus_message_iter_next(&iter);
1208 dbus_message_iter_get_basic(&iter, ¬ify_path);
1210 if (notify_path == NULL) {
1215 session_path = g_strdup_printf("/sessions%s", notify_path);
1216 if (session_path == NULL) {
1221 session = g_hash_table_lookup(session_hash, session_path);
1222 if (session != NULL) {
1227 session = g_try_new0(struct connman_session, 1);
1228 if (session == NULL) {
1233 info = &session->info;
1234 info_last = &session->info_last;
1236 session->owner = g_strdup(owner);
1237 session->session_path = session_path;
1238 session->notify_path = g_strdup(notify_path);
1239 session->notify_watch =
1240 g_dbus_add_disconnect_watch(connection, session->owner,
1241 owner_disconnect, session, NULL);
1244 info->online = FALSE;
1245 info->priority = priority;
1246 info->avoid_handover = avoid_handover;
1247 info->stay_connected = stay_connected;
1248 info->periodic_connect = periodic_connect;
1249 info->idle_timeout = idle_timeout;
1250 info->ecall = ecall;
1251 info->roaming_policy = roaming_policy;
1252 info->service = NULL;
1255 if (allowed_bearers == NULL) {
1256 info->allowed_bearers =
1257 session_allowed_bearers_any();
1259 if (info->allowed_bearers == NULL) {
1264 info->allowed_bearers = allowed_bearers;
1267 g_hash_table_replace(session_hash, session->session_path, session);
1269 DBG("add %s", session->session_path);
1271 if (g_dbus_register_interface(connection, session->session_path,
1272 CONNMAN_SESSION_INTERFACE,
1273 session_methods, NULL,
1274 NULL, session, NULL) == FALSE) {
1275 connman_error("Failed to register %s", session->session_path);
1276 g_hash_table_remove(session_hash, session->session_path);
1283 g_dbus_send_reply(connection, msg,
1284 DBUS_TYPE_OBJECT_PATH, &session->session_path,
1288 update_allowed_bearers(session);
1290 if (info->ecall == TRUE) {
1291 ecall_session = session;
1292 update_ecall_sessions(session);
1295 info_last->bearer = info->bearer;
1296 info_last->online = info->online;
1297 info_last->priority = info->priority;
1298 info_last->avoid_handover = info->avoid_handover;
1299 info_last->stay_connected = info->stay_connected;
1300 info_last->periodic_connect = info->periodic_connect;
1301 info_last->idle_timeout = info->idle_timeout;
1302 info_last->ecall = info->ecall;
1303 info_last->roaming_policy = info->roaming_policy;
1304 info_last->service = info->service;
1305 info_last->marker = info->marker;
1306 info_last->allowed_bearers = info->allowed_bearers;
1307 update_info(info_last);
1309 session->info_dirty = TRUE;
1310 session->append_all = TRUE;
1312 session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);
1317 connman_error("Failed to create session");
1318 g_free(session_path);
1320 g_slist_foreach(allowed_bearers, cleanup_bearer_info, NULL);
1321 g_slist_free(allowed_bearers);
1326 int __connman_session_destroy(DBusMessage *msg)
1328 const char *owner, *session_path;
1329 struct connman_session *session;
1331 owner = dbus_message_get_sender(msg);
1333 DBG("owner %s", owner);
1335 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &session_path,
1337 if (session_path == NULL)
1340 session = g_hash_table_lookup(session_hash, session_path);
1341 if (session == NULL)
1344 if (g_strcmp0(owner, session->owner) != 0)
1347 session_disconnect(session);
1352 connman_bool_t __connman_session_mode()
1357 void __connman_session_set_mode(connman_bool_t enable)
1359 DBG("enable %d", enable);
1361 if (sessionmode == enable)
1364 sessionmode = enable;
1366 if (sessionmode == TRUE)
1367 __connman_service_disconnect_all();
1370 static void service_add(struct connman_service *service)
1372 GHashTableIter iter;
1373 gpointer key, value;
1374 struct connman_session *session;
1376 DBG("service %p", service);
1378 g_hash_table_iter_init(&iter, session_hash);
1380 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1383 if (service_match(session, service) == FALSE)
1386 g_sequence_insert_sorted(session->service_list, service,
1387 sort_services, session);
1389 session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
1393 static int service_remove_from_session(struct connman_session *session,
1394 struct connman_service *service)
1396 GSequenceIter *iter;
1398 iter = lookup_service(session, service);
1402 session->info.online = FALSE;
1403 g_sequence_remove(iter);
1408 static void service_remove(struct connman_service *service)
1411 GHashTableIter iter;
1412 gpointer key, value;
1413 struct connman_session *session;
1414 struct session_info *info;
1416 DBG("service %p", service);
1418 g_hash_table_iter_init(&iter, session_hash);
1420 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1422 info = &session->info;
1424 if (service_remove_from_session(session, service) != 0)
1427 info->service = NULL;
1428 session_changed(session, CONNMAN_SESSION_TRIGGER_SERVICE);
1432 static void service_state_changed(struct connman_service *service,
1433 enum connman_service_state state)
1435 GHashTableIter iter;
1436 gpointer key, value;
1437 struct connman_session *session;
1438 struct session_info *info;
1439 connman_bool_t online;
1441 DBG("service %p state %d", service, state);
1443 g_hash_table_iter_init(&iter, session_hash);
1445 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1447 info = &session->info;
1449 if (info->service == service) {
1450 online = __connman_service_is_connected(service);
1451 if (info->online == online)
1454 info->online = online;
1455 session->info_dirty = TRUE;
1456 session_changed(session,
1457 CONNMAN_SESSION_TRIGGER_SERVICE);
1462 static void ipconfig_changed(struct connman_service *service,
1463 struct connman_ipconfig *ipconfig)
1465 GHashTableIter iter;
1466 gpointer key, value;
1467 struct connman_session *session;
1468 struct session_info *info;
1469 enum connman_ipconfig_type type;
1471 DBG("service %p ipconfig %p", service, ipconfig);
1473 type = __connman_ipconfig_get_config_type(ipconfig);
1475 g_hash_table_iter_init(&iter, session_hash);
1477 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1479 info = &session->info;
1481 if (info->service == service) {
1482 if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1483 ipconfig_ipv4_changed(session);
1484 else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1485 ipconfig_ipv6_changed(session);
1490 static struct connman_notifier session_notifier = {
1492 .service_add = service_add,
1493 .service_remove = service_remove,
1494 .service_state_changed = service_state_changed,
1495 .ipconfig_changed = ipconfig_changed,
1498 int __connman_session_init(void)
1504 connection = connman_dbus_get_connection();
1505 if (connection == NULL)
1508 err = connman_notifier_register(&session_notifier);
1510 dbus_connection_unref(connection);
1514 session_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1515 NULL, cleanup_session);
1517 sessionmode = FALSE;
1521 void __connman_session_cleanup(void)
1525 if (connection == NULL)
1528 connman_notifier_unregister(&session_notifier);
1530 g_hash_table_foreach(session_hash, release_session, NULL);
1531 g_hash_table_destroy(session_hash);
1533 dbus_connection_unref(connection);