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 done:
 176         passphrase_reply->callback(passphrase_reply->service, values_received,
 177                                 name, name_len,
 178                                 identity, passphrase,
 179                                 wps, wpspin,
 180                                 passphrase_reply->user_data);
 181         connman_service_unref(passphrase_reply->service);
 182         dbus_message_unref(reply);
 183         g_free(passphrase_reply);
 184 }
 185
 186 static void request_input_append_alternates(DBusMessageIter *iter,
 187                                                         void *user_data)
 188 {
 189         const char *str = user_data;
 190         char **alternates, **alternative;
 191
 192         if (str == NULL)
 193                 return;
 194
 195         alternates = g_strsplit(str, ",", 0);
 196         if (alternates == NULL)
 197                 return;
 198
 199         for (alternative = alternates; *alternative != NULL; alternative++)
 200                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
 201                                                                 alternative);
 202
 203         g_strfreev(alternates);
 204 }
 205
 206 static void request_input_append_identity(DBusMessageIter *iter,
 207                                                         void *user_data)
 208 {
 209         char *str = "string";
 210
 211         connman_dbus_dict_append_basic(iter, "Type",
 212                                 DBUS_TYPE_STRING, &str);
 213         str = "mandatory";
 214         connman_dbus_dict_append_basic(iter, "Requirement",
 215                                 DBUS_TYPE_STRING, &str);
 216 }
 217
 218 static void request_input_append_passphrase(DBusMessageIter *iter,
 219                                                         void *user_data)
 220 {
 221         struct connman_service *service = user_data;
 222         char *value;
 223         const char *phase2;
 224
 225         switch (__connman_service_get_security(service)) {
 226         case CONNMAN_SERVICE_SECURITY_WEP:
 227                 value = "wep";
 228                 break;
 229         case CONNMAN_SERVICE_SECURITY_PSK:
 230                 value = "psk";
 231                 break;
 232         case CONNMAN_SERVICE_SECURITY_8021X:
 233                 phase2 = __connman_service_get_phase2(service);
 234
 235                 if (phase2 != NULL && (
 236                                 g_str_has_suffix(phase2, "GTC") == TRUE ||
 237                                 g_str_has_suffix(phase2, "OTP") == TRUE))
 238                         value = "response";
 239                 else
 240                         value = "passphrase";
 241
 242                 break;
 243         default:
 244                 value = "string";
 245                 break;
 246         }
 247         connman_dbus_dict_append_basic(iter, "Type",
 248                                 DBUS_TYPE_STRING, &value);
 249         value = "mandatory";
 250         connman_dbus_dict_append_basic(iter, "Requirement",
 251                                 DBUS_TYPE_STRING, &value);
 252
 253         if (__connman_service_wps_enabled(service) == TRUE) {
 254                 connman_dbus_dict_append_array(iter, "Alternates",
 255                                         DBUS_TYPE_STRING,
 256                                         request_input_append_alternates,
 257                                         "WPS");
 258         }
 259 }
 260
 261 static void request_input_append_wps(DBusMessageIter *iter, void *user_data)
 262 {
 263         const char *str = "wpspin";
 264
 265         connman_dbus_dict_append_basic(iter, "Type",
 266                                 DBUS_TYPE_STRING, &str);
 267         str = "alternate";
 268         connman_dbus_dict_append_basic(iter, "Requirement",
 269                                 DBUS_TYPE_STRING, &str);
 270 }
 271
 272 static void request_input_append_name(DBusMessageIter *iter, void *user_data)
 273 {
 274         const char *str = "string";
 275
 276         connman_dbus_dict_append_basic(iter, "Type",
 277                                 DBUS_TYPE_STRING, &str);
 278         str = "mandatory";
 279         connman_dbus_dict_append_basic(iter, "Requirement",
 280                                 DBUS_TYPE_STRING, &str);
 281         connman_dbus_dict_append_array(iter, "Alternates",
 282                                 DBUS_TYPE_STRING,
 283                                 request_input_append_alternates,
 284                                 "SSID");
 285 }
 286
 287 static void request_input_append_ssid(DBusMessageIter *iter, void *user_data)
 288 {
 289         const char *str = "ssid";
 290
 291         connman_dbus_dict_append_basic(iter, "Type",
 292                                 DBUS_TYPE_STRING, &str);
 293         str = "alternate";
 294         connman_dbus_dict_append_basic(iter, "Requirement",
 295                                 DBUS_TYPE_STRING, &str);
 296 }
 297
 298 static void request_input_append_password(DBusMessageIter *iter,
 299                                                         void *user_data)
 300 {
 301         char *str = "passphrase";
 302
 303         connman_dbus_dict_append_basic(iter, "Type",
 304                                 DBUS_TYPE_STRING, &str);
 305         str = "mandatory";
 306         connman_dbus_dict_append_basic(iter, "Requirement",
 307                                 DBUS_TYPE_STRING, &str);
 308 }
 309
 310 static void request_input_login_reply(DBusPendingCall *call, void *user_data)
 311 {
 312         struct request_input_reply *username_password_reply = user_data;
 313         char *username = NULL;
 314         char *password = NULL;
 315         char *key;
 316         DBusMessageIter iter, dict;
 317         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 318
 319         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
 320                 goto done;
 321
 322         dbus_message_iter_init(reply, &iter);
 323         dbus_message_iter_recurse(&iter, &dict);
 324         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 325                 DBusMessageIter entry, value;
 326
 327                 dbus_message_iter_recurse(&dict, &entry);
 328                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 329                         break;
 330
 331                 dbus_message_iter_get_basic(&entry, &key);
 332
 333                 if (g_str_equal(key, "Username")) {
 334                         dbus_message_iter_next(&entry);
 335                         if (dbus_message_iter_get_arg_type(&entry)
 336                                                         != DBUS_TYPE_VARIANT)
 337                                 break;
 338                         dbus_message_iter_recurse(&entry, &value);
 339                         dbus_message_iter_get_basic(&value, &username);
 340
 341                 } else if (g_str_equal(key, "Password")) {
 342                         dbus_message_iter_next(&entry);
 343                         if (dbus_message_iter_get_arg_type(&entry) !=
 344                                                         DBUS_TYPE_VARIANT)
 345                                 break;
 346                         dbus_message_iter_recurse(&entry, &value);
 347                         dbus_message_iter_get_basic(&value, &password);
 348                 }
 349
 350                 dbus_message_iter_next(&dict);
 351         }
 352
 353 done:
 354         username_password_reply->callback(username_password_reply->service,
 355                                         TRUE, NULL, 0,
 356                                         username, password,
 357                                         FALSE, NULL,
 358                                         username_password_reply->user_data);
 359         connman_service_unref(username_password_reply->service);
 360         dbus_message_unref(reply);
 361         g_free(username_password_reply);
 362 }
 363
 364 int __connman_agent_request_passphrase_input(struct connman_service *service,
 365                                 authentication_cb_t callback, void *user_data)
 366 {
 367         DBusMessage *message;
 368         const char *path;
 369         DBusMessageIter iter;
 370         DBusMessageIter dict;
 371         DBusPendingCall *call;
 372         struct request_input_reply *passphrase_reply;
 373
 374         if (service == NULL || agent_path == NULL || callback == NULL)
 375                 return -ESRCH;
 376
 377         message = dbus_message_new_method_call(agent_sender, agent_path,
 378                                         CONNMAN_AGENT_INTERFACE,
 379                                         "RequestInput");
 380         if (message == NULL)
 381                 return -ENOMEM;
 382
 383         dbus_message_iter_init_append(message, &iter);
 384
 385         path = __connman_service_get_path(service);
 386         dbus_message_iter_append_basic(&iter,
 387                                 DBUS_TYPE_OBJECT_PATH, &path);
 388
 389         connman_dbus_dict_open(&iter, &dict);
 390
 391         if (__connman_service_is_hidden(service)) {
 392                 connman_dbus_dict_append_dict(&dict, "Name",
 393                                         request_input_append_name, NULL);
 394                 connman_dbus_dict_append_dict(&dict, "SSID",
 395                                         request_input_append_ssid, NULL);
 396         }
 397
 398         if (__connman_service_get_security(service) ==
 399                         CONNMAN_SERVICE_SECURITY_8021X) {
 400                 connman_dbus_dict_append_dict(&dict, "Identity",
 401                                         request_input_append_identity, service);
 402         }
 403
 404         connman_dbus_dict_append_dict(&dict, "Passphrase",
 405                                 request_input_append_passphrase, service);
 406
 407         if (__connman_service_wps_enabled(service) == TRUE) {
 408             connman_dbus_dict_append_dict(&dict, "WPS",
 409                                 request_input_append_wps, NULL);
 410         }
 411
 412         connman_dbus_dict_close(&iter, &dict);
 413
 414         passphrase_reply = g_try_new0(struct request_input_reply, 1);
 415         if (passphrase_reply == NULL) {
 416                 dbus_message_unref(message);
 417                 return -ENOMEM;
 418         }
 419
 420         if (dbus_connection_send_with_reply(connection, message,
 421                                                 &call, -1) == FALSE) {
 422                 dbus_message_unref(message);
 423                 g_free(passphrase_reply);
 424                 return -ESRCH;
 425         }
 426
 427         if (call == NULL) {
 428                 dbus_message_unref(message);
 429                 g_free(passphrase_reply);
 430                 return -ESRCH;
 431         }
 432
 433         passphrase_reply->service = connman_service_ref(service);
 434         passphrase_reply->callback = callback;
 435         passphrase_reply->user_data = user_data;
 436
 437         dbus_pending_call_set_notify(call, request_input_passphrase_reply,
 438                                 passphrase_reply, NULL);
 439
 440         dbus_message_unref(message);
 441
 442         return -EIO;
 443 }
 444
 445 int __connman_agent_request_login_input(struct connman_service *service,
 446                                 authentication_cb_t callback, void *user_data)
 447 {
 448         DBusMessage *message;
 449         const char *path;
 450         DBusMessageIter iter;
 451         DBusMessageIter dict;
 452         DBusPendingCall *call;
 453         struct request_input_reply *username_password_reply;
 454
 455         if (service == NULL || agent_path == NULL || callback == NULL)
 456                 return -ESRCH;
 457
 458         message = dbus_message_new_method_call(agent_sender, agent_path,
 459                                         CONNMAN_AGENT_INTERFACE,
 460                                         "RequestInput");
 461         if (message == NULL)
 462                 return -ENOMEM;
 463
 464         dbus_message_iter_init_append(message, &iter);
 465
 466         path = __connman_service_get_path(service);
 467         dbus_message_iter_append_basic(&iter,
 468                                 DBUS_TYPE_OBJECT_PATH, &path);
 469
 470         connman_dbus_dict_open(&iter, &dict);
 471
 472         connman_dbus_dict_append_dict(&dict, "Username",
 473                                 request_input_append_identity, service);
 474
 475         connman_dbus_dict_append_dict(&dict, "Password",
 476                                 request_input_append_password, service);
 477
 478         connman_dbus_dict_close(&iter, &dict);
 479
 480         username_password_reply = g_try_new0(struct request_input_reply, 1);
 481         if (username_password_reply == NULL) {
 482                 dbus_message_unref(message);
 483                 return -ENOMEM;
 484         }
 485
 486         if (dbus_connection_send_with_reply(connection, message,
 487                                                         &call, -1) == FALSE) {
 488                 dbus_message_unref(message);
 489                 g_free(username_password_reply);
 490                 return -ESRCH;
 491         }
 492
 493         if (call == NULL) {
 494                 dbus_message_unref(message);
 495                 g_free(username_password_reply);
 496                 return -ESRCH;
 497         }
 498
 499         username_password_reply->service = connman_service_ref(service);
 500         username_password_reply->callback = callback;
 501         username_password_reply->user_data = user_data;
 502
 503         dbus_pending_call_set_notify(call, request_input_login_reply,
 504                                                 username_password_reply, NULL);
 505
 506         dbus_message_unref(message);
 507
 508         return -EIO;
 509 }
 510
 511 struct request_browser_reply_data {
 512         struct connman_service *service;
 513         browser_authentication_cb_t callback;
 514         void *user_data;
 515 };
 516
 517 static void request_browser_reply(DBusPendingCall *call, void *user_data)
 518 {
 519         struct request_browser_reply_data *browser_reply_data = user_data;
 520         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 521         connman_bool_t result = FALSE;
 522
 523         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
 524                 goto done;
 525
 526         result = TRUE;
 527
 528 done:
 529         browser_reply_data->callback(browser_reply_data->service,
 530                                         result, browser_reply_data->user_data);
 531         connman_service_unref(browser_reply_data->service);
 532         dbus_message_unref(reply);
 533         g_free(browser_reply_data);
 534 }
 535
 536 int __connman_agent_request_browser(struct connman_service *service,
 537                                 browser_authentication_cb_t callback,
 538                                 const char *url, void *user_data)
 539 {
 540         struct request_browser_reply_data *browser_reply_data;
 541         DBusPendingCall *call;
 542         DBusMessage *message;
 543         DBusMessageIter iter;
 544         const char *path;
 545
 546         if (service == NULL || agent_path == NULL || callback == NULL)
 547                 return -ESRCH;
 548
 549         if (url == NULL)
 550                 url = "";
 551
 552         message = dbus_message_new_method_call(agent_sender, agent_path,
 553                                         CONNMAN_AGENT_INTERFACE,
 554                                         "RequestBrowser");
 555         if (message == NULL)
 556                 return -ENOMEM;
 557
 558         dbus_message_iter_init_append(message, &iter);
 559
 560         path = __connman_service_get_path(service);
 561         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 562
 563         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url);
 564
 565         browser_reply_data = g_try_new0(struct request_browser_reply_data, 1);
 566         if (browser_reply_data == NULL) {
 567                 dbus_message_unref(message);
 568                 return -ENOMEM;
 569         }
 570
 571         if (dbus_connection_send_with_reply(connection, message,
 572                                                         &call, -1) == FALSE) {
 573                 dbus_message_unref(message);
 574                 g_free(browser_reply_data);
 575                 return -ESRCH;
 576         }
 577
 578         if (call == NULL) {
 579                 dbus_message_unref(message);
 580                 g_free(browser_reply_data);
 581                 return -ESRCH;
 582         }
 583
 584         browser_reply_data->service = connman_service_ref(service);
 585         browser_reply_data->callback = callback;
 586         browser_reply_data->user_data = user_data;
 587
 588         dbus_pending_call_set_notify(call, request_browser_reply,
 589                                                 browser_reply_data, NULL);
 590
 591         dbus_message_unref(message);
 592
 593         return -EIO;
 594 }
 595
 596 struct report_error_data {
 597         struct connman_service *service;
 598         report_error_cb_t callback;
 599         void *user_data;
 600 };
 601
 602 static void report_error_reply(DBusPendingCall *call, void *user_data)
 603 {
 604         struct report_error_data *report_error = user_data;
 605         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 606         gboolean retry = FALSE;
 607         const char *dbus_err;
 608
 609         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 610                 dbus_err = dbus_message_get_error_name(reply);
 611                 if (dbus_err != NULL &&
 612                         strcmp(dbus_err,
 613                                 CONNMAN_AGENT_INTERFACE ".Error.Retry") == 0)
 614                         retry = TRUE;
 615         }
 616
 617         report_error->callback(report_error->service, retry,
 618                         report_error->user_data);
 619         connman_service_unref(report_error->service);
 620         g_free(report_error);
 621         dbus_message_unref(reply);
 622 }
 623
 624 int __connman_agent_report_error(struct connman_service *service,
 625                                 const char *error,
 626                                 report_error_cb_t callback, void *user_data)
 627 {
 628         DBusMessage *message;
 629         DBusMessageIter iter;
 630         const char *path;
 631         struct report_error_data *report_error;
 632         DBusPendingCall *call;
 633
 634         if (service == NULL || agent_path == NULL || error == NULL ||
 635                 callback == NULL)
 636                 return -ESRCH;
 637
 638         message = dbus_message_new_method_call(agent_sender, agent_path,
 639                                         CONNMAN_AGENT_INTERFACE,
 640                                         "ReportError");
 641         if (message == NULL)
 642                 return -ENOMEM;
 643
 644         dbus_message_iter_init_append(message, &iter);
 645
 646         path = __connman_service_get_path(service);
 647         dbus_message_iter_append_basic(&iter,
 648                                 DBUS_TYPE_OBJECT_PATH, &path);
 649         dbus_message_iter_append_basic(&iter,
 650                                 DBUS_TYPE_STRING, &error);
 651
 652         report_error = g_try_new0(struct report_error_data, 1);
 653         if (report_error == NULL) {
 654                 dbus_message_unref(message);
 655                 return -ENOMEM;
 656         }
 657
 658         if (dbus_connection_send_with_reply(connection, message,
 659                                                 &call, -1) == FALSE) {
 660                 dbus_message_unref(message);
 661                 g_free(report_error);
 662                 return -ESRCH;
 663         }
 664
 665         if (call == NULL) {
 666                 dbus_message_unref(message);
 667                 g_free(report_error);
 668                 return -ESRCH;
 669         }
 670
 671         report_error->service = connman_service_ref(service);
 672         report_error->callback = callback;
 673         report_error->user_data = user_data;
 674         dbus_pending_call_set_notify(call, report_error_reply,
 675                                 report_error, NULL);
 676         dbus_message_unref(message);
 677
 678         return -EIO;
 679 }
 680
 681 int __connman_agent_init(void)
 682 {
 683         DBG("");
 684
 685         connection = connman_dbus_get_connection();
 686         if (connection == NULL)
 687                 return -1;
 688
 689         return 0;
 690 }
 691
 692 void __connman_agent_cleanup(void)
 693 {
 694         DBusMessage *message;
 695
 696         DBG("");
 697
 698         if (connection == NULL)
 699                 return;
 700
 701         if (agent_watch > 0)
 702                 g_dbus_remove_watch(connection, agent_watch);
 703
 704         if (agent_path == NULL)
 705                 return;
 706
 707         message = dbus_message_new_method_call(agent_sender, agent_path,
 708                                         CONNMAN_AGENT_INTERFACE, "Release");
 709         if (message == NULL)
 710                 return;
 711
 712         dbus_message_set_no_reply(message, TRUE);
 713
 714         g_dbus_send_message(connection, message);
 715
 716         agent_free();
 717
 718         dbus_connection_unref(connection);
 719 }