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