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         connman_dbus_dict_append_array(&dict, "Technologies",
  56                         DBUS_TYPE_OBJECT_PATH, __connman_technology_list, NULL);
  57
  58         str = __connman_notifier_get_state();
  59         connman_dbus_dict_append_basic(&dict, "State",
  60                                                 DBUS_TYPE_STRING, &str);
  61
  62         offlinemode = __connman_technology_get_offlinemode();
  63         connman_dbus_dict_append_basic(&dict, "OfflineMode",
  64                                         DBUS_TYPE_BOOLEAN, &offlinemode);
  65
  66         connman_dbus_dict_append_array(&dict, "AvailableDebugs",
  67                         DBUS_TYPE_STRING, __connman_debug_list_available, NULL);
  68         connman_dbus_dict_append_array(&dict, "EnabledDebugs",
  69                         DBUS_TYPE_STRING, __connman_debug_list_enabled, NULL);
  70
  71         sessionmode = __connman_session_mode();
  72         connman_dbus_dict_append_basic(&dict, "SessionMode",
  73                                         DBUS_TYPE_BOOLEAN,
  74                                         &sessionmode);
  75
  76         connman_dbus_dict_close(&array, &dict);
  77
  78         return reply;
  79 }
  80
  81 static DBusMessage *set_property(DBusConnection *conn,
  82                                         DBusMessage *msg, void *data)
  83 {
  84         DBusMessageIter iter, value;
  85         const char *name;
  86         int type;
  87
  88         DBG("conn %p", conn);
  89
  90         if (dbus_message_iter_init(msg, &iter) == FALSE)
  91                 return __connman_error_invalid_arguments(msg);
  92
  93         dbus_message_iter_get_basic(&iter, &name);
  94         dbus_message_iter_next(&iter);
  95         dbus_message_iter_recurse(&iter, &value);
  96
  97         type = dbus_message_iter_get_arg_type(&value);
  98
  99         if (g_str_equal(name, "OfflineMode") == TRUE) {
 100                 connman_bool_t offlinemode;
 101
 102                 if (type != DBUS_TYPE_BOOLEAN)
 103                         return __connman_error_invalid_arguments(msg);
 104
 105                 dbus_message_iter_get_basic(&value, &offlinemode);
 106
 107                 __connman_technology_set_offlinemode(offlinemode);
 108         } else if (g_str_equal(name, "SessionMode") == TRUE) {
 109                 connman_bool_t sessionmode;
 110
 111                 if (type != DBUS_TYPE_BOOLEAN)
 112                         return __connman_error_invalid_arguments(msg);
 113
 114                 dbus_message_iter_get_basic(&value, &sessionmode);
 115
 116                 if (session_mode_pending != NULL)
 117                         return __connman_error_in_progress(msg);
 118
 119                 __connman_session_set_mode(sessionmode);
 120
 121                 if (sessionmode == TRUE && connman_state_idle == FALSE) {
 122                         session_mode_pending = msg;
 123                         return NULL;
 124                 }
 125
 126         } else
 127                 return __connman_error_invalid_property(msg);
 128
 129         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 130 }
 131
 132 static DBusMessage *remove_provider(DBusConnection *conn,
 133                                     DBusMessage *msg, void *data)
 134 {
 135         const char *path;
 136         int err;
 137
 138         DBG("conn %p", conn);
 139
 140         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 141                                                         DBUS_TYPE_INVALID);
 142
 143         err = __connman_provider_remove(path);
 144         if (err < 0)
 145                 return __connman_error_failed(msg, -err);
 146
 147         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 148 }
 149
 150 static DBusMessage *request_scan(DBusConnection *conn,
 151                                         DBusMessage *msg, void *data)
 152 {
 153         enum connman_service_type type;
 154         const char *str;
 155         int err;
 156
 157         DBG("conn %p", conn);
 158
 159         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
 160                                                         DBUS_TYPE_INVALID);
 161
 162         if (g_strcmp0(str, "") == 0)
 163                 type = CONNMAN_SERVICE_TYPE_UNKNOWN;
 164         else if (g_strcmp0(str, "wifi") == 0)
 165                 type = CONNMAN_SERVICE_TYPE_WIFI;
 166         else if (g_strcmp0(str, "wimax") == 0)
 167                 type = CONNMAN_SERVICE_TYPE_WIMAX;
 168         else
 169                 return __connman_error_invalid_arguments(msg);
 170
 171         err = __connman_device_request_scan(type);
 172         if (err < 0) {
 173                 if (err == -EINPROGRESS) {
 174                         connman_error("Invalid return code from scan");
 175                         err = -EINVAL;
 176                 }
 177
 178                 return __connman_error_failed(msg, -err);
 179         }
 180
 181         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 182 }
 183
 184 static DBusConnection *connection = NULL;
 185
 186 static void session_mode_notify(void)
 187 {
 188         DBusMessage *reply;
 189
 190         reply = g_dbus_create_reply(session_mode_pending, DBUS_TYPE_INVALID);
 191         g_dbus_send_message(connection, reply);
 192
 193         dbus_message_unref(session_mode_pending);
 194         session_mode_pending = NULL;
 195 }
 196
 197 static void idle_state(connman_bool_t idle)
 198 {
 199
 200         DBG("idle %d", idle);
 201
 202         connman_state_idle = idle;
 203
 204         if (connman_state_idle == FALSE || session_mode_pending == NULL)
 205                 return;
 206
 207         session_mode_notify();
 208 }
 209
 210 static struct connman_notifier technology_notifier = {
 211         .name           = "manager",
 212         .priority       = CONNMAN_NOTIFIER_PRIORITY_HIGH,
 213         .idle_state     = idle_state,
 214 };
 215
 216 static DBusMessage *enable_technology(DBusConnection *conn,
 217                                         DBusMessage *msg, void *data)
 218 {
 219         enum connman_service_type type;
 220         const char *str;
 221
 222         DBG("conn %p", conn);
 223
 224         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
 225                                                         DBUS_TYPE_INVALID);
 226
 227         if (g_strcmp0(str, "ethernet") == 0)
 228                 type = CONNMAN_SERVICE_TYPE_ETHERNET;
 229         else if (g_strcmp0(str, "wifi") == 0)
 230                 type = CONNMAN_SERVICE_TYPE_WIFI;
 231         else if (g_strcmp0(str, "wimax") == 0)
 232                 type = CONNMAN_SERVICE_TYPE_WIMAX;
 233         else if (g_strcmp0(str, "bluetooth") == 0)
 234                 type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
 235         else if (g_strcmp0(str, "cellular") == 0)
 236                 type = CONNMAN_SERVICE_TYPE_CELLULAR;
 237         else
 238                 return __connman_error_invalid_arguments(msg);
 239
 240         if (__connman_notifier_is_registered(type) == FALSE)
 241                 return __connman_error_not_registered(msg);
 242
 243         if (__connman_notifier_is_enabled(type) == TRUE)
 244                 return __connman_error_already_enabled(msg);
 245
 246          __connman_technology_enable(type, msg);
 247
 248         return NULL;
 249 }
 250
 251 static DBusMessage *disable_technology(DBusConnection *conn,
 252                                         DBusMessage *msg, void *data)
 253 {
 254         enum connman_service_type type;
 255         const char *str;
 256
 257         DBG("conn %p", conn);
 258
 259         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
 260                                                         DBUS_TYPE_INVALID);
 261
 262         if (g_strcmp0(str, "ethernet") == 0)
 263                 type = CONNMAN_SERVICE_TYPE_ETHERNET;
 264         else if (g_strcmp0(str, "wifi") == 0)
 265                 type = CONNMAN_SERVICE_TYPE_WIFI;
 266         else if (g_strcmp0(str, "wimax") == 0)
 267                 type = CONNMAN_SERVICE_TYPE_WIMAX;
 268         else if (g_strcmp0(str, "bluetooth") == 0)
 269                 type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
 270         else if (g_strcmp0(str, "cellular") == 0)
 271                 type = CONNMAN_SERVICE_TYPE_CELLULAR;
 272         else
 273                 return __connman_error_invalid_arguments(msg);
 274
 275         if (__connman_notifier_is_registered(type) == FALSE)
 276                 return __connman_error_not_registered(msg);
 277
 278         if (__connman_notifier_is_enabled(type) == FALSE)
 279                 return __connman_error_already_disabled(msg);
 280
 281         __connman_technology_disable(type, msg);
 282
 283         return NULL;
 284 }
 285
 286 static DBusMessage *get_services(DBusConnection *conn,
 287                                         DBusMessage *msg, void *data)
 288 {
 289         DBusMessage *reply;
 290         DBusMessageIter iter, array;
 291
 292         reply = dbus_message_new_method_return(msg);
 293         if (reply == NULL)
 294                 return NULL;
 295
 296         dbus_message_iter_init_append(reply, &iter);
 297
 298         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 299                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 300                         DBUS_TYPE_OBJECT_PATH_AS_STRING
 301                         DBUS_TYPE_ARRAY_AS_STRING
 302                                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 303                                         DBUS_TYPE_STRING_AS_STRING
 304                                         DBUS_TYPE_VARIANT_AS_STRING
 305                                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 306                         DBUS_STRUCT_END_CHAR_AS_STRING, &array);
 307
 308         __connman_service_list_struct(&array);
 309
 310         dbus_message_iter_close_container(&iter, &array);
 311
 312         return reply;
 313 }
 314
 315 static DBusMessage *connect_provider(DBusConnection *conn,
 316                                         DBusMessage *msg, void *data)
 317 {
 318         int err;
 319
 320         DBG("conn %p", conn);
 321
 322         if (__connman_session_mode() == TRUE) {
 323                 connman_info("Session mode enabled: "
 324                                 "direct provider connect disabled");
 325
 326                 return __connman_error_failed(msg, -EINVAL);
 327         }
 328
 329         err = __connman_provider_create_and_connect(msg);
 330         if (err < 0) {
 331                 if (err == -EINPROGRESS) {
 332                         connman_error("Invalid return code from connect");
 333                         err = -EINVAL;
 334                 }
 335
 336                 return __connman_error_failed(msg, -err);
 337         }
 338
 339         return NULL;
 340 }
 341
 342 static DBusMessage *register_agent(DBusConnection *conn,
 343                                         DBusMessage *msg, void *data)
 344 {
 345         const char *sender, *path;
 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_INVALID);
 354
 355         err = __connman_agent_register(sender, path);
 356         if (err < 0)
 357                 return __connman_error_failed(msg, -err);
 358
 359         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 360 }
 361
 362 static DBusMessage *unregister_agent(DBusConnection *conn,
 363                                         DBusMessage *msg, void *data)
 364 {
 365         const char *sender, *path;
 366         int err;
 367
 368         DBG("conn %p", conn);
 369
 370         sender = dbus_message_get_sender(msg);
 371
 372         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 373                                                         DBUS_TYPE_INVALID);
 374
 375         err = __connman_agent_unregister(sender, path);
 376         if (err < 0)
 377                 return __connman_error_failed(msg, -err);
 378
 379         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 380 }
 381
 382 static DBusMessage *register_counter(DBusConnection *conn,
 383                                         DBusMessage *msg, void *data)
 384 {
 385         const char *sender, *path;
 386         unsigned int accuracy, period;
 387         int err;
 388
 389         DBG("conn %p", conn);
 390
 391         sender = dbus_message_get_sender(msg);
 392
 393         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 394                                                 DBUS_TYPE_UINT32, &accuracy,
 395                                                 DBUS_TYPE_UINT32, &period,
 396                                                         DBUS_TYPE_INVALID);
 397
 398         /* FIXME: add handling of accuracy parameter */
 399
 400         err = __connman_counter_register(sender, path, period);
 401         if (err < 0)
 402                 return __connman_error_failed(msg, -err);
 403
 404         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 405 }
 406
 407 static DBusMessage *unregister_counter(DBusConnection *conn,
 408                                         DBusMessage *msg, void *data)
 409 {
 410         const char *sender, *path;
 411         int err;
 412
 413         DBG("conn %p", conn);
 414
 415         sender = dbus_message_get_sender(msg);
 416
 417         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 418                                                         DBUS_TYPE_INVALID);
 419
 420         err = __connman_counter_unregister(sender, path);
 421         if (err < 0)
 422                 return __connman_error_failed(msg, -err);
 423
 424         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 425 }
 426
 427 static DBusMessage *create_session(DBusConnection *conn,
 428                                         DBusMessage *msg, void *data)
 429 {
 430         int err;
 431
 432         DBG("conn %p", conn);
 433
 434         err = __connman_session_create(msg);
 435         if (err < 0)
 436                 return __connman_error_failed(msg, -err);
 437
 438         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 439 }
 440
 441 static DBusMessage *destroy_session(DBusConnection *conn,
 442                                         DBusMessage *msg, void *data)
 443 {
 444         int err;
 445
 446         DBG("conn %p", conn);
 447
 448         err = __connman_session_destroy(msg);
 449         if (err < 0)
 450                 return __connman_error_failed(msg, -err);
 451
 452         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 453 }
 454
 455 static DBusMessage *request_private_network(DBusConnection *conn,
 456                                         DBusMessage *msg, void *data)
 457 {
 458         const char *sender;
 459         int  err;
 460
 461         DBG("conn %p", conn);
 462
 463         sender = dbus_message_get_sender(msg);
 464
 465         err = __connman_private_network_request(msg, sender);
 466         if (err < 0)
 467                 return __connman_error_failed(msg, -err);
 468
 469         return NULL;
 470 }
 471
 472 static DBusMessage *release_private_network(DBusConnection *conn,
 473                                         DBusMessage *msg, void *data)
 474 {
 475         const char *path;
 476         int err;
 477
 478         DBG("conn %p", conn);
 479
 480         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 481                                                         DBUS_TYPE_INVALID);
 482
 483         err = __connman_private_network_release(path);
 484         if (err < 0)
 485                 return __connman_error_failed(msg, -err);
 486
 487         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 488 }
 489
 490 static GDBusMethodTable manager_methods[] = {
 491         { "GetProperties",     "",      "a{sv}", get_properties     },
 492         { "SetProperty",       "sv",    "",      set_property,
 493                                                 G_DBUS_METHOD_FLAG_ASYNC },
 494         { "RemoveProvider",    "o",     "",      remove_provider    },
 495         { "RequestScan",       "s",     "",      request_scan       },
 496         { "EnableTechnology",  "s",     "",      enable_technology,
 497                                                 G_DBUS_METHOD_FLAG_ASYNC },
 498         { "DisableTechnology", "s",     "",      disable_technology,
 499                                                 G_DBUS_METHOD_FLAG_ASYNC },
 500         { "GetServices",       "",      "a(oa{sv})", get_services   },
 501         { "ConnectProvider",   "a{sv}", "o",     connect_provider,
 502                                                 G_DBUS_METHOD_FLAG_ASYNC },
 503         { "RegisterAgent",     "o",     "",      register_agent     },
 504         { "UnregisterAgent",   "o",     "",      unregister_agent   },
 505         { "RegisterCounter",   "ouu",   "",      register_counter   },
 506         { "UnregisterCounter", "o",     "",      unregister_counter },
 507         { "CreateSession",     "a{sv}o", "o",    create_session     },
 508         { "DestroySession",    "o",     "",      destroy_session    },
 509         { "RequestPrivateNetwork",    "",     "oa{sv}h",
 510                                                 request_private_network,
 511                                                 G_DBUS_METHOD_FLAG_ASYNC },
 512         { "ReleasePrivateNetwork",    "o",    "",
 513                                                 release_private_network },
 514         { },
 515 };
 516
 517 static GDBusSignalTable manager_signals[] = {
 518         { "PropertyChanged", "sv" },
 519         { "TechnologyAdded", "a{sv}" },
 520         { "TechnologyRemoved", "o" },
 521         { },
 522 };
 523
 524 int __connman_manager_init(void)
 525 {
 526         DBG("");
 527
 528         connection = connman_dbus_get_connection();
 529         if (connection == NULL)
 530                 return -1;
 531
 532         if (connman_notifier_register(&technology_notifier) < 0)
 533                 connman_error("Failed to register technology notifier");
 534
 535         g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
 536                                         CONNMAN_MANAGER_INTERFACE,
 537                                         manager_methods,
 538                                         manager_signals, NULL, NULL, NULL);
 539
 540         connman_state_idle = TRUE;
 541
 542         return 0;
 543 }
 544
 545 void __connman_manager_cleanup(void)
 546 {
 547         DBG("");
 548
 549         if (connection == NULL)
 550                 return;
 551
 552         connman_notifier_unregister(&technology_notifier);
 553
 554         g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
 555                                                 CONNMAN_MANAGER_INTERFACE);
 556
 557         dbus_connection_unref(connection);
 558 }