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 struct request_browser_reply_data {
 599         struct connman_service *service;
 600         browser_authentication_cb_t callback;
 601         void *user_data;
 602 };
 603
 604 static void request_browser_reply(DBusMessage *reply, void *user_data)
 605 {
 606         struct request_browser_reply_data *browser_reply_data = user_data;
 607         bool result = false;
 608         const char *error = NULL;
 609
 610         if (!reply) {
 611                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
 612                 goto done;
 613         }
 614
 615         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 616                 error = dbus_message_get_error_name(reply);
 617                 goto done;
 618         }
 619
 620         result = true;
 621
 622 done:
 623         browser_reply_data->callback(browser_reply_data->service, result,
 624                                         error, browser_reply_data->user_data);
 625         g_free(browser_reply_data);
 626 }
 627
 628 int __connman_agent_request_browser(struct connman_service *service,
 629                                 browser_authentication_cb_t callback,
 630                                 const char *url, void *user_data)
 631 {
 632         struct request_browser_reply_data *browser_reply_data;
 633         DBusMessage *message;
 634         DBusMessageIter iter;
 635         const char *path, *agent_sender, *agent_path;
 636         int err;
 637         void *agent;
 638
 639         agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
 640
 641         if (!service || !agent || !agent_path || !callback)
 642                 return -ESRCH;
 643
 644         if (!url)
 645                 url = "";
 646
 647         message = dbus_message_new_method_call(agent_sender, agent_path,
 648                                         CONNMAN_AGENT_INTERFACE,
 649                                         "RequestBrowser");
 650         if (!message)
 651                 return -ENOMEM;
 652
 653         dbus_message_iter_init_append(message, &iter);
 654
 655         path = __connman_service_get_path(service);
 656         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 657
 658         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url);
 659
 660         browser_reply_data = g_try_new0(struct request_browser_reply_data, 1);
 661         if (!browser_reply_data) {
 662                 dbus_message_unref(message);
 663                 return -ENOMEM;
 664         }
 665
 666         browser_reply_data->service = service;
 667         browser_reply_data->callback = callback;
 668         browser_reply_data->user_data = user_data;
 669
 670         err = connman_agent_queue_message(service, message,
 671                                 connman_timeout_browser_launch(),
 672                                 request_browser_reply, browser_reply_data,
 673                                 agent);
 674
 675         if (err < 0 && err != -EBUSY) {
 676                 DBG("error %d sending browser request", err);
 677                 dbus_message_unref(message);
 678                 g_free(browser_reply_data);
 679                 return err;
 680         }
 681
 682         dbus_message_unref(message);
 683
 684         return -EINPROGRESS;
 685 }
 686
 687 int __connman_agent_report_peer_error(struct connman_peer *peer,
 688                                         const char *path, const char *error,
 689                                         report_error_cb_t callback,
 690                                         const char *dbus_sender,
 691                                         void *user_data)
 692 {
 693         return connman_agent_report_error_full(peer, path, "ReportPeerError",
 694                                 error, callback, dbus_sender, user_data);
 695 }
 696
 697 static void request_peer_authorization_reply(DBusMessage *reply,
 698                                                         void *user_data)
 699 {
 700         struct request_input_reply *auth_reply = user_data;
 701         DBusMessageIter iter, dict;
 702         const char *error = NULL;
 703         bool choice_done = false;
 704         char *wpspin = NULL;
 705         char *key;
 706
 707         if (!reply) {
 708                 error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
 709                 goto done;
 710         }
 711
 712         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 713                 error = dbus_message_get_error_name(reply);
 714                 goto done;
 715         }
 716
 717         if (!check_reply_has_dict(reply))
 718                 goto done;
 719
 720         dbus_message_iter_init(reply, &iter);
 721         dbus_message_iter_recurse(&iter, &dict);
 722         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 723                 DBusMessageIter entry, value;
 724
 725                 dbus_message_iter_recurse(&dict, &entry);
 726                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 727                         break;
 728
 729                 dbus_message_iter_get_basic(&entry, &key);
 730
 731                 if (g_str_equal(key, "WPS")) {
 732                         choice_done = true;
 733
 734                         dbus_message_iter_next(&entry);
 735                         if (dbus_message_iter_get_arg_type(&entry)
 736                                                         != DBUS_TYPE_VARIANT)
 737                                 break;
 738                         dbus_message_iter_recurse(&entry, &value);
 739                         dbus_message_iter_get_basic(&value, &wpspin);
 740                         break;
 741                 }
 742                 dbus_message_iter_next(&dict);
 743         }
 744
 745         if (!auth_reply->wps_requested)
 746                 choice_done = true;
 747
 748 done:
 749         auth_reply->peer_callback(auth_reply->peer, choice_done, wpspin,
 750                                                 error, auth_reply->user_data);
 751
 752         g_free(auth_reply);
 753 }
 754
 755 int __connman_agent_request_peer_authorization(struct connman_peer *peer,
 756                                                 peer_wps_cb_t callback,
 757                                                 bool wps_requested,
 758                                                 const char *dbus_sender,
 759                                                 void *user_data)
 760 {
 761         struct request_wps_data wps = { .peer = true };
 762         const char *path, *agent_sender, *agent_path;
 763         struct request_input_reply *auth_reply;
 764         DBusMessageIter dict, iter;
 765         DBusMessage *message;
 766         void *agent;
 767         int err;
 768
 769         agent = connman_agent_get_info(dbus_sender, &agent_sender,
 770                                                         &agent_path);
 771         DBG("agent %p peer %p path %s", agent, peer, agent_path);
 772
 773         if (!peer || !agent || !agent_path || !callback)
 774                 return -ESRCH;
 775
 776         message = dbus_message_new_method_call(agent_sender, agent_path,
 777                         CONNMAN_AGENT_INTERFACE, "RequestPeerAuthorization");
 778         if (!message)
 779                 return -ENOMEM;
 780
 781         dbus_message_iter_init_append(message, &iter);
 782
 783         path = __connman_peer_get_path(peer);
 784         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 785
 786         connman_dbus_dict_open(&iter, &dict);
 787
 788         if (wps_requested)
 789                 connman_dbus_dict_append_dict(&dict, "WPS",
 790                                         request_input_append_wps, &wps);
 791
 792         connman_dbus_dict_close(&iter, &dict);
 793
 794         auth_reply = g_try_new0(struct request_input_reply, 1);
 795         if (!auth_reply) {
 796                 dbus_message_unref(message);
 797                 return -ENOMEM;
 798         }
 799
 800         auth_reply->peer = peer;
 801         auth_reply->peer_callback = callback;
 802         auth_reply->wps_requested = wps_requested;
 803         auth_reply->user_data = user_data;
 804
 805         err = connman_agent_queue_message(peer, message,
 806                                         connman_timeout_input_request(),
 807                                         request_peer_authorization_reply,
 808                                         auth_reply, agent);
 809         if (err < 0 && err != -EBUSY) {
 810                 DBG("error %d sending agent message", err);
 811                 dbus_message_unref(message);
 812                 g_free(auth_reply);
 813                 return err;
 814         }
 815
 816         dbus_message_unref(message);
 817
 818         return -EINPROGRESS;
 819 }