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 DBusMessage *request_scan(DBusConnection *conn,
 180                                         DBusMessage *msg, void *data)
 181 {
 182         enum connman_service_type type;
 183         const char *str;
 184         int err;
 185
 186         DBG("conn %p", conn);
 187
 188         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
 189                                                         DBUS_TYPE_INVALID);
 190
 191         if (g_strcmp0(str, "") == 0)
 192                 type = CONNMAN_SERVICE_TYPE_UNKNOWN;
 193         else if (g_strcmp0(str, "wifi") == 0)
 194                 type = CONNMAN_SERVICE_TYPE_WIFI;
 195         else if (g_strcmp0(str, "wimax") == 0)
 196                 type = CONNMAN_SERVICE_TYPE_WIMAX;
 197         else
 198                 return __connman_error_invalid_arguments(msg);
 199
 200         err = __connman_device_request_scan(type);
 201         if (err < 0) {
 202                 if (err == -EINPROGRESS) {
 203                         connman_error("Invalid return code from scan");
 204                         err = -EINVAL;
 205                 }
 206
 207                 return __connman_error_failed(msg, -err);
 208         }
 209
 210         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 211 }
 212
 213 static DBusConnection *connection = NULL;
 214
 215 static void session_mode_notify(void)
 216 {
 217         DBusMessage *reply;
 218
 219         reply = g_dbus_create_reply(session_mode_pending, DBUS_TYPE_INVALID);
 220         g_dbus_send_message(connection, reply);
 221
 222         dbus_message_unref(session_mode_pending);
 223         session_mode_pending = NULL;
 224 }
 225
 226 static void idle_state(connman_bool_t idle)
 227 {
 228
 229         DBG("idle %d", idle);
 230
 231         connman_state_idle = idle;
 232
 233         if (connman_state_idle == FALSE || session_mode_pending == NULL)
 234                 return;
 235
 236         session_mode_notify();
 237 }
 238
 239 static struct connman_notifier technology_notifier = {
 240         .name           = "manager",
 241         .priority       = CONNMAN_NOTIFIER_PRIORITY_HIGH,
 242         .idle_state     = idle_state,
 243 };
 244
 245 static DBusMessage *get_services(DBusConnection *conn,
 246                                         DBusMessage *msg, void *data)
 247 {
 248         DBusMessage *reply;
 249         DBusMessageIter iter, array;
 250
 251         reply = dbus_message_new_method_return(msg);
 252         if (reply == NULL)
 253                 return NULL;
 254
 255         dbus_message_iter_init_append(reply, &iter);
 256
 257         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 258                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 259                         DBUS_TYPE_OBJECT_PATH_AS_STRING
 260                         DBUS_TYPE_ARRAY_AS_STRING
 261                                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 262                                         DBUS_TYPE_STRING_AS_STRING
 263                                         DBUS_TYPE_VARIANT_AS_STRING
 264                                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 265                         DBUS_STRUCT_END_CHAR_AS_STRING, &array);
 266
 267         __connman_service_list_struct(&array);
 268
 269         dbus_message_iter_close_container(&iter, &array);
 270
 271         return reply;
 272 }
 273
 274 static DBusMessage *connect_provider(DBusConnection *conn,
 275                                         DBusMessage *msg, void *data)
 276 {
 277         int err;
 278
 279         DBG("conn %p", conn);
 280
 281         if (__connman_session_mode() == TRUE) {
 282                 connman_info("Session mode enabled: "
 283                                 "direct provider connect disabled");
 284
 285                 return __connman_error_failed(msg, -EINVAL);
 286         }
 287
 288         err = __connman_provider_create_and_connect(msg);
 289         if (err < 0) {
 290                 if (err == -EINPROGRESS) {
 291                         connman_error("Invalid return code from connect");
 292                         err = -EINVAL;
 293                 }
 294
 295                 return __connman_error_failed(msg, -err);
 296         }
 297
 298         return NULL;
 299 }
 300
 301 static DBusMessage *register_agent(DBusConnection *conn,
 302                                         DBusMessage *msg, void *data)
 303 {
 304         const char *sender, *path;
 305         int err;
 306
 307         DBG("conn %p", conn);
 308
 309         sender = dbus_message_get_sender(msg);
 310
 311         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 312                                                         DBUS_TYPE_INVALID);
 313
 314         err = __connman_agent_register(sender, path);
 315         if (err < 0)
 316                 return __connman_error_failed(msg, -err);
 317
 318         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 319 }
 320
 321 static DBusMessage *unregister_agent(DBusConnection *conn,
 322                                         DBusMessage *msg, void *data)
 323 {
 324         const char *sender, *path;
 325         int err;
 326
 327         DBG("conn %p", conn);
 328
 329         sender = dbus_message_get_sender(msg);
 330
 331         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 332                                                         DBUS_TYPE_INVALID);
 333
 334         err = __connman_agent_unregister(sender, path);
 335         if (err < 0)
 336                 return __connman_error_failed(msg, -err);
 337
 338         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 339 }
 340
 341 static DBusMessage *register_counter(DBusConnection *conn,
 342                                         DBusMessage *msg, void *data)
 343 {
 344         const char *sender, *path;
 345         unsigned int accuracy, period;
 346         int err;
 347
 348         DBG("conn %p", conn);
 349
 350         sender = dbus_message_get_sender(msg);
 351
 352         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 353                                                 DBUS_TYPE_UINT32, &accuracy,
 354                                                 DBUS_TYPE_UINT32, &period,
 355                                                         DBUS_TYPE_INVALID);
 356
 357         /* FIXME: add handling of accuracy parameter */
 358
 359         err = __connman_counter_register(sender, path, period);
 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 *unregister_counter(DBusConnection *conn,
 367                                         DBusMessage *msg, void *data)
 368 {
 369         const char *sender, *path;
 370         int err;
 371
 372         DBG("conn %p", conn);
 373
 374         sender = dbus_message_get_sender(msg);
 375
 376         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 377                                                         DBUS_TYPE_INVALID);
 378
 379         err = __connman_counter_unregister(sender, path);
 380         if (err < 0)
 381                 return __connman_error_failed(msg, -err);
 382
 383         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 384 }
 385
 386 static DBusMessage *create_session(DBusConnection *conn,
 387                                         DBusMessage *msg, void *data)
 388 {
 389         int err;
 390
 391         DBG("conn %p", conn);
 392
 393         err = __connman_session_create(msg);
 394         if (err < 0)
 395                 return __connman_error_failed(msg, -err);
 396
 397         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 398 }
 399
 400 static DBusMessage *destroy_session(DBusConnection *conn,
 401                                         DBusMessage *msg, void *data)
 402 {
 403         int err;
 404
 405         DBG("conn %p", conn);
 406
 407         err = __connman_session_destroy(msg);
 408         if (err < 0)
 409                 return __connman_error_failed(msg, -err);
 410
 411         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 412 }
 413
 414 static DBusMessage *request_private_network(DBusConnection *conn,
 415                                         DBusMessage *msg, void *data)
 416 {
 417         const char *sender;
 418         int  err;
 419
 420         DBG("conn %p", conn);
 421
 422         sender = dbus_message_get_sender(msg);
 423
 424         err = __connman_private_network_request(msg, sender);
 425         if (err < 0)
 426                 return __connman_error_failed(msg, -err);
 427
 428         return NULL;
 429 }
 430
 431 static DBusMessage *release_private_network(DBusConnection *conn,
 432                                         DBusMessage *msg, void *data)
 433 {
 434         const char *path;
 435         int err;
 436
 437         DBG("conn %p", conn);
 438
 439         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 440                                                         DBUS_TYPE_INVALID);
 441
 442         err = __connman_private_network_release(path);
 443         if (err < 0)
 444                 return __connman_error_failed(msg, -err);
 445
 446         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 447 }
 448
 449 static GDBusMethodTable manager_methods[] = {
 450         { "GetProperties",     "",      "a{sv}", get_properties     },
 451         { "SetProperty",       "sv",    "",      set_property,
 452                                                 G_DBUS_METHOD_FLAG_ASYNC },
 453         { "GetTechnologies",   "",      "a(oa{sv})", get_technologies   },
 454         { "RemoveProvider",    "o",     "",      remove_provider    },
 455         { "RequestScan",       "s",     "",      request_scan       },
 456         { "GetServices",       "",      "a(oa{sv})", get_services   },
 457         { "ConnectProvider",   "a{sv}", "o",     connect_provider,
 458                                                 G_DBUS_METHOD_FLAG_ASYNC },
 459         { "RegisterAgent",     "o",     "",      register_agent     },
 460         { "UnregisterAgent",   "o",     "",      unregister_agent   },
 461         { "RegisterCounter",   "ouu",   "",      register_counter   },
 462         { "UnregisterCounter", "o",     "",      unregister_counter },
 463         { "CreateSession",     "a{sv}o", "o",    create_session     },
 464         { "DestroySession",    "o",     "",      destroy_session    },
 465         { "RequestPrivateNetwork",    "",     "oa{sv}h",
 466                                                 request_private_network,
 467                                                 G_DBUS_METHOD_FLAG_ASYNC },
 468         { "ReleasePrivateNetwork",    "o",    "",
 469                                                 release_private_network },
 470         { },
 471 };
 472
 473 static GDBusSignalTable manager_signals[] = {
 474         { "PropertyChanged", "sv" },
 475         { "TechnologyAdded", "a{sv}" },
 476         { "TechnologyRemoved", "o" },
 477         { },
 478 };
 479
 480 int __connman_manager_init(void)
 481 {
 482         DBG("");
 483
 484         connection = connman_dbus_get_connection();
 485         if (connection == NULL)
 486                 return -1;
 487
 488         if (connman_notifier_register(&technology_notifier) < 0)
 489                 connman_error("Failed to register technology notifier");
 490
 491         g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
 492                                         CONNMAN_MANAGER_INTERFACE,
 493                                         manager_methods,
 494                                         manager_signals, NULL, NULL, NULL);
 495
 496         connman_state_idle = TRUE;
 497
 498         return 0;
 499 }
 500
 501 void __connman_manager_cleanup(void)
 502 {
 503         DBG("");
 504
 505         if (connection == NULL)
 506                 return;
 507
 508         connman_notifier_unregister(&technology_notifier);
 509
 510         g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
 511                                                 CONNMAN_MANAGER_INTERFACE);
 512
 513         dbus_connection_unref(connection);
 514 }