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