unit/session-api.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2011  BWM CarIT GmbH. All rights reserved.
   6  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27
  28 #include <gdbus/gdbus.h>
  29
  30 #include "test-connman.h"
  31
  32 static enum connman_session_state string2state(const char *state)
  33 {
  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;
  38
  39         return CONNMAN_SESSION_STATE_DISCONNECTED;
  40 }
  41
  42 static enum connman_session_state string2type(const char *type)
  43 {
  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;
  48
  49         return CONNMAN_SESSION_TYPE_ANY;
  50 }
  51
  52 void bearer_info_cleanup(gpointer data, gpointer user_data)
  53 {
  54         struct test_bearer_info *info = data;
  55
  56         g_free(info->name);
  57         g_free(info);
  58 }
  59
  60 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
  61 {
  62         struct test_bearer_info *info;
  63         DBusMessageIter array;
  64         GSList *list = NULL;
  65
  66         dbus_message_iter_recurse(iter, &array);
  67
  68         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
  69                 char *bearer = NULL;
  70
  71                 dbus_message_iter_get_basic(&array, &bearer);
  72
  73                 info = g_try_new0(struct test_bearer_info, 1);
  74                 if (info == NULL) {
  75                         g_slist_foreach(list, bearer_info_cleanup, NULL);
  76                         g_slist_free(list);
  77
  78                         return NULL;
  79                 }
  80
  81                 info->name = g_strdup(bearer);
  82
  83                 list = g_slist_append(list, info);
  84
  85                 dbus_message_iter_next(&array);
  86         }
  87
  88         return list;
  89 }
  90
  91 static DBusMessage *notify_release(DBusConnection *conn,
  92                                         DBusMessage *msg, void *user_data)
  93 {
  94         struct test_session *session = user_data;
  95
  96         LOG("session %p", session);
  97
  98         if (session->notify != NULL)
  99                 session->notify(session);
 100
 101         return NULL;
 102 }
 103
 104 static DBusMessage *notify_update(DBusConnection *conn,
 105                                         DBusMessage *msg, void *user_data)
 106 {
 107         struct test_session *session = user_data;
 108         struct test_session_info *info = session->info;
 109         DBusMessageIter iter, array;
 110         GSList *allowed_bearers;
 111
 112         LOG("session %p notify %s", session, session->notify_path);
 113
 114         dbus_message_iter_init(msg, &iter);
 115         dbus_message_iter_recurse(&iter, &array);
 116
 117         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
 118                 DBusMessageIter entry, value;
 119                 const char *key;
 120
 121                 dbus_message_iter_recurse(&array, &entry);
 122                 dbus_message_iter_get_basic(&entry, &key);
 123
 124                 dbus_message_iter_next(&entry);
 125                 dbus_message_iter_recurse(&entry, &value);
 126
 127                 switch (dbus_message_iter_get_arg_type(&value)) {
 128                 case DBUS_TYPE_ARRAY:
 129                         if (g_str_equal(key, "AllowedBearers") == TRUE) {
 130                                 allowed_bearers = session_parse_allowed_bearers(&value);
 131
 132                                 g_slist_foreach(info->allowed_bearers,
 133                                                 bearer_info_cleanup, NULL);
 134                                 g_slist_free(info->allowed_bearers);
 135
 136                                 info->allowed_bearers = allowed_bearers;
 137
 138                         } else if (g_str_equal(key, "IPv4") == TRUE) {
 139                                 /* XXX */
 140
 141                         } else if (g_str_equal(key, "IPv6") == TRUE) {
 142                                 /* XXX */
 143
 144                         } else {
 145                                 g_assert(FALSE);
 146                                 return __connman_error_invalid_arguments(msg);
 147                         }
 148                         break;
 149                 case DBUS_TYPE_STRING:
 150                         if (g_str_equal(key, "State") == TRUE) {
 151                                 const char *val;
 152                                 dbus_message_iter_get_basic(&value, &val);
 153
 154                                 info->state = string2state(val);
 155                         } else if (g_str_equal(key, "Bearer") == TRUE) {
 156                                 const char *val;
 157                                 dbus_message_iter_get_basic(&value, &val);
 158
 159                                 if (info->bearer != NULL)
 160                                         g_free(info->bearer);
 161
 162                                 info->bearer = g_strdup(val);
 163
 164                         } else if (g_str_equal(key, "Name") == TRUE) {
 165                                 const char *val;
 166                                 dbus_message_iter_get_basic(&value, &val);
 167
 168                                 if (info->name != NULL)
 169                                         g_free(info->name);
 170
 171                                 info->name = g_strdup(val);
 172
 173                         } else if (g_str_equal(key, "Interface") == TRUE) {
 174                                 const char *val;
 175                                 dbus_message_iter_get_basic(&value, &val);
 176
 177                                 if (info->interface != NULL)
 178                                         g_free(info->interface);
 179
 180                                 info->interface = g_strdup(val);
 181
 182                         } else if (g_str_equal(key, "ConnectionType")
 183                                                                 == TRUE) {
 184                                 const char *val;
 185                                 dbus_message_iter_get_basic(&value, &val);
 186
 187                                 info->type = string2type(val);
 188                         } else {
 189                                 g_assert(FALSE);
 190                                 return __connman_error_invalid_arguments(msg);
 191                         }
 192                         break;
 193                 default:
 194                         g_assert(FALSE);
 195                         return __connman_error_invalid_arguments(msg);
 196                 }
 197                 dbus_message_iter_next(&array);
 198         }
 199
 200         if (session->notify != NULL)
 201                 session->notify(session);
 202
 203         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 204 }
 205
 206 static const GDBusMethodTable notify_methods[] = {
 207         { GDBUS_METHOD("Release", NULL, NULL, notify_release) },
 208         { GDBUS_METHOD("Update",
 209                         GDBUS_ARGS({ "settings", "a{sv}" }), NULL,
 210                         notify_update) },
 211         { },
 212 };
 213
 214 int session_notify_register(struct test_session *session,
 215                                 const char *notify_path)
 216 {
 217         if (g_dbus_register_interface(session->connection, notify_path,
 218                         CONNMAN_NOTIFICATION_INTERFACE,
 219                         notify_methods, NULL, NULL,
 220                         session, NULL) == FALSE) {
 221                 return -EINVAL;
 222         }
 223
 224         return 0;
 225 }
 226
 227 int session_notify_unregister(struct test_session *session,
 228                                 const char *notify_path)
 229 {
 230         if (g_dbus_unregister_interface(session->connection, notify_path,
 231                                 CONNMAN_NOTIFICATION_INTERFACE) == FALSE) {
 232                 return -EINVAL;
 233         }
 234
 235         return 0;
 236 }
 237
 238 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
 239 {
 240         struct test_session_info *info = user_data;
 241         GSList *list;
 242
 243         for (list = info->allowed_bearers;
 244                         list != NULL; list = list->next) {
 245                 struct test_bearer_info *bearer_info = list->data;
 246
 247                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
 248                                                 &bearer_info->name);
 249         }
 250 }
 251
 252 void session_append_settings(DBusMessageIter *dict,
 253                                 struct test_session_info *info)
 254 {
 255         connman_dbus_dict_append_array(dict, "AllowedBearers",
 256                                                 DBUS_TYPE_STRING,
 257                                                 append_allowed_bearers,
 258                                                 info);
 259 }
 260
 261 DBusMessage *session_connect(DBusConnection *connection,
 262                                 struct test_session *session)
 263 {
 264         DBusMessage *message, *reply;
 265         DBusError error;
 266
 267         message = dbus_message_new_method_call(CONNMAN_SERVICE,
 268                                                 session->session_path,
 269                                                 CONNMAN_SESSION_INTERFACE,
 270                                                         "Connect");
 271         if (message == NULL)
 272                 return NULL;
 273
 274         dbus_error_init(&error);
 275
 276         reply = dbus_connection_send_with_reply_and_block(connection,
 277                                                         message, -1, &error);
 278         if (reply == NULL) {
 279                 if (dbus_error_is_set(&error) == TRUE) {
 280                         LOG("%s", error.message);
 281                         dbus_error_free(&error);
 282                 } else {
 283                         LOG("Failed to get properties");
 284                 }
 285                 dbus_message_unref(message);
 286                 return NULL;
 287         }
 288
 289         dbus_message_unref(message);
 290
 291         return reply;
 292 }
 293
 294 DBusMessage *session_disconnect(DBusConnection *connection,
 295                                         struct test_session *session)
 296 {
 297         DBusMessage *message, *reply;
 298         DBusError error;
 299
 300         message = dbus_message_new_method_call(CONNMAN_SERVICE,
 301                                                 session->session_path,
 302                                                 CONNMAN_SESSION_INTERFACE,
 303                                                         "Disconnect");
 304         if (message == NULL)
 305                 return NULL;
 306
 307         dbus_error_init(&error);
 308
 309         reply = dbus_connection_send_with_reply_and_block(connection,
 310                                                         message, -1, &error);
 311         if (reply == NULL) {
 312                 if (dbus_error_is_set(&error) == TRUE) {
 313                         LOG("%s", error.message);
 314                         dbus_error_free(&error);
 315                 } else {
 316                         LOG("Failed to get properties");
 317                 }
 318                 dbus_message_unref(message);
 319                 return NULL;
 320         }
 321
 322         dbus_message_unref(message);
 323
 324         return reply;
 325 }