5 * Copyright (C) 2011 BWM CarIT GmbH. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
28 #include <gdbus/gdbus.h>
30 #include "test-connman.h"
32 static const char *roamingpolicy2string(enum connman_session_roaming_policy policy)
35 case CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN:
37 case CONNMAN_SESSION_ROAMING_POLICY_DEFAULT:
39 case CONNMAN_SESSION_ROAMING_POLICY_ALWAYS:
41 case CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN:
43 case CONNMAN_SESSION_ROAMING_POLICY_NATIONAL:
45 case CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL:
46 return "international";
52 static enum connman_session_roaming_policy string2roamingpolicy(const char *policy)
54 if (g_strcmp0(policy, "default") == 0)
55 return CONNMAN_SESSION_ROAMING_POLICY_DEFAULT;
56 else if (g_strcmp0(policy, "always") == 0)
57 return CONNMAN_SESSION_ROAMING_POLICY_ALWAYS;
58 else if (g_strcmp0(policy, "forbidden") == 0)
59 return CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
60 else if (g_strcmp0(policy, "national") == 0)
61 return CONNMAN_SESSION_ROAMING_POLICY_NATIONAL;
62 else if (g_strcmp0(policy, "international") == 0)
63 return CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL;
65 return CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN;
68 void bearer_info_cleanup(gpointer data, gpointer user_data)
70 struct test_bearer_info *info = data;
76 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
78 struct test_bearer_info *info;
79 DBusMessageIter array;
82 dbus_message_iter_recurse(iter, &array);
84 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
87 dbus_message_iter_get_basic(&array, &bearer);
89 info = g_try_new0(struct test_bearer_info, 1);
91 g_slist_foreach(list, bearer_info_cleanup, NULL);
97 info->name = g_strdup(bearer);
99 list = g_slist_append(list, info);
101 dbus_message_iter_next(&array);
107 static DBusMessage *notify_release(DBusConnection *conn,
108 DBusMessage *msg, void *user_data)
110 struct test_session *session = user_data;
112 LOG("session %p", session);
114 if (session->notify != NULL)
115 session->notify(session);
120 static DBusMessage *notify_update(DBusConnection *conn,
121 DBusMessage *msg, void *user_data)
123 struct test_session *session = user_data;
124 struct test_session_info *info = session->info;
125 DBusMessageIter iter, array;
126 GSList *allowed_bearers;
128 LOG("session %p notify %s", session, session->notify_path);
130 dbus_message_iter_init(msg, &iter);
131 dbus_message_iter_recurse(&iter, &array);
133 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
134 DBusMessageIter entry, value;
137 dbus_message_iter_recurse(&array, &entry);
138 dbus_message_iter_get_basic(&entry, &key);
140 dbus_message_iter_next(&entry);
141 dbus_message_iter_recurse(&entry, &value);
143 switch (dbus_message_iter_get_arg_type(&value)) {
144 case DBUS_TYPE_ARRAY:
145 if (g_str_equal(key, "AllowedBearers") == TRUE) {
146 allowed_bearers = session_parse_allowed_bearers(&value);
148 g_slist_foreach(info->allowed_bearers,
149 bearer_info_cleanup, NULL);
150 g_slist_free(info->allowed_bearers);
152 info->allowed_bearers = allowed_bearers;
154 } else if (g_str_equal(key, "IPv4") == TRUE) {
157 } else if (g_str_equal(key, "IPv6") == TRUE) {
162 return __connman_error_invalid_arguments(msg);
165 case DBUS_TYPE_BOOLEAN:
166 if (g_str_equal(key, "Online") == TRUE) {
167 dbus_message_iter_get_basic(&value,
169 } else if (g_str_equal(key, "Priority") == TRUE) {
170 dbus_message_iter_get_basic(&value,
173 } else if (g_str_equal(key, "AvoidHandover") == TRUE) {
174 dbus_message_iter_get_basic(&value,
175 &info->avoid_handover);
177 } else if (g_str_equal(key, "StayConnected") == TRUE) {
178 dbus_message_iter_get_basic(&value,
179 &info->stay_connected);
181 } else if (g_str_equal(key, "EmergencyCall") == TRUE) {
182 dbus_message_iter_get_basic(&value,
187 return __connman_error_invalid_arguments(msg);
190 case DBUS_TYPE_UINT32:
191 if (g_str_equal(key, "PeriodicConnect") == TRUE) {
192 dbus_message_iter_get_basic(&value,
193 &info->periodic_connect);
195 } else if (g_str_equal(key, "IdleTimeout") == TRUE) {
196 dbus_message_iter_get_basic(&value,
197 &info->idle_timeout);
199 } else if (g_str_equal(key, "SessionMarker") == TRUE) {
200 dbus_message_iter_get_basic(&value,
205 return __connman_error_invalid_arguments(msg);
208 case DBUS_TYPE_STRING:
209 if (g_str_equal(key, "Bearer") == TRUE) {
211 dbus_message_iter_get_basic(&value, &val);
213 if (info->bearer != NULL)
214 g_free(info->bearer);
216 info->bearer = g_strdup(val);
218 } else if (g_str_equal(key, "Name") == TRUE) {
220 dbus_message_iter_get_basic(&value, &val);
222 if (info->name != NULL)
225 info->name = g_strdup(val);
227 } else if (g_str_equal(key, "RoamingPolicy") == TRUE) {
229 dbus_message_iter_get_basic(&value, &val);
230 info->roaming_policy =
231 string2roamingpolicy(val);
233 } else if (g_str_equal(key, "Interface") == TRUE) {
235 dbus_message_iter_get_basic(&value, &val);
237 if (info->interface != NULL)
238 g_free(info->interface);
240 info->interface = g_strdup(val);
244 return __connman_error_invalid_arguments(msg);
249 return __connman_error_invalid_arguments(msg);
251 dbus_message_iter_next(&array);
254 if (session->notify != NULL)
255 session->notify(session);
257 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
260 static GDBusMethodTable notify_methods[] = {
261 { "Release", "", "", notify_release },
262 { "Update", "a{sv}", "", notify_update },
266 int session_notify_register(struct test_session *session,
267 const char *notify_path)
269 if (g_dbus_register_interface(session->connection, notify_path,
270 CONNMAN_NOTIFICATION_INTERFACE,
271 notify_methods, NULL, NULL,
272 session, NULL) == FALSE) {
279 int session_notify_unregister(struct test_session *session,
280 const char *notify_path)
282 if (g_dbus_unregister_interface(session->connection, notify_path,
283 CONNMAN_NOTIFICATION_INTERFACE) == FALSE) {
290 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
292 struct test_session_info *info = user_data;
295 for (list = info->allowed_bearers;
296 list != NULL; list = list->next) {
297 struct test_bearer_info *info = list->data;
299 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
304 void session_append_settings(DBusMessageIter *dict,
305 struct test_session_info *info)
309 connman_dbus_dict_append_basic(dict, "Priority",
313 connman_dbus_dict_append_array(dict, "AllowedBearers",
315 append_allowed_bearers,
318 connman_dbus_dict_append_basic(dict, "AvoidHandover",
320 &info->avoid_handover);
322 connman_dbus_dict_append_basic(dict, "StayConnected",
324 &info->stay_connected);
326 connman_dbus_dict_append_basic(dict, "PeriodicConnect",
328 &info->periodic_connect);
330 connman_dbus_dict_append_basic(dict, "IdleTimeout",
332 &info->idle_timeout);
334 connman_dbus_dict_append_basic(dict, "EmergencyCall",
338 policy = roamingpolicy2string(info->roaming_policy);
339 connman_dbus_dict_append_basic(dict, "RoamingPolicy",
344 DBusMessage *session_connect(DBusConnection *connection,
345 struct test_session *session)
347 DBusMessage *message, *reply;
350 message = dbus_message_new_method_call(CONNMAN_SERVICE,
351 session->session_path,
352 CONNMAN_SESSION_INTERFACE,
357 dbus_error_init(&error);
359 reply = dbus_connection_send_with_reply_and_block(connection,
360 message, -1, &error);
362 if (dbus_error_is_set(&error) == TRUE) {
363 LOG("%s", error.message);
364 dbus_error_free(&error);
366 LOG("Failed to get properties");
368 dbus_message_unref(message);
372 dbus_message_unref(message);
377 DBusMessage *session_disconnect(DBusConnection *connection,
378 struct test_session *session)
380 DBusMessage *message, *reply;
383 message = dbus_message_new_method_call(CONNMAN_SERVICE,
384 session->session_path,
385 CONNMAN_SESSION_INTERFACE,
390 dbus_error_init(&error);
392 reply = dbus_connection_send_with_reply_and_block(connection,
393 message, -1, &error);
395 if (dbus_error_is_set(&error) == TRUE) {
396 LOG("%s", error.message);
397 dbus_error_free(&error);
399 LOG("Failed to get properties");
401 dbus_message_unref(message);
405 dbus_message_unref(message);