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