src/agent.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include <gdbus.h>
  31
  32 #include "connman.h"
  33
  34 static DBusConnection *connection = NULL;
  35 static guint agent_watch = 0;
  36 static gchar *agent_path = NULL;
  37 static gchar *agent_sender = NULL;
  38
  39 static void agent_free(void)
  40 {
  41         agent_watch = 0;
  42
  43         g_free(agent_sender);
  44         agent_sender = NULL;
  45
  46         g_free(agent_path);
  47         agent_path = NULL;
  48 }
  49
  50 static void agent_disconnect(DBusConnection *connection, void *data)
  51 {
  52         DBG("data %p", data);
  53
  54         agent_free();
  55 }
  56
  57 int __connman_agent_register(const char *sender, const char *path)
  58 {
  59         DBG("sender %s path %s", sender, path);
  60
  61         if (agent_path != NULL)
  62                 return -EEXIST;
  63
  64         agent_sender = g_strdup(sender);
  65         agent_path = g_strdup(path);
  66
  67         agent_watch = g_dbus_add_disconnect_watch(connection, sender,
  68                                                 agent_disconnect, NULL, NULL);
  69
  70         return 0;
  71 }
  72
  73 int __connman_agent_unregister(const char *sender, const char *path)
  74 {
  75         DBG("sender %s path %s", sender, path);
  76
  77         if (agent_path == NULL)
  78                 return -ESRCH;
  79
  80         if (agent_watch > 0)
  81                 g_dbus_remove_watch(connection, agent_watch);
  82
  83         agent_free();
  84
  85         return 0;
  86 }
  87
  88 struct request_input_reply {
  89         struct connman_service *service;
  90         authentication_cb_t callback;
  91         void *user_data;
  92 };
  93
  94 static void request_input_passphrase_reply(DBusPendingCall *call, void *user_data)
  95 {
  96         struct request_input_reply *passphrase_reply = user_data;
  97         connman_bool_t values_received = FALSE;
  98         connman_bool_t wps = FALSE;
  99         char *identity = NULL;
 100         char *passphrase = NULL;
 101         char *wpspin = NULL;
 102         char *key;
 103         char *name = NULL;
 104         int name_len = 0;
 105         DBusMessageIter iter, dict;
 106         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 107
 108         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
 109                 goto done;
 110
 111         values_received = TRUE;
 112
 113         dbus_message_iter_init(reply, &iter);
 114         dbus_message_iter_recurse(&iter, &dict);
 115         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 116                 DBusMessageIter entry, value;
 117
 118                 dbus_message_iter_recurse(&dict, &entry);
 119                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 120                         break;
 121
 122                 dbus_message_iter_get_basic(&entry, &key);
 123
 124                 if (g_str_equal(key, "Identity")) {
 125                         dbus_message_iter_next(&entry);
 126                         if (dbus_message_iter_get_arg_type(&entry)
 127                                                         != DBUS_TYPE_VARIANT)
 128                                 break;
 129                         dbus_message_iter_recurse(&entry, &value);
 130                         dbus_message_iter_get_basic(&value, &identity);
 131
 132                 } else if (g_str_equal(key, "Passphrase")) {
 133                         dbus_message_iter_next(&entry);
 134                         if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
 135                                 break;
 136                         dbus_message_iter_recurse(&entry, &value);
 137                         dbus_message_iter_get_basic(&value, &passphrase);
 138
 139                 } else if (g_str_equal(key, "WPS")) {
 140                         wps = TRUE;
 141
 142                         dbus_message_iter_next(&entry);
 143                         if (dbus_message_iter_get_arg_type(&entry)
 144                                                         != DBUS_TYPE_VARIANT)
 145                                 break;
 146                         dbus_message_iter_recurse(&entry, &value);
 147                         dbus_message_iter_get_basic(&value, &wpspin);
 148                         break;
 149                 } else if (g_str_equal(key, "Name")) {
 150                         dbus_message_iter_next(&entry);
 151                         if (dbus_message_iter_get_arg_type(&entry)
 152                                                         != DBUS_TYPE_VARIANT)
 153                                 break;
 154                         dbus_message_iter_recurse(&entry, &value);
 155                         dbus_message_iter_get_basic(&value, &name);
 156                         name_len = strlen(name);
 157                 } else if (g_str_equal(key, "SSID")) {
 158                         dbus_message_iter_next(&entry);
 159                         if (dbus_message_iter_get_arg_type(&entry)
 160                                                         != DBUS_TYPE_VARIANT)
 161                                 break;
 162                         dbus_message_iter_recurse(&entry, &value);
 163                         if (dbus_message_iter_get_arg_type(&value)
 164                                                         != DBUS_TYPE_VARIANT)
 165                                 break;
 166                         if (dbus_message_iter_get_element_type(&value)
 167                                                         != DBUS_TYPE_VARIANT)
 168                                 break;
 169                         dbus_message_iter_get_fixed_array(&value, &name,
 170                                                         &name_len);
 171                 }
 172                 dbus_message_iter_next(&dict);
 173         }
 174
 175         if (wps == TRUE) {
 176                 struct connman_network *network;
 177
 178                 network = __connman_service_get_network(
 179                                                 passphrase_reply->service);
 180                 if (network == NULL)
 181                         goto done;
 182
 183                 connman_network_set_bool(network, "WiFi.UseWPS", wps);
 184
 185                 if (wpspin != NULL && strlen(wpspin) > 0)
 186                         connman_network_set_string(network,
 187                                                 "WiFi.PinWPS", wpspin);
 188                 else
 189                         connman_network_set_string(network,
 190                                                 "WiFi.PinWPS", NULL);
 191         }
 192
 193 done:
 194         passphrase_reply->callback(passphrase_reply->service, values_received,
 195                                 name, name_len,
 196                                 identity, passphrase,
 197                                 wps, wpspin,
 198                                 passphrase_reply->user_data);
 199         connman_service_unref(passphrase_reply->service);
 200         dbus_message_unref(reply);
 201         g_free(passphrase_reply);
 202 }
 203
 204 static void request_input_append_alternates(DBusMessageIter *iter,
 205                                                         void *user_data)
 206 {
 207         const char *str = user_data;
 208         char **alternates, **alternative;
 209
 210         if (str == NULL)
 211                 return;
 212
 213         alternates = g_strsplit(str, ",", 0);
 214         if (alternates == NULL)
 215                 return;
 216
 217         for (alternative = alternates; *alternative != NULL; alternative++)
 218                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
 219                                                                 alternative);
 220
 221         g_strfreev(alternates);
 222 }
 223
 224 static void request_input_append_identity(DBusMessageIter *iter,
 225                                                         void *user_data)
 226 {
 227         char *str = "string";
 228
 229         connman_dbus_dict_append_basic(iter, "Type",
 230                                 DBUS_TYPE_STRING, &str);
 231         str = "mandatory";
 232         connman_dbus_dict_append_basic(iter, "Requirement",
 233                                 DBUS_TYPE_STRING, &str);
 234 }
 235
 236 static void request_input_append_passphrase(DBusMessageIter *iter,
 237                                                         void *user_data)
 238 {
 239         struct connman_service *service = user_data;
 240         char *value;
 241         const char *phase2;
 242
 243         switch (__connman_service_get_security(service)) {
 244         case CONNMAN_SERVICE_SECURITY_WEP:
 245                 value = "wep";
 246                 break;
 247         case CONNMAN_SERVICE_SECURITY_PSK:
 248                 value = "psk";
 249                 break;
 250         case CONNMAN_SERVICE_SECURITY_8021X:
 251                 phase2 = __connman_service_get_phase2(service);
 252
 253                 if (phase2 != NULL && (
 254                                 g_str_has_suffix(phase2, "GTC") == TRUE ||
 255                                 g_str_has_suffix(phase2, "OTP") == TRUE))
 256                         value = "response";
 257                 else
 258                         value = "passphrase";
 259
 260                 break;
 261         default:
 262                 value = "string";
 263                 break;
 264         }
 265         connman_dbus_dict_append_basic(iter, "Type",
 266                                 DBUS_TYPE_STRING, &value);
 267         value = "mandatory";
 268         connman_dbus_dict_append_basic(iter, "Requirement",
 269                                 DBUS_TYPE_STRING, &value);
 270
 271         if (__connman_service_wps_enabled(service) == TRUE) {
 272                 connman_dbus_dict_append_array(iter, "Alternates",
 273                                         DBUS_TYPE_STRING,
 274                                         request_input_append_alternates,
 275                                         "WPS");
 276         }
 277 }
 278
 279 static void request_input_append_wps(DBusMessageIter *iter, void *user_data)
 280 {
 281         const char *str = "wpspin";
 282
 283         connman_dbus_dict_append_basic(iter, "Type",
 284                                 DBUS_TYPE_STRING, &str);
 285         str = "alternate";
 286         connman_dbus_dict_append_basic(iter, "Requirement",
 287                                 DBUS_TYPE_STRING, &str);
 288 }
 289
 290 static void request_input_append_name(DBusMessageIter *iter, void *user_data)
 291 {
 292         const char *str = "string";
 293
 294         connman_dbus_dict_append_basic(iter, "Type",
 295                                 DBUS_TYPE_STRING, &str);
 296         str = "mandatory";
 297         connman_dbus_dict_append_basic(iter, "Requirement",
 298                                 DBUS_TYPE_STRING, &str);
 299         connman_dbus_dict_append_array(iter, "Alternates",
 300                                 DBUS_TYPE_STRING,
 301                                 request_input_append_alternates,
 302                                 "SSID");
 303 }
 304
 305 static void request_input_append_ssid(DBusMessageIter *iter, void *user_data)
 306 {
 307         const char *str = "ssid";
 308
 309         connman_dbus_dict_append_basic(iter, "Type",
 310                                 DBUS_TYPE_STRING, &str);
 311         str = "alternate";
 312         connman_dbus_dict_append_basic(iter, "Requirement",
 313                                 DBUS_TYPE_STRING, &str);
 314 }
 315
 316 static void request_input_append_password(DBusMessageIter *iter,
 317                                                         void *user_data)
 318 {
 319         char *str = "passphrase";
 320
 321         connman_dbus_dict_append_basic(iter, "Type",
 322                                 DBUS_TYPE_STRING, &str);
 323         str = "mandatory";
 324         connman_dbus_dict_append_basic(iter, "Requirement",
 325                                 DBUS_TYPE_STRING, &str);
 326 }
 327
 328 static void request_input_login_reply(DBusPendingCall *call, void *user_data)
 329 {
 330         struct request_input_reply *username_password_reply = user_data;
 331         char *username = NULL;
 332         char *password = NULL;
 333         char *key;
 334         DBusMessageIter iter, dict;
 335         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 336
 337         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
 338                 goto done;
 339
 340         dbus_message_iter_init(reply, &iter);
 341         dbus_message_iter_recurse(&iter, &dict);
 342         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 343                 DBusMessageIter entry, value;
 344
 345                 dbus_message_iter_recurse(&dict, &entry);
 346                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 347                         break;
 348
 349                 dbus_message_iter_get_basic(&entry, &key);
 350
 351                 if (g_str_equal(key, "Username")) {
 352                         dbus_message_iter_next(&entry);
 353                         if (dbus_message_iter_get_arg_type(&entry)
 354                                                         != DBUS_TYPE_VARIANT)
 355                                 break;
 356                         dbus_message_iter_recurse(&entry, &value);
 357                         dbus_message_iter_get_basic(&value, &username);
 358
 359                 } else if (g_str_equal(key, "Password")) {
 360                         dbus_message_iter_next(&entry);
 361                         if (dbus_message_iter_get_arg_type(&entry) !=
 362                                                         DBUS_TYPE_VARIANT)
 363                                 break;
 364                         dbus_message_iter_recurse(&entry, &value);
 365                         dbus_message_iter_get_basic(&value, &password);
 366                 }
 367
 368                 dbus_message_iter_next(&dict);
 369         }
 370
 371 done:
 372         username_password_reply->callback(username_password_reply->service,
 373                                         TRUE, NULL, 0,
 374                                         username, password,
 375                                         FALSE, NULL,
 376                                         username_password_reply->user_data);
 377         connman_service_unref(username_password_reply->service);
 378         dbus_message_unref(reply);
 379         g_free(username_password_reply);
 380 }
 381
 382 int __connman_agent_request_passphrase_input(struct connman_service *service,
 383                                 authentication_cb_t callback, void *user_data)
 384 {
 385         DBusMessage *message;
 386         const char *path;
 387         DBusMessageIter iter;
 388         DBusMessageIter dict;
 389         DBusPendingCall *call;
 390         struct request_input_reply *passphrase_reply;
 391
 392         if (service == NULL || agent_path == NULL || callback == NULL)
 393                 return -ESRCH;
 394
 395         message = dbus_message_new_method_call(agent_sender, agent_path,
 396                                         CONNMAN_AGENT_INTERFACE,
 397                                         "RequestInput");
 398         if (message == NULL)
 399                 return -ENOMEM;
 400
 401         dbus_message_iter_init_append(message, &iter);
 402
 403         path = __connman_service_get_path(service);
 404         dbus_message_iter_append_basic(&iter,
 405                                 DBUS_TYPE_OBJECT_PATH, &path);
 406
 407         connman_dbus_dict_open(&iter, &dict);
 408
 409         if (__connman_service_is_hidden(service)) {
 410                 connman_dbus_dict_append_dict(&dict, "Name",
 411                                         request_input_append_name, NULL);
 412                 connman_dbus_dict_append_dict(&dict, "SSID",
 413                                         request_input_append_ssid, NULL);
 414         }
 415
 416         if (__connman_service_get_security(service) ==
 417                         CONNMAN_SERVICE_SECURITY_8021X) {
 418                 connman_dbus_dict_append_dict(&dict, "Identity",
 419                                         request_input_append_identity, service);
 420         }
 421
 422         connman_dbus_dict_append_dict(&dict, "Passphrase",
 423                                 request_input_append_passphrase, service);
 424
 425         if (__connman_service_wps_enabled(service) == TRUE) {
 426             connman_dbus_dict_append_dict(&dict, "WPS",
 427                                 request_input_append_wps, NULL);
 428         }
 429
 430         connman_dbus_dict_close(&iter, &dict);
 431
 432         passphrase_reply = g_try_new0(struct request_input_reply, 1);
 433         if (passphrase_reply == NULL) {
 434                 dbus_message_unref(message);
 435                 return -ENOMEM;
 436         }
 437
 438         if (dbus_connection_send_with_reply(connection, message,
 439                                                 &call, -1) == FALSE) {
 440                 dbus_message_unref(message);
 441                 g_free(passphrase_reply);
 442                 return -ESRCH;
 443         }
 444
 445         if (call == NULL) {
 446                 dbus_message_unref(message);
 447                 g_free(passphrase_reply);
 448                 return -ESRCH;
 449         }
 450
 451         passphrase_reply->service = connman_service_ref(service);
 452         passphrase_reply->callback = callback;
 453         passphrase_reply->user_data = user_data;
 454
 455         dbus_pending_call_set_notify(call, request_input_passphrase_reply,
 456                                 passphrase_reply, NULL);
 457
 458         dbus_message_unref(message);
 459
 460         return -EIO;
 461 }
 462
 463 int __connman_agent_request_login_input(struct connman_service *service,
 464                                 authentication_cb_t callback, void *user_data)
 465 {
 466         DBusMessage *message;
 467         const char *path;
 468         DBusMessageIter iter;
 469         DBusMessageIter dict;
 470         DBusPendingCall *call;
 471         struct request_input_reply *username_password_reply;
 472
 473         if (service == NULL || agent_path == NULL || callback == NULL)
 474                 return -ESRCH;
 475
 476         message = dbus_message_new_method_call(agent_sender, agent_path,
 477                                         CONNMAN_AGENT_INTERFACE,
 478                                         "RequestInput");
 479         if (message == NULL)
 480                 return -ENOMEM;
 481
 482         dbus_message_iter_init_append(message, &iter);
 483
 484         path = __connman_service_get_path(service);
 485         dbus_message_iter_append_basic(&iter,
 486                                 DBUS_TYPE_OBJECT_PATH, &path);
 487
 488         connman_dbus_dict_open(&iter, &dict);
 489
 490         connman_dbus_dict_append_dict(&dict, "Username",
 491                                 request_input_append_identity, service);
 492
 493         connman_dbus_dict_append_dict(&dict, "Password",
 494                                 request_input_append_password, service);
 495
 496         connman_dbus_dict_close(&iter, &dict);
 497
 498         username_password_reply = g_try_new0(struct request_input_reply, 1);
 499         if (username_password_reply == NULL) {
 500                 dbus_message_unref(message);
 501                 return -ENOMEM;
 502         }
 503
 504         if (dbus_connection_send_with_reply(connection, message,
 505                                                         &call, -1) == FALSE) {
 506                 dbus_message_unref(message);
 507                 g_free(username_password_reply);
 508                 return -ESRCH;
 509         }
 510
 511         if (call == NULL) {
 512                 dbus_message_unref(message);
 513                 g_free(username_password_reply);
 514                 return -ESRCH;
 515         }
 516
 517         username_password_reply->service = connman_service_ref(service);
 518         username_password_reply->callback = callback;
 519         username_password_reply->user_data = user_data;
 520
 521         dbus_pending_call_set_notify(call, request_input_login_reply,
 522                                                 username_password_reply, NULL);
 523
 524         dbus_message_unref(message);
 525
 526         return -EIO;
 527 }
 528
 529 struct request_browser_reply_data {
 530         struct connman_service *service;
 531         browser_authentication_cb_t callback;
 532         void *user_data;
 533 };
 534
 535 static void request_browser_reply(DBusPendingCall *call, void *user_data)
 536 {
 537         struct request_browser_reply_data *browser_reply_data = user_data;
 538         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 539         connman_bool_t result = FALSE;
 540
 541         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
 542                 goto done;
 543
 544         result = TRUE;
 545
 546 done:
 547         browser_reply_data->callback(browser_reply_data->service,
 548                                         result, browser_reply_data->user_data);
 549         connman_service_unref(browser_reply_data->service);
 550         dbus_message_unref(reply);
 551         g_free(browser_reply_data);
 552 }
 553
 554 int __connman_agent_request_browser(struct connman_service *service,
 555                                 browser_authentication_cb_t callback,
 556                                 const char *url, void *user_data)
 557 {
 558         struct request_browser_reply_data *browser_reply_data;
 559         DBusPendingCall *call;
 560         DBusMessage *message;
 561         DBusMessageIter iter;
 562         const char *path;
 563
 564         if (service == NULL || agent_path == NULL || callback == NULL)
 565                 return -ESRCH;
 566
 567         if (url == NULL)
 568                 url = "";
 569
 570         message = dbus_message_new_method_call(agent_sender, agent_path,
 571                                         CONNMAN_AGENT_INTERFACE,
 572                                         "RequestBrowser");
 573         if (message == NULL)
 574                 return -ENOMEM;
 575
 576         dbus_message_iter_init_append(message, &iter);
 577
 578         path = __connman_service_get_path(service);
 579         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 580
 581         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url);
 582
 583         browser_reply_data = g_try_new0(struct request_browser_reply_data, 1);
 584         if (browser_reply_data == NULL) {
 585                 dbus_message_unref(message);
 586                 return -ENOMEM;
 587         }
 588
 589         if (dbus_connection_send_with_reply(connection, message,
 590                                                         &call, -1) == FALSE) {
 591                 dbus_message_unref(message);
 592                 g_free(browser_reply_data);
 593                 return -ESRCH;
 594         }
 595
 596         if (call == NULL) {
 597                 dbus_message_unref(message);
 598                 g_free(browser_reply_data);
 599                 return -ESRCH;
 600         }
 601
 602         browser_reply_data->service = connman_service_ref(service);
 603         browser_reply_data->callback = callback;
 604         browser_reply_data->user_data = user_data;
 605
 606         dbus_pending_call_set_notify(call, request_browser_reply,
 607                                                 browser_reply_data, NULL);
 608
 609         dbus_message_unref(message);
 610
 611         return -EIO;
 612 }
 613
 614 struct report_error_data {
 615         struct connman_service *service;
 616         report_error_cb_t callback;
 617         void *user_data;
 618 };
 619
 620 static void report_error_reply(DBusPendingCall *call, void *user_data)
 621 {
 622         struct report_error_data *report_error = user_data;
 623         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 624         gboolean retry = FALSE;
 625         const char *dbus_err;
 626
 627         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 628                 dbus_err = dbus_message_get_error_name(reply);
 629                 if (dbus_err != NULL &&
 630                         strcmp(dbus_err,
 631                                 CONNMAN_AGENT_INTERFACE ".Error.Retry") == 0)
 632                         retry = TRUE;
 633         }
 634
 635         report_error->callback(report_error->service, retry,
 636                         report_error->user_data);
 637         connman_service_unref(report_error->service);
 638         g_free(report_error);
 639         dbus_message_unref(reply);
 640 }
 641
 642 int __connman_agent_report_error(struct connman_service *service,
 643                                 const char *error,
 644                                 report_error_cb_t callback, void *user_data)
 645 {
 646         DBusMessage *message;
 647         DBusMessageIter iter;
 648         const char *path;
 649         struct report_error_data *report_error;
 650         DBusPendingCall *call;
 651
 652         if (service == NULL || agent_path == NULL || error == NULL ||
 653                 callback == NULL)
 654                 return -ESRCH;
 655
 656         message = dbus_message_new_method_call(agent_sender, agent_path,
 657                                         CONNMAN_AGENT_INTERFACE,
 658                                         "ReportError");
 659         if (message == NULL)
 660                 return -ENOMEM;
 661
 662         dbus_message_iter_init_append(message, &iter);
 663
 664         path = __connman_service_get_path(service);
 665         dbus_message_iter_append_basic(&iter,
 666                                 DBUS_TYPE_OBJECT_PATH, &path);
 667         dbus_message_iter_append_basic(&iter,
 668                                 DBUS_TYPE_STRING, &error);
 669
 670         report_error = g_try_new0(struct report_error_data, 1);
 671         if (report_error == NULL) {
 672                 dbus_message_unref(message);
 673                 return -ENOMEM;
 674         }
 675
 676         if (dbus_connection_send_with_reply(connection, message,
 677                                                 &call, -1) == FALSE) {
 678                 dbus_message_unref(message);
 679                 g_free(report_error);
 680                 return -ESRCH;
 681         }
 682
 683         if (call == NULL) {
 684                 dbus_message_unref(message);
 685                 g_free(report_error);
 686                 return -ESRCH;
 687         }
 688
 689         report_error->service = connman_service_ref(service);
 690         report_error->callback = callback;
 691         report_error->user_data = user_data;
 692         dbus_pending_call_set_notify(call, report_error_reply,
 693                                 report_error, NULL);
 694         dbus_message_unref(message);
 695
 696         return -EIO;
 697 }
 698
 699 int __connman_agent_init(void)
 700 {
 701         DBG("");
 702
 703         connection = connman_dbus_get_connection();
 704         if (connection == NULL)
 705                 return -1;
 706
 707         return 0;
 708 }
 709
 710 void __connman_agent_cleanup(void)
 711 {
 712         DBusMessage *message;
 713
 714         DBG("");
 715
 716         if (connection == NULL)
 717                 return;
 718
 719         if (agent_watch > 0)
 720                 g_dbus_remove_watch(connection, agent_watch);
 721
 722         if (agent_path == NULL)
 723                 return;
 724
 725         message = dbus_message_new_method_call(agent_sender, agent_path,
 726                                         CONNMAN_AGENT_INTERFACE, "Release");
 727         if (message == NULL)
 728                 return;
 729
 730         dbus_message_set_no_reply(message, TRUE);
 731
 732         g_dbus_send_message(connection, message);
 733
 734         agent_free();
 735
 736         dbus_connection_unref(connection);
 737 }