src/manager.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  Intel Corporation. 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.h>
  29
  30 #include "connman.h"
  31
  32 connman_bool_t connman_state_idle;
  33 DBusMessage *session_mode_pending = NULL;
  34
  35 static DBusMessage *get_properties(DBusConnection *conn,
  36                                         DBusMessage *msg, void *data)
  37 {
  38         DBusMessage *reply;
  39         DBusMessageIter array, dict;
  40         connman_bool_t offlinemode, sessionmode;
  41         const char *str;
  42
  43         DBG("conn %p", conn);
  44
  45         reply = dbus_message_new_method_return(msg);
  46         if (reply == NULL)
  47                 return NULL;
  48
  49         dbus_message_iter_init_append(reply, &array);
  50
  51         connman_dbus_dict_open(&array, &dict);
  52
  53         connman_dbus_dict_append_array(&dict, "Services",
  54                         DBUS_TYPE_OBJECT_PATH, __connman_service_list, NULL);
  55
  56         str = __connman_notifier_get_state();
  57         connman_dbus_dict_append_basic(&dict, "State",
  58                                                 DBUS_TYPE_STRING, &str);
  59
  60         offlinemode = __connman_technology_get_offlinemode();
  61         connman_dbus_dict_append_basic(&dict, "OfflineMode",
  62                                         DBUS_TYPE_BOOLEAN, &offlinemode);
  63
  64         connman_dbus_dict_append_array(&dict, "AvailableDebugs",
  65                         DBUS_TYPE_STRING, __connman_debug_list_available, NULL);
  66         connman_dbus_dict_append_array(&dict, "EnabledDebugs",
  67                         DBUS_TYPE_STRING, __connman_debug_list_enabled, NULL);
  68
  69         sessionmode = __connman_session_mode();
  70         connman_dbus_dict_append_basic(&dict, "SessionMode",
  71                                         DBUS_TYPE_BOOLEAN,
  72                                         &sessionmode);
  73
  74         connman_dbus_dict_close(&array, &dict);
  75
  76         return reply;
  77 }
  78
  79 static DBusMessage *set_property(DBusConnection *conn,
  80                                         DBusMessage *msg, void *data)
  81 {
  82         DBusMessageIter iter, value;
  83         const char *name;
  84         int type;
  85
  86         DBG("conn %p", conn);
  87
  88         if (dbus_message_iter_init(msg, &iter) == FALSE)
  89                 return __connman_error_invalid_arguments(msg);
  90
  91         dbus_message_iter_get_basic(&iter, &name);
  92         dbus_message_iter_next(&iter);
  93         dbus_message_iter_recurse(&iter, &value);
  94
  95         type = dbus_message_iter_get_arg_type(&value);
  96
  97         if (g_str_equal(name, "OfflineMode") == TRUE) {
  98                 connman_bool_t offlinemode;
  99
 100                 if (type != DBUS_TYPE_BOOLEAN)
 101                         return __connman_error_invalid_arguments(msg);
 102
 103                 dbus_message_iter_get_basic(&value, &offlinemode);
 104
 105                 __connman_technology_set_offlinemode(offlinemode);
 106         } else if (g_str_equal(name, "SessionMode") == TRUE) {
 107                 connman_bool_t sessionmode;
 108
 109                 if (type != DBUS_TYPE_BOOLEAN)
 110                         return __connman_error_invalid_arguments(msg);
 111
 112                 dbus_message_iter_get_basic(&value, &sessionmode);
 113
 114                 if (session_mode_pending != NULL)
 115                         return __connman_error_in_progress(msg);
 116
 117                 __connman_session_set_mode(sessionmode);
 118
 119                 if (sessionmode == TRUE && connman_state_idle == FALSE) {
 120                         session_mode_pending = msg;
 121                         return NULL;
 122                 }
 123
 124         } else
 125                 return __connman_error_invalid_property(msg);
 126
 127         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 128 }
 129
 130 static DBusMessage *get_technologies(DBusConnection *conn,
 131                 DBusMessage *msg, void *data)
 132 {
 133         DBusMessage *reply;
 134         DBusMessageIter iter, array;
 135
 136         DBG("");
 137
 138         reply = dbus_message_new_method_return(msg);
 139         if (reply == NULL)
 140                 return NULL;
 141
 142         dbus_message_iter_init_append(reply, &iter);
 143
 144         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 145                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 146                         DBUS_TYPE_OBJECT_PATH_AS_STRING
 147                         DBUS_TYPE_ARRAY_AS_STRING
 148                                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 149                                         DBUS_TYPE_STRING_AS_STRING
 150                                         DBUS_TYPE_VARIANT_AS_STRING
 151                                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 152                         DBUS_STRUCT_END_CHAR_AS_STRING, &array);
 153
 154         __connman_technology_list_struct(&array);
 155
 156         dbus_message_iter_close_container(&iter, &array);
 157
 158         return reply;
 159 }
 160
 161 static DBusMessage *remove_provider(DBusConnection *conn,
 162                                     DBusMessage *msg, void *data)
 163 {
 164         const char *path;
 165         int err;
 166
 167         DBG("conn %p", conn);
 168
 169         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 170                                                         DBUS_TYPE_INVALID);
 171
 172         err = __connman_provider_remove(path);
 173         if (err < 0)
 174                 return __connman_error_failed(msg, -err);
 175
 176         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 177 }
 178
 179 static DBusConnection *connection = NULL;
 180
 181 static void session_mode_notify(void)
 182 {
 183         DBusMessage *reply;
 184
 185         reply = g_dbus_create_reply(session_mode_pending, DBUS_TYPE_INVALID);
 186         g_dbus_send_message(connection, reply);
 187
 188         dbus_message_unref(session_mode_pending);
 189         session_mode_pending = NULL;
 190 }
 191
 192 static void idle_state(connman_bool_t idle)
 193 {
 194
 195         DBG("idle %d", idle);
 196
 197         connman_state_idle = idle;
 198
 199         if (connman_state_idle == FALSE || session_mode_pending == NULL)
 200                 return;
 201
 202         session_mode_notify();
 203 }
 204
 205 static struct connman_notifier technology_notifier = {
 206         .name           = "manager",
 207         .priority       = CONNMAN_NOTIFIER_PRIORITY_HIGH,
 208         .idle_state     = idle_state,
 209 };
 210
 211 static DBusMessage *get_services(DBusConnection *conn,
 212                                         DBusMessage *msg, void *data)
 213 {
 214         DBusMessage *reply;
 215         DBusMessageIter iter, array;
 216
 217         reply = dbus_message_new_method_return(msg);
 218         if (reply == NULL)
 219                 return NULL;
 220
 221         dbus_message_iter_init_append(reply, &iter);
 222
 223         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 224                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 225                         DBUS_TYPE_OBJECT_PATH_AS_STRING
 226                         DBUS_TYPE_ARRAY_AS_STRING
 227                                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 228                                         DBUS_TYPE_STRING_AS_STRING
 229                                         DBUS_TYPE_VARIANT_AS_STRING
 230                                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 231                         DBUS_STRUCT_END_CHAR_AS_STRING, &array);
 232
 233         __connman_service_list_struct(&array);
 234
 235         dbus_message_iter_close_container(&iter, &array);
 236
 237         return reply;
 238 }
 239
 240 static DBusMessage *connect_provider(DBusConnection *conn,
 241                                         DBusMessage *msg, void *data)
 242 {
 243         int err;
 244
 245         DBG("conn %p", conn);
 246
 247         if (__connman_session_mode() == TRUE) {
 248                 connman_info("Session mode enabled: "
 249                                 "direct provider connect disabled");
 250
 251                 return __connman_error_failed(msg, -EINVAL);
 252         }
 253
 254         err = __connman_provider_create_and_connect(msg);
 255         if (err < 0) {
 256                 if (err == -EINPROGRESS) {
 257                         connman_error("Invalid return code from connect");
 258                         err = -EINVAL;
 259                 }
 260
 261                 return __connman_error_failed(msg, -err);
 262         }
 263
 264         return NULL;
 265 }
 266
 267 static DBusMessage *register_agent(DBusConnection *conn,
 268                                         DBusMessage *msg, void *data)
 269 {
 270         const char *sender, *path;
 271         int err;
 272
 273         DBG("conn %p", conn);
 274
 275         sender = dbus_message_get_sender(msg);
 276
 277         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 278                                                         DBUS_TYPE_INVALID);
 279
 280         err = __connman_agent_register(sender, path);
 281         if (err < 0)
 282                 return __connman_error_failed(msg, -err);
 283
 284         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 285 }
 286
 287 static DBusMessage *unregister_agent(DBusConnection *conn,
 288                                         DBusMessage *msg, void *data)
 289 {
 290         const char *sender, *path;
 291         int err;
 292
 293         DBG("conn %p", conn);
 294
 295         sender = dbus_message_get_sender(msg);
 296
 297         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 298                                                         DBUS_TYPE_INVALID);
 299
 300         err = __connman_agent_unregister(sender, path);
 301         if (err < 0)
 302                 return __connman_error_failed(msg, -err);
 303
 304         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 305 }
 306
 307 static DBusMessage *register_counter(DBusConnection *conn,
 308                                         DBusMessage *msg, void *data)
 309 {
 310         const char *sender, *path;
 311         unsigned int accuracy, period;
 312         int err;
 313
 314         DBG("conn %p", conn);
 315
 316         sender = dbus_message_get_sender(msg);
 317
 318         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 319                                                 DBUS_TYPE_UINT32, &accuracy,
 320                                                 DBUS_TYPE_UINT32, &period,
 321                                                         DBUS_TYPE_INVALID);
 322
 323         /* FIXME: add handling of accuracy parameter */
 324
 325         err = __connman_counter_register(sender, path, period);
 326         if (err < 0)
 327                 return __connman_error_failed(msg, -err);
 328
 329         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 330 }
 331
 332 static DBusMessage *unregister_counter(DBusConnection *conn,
 333                                         DBusMessage *msg, void *data)
 334 {
 335         const char *sender, *path;
 336         int err;
 337
 338         DBG("conn %p", conn);
 339
 340         sender = dbus_message_get_sender(msg);
 341
 342         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 343                                                         DBUS_TYPE_INVALID);
 344
 345         err = __connman_counter_unregister(sender, path);
 346         if (err < 0)
 347                 return __connman_error_failed(msg, -err);
 348
 349         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 350 }
 351
 352 static DBusMessage *create_session(DBusConnection *conn,
 353                                         DBusMessage *msg, void *data)
 354 {
 355         int err;
 356
 357         DBG("conn %p", conn);
 358
 359         err = __connman_session_create(msg);
 360         if (err < 0)
 361                 return __connman_error_failed(msg, -err);
 362
 363         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 364 }
 365
 366 static DBusMessage *destroy_session(DBusConnection *conn,
 367                                         DBusMessage *msg, void *data)
 368 {
 369         int err;
 370
 371         DBG("conn %p", conn);
 372
 373         err = __connman_session_destroy(msg);
 374         if (err < 0)
 375                 return __connman_error_failed(msg, -err);
 376
 377         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 378 }
 379
 380 static DBusMessage *request_private_network(DBusConnection *conn,
 381                                         DBusMessage *msg, void *data)
 382 {
 383         const char *sender;
 384         int  err;
 385
 386         DBG("conn %p", conn);
 387
 388         sender = dbus_message_get_sender(msg);
 389
 390         err = __connman_private_network_request(msg, sender);
 391         if (err < 0)
 392                 return __connman_error_failed(msg, -err);
 393
 394         return NULL;
 395 }
 396
 397 static DBusMessage *release_private_network(DBusConnection *conn,
 398                                         DBusMessage *msg, void *data)
 399 {
 400         const char *path;
 401         int err;
 402
 403         DBG("conn %p", conn);
 404
 405         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 406                                                         DBUS_TYPE_INVALID);
 407
 408         err = __connman_private_network_release(path);
 409         if (err < 0)
 410                 return __connman_error_failed(msg, -err);
 411
 412         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 413 }
 414
 415 static GDBusMethodTable manager_methods[] = {
 416         { "GetProperties",     "",      "a{sv}", get_properties     },
 417         { "SetProperty",       "sv",    "",      set_property,
 418                                                 G_DBUS_METHOD_FLAG_ASYNC },
 419         { "GetTechnologies",   "",      "a(oa{sv})", get_technologies   },
 420         { "RemoveProvider",    "o",     "",      remove_provider    },
 421         { "GetServices",       "",      "a(oa{sv})", get_services   },
 422         { "ConnectProvider",   "a{sv}", "o",     connect_provider,
 423                                                 G_DBUS_METHOD_FLAG_ASYNC },
 424         { "RegisterAgent",     "o",     "",      register_agent     },
 425         { "UnregisterAgent",   "o",     "",      unregister_agent   },
 426         { "RegisterCounter",   "ouu",   "",      register_counter   },
 427         { "UnregisterCounter", "o",     "",      unregister_counter },
 428         { "CreateSession",     "a{sv}o", "o",    create_session     },
 429         { "DestroySession",    "o",     "",      destroy_session    },
 430         { "RequestPrivateNetwork",    "",     "oa{sv}h",
 431                                                 request_private_network,
 432                                                 G_DBUS_METHOD_FLAG_ASYNC },
 433         { "ReleasePrivateNetwork",    "o",    "",
 434                                                 release_private_network },
 435         { },
 436 };
 437
 438 static GDBusSignalTable manager_signals[] = {
 439         { "PropertyChanged", "sv" },
 440         { "TechnologyAdded", "a{sv}" },
 441         { "TechnologyRemoved", "o" },
 442         { },
 443 };
 444
 445 int __connman_manager_init(void)
 446 {
 447         DBG("");
 448
 449         connection = connman_dbus_get_connection();
 450         if (connection == NULL)
 451                 return -1;
 452
 453         if (connman_notifier_register(&technology_notifier) < 0)
 454                 connman_error("Failed to register technology notifier");
 455
 456         g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
 457                                         CONNMAN_MANAGER_INTERFACE,
 458                                         manager_methods,
 459                                         manager_signals, NULL, NULL, NULL);
 460
 461         connman_state_idle = TRUE;
 462
 463         return 0;
 464 }
 465
 466 void __connman_manager_cleanup(void)
 467 {
 468         DBG("");
 469
 470         if (connection == NULL)
 471                 return;
 472
 473         connman_notifier_unregister(&technology_notifier);
 474
 475         g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
 476                                                 CONNMAN_MANAGER_INTERFACE);
 477
 478         dbus_connection_unref(connection);
 479 }