src/agent-connman.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2012-2013  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 #include <connman/agent.h>
  32 #include <connman/setting.h>
  33 #include <connman/service.h>
  34
  35 #include "connman.h"
  36
  37 static bool check_reply_has_dict(DBusMessage *reply)
  38 {
  39         const char *signature = DBUS_TYPE_ARRAY_AS_STRING
  40                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
  41                 DBUS_TYPE_STRING_AS_STRING
  42                 DBUS_TYPE_VARIANT_AS_STRING
  43                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
  44
  45         if (dbus_message_has_signature(reply, signature))
  46                 return true;
  47
  48         connman_warn("Reply %s to %s from %s has wrong signature %s",
  49                         signature,
  50                         dbus_message_get_interface(reply),
  51                         dbus_message_get_sender(reply),
  52                         dbus_message_get_signature(reply));
  53
  54         return false;
  55 }
  56
  57 struct request_input_reply {
  58         struct connman_service *service;
  59         struct connman_peer *peer;
  60         union {
  61                 authentication_cb_t service_callback;
  62                 peer_wps_cb_t peer_callback;
  63         };
  64         bool wps_requested;
  65         void *user_data;
  66 };
  67
  68 static void request_input_passphrase_reply(DBusMessage *reply, void *user_data)
  69 {
  70         struct request_input_reply *passphrase_reply = user_data;
  71         bool values_received = false;
  72         bool wps = false;
  73         const char *error = NULL;
  74         char *identity = NULL;
  75         char *passphrase = NULL;
  76         char *wpspin = NULL;
  77         char *key;
  78         char *name = NULL;
  79         int name_len = 0;
  80         DBusMessageIter iter, dict;
  81
  82         if (!reply) {
  83                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
  84                 goto done;
  85         }
  86
  87         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
  88                 error = dbus_message_get_error_name(reply);
  89                 goto done;
  90         }
  91
  92         if (!check_reply_has_dict(reply))
  93                 goto done;
  94
  95         values_received = true;
  96
  97         dbus_message_iter_init(reply, &iter);
  98         dbus_message_iter_recurse(&iter, &dict);
  99         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 100                 DBusMessageIter entry, value;
 101
 102                 dbus_message_iter_recurse(&dict, &entry);
 103                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 104                         break;
 105
 106                 dbus_message_iter_get_basic(&entry, &key);
 107
 108                 if (g_str_equal(key, "Identity")) {
 109                         dbus_message_iter_next(&entry);
 110                         if (dbus_message_iter_get_arg_type(&entry)
 111                                                         != DBUS_TYPE_VARIANT)
 112                                 break;
 113                         dbus_message_iter_recurse(&entry, &value);
 114                         dbus_message_iter_get_basic(&value, &identity);
 115
 116                 } else if (g_str_equal(key, "Passphrase")) {
 117                         dbus_message_iter_next(&entry);
 118                         if (dbus_message_iter_get_arg_type(&entry)
 119                                                         != DBUS_TYPE_VARIANT)
 120                                 break;
 121                         dbus_message_iter_recurse(&entry, &value);
 122                         dbus_message_iter_get_basic(&value, &passphrase);
 123
 124                 } else if (g_str_equal(key, "WPS")) {
 125                         wps = true;
 126
 127                         dbus_message_iter_next(&entry);
 128                         if (dbus_message_iter_get_arg_type(&entry)
 129                                                         != DBUS_TYPE_VARIANT)
 130                                 break;
 131                         dbus_message_iter_recurse(&entry, &value);
 132                         dbus_message_iter_get_basic(&value, &wpspin);
 133                         break;
 134                 } else if (g_str_equal(key, "Name")) {
 135                         dbus_message_iter_next(&entry);
 136                         if (dbus_message_iter_get_arg_type(&entry)
 137                                                         != DBUS_TYPE_VARIANT)
 138                                 break;
 139                         dbus_message_iter_recurse(&entry, &value);
 140                         dbus_message_iter_get_basic(&value, &name);
 141                         name_len = strlen(name);
 142                 } else if (g_str_equal(key, "SSID")) {
 143 #if defined TIZEN_EXT
 144                         DBusMessageIter array;
 145 #endif
 146                         dbus_message_iter_next(&entry);
 147                         if (dbus_message_iter_get_arg_type(&entry)
 148                                                         != DBUS_TYPE_VARIANT)
 149                                 break;
 150 #if defined TIZEN_EXT
 151                         dbus_message_iter_recurse(&entry, &array);
 152                         if (dbus_message_iter_get_arg_type(&array)
 153                                                         != DBUS_TYPE_ARRAY)
 154                                 break;
 155                         dbus_message_iter_recurse(&array, &value);
 156                         if (dbus_message_iter_get_arg_type(&value)
 157                                                         != DBUS_TYPE_BYTE)
 158                                 break;
 159 #else
 160
 161                         dbus_message_iter_recurse(&entry, &value);
 162                         if (dbus_message_iter_get_arg_type(&value)
 163                                                         != DBUS_TYPE_VARIANT)
 164                                 break;
 165                         if (dbus_message_iter_get_element_type(&value)
 166                                                         != DBUS_TYPE_VARIANT)
 167                                 break;
 168 #endif
 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->service_callback(passphrase_reply->service,
 177                                         values_received, name, name_len,
 178                                         identity, passphrase, wps, wpspin,
 179                                         error, passphrase_reply->user_data);
 180
 181         g_free(passphrase_reply);
 182 }
 183
 184 static void request_input_append_alternates(DBusMessageIter *iter,
 185                                                         void *user_data)
 186 {
 187         const char *str = user_data;
 188         char **alternates, **alternative;
 189
 190         if (!str)
 191                 return;
 192
 193         alternates = g_strsplit(str, ",", 0);
 194         if (!alternates)
 195                 return;
 196
 197         for (alternative = alternates; *alternative; alternative++)
 198                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
 199                                                                 alternative);
 200
 201         g_strfreev(alternates);
 202 }
 203
 204 static void request_input_append_identity(DBusMessageIter *iter,
 205                                                         void *user_data)
 206 {
 207         char *str = "string";
 208
 209         connman_dbus_dict_append_basic(iter, "Type",
 210                                 DBUS_TYPE_STRING, &str);
 211         str = "mandatory";
 212         connman_dbus_dict_append_basic(iter, "Requirement",
 213                                 DBUS_TYPE_STRING, &str);
 214 }
 215
 216 static void request_input_append_passphrase(DBusMessageIter *iter,
 217                                                         void *user_data)
 218 {
 219         struct connman_service *service = user_data;
 220         char *value;
 221         const char *phase2;
 222
 223         switch (__connman_service_get_security(service)) {
 224         case CONNMAN_SERVICE_SECURITY_WEP:
 225                 value = "wep";
 226                 break;
 227         case CONNMAN_SERVICE_SECURITY_PSK:
 228 #if defined TIZEN_EXT
 229         case CONNMAN_SERVICE_SECURITY_RSN:
 230 #endif
 231                 value = "psk";
 232                 break;
 233         case CONNMAN_SERVICE_SECURITY_8021X:
 234                 phase2 = __connman_service_get_phase2(service);
 235
 236                 if (phase2 && (
 237                                 g_str_has_suffix(phase2, "GTC") ||
 238                                 g_str_has_suffix(phase2, "OTP")))
 239                         value = "response";
 240                 else
 241                         value = "passphrase";
 242
 243                 break;
 244         default:
 245                 value = "string";
 246                 break;
 247         }
 248         connman_dbus_dict_append_basic(iter, "Type",
 249                                 DBUS_TYPE_STRING, &value);
 250         value = "mandatory";
 251         connman_dbus_dict_append_basic(iter, "Requirement",
 252                                 DBUS_TYPE_STRING, &value);
 253
 254         if (__connman_service_wps_enabled(service)) {
 255                 connman_dbus_dict_append_array(iter, "Alternates",
 256                                         DBUS_TYPE_STRING,
 257                                         request_input_append_alternates,
 258                                         "WPS");
 259         }
 260 }
 261
 262 struct request_wps_data {
 263         bool peer;
 264 };
 265
 266 static void request_input_append_wps(DBusMessageIter *iter, void *user_data)
 267 {
 268         struct request_wps_data *wps = user_data;
 269         const char *str = "wpspin";
 270
 271         connman_dbus_dict_append_basic(iter, "Type",
 272                                 DBUS_TYPE_STRING, &str);
 273         if (wps && wps->peer)
 274                 str = "mandatory";
 275         else
 276                 str = "alternate";
 277         connman_dbus_dict_append_basic(iter, "Requirement",
 278                                 DBUS_TYPE_STRING, &str);
 279 }
 280
 281 static void request_input_append_name(DBusMessageIter *iter, void *user_data)
 282 {
 283         const char *str = "string";
 284
 285         connman_dbus_dict_append_basic(iter, "Type",
 286                                 DBUS_TYPE_STRING, &str);
 287         str = "mandatory";
 288         connman_dbus_dict_append_basic(iter, "Requirement",
 289                                 DBUS_TYPE_STRING, &str);
 290         connman_dbus_dict_append_array(iter, "Alternates",
 291                                 DBUS_TYPE_STRING,
 292                                 request_input_append_alternates,
 293                                 "SSID");
 294 }
 295
 296 static void request_input_append_ssid(DBusMessageIter *iter, void *user_data)
 297 {
 298         const char *str = "ssid";
 299
 300         connman_dbus_dict_append_basic(iter, "Type",
 301                                 DBUS_TYPE_STRING, &str);
 302         str = "alternate";
 303         connman_dbus_dict_append_basic(iter, "Requirement",
 304                                 DBUS_TYPE_STRING, &str);
 305 }
 306
 307 static void request_input_append_password(DBusMessageIter *iter,
 308                                                         void *user_data)
 309 {
 310         char *str = "passphrase";
 311
 312         connman_dbus_dict_append_basic(iter, "Type",
 313                                 DBUS_TYPE_STRING, &str);
 314         str = "mandatory";
 315         connman_dbus_dict_append_basic(iter, "Requirement",
 316                                 DBUS_TYPE_STRING, &str);
 317 }
 318
 319 struct previous_passphrase_data {
 320         const char *passphrase;
 321         const char *type;
 322 };
 323
 324 static void request_input_append_previouspassphrase(DBusMessageIter *iter,
 325                                                         void *user_data)
 326 {
 327         struct previous_passphrase_data *data = user_data;
 328         const char *requirement = "informational";
 329
 330         connman_dbus_dict_append_basic(iter, "Type",
 331                                 DBUS_TYPE_STRING, &data->type);
 332
 333         connman_dbus_dict_append_basic(iter, "Requirement",
 334                                 DBUS_TYPE_STRING, &requirement);
 335
 336         connman_dbus_dict_append_basic(iter, "Value",
 337                                 DBUS_TYPE_STRING, &data->passphrase);
 338 }
 339
 340 static void previous_passphrase_handler(DBusMessageIter *iter,
 341                                         struct connman_service *service)
 342 {
 343         enum connman_service_security security;
 344         struct previous_passphrase_data data;
 345         struct connman_network *network;
 346
 347         network = __connman_service_get_network(service);
 348         data.passphrase = connman_network_get_string(network, "WiFi.PinWPS");
 349
 350         if (connman_network_get_bool(network, "WiFi.UseWPS") &&
 351                                                 data.passphrase) {
 352                 data.type = "wpspin";
 353         } else {
 354                 data.passphrase = __connman_service_get_passphrase(service);
 355                 if (!data.passphrase)
 356                         return;
 357
 358                 security = __connman_service_get_security(service);
 359                 switch (security) {
 360                 case CONNMAN_SERVICE_SECURITY_WEP:
 361                         data.type = "wep";
 362                         break;
 363                 case CONNMAN_SERVICE_SECURITY_PSK:
 364 #if defined TIZEN_EXT
 365                 case CONNMAN_SERVICE_SECURITY_RSN:
 366 #endif
 367                         data.type  = "psk";
 368                         break;
 369                 /*
 370                  * This should never happen: no passphrase is set if security
 371                  * is not one of the above. */
 372                 default:
 373                         break;
 374                 }
 375         }
 376
 377         connman_dbus_dict_append_dict(iter, "PreviousPassphrase",
 378                         request_input_append_previouspassphrase, &data);
 379 }
 380
 381 static void request_input_login_reply(DBusMessage *reply, void *user_data)
 382 {
 383         struct request_input_reply *username_password_reply = user_data;
 384         const char *error = NULL;
 385         bool values_received = false;
 386         char *username = NULL;
 387         char *password = NULL;
 388         char *key;
 389         DBusMessageIter iter, dict;
 390
 391         if (!reply) {
 392                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
 393                 goto done;
 394         }
 395
 396         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 397                 error = dbus_message_get_error_name(reply);
 398                 goto done;
 399         }
 400
 401         if (!check_reply_has_dict(reply))
 402                 goto done;
 403
 404         values_received = true;
 405
 406         dbus_message_iter_init(reply, &iter);
 407         dbus_message_iter_recurse(&iter, &dict);
 408         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 409                 DBusMessageIter entry, value;
 410
 411                 dbus_message_iter_recurse(&dict, &entry);
 412                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 413                         break;
 414
 415                 dbus_message_iter_get_basic(&entry, &key);
 416
 417                 if (g_str_equal(key, "Username")) {
 418                         dbus_message_iter_next(&entry);
 419                         if (dbus_message_iter_get_arg_type(&entry)
 420                                                         != DBUS_TYPE_VARIANT)
 421                                 break;
 422                         dbus_message_iter_recurse(&entry, &value);
 423                         dbus_message_iter_get_basic(&value, &username);
 424
 425                 } else if (g_str_equal(key, "Password")) {
 426                         dbus_message_iter_next(&entry);
 427                         if (dbus_message_iter_get_arg_type(&entry) !=
 428                                                         DBUS_TYPE_VARIANT)
 429                                 break;
 430                         dbus_message_iter_recurse(&entry, &value);
 431                         dbus_message_iter_get_basic(&value, &password);
 432                 }
 433
 434                 dbus_message_iter_next(&dict);
 435         }
 436
 437 done:
 438         username_password_reply->service_callback(
 439                         username_password_reply->service, values_received,
 440                         NULL, 0, username, password, FALSE, NULL, error,
 441                         username_password_reply->user_data);
 442
 443         g_free(username_password_reply);
 444 }
 445
 446 int __connman_agent_request_passphrase_input(struct connman_service *service,
 447                                 authentication_cb_t callback,
 448                                 const char *dbus_sender, void *user_data)
 449 {
 450         DBusMessage *message;
 451         const char *path, *agent_sender, *agent_path;
 452         DBusMessageIter iter;
 453         DBusMessageIter dict;
 454         struct request_input_reply *passphrase_reply;
 455         int err;
 456         void *agent;
 457
 458         agent = connman_agent_get_info(dbus_sender, &agent_sender,
 459                                                         &agent_path);
 460
 461         DBG("agent %p service %p path %s", agent, service, agent_path);
 462
 463         if (!service || !agent || !agent_path || !callback)
 464                 return -ESRCH;
 465
 466         message = dbus_message_new_method_call(agent_sender, agent_path,
 467                                         CONNMAN_AGENT_INTERFACE,
 468                                         "RequestInput");
 469         if (!message)
 470                 return -ENOMEM;
 471
 472         dbus_message_iter_init_append(message, &iter);
 473
 474         path = __connman_service_get_path(service);
 475         dbus_message_iter_append_basic(&iter,
 476                                 DBUS_TYPE_OBJECT_PATH, &path);
 477
 478         connman_dbus_dict_open(&iter, &dict);
 479
 480         if (__connman_service_is_hidden(service)) {
 481                 connman_dbus_dict_append_dict(&dict, "Name",
 482                                         request_input_append_name, NULL);
 483                 connman_dbus_dict_append_dict(&dict, "SSID",
 484                                         request_input_append_ssid, NULL);
 485         }
 486
 487         if (__connman_service_get_security(service) ==
 488                         CONNMAN_SERVICE_SECURITY_8021X) {
 489                 connman_dbus_dict_append_dict(&dict, "Identity",
 490                                         request_input_append_identity, service);
 491         }
 492
 493         if (__connman_service_get_security(service) !=
 494                         CONNMAN_SERVICE_SECURITY_NONE) {
 495                 connman_dbus_dict_append_dict(&dict, "Passphrase",
 496                                 request_input_append_passphrase, service);
 497
 498                 previous_passphrase_handler(&dict, service);
 499         }
 500
 501         if (__connman_service_wps_enabled(service))
 502                 connman_dbus_dict_append_dict(&dict, "WPS",
 503                                 request_input_append_wps, NULL);
 504
 505         connman_dbus_dict_close(&iter, &dict);
 506
 507         passphrase_reply = g_try_new0(struct request_input_reply, 1);
 508         if (!passphrase_reply) {
 509                 dbus_message_unref(message);
 510                 return -ENOMEM;
 511         }
 512
 513         passphrase_reply->service = service;
 514         passphrase_reply->service_callback = callback;
 515         passphrase_reply->user_data = user_data;
 516
 517         err = connman_agent_queue_message(service, message,
 518                         connman_timeout_input_request(),
 519                         request_input_passphrase_reply,
 520                         passphrase_reply, agent);
 521
 522         if (err < 0 && err != -EBUSY) {
 523                 DBG("error %d sending agent message", err);
 524                 dbus_message_unref(message);
 525                 g_free(passphrase_reply);
 526                 return err;
 527         }
 528
 529         dbus_message_unref(message);
 530
 531         return -EINPROGRESS;
 532 }
 533
 534 int __connman_agent_request_login_input(struct connman_service *service,
 535                                 authentication_cb_t callback, void *user_data)
 536 {
 537         DBusMessage *message;
 538         const char *path, *agent_sender, *agent_path;
 539         DBusMessageIter iter;
 540         DBusMessageIter dict;
 541         struct request_input_reply *username_password_reply;
 542         int err;
 543         void *agent;
 544
 545         agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
 546
 547         if (!service || !agent || !agent_path || !callback)
 548                 return -ESRCH;
 549
 550         message = dbus_message_new_method_call(agent_sender, agent_path,
 551                                         CONNMAN_AGENT_INTERFACE,
 552                                         "RequestInput");
 553         if (!message)
 554                 return -ENOMEM;
 555
 556         dbus_message_iter_init_append(message, &iter);
 557
 558         path = __connman_service_get_path(service);
 559         dbus_message_iter_append_basic(&iter,
 560                                 DBUS_TYPE_OBJECT_PATH, &path);
 561
 562         connman_dbus_dict_open(&iter, &dict);
 563
 564         connman_dbus_dict_append_dict(&dict, "Username",
 565                                 request_input_append_identity, service);
 566
 567         connman_dbus_dict_append_dict(&dict, "Password",
 568                                 request_input_append_password, service);
 569
 570         connman_dbus_dict_close(&iter, &dict);
 571
 572         username_password_reply = g_try_new0(struct request_input_reply, 1);
 573         if (!username_password_reply) {
 574                 dbus_message_unref(message);
 575                 return -ENOMEM;
 576         }
 577
 578         username_password_reply->service = service;
 579         username_password_reply->service_callback = callback;
 580         username_password_reply->user_data = user_data;
 581
 582         err = connman_agent_queue_message(service, message,
 583                         connman_timeout_input_request(),
 584                         request_input_login_reply, username_password_reply,
 585                         agent);
 586         if (err < 0 && err != -EBUSY) {
 587                 DBG("error %d sending agent request", err);
 588                 dbus_message_unref(message);
 589                 g_free(username_password_reply);
 590                 return err;
 591         }
 592
 593         dbus_message_unref(message);
 594
 595         return -EINPROGRESS;
 596 }
 597
 598 #if defined TIZEN_CONNMAN_USE_BLACKLIST
 599 dbus_bool_t __connman_agent_request_blacklist_check(
 600                 const char *name, const char *security, const char *eap)
 601 {
 602         DBusMessage *message;
 603         DBusMessage *reply;
 604         DBusMessageIter iter;
 605         DBusError error;
 606         dbus_bool_t allowed = TRUE;
 607         const char *no_eap = "";
 608
 609         if (agent_path == NULL) {
 610                 DBG("agent is not registered");
 611                 return FALSE;
 612         }
 613
 614         if (name == NULL || security == NULL)
 615                 return FALSE;
 616
 617         message = dbus_message_new_method_call(agent_sender, agent_path,
 618                                         "net.netconfig.wifi",
 619                                         "CheckBlackList");
 620         if (message == NULL) {
 621                 DBG("dbus_message_new_method_call() failed");
 622                 return TRUE;
 623         }
 624
 625         dbus_message_iter_init_append(message, &iter);
 626         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
 627         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &security);
 628
 629         if (eap)
 630                 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &eap);
 631         else
 632                 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &no_eap);
 633
 634         dbus_error_init(&error);
 635
 636         reply = dbus_connection_send_with_reply_and_block(connection, message, 2000, &error);
 637         if (reply == NULL) {
 638                 if (dbus_error_is_set(&error) == TRUE) {
 639                         DBG("dbus_connection_send_with_reply_and_block() failed. "
 640                                         "dbus error [%s: %s]", error.name, error.message);
 641
 642                         dbus_error_free(&error);
 643                 } else
 644                         DBG("failed to get properties");
 645
 646                 dbus_message_unref(message);
 647
 648                 return TRUE;
 649         }
 650
 651         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 652                 DBG("failed to request blacklist check");
 653                 return TRUE;
 654         }
 655
 656         dbus_message_iter_init(reply, &iter);
 657         dbus_message_iter_get_basic(&iter, &allowed);
 658
 659         dbus_message_unref(message);
 660
 661         return allowed;
 662 }
 663 #endif
 664
 665 struct request_browser_reply_data {
 666         struct connman_service *service;
 667         browser_authentication_cb_t callback;
 668         void *user_data;
 669 };
 670
 671 static void request_browser_reply(DBusMessage *reply, void *user_data)
 672 {
 673         struct request_browser_reply_data *browser_reply_data = user_data;
 674         bool result = false;
 675         const char *error = NULL;
 676
 677         if (!reply) {
 678                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
 679                 goto done;
 680         }
 681
 682         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 683                 error = dbus_message_get_error_name(reply);
 684                 goto done;
 685         }
 686
 687         result = true;
 688
 689 done:
 690         browser_reply_data->callback(browser_reply_data->service, result,
 691                                         error, browser_reply_data->user_data);
 692         g_free(browser_reply_data);
 693 }
 694
 695 int __connman_agent_request_browser(struct connman_service *service,
 696                                 browser_authentication_cb_t callback,
 697                                 const char *url, void *user_data)
 698 {
 699         struct request_browser_reply_data *browser_reply_data;
 700         DBusMessage *message;
 701         DBusMessageIter iter;
 702         const char *path, *agent_sender, *agent_path;
 703         int err;
 704         void *agent;
 705
 706         agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
 707
 708         if (!service || !agent || !agent_path || !callback)
 709                 return -ESRCH;
 710
 711         if (!url)
 712                 url = "";
 713
 714         message = dbus_message_new_method_call(agent_sender, agent_path,
 715                                         CONNMAN_AGENT_INTERFACE,
 716                                         "RequestBrowser");
 717         if (!message)
 718                 return -ENOMEM;
 719
 720         dbus_message_iter_init_append(message, &iter);
 721
 722         path = __connman_service_get_path(service);
 723         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 724
 725         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url);
 726
 727         browser_reply_data = g_try_new0(struct request_browser_reply_data, 1);
 728         if (!browser_reply_data) {
 729                 dbus_message_unref(message);
 730                 return -ENOMEM;
 731         }
 732
 733         browser_reply_data->service = service;
 734         browser_reply_data->callback = callback;
 735         browser_reply_data->user_data = user_data;
 736
 737         err = connman_agent_queue_message(service, message,
 738                                 connman_timeout_browser_launch(),
 739                                 request_browser_reply, browser_reply_data,
 740                                 agent);
 741
 742         if (err < 0 && err != -EBUSY) {
 743                 DBG("error %d sending browser request", err);
 744                 dbus_message_unref(message);
 745                 g_free(browser_reply_data);
 746                 return err;
 747         }
 748
 749         dbus_message_unref(message);
 750
 751         return -EINPROGRESS;
 752 }
 753
 754 int __connman_agent_report_peer_error(struct connman_peer *peer,
 755                                         const char *path, const char *error,
 756                                         report_error_cb_t callback,
 757                                         const char *dbus_sender,
 758                                         void *user_data)
 759 {
 760         return connman_agent_report_error_full(peer, path, "ReportPeerError",
 761                                 error, callback, dbus_sender, user_data);
 762 }
 763
 764 static void request_peer_authorization_reply(DBusMessage *reply,
 765                                                         void *user_data)
 766 {
 767         struct request_input_reply *auth_reply = user_data;
 768         DBusMessageIter iter, dict;
 769         const char *error = NULL;
 770         bool choice_done = false;
 771         char *wpspin = NULL;
 772         char *key;
 773
 774         if (!reply) {
 775                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
 776                 goto done;
 777         }
 778
 779         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 780                 error = dbus_message_get_error_name(reply);
 781                 goto done;
 782         }
 783
 784         if (!check_reply_has_dict(reply))
 785                 goto done;
 786
 787         dbus_message_iter_init(reply, &iter);
 788         dbus_message_iter_recurse(&iter, &dict);
 789         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 790                 DBusMessageIter entry, value;
 791
 792                 dbus_message_iter_recurse(&dict, &entry);
 793                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 794                         break;
 795
 796                 dbus_message_iter_get_basic(&entry, &key);
 797
 798                 if (g_str_equal(key, "WPS")) {
 799                         choice_done = true;
 800
 801                         dbus_message_iter_next(&entry);
 802                         if (dbus_message_iter_get_arg_type(&entry)
 803                                                         != DBUS_TYPE_VARIANT)
 804                                 break;
 805                         dbus_message_iter_recurse(&entry, &value);
 806                         dbus_message_iter_get_basic(&value, &wpspin);
 807                         break;
 808                 }
 809                 dbus_message_iter_next(&dict);
 810         }
 811
 812         if (!auth_reply->wps_requested)
 813                 choice_done = true;
 814
 815 done:
 816         auth_reply->peer_callback(auth_reply->peer, choice_done, wpspin,
 817                                                 error, auth_reply->user_data);
 818
 819         g_free(auth_reply);
 820 }
 821
 822 int __connman_agent_request_peer_authorization(struct connman_peer *peer,
 823                                                 peer_wps_cb_t callback,
 824                                                 bool wps_requested,
 825                                                 const char *dbus_sender,
 826                                                 void *user_data)
 827 {
 828         struct request_wps_data wps = { .peer = true };
 829         const char *path, *agent_sender, *agent_path;
 830         struct request_input_reply *auth_reply;
 831         DBusMessageIter dict, iter;
 832         DBusMessage *message;
 833         void *agent;
 834         int err;
 835
 836         agent = connman_agent_get_info(dbus_sender, &agent_sender,
 837                                                         &agent_path);
 838         DBG("agent %p peer %p path %s", agent, peer, agent_path);
 839
 840         if (!peer || !agent || !agent_path || !callback)
 841                 return -ESRCH;
 842
 843         message = dbus_message_new_method_call(agent_sender, agent_path,
 844                         CONNMAN_AGENT_INTERFACE, "RequestPeerAuthorization");
 845         if (!message)
 846                 return -ENOMEM;
 847
 848         dbus_message_iter_init_append(message, &iter);
 849
 850         path = __connman_peer_get_path(peer);
 851         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 852
 853         connman_dbus_dict_open(&iter, &dict);
 854
 855         if (wps_requested)
 856                 connman_dbus_dict_append_dict(&dict, "WPS",
 857                                         request_input_append_wps, &wps);
 858
 859         connman_dbus_dict_close(&iter, &dict);
 860
 861         auth_reply = g_try_new0(struct request_input_reply, 1);
 862         if (!auth_reply) {
 863                 dbus_message_unref(message);
 864                 return -ENOMEM;
 865         }
 866
 867         auth_reply->peer = peer;
 868         auth_reply->peer_callback = callback;
 869         auth_reply->wps_requested = wps_requested;
 870         auth_reply->user_data = user_data;
 871
 872         err = connman_agent_queue_message(peer, message,
 873                                         connman_timeout_input_request(),
 874                                         request_peer_authorization_reply,
 875                                         auth_reply, agent);
 876         if (err < 0 && err != -EBUSY) {
 877                 DBG("error %d sending agent message", err);
 878                 dbus_message_unref(message);
 879                 g_free(auth_reply);
 880                 return err;
 881         }
 882
 883         dbus_message_unref(message);
 884
 885         return -EINPROGRESS;
 886 }