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                 value = "psk";
 229                 break;
 230         case CONNMAN_SERVICE_SECURITY_8021X:
 231                 phase2 = __connman_service_get_phase2(service);
 232
 233                 if (phase2 && (
 234                                 g_str_has_suffix(phase2, "GTC") ||
 235                                 g_str_has_suffix(phase2, "OTP")))
 236                         value = "response";
 237                 else
 238                         value = "passphrase";
 239
 240                 break;
 241         default:
 242                 value = "string";
 243                 break;
 244         }
 245         connman_dbus_dict_append_basic(iter, "Type",
 246                                 DBUS_TYPE_STRING, &value);
 247         value = "mandatory";
 248         connman_dbus_dict_append_basic(iter, "Requirement",
 249                                 DBUS_TYPE_STRING, &value);
 250
 251         if (__connman_service_wps_enabled(service)) {
 252                 connman_dbus_dict_append_array(iter, "Alternates",
 253                                         DBUS_TYPE_STRING,
 254                                         request_input_append_alternates,
 255                                         "WPS");
 256         }
 257 }
 258
 259 struct request_wps_data {
 260         bool peer;
 261 };
 262
 263 static void request_input_append_wps(DBusMessageIter *iter, void *user_data)
 264 {
 265         struct request_wps_data *wps = user_data;
 266         const char *str = "wpspin";
 267
 268         connman_dbus_dict_append_basic(iter, "Type",
 269                                 DBUS_TYPE_STRING, &str);
 270         if (wps && wps->peer)
 271                 str = "mandatory";
 272         else
 273                 str = "alternate";
 274         connman_dbus_dict_append_basic(iter, "Requirement",
 275                                 DBUS_TYPE_STRING, &str);
 276 }
 277
 278 static void request_input_append_name(DBusMessageIter *iter, void *user_data)
 279 {
 280         const char *str = "string";
 281
 282         connman_dbus_dict_append_basic(iter, "Type",
 283                                 DBUS_TYPE_STRING, &str);
 284         str = "mandatory";
 285         connman_dbus_dict_append_basic(iter, "Requirement",
 286                                 DBUS_TYPE_STRING, &str);
 287         connman_dbus_dict_append_array(iter, "Alternates",
 288                                 DBUS_TYPE_STRING,
 289                                 request_input_append_alternates,
 290                                 "SSID");
 291 }
 292
 293 static void request_input_append_ssid(DBusMessageIter *iter, void *user_data)
 294 {
 295         const char *str = "ssid";
 296
 297         connman_dbus_dict_append_basic(iter, "Type",
 298                                 DBUS_TYPE_STRING, &str);
 299         str = "alternate";
 300         connman_dbus_dict_append_basic(iter, "Requirement",
 301                                 DBUS_TYPE_STRING, &str);
 302 }
 303
 304 static void request_input_append_password(DBusMessageIter *iter,
 305                                                         void *user_data)
 306 {
 307         char *str = "passphrase";
 308
 309         connman_dbus_dict_append_basic(iter, "Type",
 310                                 DBUS_TYPE_STRING, &str);
 311         str = "mandatory";
 312         connman_dbus_dict_append_basic(iter, "Requirement",
 313                                 DBUS_TYPE_STRING, &str);
 314 }
 315
 316 struct previous_passphrase_data {
 317         const char *passphrase;
 318         const char *type;
 319 };
 320
 321 static void request_input_append_previouspassphrase(DBusMessageIter *iter,
 322                                                         void *user_data)
 323 {
 324         struct previous_passphrase_data *data = user_data;
 325         const char *requirement = "informational";
 326
 327         connman_dbus_dict_append_basic(iter, "Type",
 328                                 DBUS_TYPE_STRING, &data->type);
 329
 330         connman_dbus_dict_append_basic(iter, "Requirement",
 331                                 DBUS_TYPE_STRING, &requirement);
 332
 333         connman_dbus_dict_append_basic(iter, "Value",
 334                                 DBUS_TYPE_STRING, &data->passphrase);
 335 }
 336
 337 static void previous_passphrase_handler(DBusMessageIter *iter,
 338                                         struct connman_service *service)
 339 {
 340         enum connman_service_security security;
 341         struct previous_passphrase_data data;
 342         struct connman_network *network;
 343
 344         network = __connman_service_get_network(service);
 345         data.passphrase = connman_network_get_string(network, "WiFi.PinWPS");
 346
 347         if (connman_network_get_bool(network, "WiFi.UseWPS") &&
 348                                                 data.passphrase) {
 349                 data.type = "wpspin";
 350         } else {
 351                 data.passphrase = __connman_service_get_passphrase(service);
 352                 if (!data.passphrase)
 353                         return;
 354
 355                 security = __connman_service_get_security(service);
 356                 switch (security) {
 357                 case CONNMAN_SERVICE_SECURITY_WEP:
 358                         data.type = "wep";
 359                         break;
 360                 case CONNMAN_SERVICE_SECURITY_PSK:
 361                         data.type  = "psk";
 362                         break;
 363                 /*
 364                  * This should never happen: no passphrase is set if security
 365                  * is not one of the above. */
 366                 default:
 367                         break;
 368                 }
 369         }
 370
 371         connman_dbus_dict_append_dict(iter, "PreviousPassphrase",
 372                         request_input_append_previouspassphrase, &data);
 373 }
 374
 375 static void request_input_login_reply(DBusMessage *reply, void *user_data)
 376 {
 377         struct request_input_reply *username_password_reply = user_data;
 378         const char *error = NULL;
 379         bool values_received = false;
 380         char *username = NULL;
 381         char *password = NULL;
 382         char *key;
 383         DBusMessageIter iter, dict;
 384
 385         if (!reply) {
 386                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
 387                 goto done;
 388         }
 389
 390         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 391                 error = dbus_message_get_error_name(reply);
 392                 goto done;
 393         }
 394
 395         if (!check_reply_has_dict(reply))
 396                 goto done;
 397
 398         values_received = true;
 399
 400         dbus_message_iter_init(reply, &iter);
 401         dbus_message_iter_recurse(&iter, &dict);
 402         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 403                 DBusMessageIter entry, value;
 404
 405                 dbus_message_iter_recurse(&dict, &entry);
 406                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 407                         break;
 408
 409                 dbus_message_iter_get_basic(&entry, &key);
 410
 411                 if (g_str_equal(key, "Username")) {
 412                         dbus_message_iter_next(&entry);
 413                         if (dbus_message_iter_get_arg_type(&entry)
 414                                                         != DBUS_TYPE_VARIANT)
 415                                 break;
 416                         dbus_message_iter_recurse(&entry, &value);
 417                         dbus_message_iter_get_basic(&value, &username);
 418
 419                 } else if (g_str_equal(key, "Password")) {
 420                         dbus_message_iter_next(&entry);
 421                         if (dbus_message_iter_get_arg_type(&entry) !=
 422                                                         DBUS_TYPE_VARIANT)
 423                                 break;
 424                         dbus_message_iter_recurse(&entry, &value);
 425                         dbus_message_iter_get_basic(&value, &password);
 426                 }
 427
 428                 dbus_message_iter_next(&dict);
 429         }
 430
 431 done:
 432         username_password_reply->service_callback(
 433                         username_password_reply->service, values_received,
 434                         NULL, 0, username, password, FALSE, NULL, error,
 435                         username_password_reply->user_data);
 436
 437         g_free(username_password_reply);
 438 }
 439
 440 int __connman_agent_request_passphrase_input(struct connman_service *service,
 441                                 authentication_cb_t callback,
 442                                 const char *dbus_sender, void *user_data)
 443 {
 444         DBusMessage *message;
 445         const char *path, *agent_sender, *agent_path;
 446         DBusMessageIter iter;
 447         DBusMessageIter dict;
 448         struct request_input_reply *passphrase_reply;
 449         int err;
 450         void *agent;
 451
 452         agent = connman_agent_get_info(dbus_sender, &agent_sender,
 453                                                         &agent_path);
 454
 455         DBG("agent %p service %p path %s", agent, service, agent_path);
 456
 457         if (!service || !agent || !agent_path || !callback)
 458                 return -ESRCH;
 459
 460         message = dbus_message_new_method_call(agent_sender, agent_path,
 461                                         CONNMAN_AGENT_INTERFACE,
 462                                         "RequestInput");
 463         if (!message)
 464                 return -ENOMEM;
 465
 466         dbus_message_iter_init_append(message, &iter);
 467
 468         path = __connman_service_get_path(service);
 469         dbus_message_iter_append_basic(&iter,
 470                                 DBUS_TYPE_OBJECT_PATH, &path);
 471
 472         connman_dbus_dict_open(&iter, &dict);
 473
 474         if (__connman_service_is_hidden(service)) {
 475                 connman_dbus_dict_append_dict(&dict, "Name",
 476                                         request_input_append_name, NULL);
 477                 connman_dbus_dict_append_dict(&dict, "SSID",
 478                                         request_input_append_ssid, NULL);
 479         }
 480
 481         if (__connman_service_get_security(service) ==
 482                         CONNMAN_SERVICE_SECURITY_8021X) {
 483                 connman_dbus_dict_append_dict(&dict, "Identity",
 484                                         request_input_append_identity, service);
 485         }
 486
 487         if (__connman_service_get_security(service) !=
 488                         CONNMAN_SERVICE_SECURITY_NONE) {
 489                 connman_dbus_dict_append_dict(&dict, "Passphrase",
 490                                 request_input_append_passphrase, service);
 491
 492                 previous_passphrase_handler(&dict, service);
 493         }
 494
 495         if (__connman_service_wps_enabled(service))
 496                 connman_dbus_dict_append_dict(&dict, "WPS",
 497                                 request_input_append_wps, NULL);
 498
 499         connman_dbus_dict_close(&iter, &dict);
 500
 501         passphrase_reply = g_try_new0(struct request_input_reply, 1);
 502         if (!passphrase_reply) {
 503                 dbus_message_unref(message);
 504                 return -ENOMEM;
 505         }
 506
 507         passphrase_reply->service = service;
 508         passphrase_reply->service_callback = callback;
 509         passphrase_reply->user_data = user_data;
 510
 511         err = connman_agent_queue_message(service, message,
 512                         connman_timeout_input_request(),
 513                         request_input_passphrase_reply,
 514                         passphrase_reply, agent);
 515
 516         if (err < 0 && err != -EBUSY) {
 517                 DBG("error %d sending agent message", err);
 518                 dbus_message_unref(message);
 519                 g_free(passphrase_reply);
 520                 return err;
 521         }
 522
 523         dbus_message_unref(message);
 524
 525         return -EINPROGRESS;
 526 }
 527
 528 int __connman_agent_request_login_input(struct connman_service *service,
 529                                 authentication_cb_t callback, void *user_data)
 530 {
 531         DBusMessage *message;
 532         const char *path, *agent_sender, *agent_path;
 533         DBusMessageIter iter;
 534         DBusMessageIter dict;
 535         struct request_input_reply *username_password_reply;
 536         int err;
 537         void *agent;
 538
 539         agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
 540
 541         if (!service || !agent || !agent_path || !callback)
 542                 return -ESRCH;
 543
 544         message = dbus_message_new_method_call(agent_sender, agent_path,
 545                                         CONNMAN_AGENT_INTERFACE,
 546                                         "RequestInput");
 547         if (!message)
 548                 return -ENOMEM;
 549
 550         dbus_message_iter_init_append(message, &iter);
 551
 552         path = __connman_service_get_path(service);
 553         dbus_message_iter_append_basic(&iter,
 554                                 DBUS_TYPE_OBJECT_PATH, &path);
 555
 556         connman_dbus_dict_open(&iter, &dict);
 557
 558         connman_dbus_dict_append_dict(&dict, "Username",
 559                                 request_input_append_identity, service);
 560
 561         connman_dbus_dict_append_dict(&dict, "Password",
 562                                 request_input_append_password, service);
 563
 564         connman_dbus_dict_close(&iter, &dict);
 565
 566         username_password_reply = g_try_new0(struct request_input_reply, 1);
 567         if (!username_password_reply) {
 568                 dbus_message_unref(message);
 569                 return -ENOMEM;
 570         }
 571
 572         username_password_reply->service = service;
 573         username_password_reply->service_callback = callback;
 574         username_password_reply->user_data = user_data;
 575
 576         err = connman_agent_queue_message(service, message,
 577                         connman_timeout_input_request(),
 578                         request_input_login_reply, username_password_reply,
 579                         agent);
 580         if (err < 0 && err != -EBUSY) {
 581                 DBG("error %d sending agent request", err);
 582                 dbus_message_unref(message);
 583                 g_free(username_password_reply);
 584                 return err;
 585         }
 586
 587         dbus_message_unref(message);
 588
 589         return -EINPROGRESS;
 590 }
 591
 592 struct request_browser_reply_data {
 593         struct connman_service *service;
 594         browser_authentication_cb_t callback;
 595         void *user_data;
 596 };
 597
 598 static void request_browser_reply(DBusMessage *reply, void *user_data)
 599 {
 600         struct request_browser_reply_data *browser_reply_data = user_data;
 601         bool result = false;
 602         const char *error = NULL;
 603
 604         if (!reply) {
 605                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
 606                 goto done;
 607         }
 608
 609         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 610                 error = dbus_message_get_error_name(reply);
 611                 goto done;
 612         }
 613
 614         result = true;
 615
 616 done:
 617         browser_reply_data->callback(browser_reply_data->service, result,
 618                                         error, browser_reply_data->user_data);
 619         g_free(browser_reply_data);
 620 }
 621
 622 int __connman_agent_request_browser(struct connman_service *service,
 623                                 browser_authentication_cb_t callback,
 624                                 const char *url, void *user_data)
 625 {
 626         struct request_browser_reply_data *browser_reply_data;
 627         DBusMessage *message;
 628         DBusMessageIter iter;
 629         const char *path, *agent_sender, *agent_path;
 630         int err;
 631         void *agent;
 632
 633         agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
 634
 635         if (!service || !agent || !agent_path || !callback)
 636                 return -ESRCH;
 637
 638         if (!url)
 639                 url = "";
 640
 641         message = dbus_message_new_method_call(agent_sender, agent_path,
 642                                         CONNMAN_AGENT_INTERFACE,
 643                                         "RequestBrowser");
 644         if (!message)
 645                 return -ENOMEM;
 646
 647         dbus_message_iter_init_append(message, &iter);
 648
 649         path = __connman_service_get_path(service);
 650         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 651
 652         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url);
 653
 654         browser_reply_data = g_try_new0(struct request_browser_reply_data, 1);
 655         if (!browser_reply_data) {
 656                 dbus_message_unref(message);
 657                 return -ENOMEM;
 658         }
 659
 660         browser_reply_data->service = service;
 661         browser_reply_data->callback = callback;
 662         browser_reply_data->user_data = user_data;
 663
 664         err = connman_agent_queue_message(service, message,
 665                                 connman_timeout_browser_launch(),
 666                                 request_browser_reply, browser_reply_data,
 667                                 agent);
 668
 669         if (err < 0 && err != -EBUSY) {
 670                 DBG("error %d sending browser request", err);
 671                 dbus_message_unref(message);
 672                 g_free(browser_reply_data);
 673                 return err;
 674         }
 675
 676         dbus_message_unref(message);
 677
 678         return -EINPROGRESS;
 679 }
 680
 681 int __connman_agent_report_peer_error(struct connman_peer *peer,
 682                                         const char *path, const char *error,
 683                                         report_error_cb_t callback,
 684                                         const char *dbus_sender,
 685                                         void *user_data)
 686 {
 687         return connman_agent_report_error_full(peer, path, "ReportPeerError",
 688                                 error, callback, dbus_sender, user_data);
 689 }
 690
 691 static void request_peer_authorization_reply(DBusMessage *reply,
 692                                                         void *user_data)
 693 {
 694         struct request_input_reply *auth_reply = user_data;
 695         DBusMessageIter iter, dict;
 696         const char *error = NULL;
 697         bool choice_done = false;
 698         char *wpspin = NULL;
 699         char *key;
 700
 701         if (!reply) {
 702                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
 703                 goto done;
 704         }
 705
 706         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 707                 error = dbus_message_get_error_name(reply);
 708                 goto done;
 709         }
 710
 711         if (!check_reply_has_dict(reply))
 712                 goto done;
 713
 714         dbus_message_iter_init(reply, &iter);
 715         dbus_message_iter_recurse(&iter, &dict);
 716         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 717                 DBusMessageIter entry, value;
 718
 719                 dbus_message_iter_recurse(&dict, &entry);
 720                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 721                         break;
 722
 723                 dbus_message_iter_get_basic(&entry, &key);
 724
 725                 if (g_str_equal(key, "WPS")) {
 726                         choice_done = true;
 727
 728                         dbus_message_iter_next(&entry);
 729                         if (dbus_message_iter_get_arg_type(&entry)
 730                                                         != DBUS_TYPE_VARIANT)
 731                                 break;
 732                         dbus_message_iter_recurse(&entry, &value);
 733                         dbus_message_iter_get_basic(&value, &wpspin);
 734                         break;
 735                 }
 736                 dbus_message_iter_next(&dict);
 737         }
 738
 739         if (!auth_reply->wps_requested)
 740                 choice_done = true;
 741
 742 done:
 743         auth_reply->peer_callback(auth_reply->peer, choice_done, wpspin,
 744                                                 error, auth_reply->user_data);
 745
 746         g_free(auth_reply);
 747 }
 748
 749 int __connman_agent_request_peer_authorization(struct connman_peer *peer,
 750                                                 peer_wps_cb_t callback,
 751                                                 bool wps_requested,
 752                                                 const char *dbus_sender,
 753                                                 void *user_data)
 754 {
 755         struct request_wps_data wps = { .peer = true };
 756         const char *path, *agent_sender, *agent_path;
 757         struct request_input_reply *auth_reply;
 758         DBusMessageIter dict, iter;
 759         DBusMessage *message;
 760         void *agent;
 761         int err;
 762
 763         agent = connman_agent_get_info(dbus_sender, &agent_sender,
 764                                                         &agent_path);
 765         DBG("agent %p peer %p path %s", agent, peer, agent_path);
 766
 767         if (!peer || !agent || !agent_path || !callback)
 768                 return -ESRCH;
 769
 770         message = dbus_message_new_method_call(agent_sender, agent_path,
 771                         CONNMAN_AGENT_INTERFACE, "RequestPeerAuthorization");
 772         if (!message)
 773                 return -ENOMEM;
 774
 775         dbus_message_iter_init_append(message, &iter);
 776
 777         path = __connman_peer_get_path(peer);
 778         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 779
 780         connman_dbus_dict_open(&iter, &dict);
 781
 782         if (wps_requested)
 783                 connman_dbus_dict_append_dict(&dict, "WPS",
 784                                         request_input_append_wps, &wps);
 785
 786         connman_dbus_dict_close(&iter, &dict);
 787
 788         auth_reply = g_try_new0(struct request_input_reply, 1);
 789         if (!auth_reply) {
 790                 dbus_message_unref(message);
 791                 return -ENOMEM;
 792         }
 793
 794         auth_reply->peer = peer;
 795         auth_reply->peer_callback = callback;
 796         auth_reply->wps_requested = wps_requested;
 797         auth_reply->user_data = user_data;
 798
 799         err = connman_agent_queue_message(peer, message,
 800                                         connman_timeout_input_request(),
 801                                         request_peer_authorization_reply,
 802                                         auth_reply, agent);
 803         if (err < 0 && err != -EBUSY) {
 804                 DBG("error %d sending agent message", err);
 805                 dbus_message_unref(message);
 806                 g_free(auth_reply);
 807                 return err;
 808         }
 809
 810         dbus_message_unref(message);
 811
 812         return -EINPROGRESS;
 813 }