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