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 <gdbus.h>
  27
  28 #include "connman.h"
  29
  30 static DBusMessage *get_properties(DBusConnection *conn,
  31                                         DBusMessage *msg, void *data)
  32 {
  33         DBusMessage *reply;
  34         DBusMessageIter array, dict;
  35         connman_bool_t offlinemode, tethering;
  36         const char *str;
  37
  38         DBG("conn %p", conn);
  39
  40         if (__connman_security_check_privilege(msg,
  41                                         CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
  42                 return __connman_error_permission_denied(msg);
  43
  44         reply = dbus_message_new_method_return(msg);
  45         if (reply == NULL)
  46                 return NULL;
  47
  48         dbus_message_iter_init_append(reply, &array);
  49
  50         connman_dbus_dict_open(&array, &dict);
  51
  52         str = __connman_profile_active_path();
  53         if (str != NULL)
  54                 connman_dbus_dict_append_basic(&dict, "ActiveProfile",
  55                                                 DBUS_TYPE_OBJECT_PATH, &str);
  56
  57         connman_dbus_dict_append_array(&dict, "Profiles",
  58                         DBUS_TYPE_OBJECT_PATH, __connman_profile_list, NULL);
  59         connman_dbus_dict_append_array(&dict, "Services",
  60                         DBUS_TYPE_OBJECT_PATH, __connman_service_list, NULL);
  61         connman_dbus_dict_append_array(&dict, "Technologies",
  62                         DBUS_TYPE_OBJECT_PATH, __connman_technology_list, NULL);
  63
  64         str = __connman_notifier_get_state();
  65         connman_dbus_dict_append_basic(&dict, "State",
  66                                                 DBUS_TYPE_STRING, &str);
  67
  68         offlinemode = __connman_profile_get_offlinemode();
  69         connman_dbus_dict_append_basic(&dict, "OfflineMode",
  70                                         DBUS_TYPE_BOOLEAN, &offlinemode);
  71
  72         tethering = __connman_tethering_get_status();
  73         connman_dbus_dict_append_basic(&dict, "Tethering",
  74                                         DBUS_TYPE_BOOLEAN, &tethering);
  75
  76         connman_dbus_dict_append_array(&dict, "AvailableTechnologies",
  77                 DBUS_TYPE_STRING, __connman_notifier_list_registered, NULL);
  78         connman_dbus_dict_append_array(&dict, "EnabledTechnologies",
  79                 DBUS_TYPE_STRING, __connman_notifier_list_enabled, NULL);
  80         connman_dbus_dict_append_array(&dict, "ConnectedTechnologies",
  81                 DBUS_TYPE_STRING, __connman_notifier_list_connected, NULL);
  82
  83         str = __connman_service_default();
  84         if (str != NULL)
  85                 connman_dbus_dict_append_basic(&dict, "DefaultTechnology",
  86                                                 DBUS_TYPE_STRING, &str);
  87
  88         connman_dbus_dict_append_array(&dict, "AvailableDebugs",
  89                         DBUS_TYPE_STRING, __connman_debug_list_available, NULL);
  90         connman_dbus_dict_append_array(&dict, "EnabledDebugs",
  91                         DBUS_TYPE_STRING, __connman_debug_list_enabled, NULL);
  92
  93         connman_dbus_dict_close(&array, &dict);
  94
  95         return reply;
  96 }
  97
  98 static DBusMessage *set_property(DBusConnection *conn,
  99                                         DBusMessage *msg, void *data)
 100 {
 101         DBusMessageIter iter, value;
 102         const char *name;
 103         int type;
 104
 105         DBG("conn %p", conn);
 106
 107         if (dbus_message_iter_init(msg, &iter) == FALSE)
 108                 return __connman_error_invalid_arguments(msg);
 109
 110         dbus_message_iter_get_basic(&iter, &name);
 111         dbus_message_iter_next(&iter);
 112         dbus_message_iter_recurse(&iter, &value);
 113
 114         if (__connman_security_check_privilege(msg,
 115                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 116                 return __connman_error_permission_denied(msg);
 117
 118         type = dbus_message_iter_get_arg_type(&value);
 119
 120         if (g_str_equal(name, "OfflineMode") == TRUE) {
 121                 connman_bool_t offlinemode;
 122
 123                 if (type != DBUS_TYPE_BOOLEAN)
 124                         return __connman_error_invalid_arguments(msg);
 125
 126                 dbus_message_iter_get_basic(&value, &offlinemode);
 127
 128                 __connman_profile_set_offlinemode(offlinemode, TRUE);
 129
 130                 __connman_profile_save_default();
 131         } else if (g_str_equal(name, "Tethering") == TRUE) {
 132                 connman_bool_t tethering;
 133
 134                 if (type != DBUS_TYPE_BOOLEAN)
 135                         return __connman_error_invalid_arguments(msg);
 136
 137                 dbus_message_iter_get_basic(&value, &tethering);
 138
 139                 if (__connman_tethering_set_status(tethering) < 0)
 140                         return __connman_error_invalid_arguments(msg);
 141
 142                 connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
 143                                         CONNMAN_MANAGER_INTERFACE, "Tethering",
 144                                                 DBUS_TYPE_BOOLEAN, &tethering);
 145         } else if (g_str_equal(name, "ActiveProfile") == TRUE) {
 146                 const char *str;
 147
 148                 dbus_message_iter_get_basic(&value, &str);
 149
 150                 return __connman_error_not_supported(msg);
 151         } else
 152                 return __connman_error_invalid_property(msg);
 153
 154         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 155 }
 156
 157 static DBusMessage *get_state(DBusConnection *conn,
 158                                         DBusMessage *msg, void *data)
 159 {
 160         const char *str;
 161
 162         DBG("conn %p", conn);
 163
 164         if (__connman_security_check_privilege(msg,
 165                                         CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
 166                 return __connman_error_permission_denied(msg);
 167
 168         str = __connman_notifier_get_state();
 169
 170         return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &str,
 171                                                 DBUS_TYPE_INVALID);
 172 }
 173
 174 static DBusMessage *create_profile(DBusConnection *conn,
 175                                         DBusMessage *msg, void *data)
 176 {
 177         const char *name, *path;
 178         int err;
 179
 180         DBG("conn %p", conn);
 181
 182         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
 183                                                         DBUS_TYPE_INVALID);
 184
 185         if (__connman_security_check_privilege(msg,
 186                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 187                 return __connman_error_permission_denied(msg);
 188
 189         err = __connman_profile_create(name, &path);
 190         if (err < 0)
 191                 return __connman_error_failed(msg, -err);
 192
 193         return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &path,
 194                                                         DBUS_TYPE_INVALID);
 195 }
 196
 197 static DBusMessage *remove_profile(DBusConnection *conn,
 198                                         DBusMessage *msg, void *data)
 199 {
 200         const char *path;
 201         int err;
 202
 203         DBG("conn %p", conn);
 204
 205         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 206                                                         DBUS_TYPE_INVALID);
 207
 208         if (__connman_security_check_privilege(msg,
 209                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 210                 return __connman_error_permission_denied(msg);
 211
 212         err = __connman_profile_remove(path);
 213         if (err < 0)
 214                 return __connman_error_failed(msg, -err);
 215
 216         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 217 }
 218
 219 static DBusMessage *remove_provider(DBusConnection *conn,
 220                                     DBusMessage *msg, void *data)
 221 {
 222         const char *path;
 223         int err;
 224
 225         DBG("conn %p", conn);
 226
 227         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &path,
 228                               DBUS_TYPE_INVALID);
 229
 230         if (__connman_security_check_privilege(msg,
 231                                 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 232                 return __connman_error_permission_denied(msg);
 233
 234         err = __connman_provider_remove(path);
 235         if (err < 0)
 236                 return __connman_error_failed(msg, -err);
 237
 238         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 239 }
 240
 241 static DBusMessage *request_scan(DBusConnection *conn,
 242                                         DBusMessage *msg, void *data)
 243 {
 244         enum connman_service_type type;
 245         const char *str;
 246         int err;
 247
 248         DBG("conn %p", conn);
 249
 250         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
 251                                                         DBUS_TYPE_INVALID);
 252
 253         if (g_strcmp0(str, "") == 0)
 254                 type = CONNMAN_SERVICE_TYPE_UNKNOWN;
 255         else if (g_strcmp0(str, "wifi") == 0)
 256                 type = CONNMAN_SERVICE_TYPE_WIFI;
 257         else if (g_strcmp0(str, "wimax") == 0)
 258                 type = CONNMAN_SERVICE_TYPE_WIMAX;
 259         else
 260                 return __connman_error_invalid_arguments(msg);
 261
 262         err = __connman_element_request_scan(type);
 263         if (err < 0) {
 264                 if (err == -EINPROGRESS) {
 265                         connman_error("Invalid return code from scan");
 266                         err = -EINVAL;
 267                 }
 268
 269                 return __connman_error_failed(msg, -err);
 270         }
 271
 272         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 273 }
 274
 275 static DBusConnection *connection = NULL;
 276
 277 static enum connman_service_type technology_type;
 278 static connman_bool_t technology_enabled;
 279 static DBusMessage *technology_pending = NULL;
 280 static guint technology_timeout = 0;
 281
 282 static void technology_reply(int error)
 283 {
 284         DBG("");
 285
 286         if (technology_timeout > 0) {
 287                 g_source_remove(technology_timeout);
 288                 technology_timeout = 0;
 289         }
 290
 291         if (technology_pending != NULL) {
 292                 if (error > 0) {
 293                         DBusMessage *reply;
 294
 295                         reply = __connman_error_failed(technology_pending,
 296                                                                 error);
 297                         if (reply != NULL)
 298                                 g_dbus_send_message(connection, reply);
 299                 } else
 300                         g_dbus_send_reply(connection, technology_pending,
 301                                                         DBUS_TYPE_INVALID);
 302
 303                 dbus_message_unref(technology_pending);
 304                 technology_pending = NULL;
 305         }
 306
 307         technology_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
 308 }
 309
 310 static gboolean technology_abort(gpointer user_data)
 311 {
 312         DBG("");
 313
 314         technology_timeout = 0;
 315
 316         technology_reply(ETIMEDOUT);
 317
 318         return FALSE;
 319 }
 320
 321 static void technology_notify(enum connman_service_type type,
 322                                                 connman_bool_t enabled)
 323 {
 324         DBG("type %d enabled %d", type, enabled);
 325
 326         if (type == technology_type && enabled == technology_enabled)
 327                 technology_reply(0);
 328 }
 329
 330 static struct connman_notifier technology_notifier = {
 331         .name           = "manager",
 332         .priority       = CONNMAN_NOTIFIER_PRIORITY_HIGH,
 333         .service_enabled= technology_notify,
 334 };
 335
 336 static DBusMessage *enable_technology(DBusConnection *conn,
 337                                         DBusMessage *msg, void *data)
 338 {
 339         enum connman_service_type type;
 340         const char *str;
 341         int err;
 342
 343         DBG("conn %p", conn);
 344
 345         if (technology_pending != NULL)
 346                 return __connman_error_in_progress(msg);
 347
 348         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
 349                                                         DBUS_TYPE_INVALID);
 350
 351         if (g_strcmp0(str, "ethernet") == 0)
 352                 type = CONNMAN_SERVICE_TYPE_ETHERNET;
 353         else if (g_strcmp0(str, "wifi") == 0)
 354                 type = CONNMAN_SERVICE_TYPE_WIFI;
 355         else if (g_strcmp0(str, "wimax") == 0)
 356                 type = CONNMAN_SERVICE_TYPE_WIMAX;
 357         else if (g_strcmp0(str, "bluetooth") == 0)
 358                 type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
 359         else if (g_strcmp0(str, "cellular") == 0)
 360                 type = CONNMAN_SERVICE_TYPE_CELLULAR;
 361         else
 362                 return __connman_error_invalid_arguments(msg);
 363
 364         if (__connman_notifier_is_registered(type) == FALSE)
 365                 return __connman_error_not_registered(msg);
 366
 367         if (__connman_notifier_is_enabled(type) == TRUE)
 368                 return __connman_error_already_enabled(msg);
 369
 370         technology_type = type;
 371         technology_enabled = TRUE;
 372         technology_pending = dbus_message_ref(msg);
 373
 374         err = __connman_element_enable_technology(type);
 375         if (err < 0 && err != -EINPROGRESS)
 376                 technology_reply(-err);
 377         else
 378                 technology_timeout = g_timeout_add_seconds(15,
 379                                                 technology_abort, NULL);
 380
 381         return NULL;
 382 }
 383
 384 static DBusMessage *disable_technology(DBusConnection *conn,
 385                                         DBusMessage *msg, void *data)
 386 {
 387         enum connman_service_type type;
 388         const char *str;
 389         int err;
 390
 391         DBG("conn %p", conn);
 392
 393         if (technology_pending != NULL)
 394                 return __connman_error_in_progress(msg);
 395
 396         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
 397                                                         DBUS_TYPE_INVALID);
 398
 399         if (g_strcmp0(str, "ethernet") == 0)
 400                 type = CONNMAN_SERVICE_TYPE_ETHERNET;
 401         else if (g_strcmp0(str, "wifi") == 0)
 402                 type = CONNMAN_SERVICE_TYPE_WIFI;
 403         else if (g_strcmp0(str, "wimax") == 0)
 404                 type = CONNMAN_SERVICE_TYPE_WIMAX;
 405         else if (g_strcmp0(str, "bluetooth") == 0)
 406                 type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
 407         else if (g_strcmp0(str, "cellular") == 0)
 408                 type = CONNMAN_SERVICE_TYPE_CELLULAR;
 409         else
 410                 return __connman_error_invalid_arguments(msg);
 411
 412         if (__connman_notifier_is_registered(type) == FALSE)
 413                 return __connman_error_not_registered(msg);
 414
 415         if (__connman_notifier_is_enabled(type) == FALSE)
 416                 return __connman_error_already_disabled(msg);
 417
 418         technology_type = type;
 419         technology_enabled = FALSE;
 420         technology_pending = dbus_message_ref(msg);
 421
 422         err = __connman_element_disable_technology(type);
 423         if (err < 0 && err != -EINPROGRESS)
 424                 technology_reply(-err);
 425         else
 426                 technology_timeout = g_timeout_add_seconds(10,
 427                                                 technology_abort, NULL);
 428
 429         return NULL;
 430 }
 431
 432 static DBusMessage *get_services(DBusConnection *conn,
 433                                         DBusMessage *msg, void *data)
 434 {
 435         DBusMessage *reply;
 436         DBusMessageIter iter, array;
 437
 438         reply = dbus_message_new_method_return(msg);
 439         if (reply == NULL)
 440                 return NULL;
 441
 442         dbus_message_iter_init_append(reply, &iter);
 443
 444         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 445                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 446                         DBUS_TYPE_OBJECT_PATH_AS_STRING
 447                         DBUS_TYPE_ARRAY_AS_STRING
 448                                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 449                                         DBUS_TYPE_STRING_AS_STRING
 450                                         DBUS_TYPE_VARIANT_AS_STRING
 451                                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 452                         DBUS_STRUCT_END_CHAR_AS_STRING, &array);
 453
 454         __connman_service_list_struct(&array);
 455
 456         dbus_message_iter_close_container(&iter, &array);
 457
 458         return reply;
 459 }
 460
 461 static DBusMessage *lookup_service(DBusConnection *conn,
 462                                         DBusMessage *msg, void *data)
 463 {
 464         const char *pattern, *path;
 465         int err;
 466
 467         DBG("conn %p", conn);
 468
 469         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern,
 470                                                         DBUS_TYPE_INVALID);
 471
 472         err = __connman_service_lookup(pattern, &path);
 473         if (err < 0)
 474                 return __connman_error_failed(msg, -err);
 475
 476         return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &path,
 477                                                         DBUS_TYPE_INVALID);
 478 }
 479
 480 static DBusMessage *connect_service(DBusConnection *conn,
 481                                         DBusMessage *msg, void *data)
 482 {
 483         int err;
 484
 485         DBG("conn %p", conn);
 486
 487         if (__connman_security_check_privilege(msg,
 488                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 489                 return __connman_error_permission_denied(msg);
 490
 491         err = __connman_service_create_and_connect(msg);
 492         if (err < 0) {
 493                 if (err == -EINPROGRESS) {
 494                         connman_error("Invalid return code from connect");
 495                         err = -EINVAL;
 496                 }
 497
 498                 return __connman_error_failed(msg, -err);
 499         }
 500
 501         return NULL;
 502 }
 503
 504
 505 static DBusMessage *connect_provider(DBusConnection *conn,
 506                                         DBusMessage *msg, void *data)
 507 {
 508         int err;
 509
 510         DBG("conn %p", conn);
 511
 512         if (__connman_security_check_privilege(msg,
 513                                 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 514                 return __connman_error_permission_denied(msg);
 515
 516         err = __connman_provider_create_and_connect(msg);
 517         if (err < 0) {
 518                 if (err == -EINPROGRESS) {
 519                         connman_error("Invalid return code from connect");
 520                         err = -EINVAL;
 521                 }
 522
 523                 return __connman_error_failed(msg, -err);
 524         }
 525
 526         return NULL;
 527 }
 528
 529 static DBusMessage *register_agent(DBusConnection *conn,
 530                                         DBusMessage *msg, void *data)
 531 {
 532         const char *sender, *path;
 533         int err;
 534
 535         DBG("conn %p", conn);
 536
 537         sender = dbus_message_get_sender(msg);
 538
 539         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 540                                                         DBUS_TYPE_INVALID);
 541
 542         err = __connman_agent_register(sender, path);
 543         if (err < 0)
 544                 return __connman_error_failed(msg, -err);
 545
 546         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 547 }
 548
 549 static DBusMessage *unregister_agent(DBusConnection *conn,
 550                                         DBusMessage *msg, void *data)
 551 {
 552         const char *sender, *path;
 553         int err;
 554
 555         DBG("conn %p", conn);
 556
 557         sender = dbus_message_get_sender(msg);
 558
 559         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 560                                                         DBUS_TYPE_INVALID);
 561
 562         err = __connman_agent_unregister(sender, path);
 563         if (err < 0)
 564                 return __connman_error_failed(msg, -err);
 565
 566         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 567 }
 568
 569 static DBusMessage *register_counter(DBusConnection *conn,
 570                                         DBusMessage *msg, void *data)
 571 {
 572         const char *sender, *path;
 573         unsigned int accuracy, period;
 574         int err;
 575
 576         DBG("conn %p", conn);
 577
 578         sender = dbus_message_get_sender(msg);
 579
 580         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 581                                                 DBUS_TYPE_UINT32, &accuracy,
 582                                                 DBUS_TYPE_UINT32, &period,
 583                                                         DBUS_TYPE_INVALID);
 584
 585         /* FIXME: add handling of accuracy parameter */
 586
 587         err = __connman_counter_register(sender, path, period);
 588         if (err < 0)
 589                 return __connman_error_failed(msg, -err);
 590
 591         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 592 }
 593
 594 static DBusMessage *unregister_counter(DBusConnection *conn,
 595                                         DBusMessage *msg, void *data)
 596 {
 597         const char *sender, *path;
 598         int err;
 599
 600         DBG("conn %p", conn);
 601
 602         sender = dbus_message_get_sender(msg);
 603
 604         dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
 605                                                         DBUS_TYPE_INVALID);
 606
 607         err = __connman_counter_unregister(sender, path);
 608         if (err < 0)
 609                 return __connman_error_failed(msg, -err);
 610
 611         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 612 }
 613
 614 static DBusMessage *request_session(DBusConnection *conn,
 615                                         DBusMessage *msg, void *data)
 616 {
 617         const char *bearer, *sender, *service_path;
 618         struct connman_service *service;
 619
 620         DBG("conn %p", conn);
 621
 622         sender = dbus_message_get_sender(msg);
 623
 624         dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &bearer,
 625                                                         DBUS_TYPE_INVALID);
 626
 627         service = __connman_session_request(bearer, sender);
 628         if (service == NULL)
 629                 return __connman_error_failed(msg, EINVAL);
 630
 631         service_path = __connman_service_get_path(service);
 632
 633         return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &service_path,
 634                                                 DBUS_TYPE_INVALID);
 635 }
 636
 637 static DBusMessage *release_session(DBusConnection *conn,
 638                                         DBusMessage *msg, void *data)
 639 {
 640         const char *sender;
 641         int err;
 642
 643         DBG("conn %p", conn);
 644
 645         sender = dbus_message_get_sender(msg);
 646
 647         err = __connman_session_release(sender);
 648         if (err < 0)
 649                 return __connman_error_failed(msg, -err);
 650
 651         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 652 }
 653
 654 static GDBusMethodTable manager_methods[] = {
 655         { "GetProperties",     "",      "a{sv}", get_properties     },
 656         { "SetProperty",       "sv",    "",      set_property       },
 657         { "GetState",          "",      "s",     get_state          },
 658         { "CreateProfile",     "s",     "o",     create_profile     },
 659         { "RemoveProfile",     "o",     "",      remove_profile     },
 660         { "RemoveProvider",    "s",     "",      remove_provider    },
 661         { "RequestScan",       "s",     "",      request_scan       },
 662         { "EnableTechnology",  "s",     "",      enable_technology,
 663                                                 G_DBUS_METHOD_FLAG_ASYNC },
 664         { "DisableTechnology", "s",     "",      disable_technology,
 665                                                 G_DBUS_METHOD_FLAG_ASYNC },
 666         { "GetServices",       "",      "a(oa{sv})", get_services   },
 667         { "LookupService",     "s",     "o",     lookup_service,    },
 668         { "ConnectService",    "a{sv}", "o",     connect_service,
 669                                                 G_DBUS_METHOD_FLAG_ASYNC },
 670         { "ConnectProvider",   "a{sv}", "o",     connect_provider,
 671                                                 G_DBUS_METHOD_FLAG_ASYNC },
 672         { "RegisterAgent",     "o",     "",      register_agent     },
 673         { "UnregisterAgent",   "o",     "",      unregister_agent   },
 674         { "RegisterCounter",   "ouu",   "",      register_counter   },
 675         { "UnregisterCounter", "o",     "",      unregister_counter },
 676         { "RequestSession",    "s",     "o",     request_session    },
 677         { "ReleaseSession",    "s",     "",      release_session    },
 678         { },
 679 };
 680
 681 static GDBusSignalTable manager_signals[] = {
 682         { "PropertyChanged", "sv" },
 683         { "StateChanged",    "s"  },
 684         { },
 685 };
 686
 687 static DBusMessage *nm_sleep(DBusConnection *conn,
 688                                         DBusMessage *msg, void *data)
 689 {
 690         DBusMessage *reply;
 691
 692         DBG("conn %p", conn);
 693
 694         reply = dbus_message_new_method_return(msg);
 695         if (reply == NULL)
 696                 return NULL;
 697
 698         dbus_message_append_args(reply, DBUS_TYPE_INVALID);
 699
 700         return reply;
 701 }
 702
 703 static DBusMessage *nm_wake(DBusConnection *conn,
 704                                         DBusMessage *msg, void *data)
 705 {
 706         DBusMessage *reply;
 707
 708         DBG("conn %p", conn);
 709
 710         reply = dbus_message_new_method_return(msg);
 711         if (reply == NULL)
 712                 return NULL;
 713
 714         dbus_message_append_args(reply, DBUS_TYPE_INVALID);
 715
 716         return reply;
 717 }
 718
 719 enum {
 720         NM_STATE_UNKNOWN = 0,
 721         NM_STATE_ASLEEP,
 722         NM_STATE_CONNECTING,
 723         NM_STATE_CONNECTED,
 724         NM_STATE_DISCONNECTED
 725 };
 726
 727 static DBusMessage *nm_state(DBusConnection *conn,
 728                                         DBusMessage *msg, void *data)
 729 {
 730         DBusMessage *reply;
 731         dbus_uint32_t state;
 732
 733         DBG("conn %p", conn);
 734
 735         reply = dbus_message_new_method_return(msg);
 736         if (reply == NULL)
 737                 return NULL;
 738
 739         if (__connman_notifier_count_connected() > 0)
 740                 state = NM_STATE_CONNECTED;
 741         else
 742                 state = NM_STATE_DISCONNECTED;
 743
 744         dbus_message_append_args(reply, DBUS_TYPE_UINT32, &state,
 745                                                         DBUS_TYPE_INVALID);
 746
 747         return reply;
 748 }
 749
 750 static GDBusMethodTable nm_methods[] = {
 751         { "sleep", "",  "",   nm_sleep        },
 752         { "wake",  "",  "",   nm_wake         },
 753         { "state", "",  "u",  nm_state        },
 754         { },
 755 };
 756
 757 static gboolean nm_compat = FALSE;
 758
 759 int __connman_manager_init(gboolean compat)
 760 {
 761         DBG("");
 762
 763         connection = connman_dbus_get_connection();
 764         if (connection == NULL)
 765                 return -1;
 766
 767         if (connman_notifier_register(&technology_notifier) < 0)
 768                 connman_error("Failed to register technology notifier");
 769
 770         g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
 771                                         CONNMAN_MANAGER_INTERFACE,
 772                                         manager_methods,
 773                                         manager_signals, NULL, NULL, NULL);
 774
 775         if (compat == TRUE) {
 776                 g_dbus_register_interface(connection, NM_PATH, NM_INTERFACE,
 777                                         nm_methods, NULL, NULL, NULL, NULL);
 778
 779                 nm_compat = TRUE;
 780         }
 781
 782         return 0;
 783 }
 784
 785 void __connman_manager_cleanup(void)
 786 {
 787         DBG("");
 788
 789         connman_notifier_unregister(&technology_notifier);
 790
 791         if (connection == NULL)
 792                 return;
 793
 794         if (nm_compat == TRUE) {
 795                 g_dbus_unregister_interface(connection, NM_PATH, NM_INTERFACE);
 796         }
 797
 798         g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
 799                                                 CONNMAN_MANAGER_INTERFACE);
 800
 801         dbus_connection_unref(connection);
 802 }