5 * Copyright (C) 2011-2014 BMW Car IT GmbH.
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
30 #include "session-test.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_type string2type(const char *type)
44 if (g_strcmp0(type, "any") == 0)
45 return CONNMAN_SESSION_TYPE_ANY;
46 if (g_strcmp0(type, "local") == 0)
47 return CONNMAN_SESSION_TYPE_LOCAL;
48 if (g_strcmp0(type, "internet") == 0)
49 return CONNMAN_SESSION_TYPE_INTERNET;
51 return CONNMAN_SESSION_TYPE_UNKNOWN;
54 void bearer_info_cleanup(gpointer data, gpointer user_data)
56 struct test_bearer_info *info = data;
62 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
64 struct test_bearer_info *info;
65 DBusMessageIter array;
68 dbus_message_iter_recurse(iter, &array);
70 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
73 dbus_message_iter_get_basic(&array, &bearer);
75 info = g_try_new0(struct test_bearer_info, 1);
77 g_slist_foreach(list, bearer_info_cleanup, NULL);
83 info->name = g_strdup(bearer);
85 list = g_slist_append(list, info);
87 dbus_message_iter_next(&array);
93 static DBusMessage *notify_release(DBusConnection *conn,
94 DBusMessage *msg, void *user_data)
96 struct test_session *session = user_data;
98 LOG("session %p", session);
101 session->notify(session);
106 static DBusMessage *notify_update(DBusConnection *conn,
107 DBusMessage *msg, void *user_data)
109 struct test_session *session = user_data;
110 struct test_session_info *info = session->info;
111 DBusMessageIter iter, array;
112 GSList *allowed_bearers;
114 LOG("session %p notify %s", session, session->notify_path);
116 dbus_message_iter_init(msg, &iter);
117 dbus_message_iter_recurse(&iter, &array);
119 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
120 DBusMessageIter entry, value;
123 dbus_message_iter_recurse(&array, &entry);
124 dbus_message_iter_get_basic(&entry, &key);
126 dbus_message_iter_next(&entry);
127 dbus_message_iter_recurse(&entry, &value);
129 switch (dbus_message_iter_get_arg_type(&value)) {
130 case DBUS_TYPE_ARRAY:
131 if (g_str_equal(key, "AllowedBearers")) {
132 allowed_bearers = session_parse_allowed_bearers(&value);
134 g_slist_foreach(info->allowed_bearers,
135 bearer_info_cleanup, NULL);
136 g_slist_free(info->allowed_bearers);
138 info->allowed_bearers = allowed_bearers;
140 } else if (g_str_equal(key, "IPv4")) {
143 } else if (g_str_equal(key, "IPv6")) {
148 return __connman_error_invalid_arguments(msg);
151 case DBUS_TYPE_STRING:
152 if (g_str_equal(key, "State")) {
154 dbus_message_iter_get_basic(&value, &val);
156 info->state = string2state(val);
157 } else if (g_str_equal(key, "Bearer")) {
159 dbus_message_iter_get_basic(&value, &val);
161 g_free(info->bearer);
162 info->bearer = g_strdup(val);
164 } else if (g_str_equal(key, "Name")) {
166 dbus_message_iter_get_basic(&value, &val);
169 info->name = g_strdup(val);
171 } else if (g_str_equal(key, "Interface")) {
173 dbus_message_iter_get_basic(&value, &val);
175 g_free(info->interface);
176 info->interface = g_strdup(val);
178 } else if (g_str_equal(key, "ConnectionType")) {
180 dbus_message_iter_get_basic(&value, &val);
182 info->type = string2type(val);
184 } else if (g_str_equal(key, "Allowedinterface")) {
186 dbus_message_iter_get_basic(&value, &val);
188 g_free(info->allowed_interface);
189 info->allowed_interface = g_strdup(val);
191 } else if (g_str_equal(key, "ContextIdentifier")) {
193 dbus_message_iter_get_basic(&value, &val);
195 g_free(info->context_identifier);
196 info->context_identifier = g_strdup(val);
200 return __connman_error_invalid_arguments(msg);
203 case DBUS_TYPE_BOOLEAN:
204 if (g_str_equal(key, "SourceIPRule")) {
206 dbus_message_iter_get_basic(&value, &val);
208 info->source_ip_rule = val;
212 return __connman_error_invalid_arguments(msg);
217 return __connman_error_invalid_arguments(msg);
219 dbus_message_iter_next(&array);
223 session->notify(session);
225 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
228 static const GDBusMethodTable notify_methods[] = {
229 { GDBUS_METHOD("Release", NULL, NULL, notify_release) },
230 { GDBUS_METHOD("Update",
231 GDBUS_ARGS({ "settings", "a{sv}" }), NULL,
236 int session_notify_register(struct test_session *session,
237 const char *notify_path)
239 if (!g_dbus_register_interface(session->connection, notify_path, CONNMAN_NOTIFICATION_INTERFACE, notify_methods, NULL, NULL, session, NULL)) {
246 int session_notify_unregister(struct test_session *session,
247 const char *notify_path)
249 if (!g_dbus_unregister_interface(session->connection, notify_path, CONNMAN_NOTIFICATION_INTERFACE)) {
256 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
258 struct test_session_info *info = user_data;
261 for (list = info->allowed_bearers;
262 list; list = list->next) {
263 struct test_bearer_info *bearer_info = list->data;
265 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
270 void session_append_settings(DBusMessageIter *dict,
271 struct test_session_info *info)
273 if (!info->allowed_bearers)
276 connman_dbus_dict_append_array(dict, "AllowedBearers",
278 append_allowed_bearers,
282 DBusMessage *session_connect(DBusConnection *connection,
283 struct test_session *session)
285 DBusMessage *message, *reply;
288 message = dbus_message_new_method_call(CONNMAN_SERVICE,
289 session->session_path,
290 CONNMAN_SESSION_INTERFACE,
295 dbus_error_init(&error);
297 reply = dbus_connection_send_with_reply_and_block(connection,
298 message, -1, &error);
300 if (dbus_error_is_set(&error)) {
301 LOG("%s", error.message);
302 dbus_error_free(&error);
304 LOG("Failed to get properties");
306 dbus_message_unref(message);
310 dbus_message_unref(message);
315 DBusMessage *session_disconnect(DBusConnection *connection,
316 struct test_session *session)
318 DBusMessage *message, *reply;
321 message = dbus_message_new_method_call(CONNMAN_SERVICE,
322 session->session_path,
323 CONNMAN_SESSION_INTERFACE,
328 dbus_error_init(&error);
330 reply = dbus_connection_send_with_reply_and_block(connection,
331 message, -1, &error);
333 if (dbus_error_is_set(&error)) {
334 LOG("%s", error.message);
335 dbus_error_free(&error);
337 LOG("Failed to get properties");
339 dbus_message_unref(message);
343 dbus_message_unref(message);