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
26 #include <gdbus/gdbus.h>
28 #include "test-connman.h"
30 static const char *roamingpolicy2string(enum connman_session_roaming_policy policy)
33 case CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN:
35 case CONNMAN_SESSION_ROAMING_POLICY_DEFAULT:
37 case CONNMAN_SESSION_ROAMING_POLICY_ALWAYS:
39 case CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN:
41 case CONNMAN_SESSION_ROAMING_POLICY_NATIONAL:
43 case CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL:
44 return "international";
50 static enum connman_session_roaming_policy string2roamingpolicy(const char *policy)
52 if (g_strcmp0(policy, "default") == 0)
53 return CONNMAN_SESSION_ROAMING_POLICY_DEFAULT;
54 else if (g_strcmp0(policy, "always") == 0)
55 return CONNMAN_SESSION_ROAMING_POLICY_ALWAYS;
56 else if (g_strcmp0(policy, "forbidden") == 0)
57 return CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
58 else if (g_strcmp0(policy, "national") == 0)
59 return CONNMAN_SESSION_ROAMING_POLICY_NATIONAL;
60 else if (g_strcmp0(policy, "international") == 0)
61 return CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL;
63 return CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN;
66 void bearer_info_cleanup(gpointer data, gpointer user_data)
68 struct test_bearer_info *info = data;
74 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
76 struct test_bearer_info *info;
77 DBusMessageIter array;
80 dbus_message_iter_recurse(iter, &array);
82 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
85 dbus_message_iter_get_basic(&array, &bearer);
87 info = g_try_new0(struct test_bearer_info, 1);
89 g_slist_foreach(list, bearer_info_cleanup, NULL);
95 info->name = g_strdup(bearer);
97 list = g_slist_append(list, info);
99 dbus_message_iter_next(&array);
105 static DBusMessage *notify_release(DBusConnection *conn,
106 DBusMessage *msg, void *user_data)
108 struct test_session *session = user_data;
110 LOG("session %p", session);
112 if (session->notify != NULL)
113 session->notify(session);
118 static DBusMessage *notify_update(DBusConnection *conn,
119 DBusMessage *msg, void *user_data)
121 struct test_session *session = user_data;
122 struct test_session_info *info = session->info;
123 DBusMessageIter iter, array;
124 GSList *allowed_bearers;
126 LOG("session %p notify %s", session, session->notify_path);
128 dbus_message_iter_init(msg, &iter);
129 dbus_message_iter_recurse(&iter, &array);
131 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
132 DBusMessageIter entry, value;
135 dbus_message_iter_recurse(&array, &entry);
136 dbus_message_iter_get_basic(&entry, &key);
138 dbus_message_iter_next(&entry);
139 dbus_message_iter_recurse(&entry, &value);
141 switch (dbus_message_iter_get_arg_type(&value)) {
142 case DBUS_TYPE_ARRAY:
143 if (g_str_equal(key, "AllowedBearers") == TRUE) {
144 allowed_bearers = session_parse_allowed_bearers(&value);
146 g_slist_foreach(info->allowed_bearers,
147 bearer_info_cleanup, NULL);
148 g_slist_free(info->allowed_bearers);
150 info->allowed_bearers = allowed_bearers;
152 } else if (g_str_equal(key, "IPv4") == TRUE) {
155 } else if (g_str_equal(key, "IPv6") == TRUE) {
160 return __connman_error_invalid_arguments(msg);
163 case DBUS_TYPE_BOOLEAN:
164 if (g_str_equal(key, "Online") == TRUE) {
165 dbus_message_iter_get_basic(&value,
167 } else if (g_str_equal(key, "Priority") == TRUE) {
168 dbus_message_iter_get_basic(&value,
171 } else if (g_str_equal(key, "AvoidHandover") == TRUE) {
172 dbus_message_iter_get_basic(&value,
173 &info->avoid_handover);
175 } else if (g_str_equal(key, "StayConnected") == TRUE) {
176 dbus_message_iter_get_basic(&value,
177 &info->stay_connected);
179 } else if (g_str_equal(key, "EmergencyCall") == TRUE) {
180 dbus_message_iter_get_basic(&value,
185 return __connman_error_invalid_arguments(msg);
188 case DBUS_TYPE_UINT32:
189 if (g_str_equal(key, "PeriodicConnect") == TRUE) {
190 dbus_message_iter_get_basic(&value,
191 &info->periodic_connect);
193 } else if (g_str_equal(key, "IdleTimeout") == TRUE) {
194 dbus_message_iter_get_basic(&value,
195 &info->idle_timeout);
197 } else if (g_str_equal(key, "SessionMarker") == TRUE) {
198 dbus_message_iter_get_basic(&value,
203 return __connman_error_invalid_arguments(msg);
206 case DBUS_TYPE_STRING:
207 if (g_str_equal(key, "Bearer") == TRUE) {
209 dbus_message_iter_get_basic(&value, &val);
211 if (info->bearer != NULL)
212 g_free(info->bearer);
214 info->bearer = g_strdup(val);
216 } else if (g_str_equal(key, "Name") == TRUE) {
218 dbus_message_iter_get_basic(&value, &val);
220 if (info->name != NULL)
223 info->name = g_strdup(val);
225 } else if (g_str_equal(key, "RoamingPolicy") == TRUE) {
227 dbus_message_iter_get_basic(&value, &val);
228 info->roaming_policy =
229 string2roamingpolicy(val);
231 } else if (g_str_equal(key, "Interface") == TRUE) {
233 dbus_message_iter_get_basic(&value, &val);
235 if (info->interface != NULL)
236 g_free(info->interface);
238 info->interface = g_strdup(val);
242 return __connman_error_invalid_arguments(msg);
247 return __connman_error_invalid_arguments(msg);
249 dbus_message_iter_next(&array);
252 if (session->notify != NULL)
253 session->notify(session);
255 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
258 static GDBusMethodTable notify_methods[] = {
259 { "Release", "", "", notify_release },
260 { "Update", "a{sv}", "", notify_update },
264 int session_notify_register(struct test_session *session,
265 const char *notify_path)
267 if (g_dbus_register_interface(session->connection, notify_path,
268 CONNMAN_NOTIFICATION_INTERFACE,
269 notify_methods, NULL, NULL,
270 session, NULL) == FALSE) {
277 int session_notify_unregister(struct test_session *session,
278 const char *notify_path)
280 if (g_dbus_unregister_interface(session->connection, notify_path,
281 CONNMAN_NOTIFICATION_INTERFACE) == FALSE) {
288 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
290 struct test_session_info *info = user_data;
293 for (list = info->allowed_bearers;
294 list != NULL; list = list->next) {
295 struct test_bearer_info *info = list->data;
297 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
302 void session_append_settings(DBusMessageIter *dict,
303 struct test_session_info *info)
307 connman_dbus_dict_append_basic(dict, "Priority",
311 connman_dbus_dict_append_array(dict, "AllowedBearers",
313 append_allowed_bearers,
316 connman_dbus_dict_append_basic(dict, "AvoidHandover",
318 &info->avoid_handover);
320 connman_dbus_dict_append_basic(dict, "StayConnected",
322 &info->stay_connected);
324 connman_dbus_dict_append_basic(dict, "PeriodicConnect",
326 &info->periodic_connect);
328 connman_dbus_dict_append_basic(dict, "IdleTimeout",
330 &info->idle_timeout);
332 connman_dbus_dict_append_basic(dict, "EmergencyCall",
336 policy = roamingpolicy2string(info->roaming_policy);
337 connman_dbus_dict_append_basic(dict, "RoamingPolicy",
342 DBusMessage *session_connect(DBusConnection *connection,
343 struct test_session *session)
345 DBusMessage *message, *reply;
348 message = dbus_message_new_method_call(CONNMAN_SERVICE,
349 session->session_path,
350 CONNMAN_SESSION_INTERFACE,
355 dbus_error_init(&error);
357 reply = dbus_connection_send_with_reply_and_block(connection,
358 message, -1, &error);
360 if (dbus_error_is_set(&error) == TRUE) {
361 LOG("%s", error.message);
362 dbus_error_free(&error);
364 LOG("Failed to get properties");
366 dbus_message_unref(message);
370 dbus_message_unref(message);
375 DBusMessage *session_disconnect(DBusConnection *connection,
376 struct test_session *session)
378 DBusMessage *message, *reply;
381 message = dbus_message_new_method_call(CONNMAN_SERVICE,
382 session->session_path,
383 CONNMAN_SESSION_INTERFACE,
388 dbus_error_init(&error);
390 reply = dbus_connection_send_with_reply_and_block(connection,
391 message, -1, &error);
393 if (dbus_error_is_set(&error) == TRUE) {
394 LOG("%s", error.message);
395 dbus_error_free(&error);
397 LOG("Failed to get properties");
399 dbus_message_unref(message);
403 dbus_message_unref(message);