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