unit/manager-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 <stdio.h>
  27
  28 #include "test-connman.h"
  29
  30 static DBusMessage *set_property(DBusConnection *connection,
  31                                 const char *property, int type, void *value)
  32 {
  33         DBusMessage *message, *reply;
  34         DBusError error;
  35         DBusMessageIter iter;
  36
  37         message = dbus_message_new_method_call(CONNMAN_SERVICE,
  38                                                 CONNMAN_MANAGER_PATH,
  39                                                 CONNMAN_MANAGER_INTERFACE,
  40                                                 "SetProperty");
  41         if (message == NULL)
  42                 return NULL;
  43
  44         dbus_message_iter_init_append(message, &iter);
  45         connman_dbus_property_append_basic(&iter, property, type, value);
  46
  47         dbus_error_init(&error);
  48
  49         reply = dbus_connection_send_with_reply_and_block(connection,
  50                                                         message, -1, &error);
  51         if (reply == NULL) {
  52                 if (dbus_error_is_set(&error) == TRUE) {
  53                         LOG("%s", error.message);
  54                         dbus_error_free(&error);
  55                 } else {
  56                         LOG("Failed to get properties");
  57                 }
  58                 dbus_message_unref(message);
  59                 return NULL;
  60         }
  61
  62         dbus_message_unref(message);
  63
  64         return reply;
  65 }
  66
  67 DBusMessage *manager_get_services(DBusConnection *connection)
  68 {
  69         DBusMessage *message, *reply;
  70         DBusError error;
  71
  72         message = dbus_message_new_method_call(CONNMAN_SERVICE,
  73                                                 CONNMAN_MANAGER_PATH,
  74                                                 CONNMAN_MANAGER_INTERFACE,
  75                                                         "GetServices");
  76         if (message == NULL)
  77                 return NULL;
  78
  79         dbus_error_init(&error);
  80
  81         reply = dbus_connection_send_with_reply_and_block(connection,
  82                                                         message, -1, &error);
  83         if (reply == NULL) {
  84                 if (dbus_error_is_set(&error) == TRUE) {
  85                         LOG("%s", error.message);
  86                         dbus_error_free(&error);
  87                 } else {
  88                         LOG("Failed to get properties");
  89                 }
  90                 dbus_message_unref(message);
  91                 return NULL;
  92         }
  93
  94         dbus_message_unref(message);
  95
  96         return reply;
  97 }
  98
  99 DBusMessage *manager_get_properties(DBusConnection *connection)
 100 {
 101         DBusMessage *message, *reply;
 102         DBusError error;
 103
 104         message = dbus_message_new_method_call(CONNMAN_SERVICE,
 105                                                 CONNMAN_MANAGER_PATH,
 106                                                 CONNMAN_MANAGER_INTERFACE,
 107                                                         "GetProperties");
 108         if (message == NULL)
 109                 return NULL;
 110
 111         dbus_error_init(&error);
 112
 113         reply = dbus_connection_send_with_reply_and_block(connection,
 114                                                         message, -1, &error);
 115         if (reply == NULL) {
 116                 if (dbus_error_is_set(&error) == TRUE) {
 117                         LOG("%s", error.message);
 118                         dbus_error_free(&error);
 119                 } else {
 120                         LOG("%s", error.message);
 121                 }
 122                 dbus_message_unref(message);
 123                 return NULL;
 124         }
 125
 126         dbus_message_unref(message);
 127
 128         return reply;
 129 }
 130
 131 DBusMessage *manager_create_session(DBusConnection *connection,
 132                                         struct test_session_info *info,
 133                                         const char *notifier_path)
 134 {
 135         DBusMessage *message, *reply;
 136         DBusError error;
 137         DBusMessageIter array, dict;
 138
 139         message = dbus_message_new_method_call(CONNMAN_SERVICE,
 140                                                 CONNMAN_MANAGER_PATH,
 141                                                 CONNMAN_MANAGER_INTERFACE,
 142                                                         "CreateSession");
 143         if (message == NULL)
 144                 return NULL;
 145
 146         dbus_error_init(&error);
 147
 148         dbus_message_iter_init_append(message, &array);
 149
 150         connman_dbus_dict_open(&array, &dict);
 151
 152         session_append_settings(&dict, info);
 153
 154         connman_dbus_dict_close(&array, &dict);
 155
 156         dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
 157                                 &notifier_path);
 158
 159         reply = dbus_connection_send_with_reply_and_block(connection,
 160                                                         message, -1, &error);
 161         if (reply == NULL) {
 162                 if (dbus_error_is_set(&error) == TRUE) {
 163                         LOG("%s", error.message);
 164                         dbus_error_free(&error);
 165                 } else {
 166                         LOG("Failed to get properties");
 167                 }
 168                 dbus_message_unref(message);
 169                 return NULL;
 170         }
 171
 172         dbus_message_unref(message);
 173
 174         return reply;
 175 }
 176
 177 DBusMessage *manager_destroy_session(DBusConnection *connection,
 178                                         const char *notifier_path)
 179 {
 180         DBusMessage *message, *reply;
 181         DBusError error;
 182         DBusMessageIter array;
 183
 184         message = dbus_message_new_method_call(CONNMAN_SERVICE,
 185                                                 CONNMAN_MANAGER_PATH,
 186                                                 CONNMAN_MANAGER_INTERFACE,
 187                                                         "DestroySession");
 188         if (message == NULL)
 189                 return NULL;
 190
 191         dbus_error_init(&error);
 192
 193         dbus_message_iter_init_append(message, &array);
 194
 195         dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
 196                                 &notifier_path);
 197
 198         reply = dbus_connection_send_with_reply_and_block(connection,
 199                                                         message, -1, &error);
 200         if (reply == NULL) {
 201                 if (dbus_error_is_set(&error) == TRUE) {
 202                         LOG("%s", error.message);
 203                         dbus_error_free(&error);
 204                 } else {
 205                         LOG("%s", error.message);
 206                 }
 207                 dbus_message_unref(message);
 208                 return NULL;
 209         }
 210
 211         dbus_message_unref(message);
 212
 213         return reply;
 214 }
 215
 216 DBusMessage *manager_set_session_mode(DBusConnection *connection,
 217                                         connman_bool_t enable)
 218 {
 219         return set_property(connection, "SessionMode",
 220                                 DBUS_TYPE_BOOLEAN, &enable);
 221 }
 222
 223 int manager_parse_properties(DBusMessage *msg,
 224                                 struct test_manager *manager)
 225 {
 226         DBusMessageIter iter, array;
 227
 228         dbus_message_iter_init(msg, &iter);
 229         dbus_message_iter_recurse(&iter, &array);
 230
 231         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
 232                 DBusMessageIter entry, value;
 233                 const char *key;
 234
 235                 dbus_message_iter_recurse(&array, &entry);
 236                 dbus_message_iter_get_basic(&entry, &key);
 237
 238                 dbus_message_iter_next(&entry);
 239                 dbus_message_iter_recurse(&entry, &value);
 240
 241                 switch (dbus_message_iter_get_arg_type(&value)) {
 242                 case DBUS_TYPE_STRING:
 243                         if (g_str_equal(key, "State") == TRUE) {
 244                                 const char *val;
 245                                 dbus_message_iter_get_basic(&value, &val);
 246
 247                                 if (manager->state != NULL)
 248                                         g_free(manager->state);
 249
 250                                 LOG("State %s", val);
 251
 252                                 manager->state = g_strdup(val);
 253                         }
 254                         break;
 255                 default:
 256                         break;
 257                 }
 258                 dbus_message_iter_next(&array);
 259         }
 260
 261         return 0;
 262 }