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 <gdbus/gdbus.h>
  27
  28 #include "test-connman.h"
  29
  30 static const char *roamingpolicy2string(enum connman_session_roaming_policy policy)
  31 {
  32         switch (policy) {
  33         case CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN:
  34                 break;
  35         case CONNMAN_SESSION_ROAMING_POLICY_DEFAULT:
  36                 return "default";
  37         case CONNMAN_SESSION_ROAMING_POLICY_ALWAYS:
  38                 return "always";
  39         case CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN:
  40                 return "forbidden";
  41         case CONNMAN_SESSION_ROAMING_POLICY_NATIONAL:
  42                 return "national";
  43         case CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL:
  44                 return "international";
  45         }
  46
  47         return "";
  48 }
  49
  50 static enum connman_session_roaming_policy string2roamingpolicy(const char *policy)
  51 {
  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;
  62         else
  63                 return CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN;
  64 }
  65
  66 void bearer_info_cleanup(gpointer data, gpointer user_data)
  67 {
  68         struct test_bearer_info *info = data;
  69
  70         g_free(info->name);
  71         g_free(info);
  72 }
  73
  74 static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
  75 {
  76         struct test_bearer_info *info;
  77         DBusMessageIter array;
  78         GSList *list = NULL;
  79
  80         dbus_message_iter_recurse(iter, &array);
  81
  82         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
  83                 char *bearer = NULL;
  84
  85                 dbus_message_iter_get_basic(&array, &bearer);
  86
  87                 info = g_try_new0(struct test_bearer_info, 1);
  88                 if (info == NULL) {
  89                         g_slist_foreach(list, bearer_info_cleanup, NULL);
  90                         g_slist_free(list);
  91
  92                         return NULL;
  93                 }
  94
  95                 info->name = g_strdup(bearer);
  96
  97                 list = g_slist_append(list, info);
  98
  99                 dbus_message_iter_next(&array);
 100         }
 101
 102         return list;
 103 }
 104
 105 static DBusMessage *notify_release(DBusConnection *conn,
 106                                         DBusMessage *msg, void *user_data)
 107 {
 108         struct test_session *session = user_data;
 109
 110         LOG("session %p", session);
 111
 112         if (session->notify != NULL)
 113                 session->notify(session);
 114
 115         return NULL;
 116 }
 117
 118 static DBusMessage *notify_update(DBusConnection *conn,
 119                                         DBusMessage *msg, void *user_data)
 120 {
 121         struct test_session *session = user_data;
 122         struct test_session_info *info = session->info;
 123         DBusMessageIter iter, array;
 124         GSList *allowed_bearers;
 125
 126         LOG("session %p notify %s", session, session->notify_path);
 127
 128         dbus_message_iter_init(msg, &iter);
 129         dbus_message_iter_recurse(&iter, &array);
 130
 131         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
 132                 DBusMessageIter entry, value;
 133                 const char *key;
 134
 135                 dbus_message_iter_recurse(&array, &entry);
 136                 dbus_message_iter_get_basic(&entry, &key);
 137
 138                 dbus_message_iter_next(&entry);
 139                 dbus_message_iter_recurse(&entry, &value);
 140
 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);
 145
 146                                 g_slist_foreach(info->allowed_bearers,
 147                                                 bearer_info_cleanup, NULL);
 148                                 g_slist_free(info->allowed_bearers);
 149
 150                                 info->allowed_bearers = allowed_bearers;
 151
 152                         } else if (g_str_equal(key, "IPv4") == TRUE) {
 153                                 /* XXX */
 154
 155                         } else if (g_str_equal(key, "IPv6") == TRUE) {
 156                                 /* XXX */
 157
 158                         } else {
 159                                 g_assert(FALSE);
 160                                 return __connman_error_invalid_arguments(msg);
 161                         }
 162                         break;
 163                 case DBUS_TYPE_BOOLEAN:
 164                         if (g_str_equal(key, "Online") == TRUE) {
 165                                 dbus_message_iter_get_basic(&value,
 166                                                         &info->online);
 167                         } else if (g_str_equal(key, "Priority") == TRUE) {
 168                                 dbus_message_iter_get_basic(&value,
 169                                                         &info->priority);
 170
 171                         } else if (g_str_equal(key, "AvoidHandover") == TRUE) {
 172                                 dbus_message_iter_get_basic(&value,
 173                                                         &info->avoid_handover);
 174
 175                         } else if (g_str_equal(key, "StayConnected") == TRUE) {
 176                                 dbus_message_iter_get_basic(&value,
 177                                                         &info->stay_connected);
 178
 179                         } else if (g_str_equal(key, "EmergencyCall") == TRUE) {
 180                                 dbus_message_iter_get_basic(&value,
 181                                                         &info->ecall);
 182
 183                         } else {
 184                                 g_assert(FALSE);
 185                                 return __connman_error_invalid_arguments(msg);
 186                         }
 187                         break;
 188                 case DBUS_TYPE_UINT32:
 189                         if (g_str_equal(key, "PeriodicConnect") == TRUE) {
 190                                 dbus_message_iter_get_basic(&value,
 191                                                         &info->periodic_connect);
 192
 193                         } else if (g_str_equal(key, "IdleTimeout") == TRUE) {
 194                                 dbus_message_iter_get_basic(&value,
 195                                                         &info->idle_timeout);
 196
 197                         } else if (g_str_equal(key, "SessionMarker") == TRUE) {
 198                                 dbus_message_iter_get_basic(&value,
 199                                                         &info->marker);
 200
 201                         } else {
 202                                 g_assert(FALSE);
 203                                 return __connman_error_invalid_arguments(msg);
 204                         }
 205                         break;
 206                 case DBUS_TYPE_STRING:
 207                         if (g_str_equal(key, "Bearer") == TRUE) {
 208                                 const char *val;
 209                                 dbus_message_iter_get_basic(&value, &val);
 210
 211                                 if (info->bearer != NULL)
 212                                         g_free(info->bearer);
 213
 214                                 info->bearer = g_strdup(val);
 215
 216                         } else if (g_str_equal(key, "Name") == TRUE) {
 217                                 const char *val;
 218                                 dbus_message_iter_get_basic(&value, &val);
 219
 220                                 if (info->name != NULL)
 221                                         g_free(info->name);
 222
 223                                 info->name = g_strdup(val);
 224
 225                         } else if (g_str_equal(key, "RoamingPolicy") == TRUE) {
 226                                 const char *val;
 227                                 dbus_message_iter_get_basic(&value, &val);
 228                                 info->roaming_policy =
 229                                         string2roamingpolicy(val);
 230
 231                         } else if (g_str_equal(key, "Interface") == TRUE) {
 232                                 const char *val;
 233                                 dbus_message_iter_get_basic(&value, &val);
 234
 235                                 if (info->interface != NULL)
 236                                         g_free(info->interface);
 237
 238                                 info->interface = g_strdup(val);
 239
 240                         } else {
 241                                 g_assert(FALSE);
 242                                 return __connman_error_invalid_arguments(msg);
 243                         }
 244                         break;
 245                 default:
 246                         g_assert(FALSE);
 247                         return __connman_error_invalid_arguments(msg);
 248                 }
 249                 dbus_message_iter_next(&array);
 250         }
 251
 252         if (session->notify != NULL)
 253                 session->notify(session);
 254
 255         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 256 }
 257
 258 static GDBusMethodTable notify_methods[] = {
 259         { "Release", "",      "", notify_release },
 260         { "Update",  "a{sv}", "", notify_update  },
 261         { },
 262 };
 263
 264 int session_notify_register(struct test_session *session,
 265                                 const char *notify_path)
 266 {
 267         if (g_dbus_register_interface(session->connection, notify_path,
 268                         CONNMAN_NOTIFICATION_INTERFACE,
 269                         notify_methods, NULL, NULL,
 270                         session, NULL) == FALSE) {
 271                 return -EINVAL;
 272         }
 273
 274         return 0;
 275 }
 276
 277 int session_notify_unregister(struct test_session *session,
 278                                 const char *notify_path)
 279 {
 280         if (g_dbus_unregister_interface(session->connection, notify_path,
 281                                 CONNMAN_NOTIFICATION_INTERFACE) == FALSE) {
 282                 return -EINVAL;
 283         }
 284
 285         return 0;
 286 }
 287
 288 static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
 289 {
 290         struct test_session_info *info = user_data;
 291         GSList *list;
 292
 293         for (list = info->allowed_bearers;
 294                         list != NULL; list = list->next) {
 295                 struct test_bearer_info *info = list->data;
 296
 297                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
 298                                                 &info->name);
 299         }
 300 }
 301
 302 void session_append_settings(DBusMessageIter *dict,
 303                                 struct test_session_info *info)
 304 {
 305         const char *policy;
 306
 307         connman_dbus_dict_append_basic(dict, "Priority",
 308                                                 DBUS_TYPE_BOOLEAN,
 309                                                 &info->priority);
 310
 311         connman_dbus_dict_append_array(dict, "AllowedBearers",
 312                                                 DBUS_TYPE_STRING,
 313                                                 append_allowed_bearers,
 314                                                 info);
 315
 316         connman_dbus_dict_append_basic(dict, "AvoidHandover",
 317                                                 DBUS_TYPE_BOOLEAN,
 318                                                 &info->avoid_handover);
 319
 320         connman_dbus_dict_append_basic(dict, "StayConnected",
 321                                                 DBUS_TYPE_BOOLEAN,
 322                                                 &info->stay_connected);
 323
 324         connman_dbus_dict_append_basic(dict, "PeriodicConnect",
 325                                                 DBUS_TYPE_UINT32,
 326                                                 &info->periodic_connect);
 327
 328         connman_dbus_dict_append_basic(dict, "IdleTimeout",
 329                                                 DBUS_TYPE_UINT32,
 330                                                 &info->idle_timeout);
 331
 332         connman_dbus_dict_append_basic(dict, "EmergencyCall",
 333                                                 DBUS_TYPE_BOOLEAN,
 334                                                 &info->ecall);
 335
 336         policy = roamingpolicy2string(info->roaming_policy);
 337         connman_dbus_dict_append_basic(dict, "RoamingPolicy",
 338                                                 DBUS_TYPE_STRING,
 339                                                 &policy);
 340 }
 341
 342 DBusMessage *session_connect(DBusConnection *connection,
 343                                 struct test_session *session)
 344 {
 345         DBusMessage *message, *reply;
 346         DBusError error;
 347
 348         message = dbus_message_new_method_call(CONNMAN_SERVICE,
 349                                                 session->session_path,
 350                                                 CONNMAN_SESSION_INTERFACE,
 351                                                         "Connect");
 352         if (message == NULL)
 353                 return NULL;
 354
 355         dbus_error_init(&error);
 356
 357         reply = dbus_connection_send_with_reply_and_block(connection,
 358                                                         message, -1, &error);
 359         if (reply == NULL) {
 360                 if (dbus_error_is_set(&error) == TRUE) {
 361                         LOG("%s", error.message);
 362                         dbus_error_free(&error);
 363                 } else {
 364                         LOG("Failed to get properties");
 365                 }
 366                 dbus_message_unref(message);
 367                 return NULL;
 368         }
 369
 370         dbus_message_unref(message);
 371
 372         return reply;
 373 }
 374
 375 DBusMessage *session_disconnect(DBusConnection *connection,
 376                                         struct test_session *session)
 377 {
 378         DBusMessage *message, *reply;
 379         DBusError error;
 380
 381         message = dbus_message_new_method_call(CONNMAN_SERVICE,
 382                                                 session->session_path,
 383                                                 CONNMAN_SESSION_INTERFACE,
 384                                                         "Disconnect");
 385         if (message == NULL)
 386                 return NULL;
 387
 388         dbus_error_init(&error);
 389
 390         reply = dbus_connection_send_with_reply_and_block(connection,
 391                                                         message, -1, &error);
 392         if (reply == NULL) {
 393                 if (dbus_error_is_set(&error) == TRUE) {
 394                         LOG("%s", error.message);
 395                         dbus_error_free(&error);
 396                 } else {
 397                         LOG("Failed to get properties");
 398                 }
 399                 dbus_message_unref(message);
 400                 return NULL;
 401         }
 402
 403         dbus_message_unref(message);
 404
 405         return reply;
 406 }