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 enum connman_session_state string2state(const char *state)
34 if (g_strcmp0(state, "connected") == 0)
35 return CONNMAN_SESSION_STATE_CONNECTED;
36 if (g_strcmp0(state, "online") == 0)
37 return CONNMAN_SESSION_STATE_ONLINE;
39 return CONNMAN_SESSION_STATE_DISCONNECTED;
42 static enum connman_session_state string2type(const char *type)
44 if (g_strcmp0(type, "local") == 0)
45 return CONNMAN_SESSION_TYPE_LOCAL;
46 if (g_strcmp0(type, "internet") == 0)
47 return CONNMAN_SESSION_TYPE_INTERNET;
49 return CONNMAN_SESSION_TYPE_ANY;
52 static const char *roamingpolicy2string(enum connman_session_roaming_policy policy)
55 case CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN:
57 case CONNMAN_SESSION_ROAMING_POLICY_DEFAULT:
59 case CONNMAN_SESSION_ROAMING_POLICY_ALWAYS:
61 case CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN:
63 case CONNMAN_SESSION_ROAMING_POLICY_NATIONAL:
65 case CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL:
66 return "international";
72 static enum connman_session_roaming_policy string2roamingpolicy(const char *policy)
74 if (g_strcmp0(policy, "default") == 0)
75 return CONNMAN_SESSION_ROAMING_POLICY_DEFAULT;
76 else if (g_strcmp0(policy, "always") == 0)
77 return CONNMAN_SESSION_ROAMING_POLICY_ALWAYS;
78 else if (g_strcmp0(policy, "forbidden") == 0)
79 return CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
80 else if (g_strcmp0(policy, "national") == 0)
81 return CONNMAN_SESSION_ROAMING_POLICY_NATIONAL;
82 else if (g_strcmp0(policy, "international") == 0)
83 return CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL;
85 return CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN;
88 void bearer_info_cleanup(gpointer data, gpointer user_data)
90 struct test_bearer_info *info = data;
96 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
98 struct test_bearer_info *info;
99 DBusMessageIter array;
102 dbus_message_iter_recurse(iter, &array);
104 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
107 dbus_message_iter_get_basic(&array, &bearer);
109 info = g_try_new0(struct test_bearer_info, 1);
111 g_slist_foreach(list, bearer_info_cleanup, NULL);
117 info->name = g_strdup(bearer);
119 list = g_slist_append(list, info);
121 dbus_message_iter_next(&array);
127 static DBusMessage *notify_release(DBusConnection *conn,
128 DBusMessage *msg, void *user_data)
130 struct test_session *session = user_data;
132 LOG("session %p", session);
134 if (session->notify != NULL)
135 session->notify(session);
140 static DBusMessage *notify_update(DBusConnection *conn,
141 DBusMessage *msg, void *user_data)
143 struct test_session *session = user_data;
144 struct test_session_info *info = session->info;
145 DBusMessageIter iter, array;
146 GSList *allowed_bearers;
148 LOG("session %p notify %s", session, session->notify_path);
150 dbus_message_iter_init(msg, &iter);
151 dbus_message_iter_recurse(&iter, &array);
153 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
154 DBusMessageIter entry, value;
157 dbus_message_iter_recurse(&array, &entry);
158 dbus_message_iter_get_basic(&entry, &key);
160 dbus_message_iter_next(&entry);
161 dbus_message_iter_recurse(&entry, &value);
163 switch (dbus_message_iter_get_arg_type(&value)) {
164 case DBUS_TYPE_ARRAY:
165 if (g_str_equal(key, "AllowedBearers") == TRUE) {
166 allowed_bearers = session_parse_allowed_bearers(&value);
168 g_slist_foreach(info->allowed_bearers,
169 bearer_info_cleanup, NULL);
170 g_slist_free(info->allowed_bearers);
172 info->allowed_bearers = allowed_bearers;
174 } else if (g_str_equal(key, "IPv4") == TRUE) {
177 } else if (g_str_equal(key, "IPv6") == TRUE) {
182 return __connman_error_invalid_arguments(msg);
185 case DBUS_TYPE_BOOLEAN:
186 if (g_str_equal(key, "Priority") == TRUE) {
187 dbus_message_iter_get_basic(&value,
190 } else if (g_str_equal(key, "AvoidHandover") == TRUE) {
191 dbus_message_iter_get_basic(&value,
192 &info->avoid_handover);
194 } else if (g_str_equal(key, "StayConnected") == TRUE) {
195 dbus_message_iter_get_basic(&value,
196 &info->stay_connected);
198 } else if (g_str_equal(key, "EmergencyCall") == TRUE) {
199 dbus_message_iter_get_basic(&value,
204 return __connman_error_invalid_arguments(msg);
207 case DBUS_TYPE_UINT32:
208 if (g_str_equal(key, "PeriodicConnect") == TRUE) {
209 dbus_message_iter_get_basic(&value,
210 &info->periodic_connect);
212 } else if (g_str_equal(key, "IdleTimeout") == TRUE) {
213 dbus_message_iter_get_basic(&value,
214 &info->idle_timeout);
216 } else if (g_str_equal(key, "SessionMarker") == TRUE) {
217 dbus_message_iter_get_basic(&value,
222 return __connman_error_invalid_arguments(msg);
225 case DBUS_TYPE_STRING:
226 if (g_str_equal(key, "State") == TRUE) {
228 dbus_message_iter_get_basic(&value, &val);
230 info->state = string2state(val);
231 } else if (g_str_equal(key, "Bearer") == TRUE) {
233 dbus_message_iter_get_basic(&value, &val);
235 if (info->bearer != NULL)
236 g_free(info->bearer);
238 info->bearer = g_strdup(val);
240 } else if (g_str_equal(key, "Name") == TRUE) {
242 dbus_message_iter_get_basic(&value, &val);
244 if (info->name != NULL)
247 info->name = g_strdup(val);
249 } else if (g_str_equal(key, "RoamingPolicy") == TRUE) {
251 dbus_message_iter_get_basic(&value, &val);
252 info->roaming_policy =
253 string2roamingpolicy(val);
255 } else if (g_str_equal(key, "Interface") == TRUE) {
257 dbus_message_iter_get_basic(&value, &val);
259 if (info->interface != NULL)
260 g_free(info->interface);
262 info->interface = g_strdup(val);
264 } else if (g_str_equal(key, "ConnectionType")
267 dbus_message_iter_get_basic(&value, &val);
269 info->type = string2type(val);
272 return __connman_error_invalid_arguments(msg);
277 return __connman_error_invalid_arguments(msg);
279 dbus_message_iter_next(&array);
282 if (session->notify != NULL)
283 session->notify(session);
285 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
288 static const GDBusMethodTable notify_methods[] = {
289 { GDBUS_METHOD("Release", NULL, NULL, notify_release) },
290 { GDBUS_METHOD("Update",
291 GDBUS_ARGS({ "settings", "a{sv}" }), NULL,
296 int session_notify_register(struct test_session *session,
297 const char *notify_path)
299 if (g_dbus_register_interface(session->connection, notify_path,
300 CONNMAN_NOTIFICATION_INTERFACE,
301 notify_methods, NULL, NULL,
302 session, NULL) == FALSE) {
309 int session_notify_unregister(struct test_session *session,
310 const char *notify_path)
312 if (g_dbus_unregister_interface(session->connection, notify_path,
313 CONNMAN_NOTIFICATION_INTERFACE) == FALSE) {
320 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
322 struct test_session_info *info = user_data;
325 for (list = info->allowed_bearers;
326 list != NULL; list = list->next) {
327 struct test_bearer_info *info = list->data;
329 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
334 void session_append_settings(DBusMessageIter *dict,
335 struct test_session_info *info)
339 connman_dbus_dict_append_basic(dict, "Priority",
343 connman_dbus_dict_append_array(dict, "AllowedBearers",
345 append_allowed_bearers,
348 connman_dbus_dict_append_basic(dict, "AvoidHandover",
350 &info->avoid_handover);
352 connman_dbus_dict_append_basic(dict, "StayConnected",
354 &info->stay_connected);
356 connman_dbus_dict_append_basic(dict, "PeriodicConnect",
358 &info->periodic_connect);
360 connman_dbus_dict_append_basic(dict, "IdleTimeout",
362 &info->idle_timeout);
364 connman_dbus_dict_append_basic(dict, "EmergencyCall",
368 policy = roamingpolicy2string(info->roaming_policy);
369 connman_dbus_dict_append_basic(dict, "RoamingPolicy",
374 DBusMessage *session_connect(DBusConnection *connection,
375 struct test_session *session)
377 DBusMessage *message, *reply;
380 message = dbus_message_new_method_call(CONNMAN_SERVICE,
381 session->session_path,
382 CONNMAN_SESSION_INTERFACE,
387 dbus_error_init(&error);
389 reply = dbus_connection_send_with_reply_and_block(connection,
390 message, -1, &error);
392 if (dbus_error_is_set(&error) == TRUE) {
393 LOG("%s", error.message);
394 dbus_error_free(&error);
396 LOG("Failed to get properties");
398 dbus_message_unref(message);
402 dbus_message_unref(message);
407 DBusMessage *session_disconnect(DBusConnection *connection,
408 struct test_session *session)
410 DBusMessage *message, *reply;
413 message = dbus_message_new_method_call(CONNMAN_SERVICE,
414 session->session_path,
415 CONNMAN_SESSION_INTERFACE,
420 dbus_error_init(&error);
422 reply = dbus_connection_send_with_reply_and_block(connection,
423 message, -1, &error);
425 if (dbus_error_is_set(&error) == TRUE) {
426 LOG("%s", error.message);
427 dbus_error_free(&error);
429 LOG("Failed to get properties");
431 dbus_message_unref(message);
435 dbus_message_unref(message);