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         authentication_cb_t callback;
  60         void *user_data;
  61 };
  62
  63 static void request_input_passphrase_reply(DBusMessage *reply, void *user_data)
  64 {
  65         struct request_input_reply *passphrase_reply = user_data;
  66         bool values_received = false;
  67         bool wps = false;
  68         const char *error = NULL;
  69         char *identity = NULL;
  70         char *passphrase = NULL;
  71         char *wpspin = NULL;
  72         char *key;
  73         char *name = NULL;
  74         int name_len = 0;
  75         DBusMessageIter iter, dict;
  76
  77         if (!reply)
  78                 goto out;
  79
  80         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
  81                 error = dbus_message_get_error_name(reply);
  82                 goto done;
  83         }
  84
  85         if (!check_reply_has_dict(reply))
  86                 goto done;
  87
  88         values_received = true;
  89
  90         dbus_message_iter_init(reply, &iter);
  91         dbus_message_iter_recurse(&iter, &dict);
  92         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
  93                 DBusMessageIter entry, value;
  94
  95                 dbus_message_iter_recurse(&dict, &entry);
  96                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
  97                         break;
  98
  99                 dbus_message_iter_get_basic(&entry, &key);
 100
 101                 if (g_str_equal(key, "Identity")) {
 102                         dbus_message_iter_next(&entry);
 103                         if (dbus_message_iter_get_arg_type(&entry)
 104                                                         != DBUS_TYPE_VARIANT)
 105                                 break;
 106                         dbus_message_iter_recurse(&entry, &value);
 107                         dbus_message_iter_get_basic(&value, &identity);
 108
 109                 } else if (g_str_equal(key, "Passphrase")) {
 110                         dbus_message_iter_next(&entry);
 111                         if (dbus_message_iter_get_arg_type(&entry)
 112                                                         != DBUS_TYPE_VARIANT)
 113                                 break;
 114                         dbus_message_iter_recurse(&entry, &value);
 115                         dbus_message_iter_get_basic(&value, &passphrase);
 116
 117                 } else if (g_str_equal(key, "WPS")) {
 118                         wps = true;
 119
 120                         dbus_message_iter_next(&entry);
 121                         if (dbus_message_iter_get_arg_type(&entry)
 122                                                         != DBUS_TYPE_VARIANT)
 123                                 break;
 124                         dbus_message_iter_recurse(&entry, &value);
 125                         dbus_message_iter_get_basic(&value, &wpspin);
 126                         break;
 127                 } else if (g_str_equal(key, "Name")) {
 128                         dbus_message_iter_next(&entry);
 129                         if (dbus_message_iter_get_arg_type(&entry)
 130                                                         != DBUS_TYPE_VARIANT)
 131                                 break;
 132                         dbus_message_iter_recurse(&entry, &value);
 133                         dbus_message_iter_get_basic(&value, &name);
 134                         name_len = strlen(name);
 135                 } else if (g_str_equal(key, "SSID")) {
 136                         dbus_message_iter_next(&entry);
 137                         if (dbus_message_iter_get_arg_type(&entry)
 138                                                         != DBUS_TYPE_VARIANT)
 139                                 break;
 140                         dbus_message_iter_recurse(&entry, &value);
 141                         if (dbus_message_iter_get_arg_type(&value)
 142                                                         != DBUS_TYPE_VARIANT)
 143                                 break;
 144                         if (dbus_message_iter_get_element_type(&value)
 145                                                         != DBUS_TYPE_VARIANT)
 146                                 break;
 147                         dbus_message_iter_get_fixed_array(&value, &name,
 148                                                         &name_len);
 149                 }
 150                 dbus_message_iter_next(&dict);
 151         }
 152
 153 done:
 154         passphrase_reply->callback(passphrase_reply->service, values_received,
 155                                 name, name_len,
 156                                 identity, passphrase,
 157                                 wps, wpspin, error,
 158                                 passphrase_reply->user_data);
 159
 160 out:
 161         g_free(passphrase_reply);
 162 }
 163
 164 static void request_input_append_alternates(DBusMessageIter *iter,
 165                                                         void *user_data)
 166 {
 167         const char *str = user_data;
 168         char **alternates, **alternative;
 169
 170         if (!str)
 171                 return;
 172
 173         alternates = g_strsplit(str, ",", 0);
 174         if (!alternates)
 175                 return;
 176
 177         for (alternative = alternates; *alternative; alternative++)
 178                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
 179                                                                 alternative);
 180
 181         g_strfreev(alternates);
 182 }
 183
 184 static void request_input_append_identity(DBusMessageIter *iter,
 185                                                         void *user_data)
 186 {
 187         char *str = "string";
 188
 189         connman_dbus_dict_append_basic(iter, "Type",
 190                                 DBUS_TYPE_STRING, &str);
 191         str = "mandatory";
 192         connman_dbus_dict_append_basic(iter, "Requirement",
 193                                 DBUS_TYPE_STRING, &str);
 194 }
 195
 196 static void request_input_append_passphrase(DBusMessageIter *iter,
 197                                                         void *user_data)
 198 {
 199         struct connman_service *service = user_data;
 200         char *value;
 201         const char *phase2;
 202
 203         switch (__connman_service_get_security(service)) {
 204         case CONNMAN_SERVICE_SECURITY_WEP:
 205                 value = "wep";
 206                 break;
 207         case CONNMAN_SERVICE_SECURITY_PSK:
 208                 value = "psk";
 209                 break;
 210         case CONNMAN_SERVICE_SECURITY_8021X:
 211                 phase2 = __connman_service_get_phase2(service);
 212
 213                 if (phase2 && (
 214                                 g_str_has_suffix(phase2, "GTC") ||
 215                                 g_str_has_suffix(phase2, "OTP")))
 216                         value = "response";
 217                 else
 218                         value = "passphrase";
 219
 220                 break;
 221         default:
 222                 value = "string";
 223                 break;
 224         }
 225         connman_dbus_dict_append_basic(iter, "Type",
 226                                 DBUS_TYPE_STRING, &value);
 227         value = "mandatory";
 228         connman_dbus_dict_append_basic(iter, "Requirement",
 229                                 DBUS_TYPE_STRING, &value);
 230
 231         if (__connman_service_wps_enabled(service)) {
 232                 connman_dbus_dict_append_array(iter, "Alternates",
 233                                         DBUS_TYPE_STRING,
 234                                         request_input_append_alternates,
 235                                         "WPS");
 236         }
 237 }
 238
 239 static void request_input_append_wps(DBusMessageIter *iter, void *user_data)
 240 {
 241         const char *str = "wpspin";
 242
 243         connman_dbus_dict_append_basic(iter, "Type",
 244                                 DBUS_TYPE_STRING, &str);
 245         str = "alternate";
 246         connman_dbus_dict_append_basic(iter, "Requirement",
 247                                 DBUS_TYPE_STRING, &str);
 248 }
 249
 250 static void request_input_append_name(DBusMessageIter *iter, void *user_data)
 251 {
 252         const char *str = "string";
 253
 254         connman_dbus_dict_append_basic(iter, "Type",
 255                                 DBUS_TYPE_STRING, &str);
 256         str = "mandatory";
 257         connman_dbus_dict_append_basic(iter, "Requirement",
 258                                 DBUS_TYPE_STRING, &str);
 259         connman_dbus_dict_append_array(iter, "Alternates",
 260                                 DBUS_TYPE_STRING,
 261                                 request_input_append_alternates,
 262                                 "SSID");
 263 }
 264
 265 static void request_input_append_ssid(DBusMessageIter *iter, void *user_data)
 266 {
 267         const char *str = "ssid";
 268
 269         connman_dbus_dict_append_basic(iter, "Type",
 270                                 DBUS_TYPE_STRING, &str);
 271         str = "alternate";
 272         connman_dbus_dict_append_basic(iter, "Requirement",
 273                                 DBUS_TYPE_STRING, &str);
 274 }
 275
 276 static void request_input_append_password(DBusMessageIter *iter,
 277                                                         void *user_data)
 278 {
 279         char *str = "passphrase";
 280
 281         connman_dbus_dict_append_basic(iter, "Type",
 282                                 DBUS_TYPE_STRING, &str);
 283         str = "mandatory";
 284         connman_dbus_dict_append_basic(iter, "Requirement",
 285                                 DBUS_TYPE_STRING, &str);
 286 }
 287
 288 struct previous_passphrase_data {
 289         const char *passphrase;
 290         const char *type;
 291 };
 292
 293 static void request_input_append_previouspassphrase(DBusMessageIter *iter,
 294                                                         void *user_data)
 295 {
 296         struct previous_passphrase_data *data = user_data;
 297         const char *requirement = "informational";
 298
 299         connman_dbus_dict_append_basic(iter, "Type",
 300                                 DBUS_TYPE_STRING, &data->type);
 301
 302         connman_dbus_dict_append_basic(iter, "Requirement",
 303                                 DBUS_TYPE_STRING, &requirement);
 304
 305         connman_dbus_dict_append_basic(iter, "Value",
 306                                 DBUS_TYPE_STRING, &data->passphrase);
 307 }
 308
 309 static void previous_passphrase_handler(DBusMessageIter *iter,
 310                                         struct connman_service *service)
 311 {
 312         enum connman_service_security security;
 313         struct previous_passphrase_data data;
 314         struct connman_network *network;
 315
 316         network = __connman_service_get_network(service);
 317         data.passphrase = connman_network_get_string(network, "WiFi.PinWPS");
 318
 319         if (connman_network_get_bool(network, "WiFi.UseWPS") &&
 320                                                 data.passphrase) {
 321                 data.type = "wpspin";
 322         } else {
 323                 data.passphrase = __connman_service_get_passphrase(service);
 324                 if (!data.passphrase)
 325                         return;
 326
 327                 security = __connman_service_get_security(service);
 328                 switch (security) {
 329                 case CONNMAN_SERVICE_SECURITY_WEP:
 330                         data.type = "wep";
 331                         break;
 332                 case CONNMAN_SERVICE_SECURITY_PSK:
 333                         data.type  = "psk";
 334                         break;
 335                 /*
 336                  * This should never happen: no passphrase is set if security
 337                  * is not one of the above. */
 338                 default:
 339                         break;
 340                 }
 341         }
 342
 343         connman_dbus_dict_append_dict(iter, "PreviousPassphrase",
 344                         request_input_append_previouspassphrase, &data);
 345 }
 346
 347 static void request_input_login_reply(DBusMessage *reply, void *user_data)
 348 {
 349         struct request_input_reply *username_password_reply = user_data;
 350         const char *error = NULL;
 351         bool values_received = false;
 352         char *username = NULL;
 353         char *password = NULL;
 354         char *key;
 355         DBusMessageIter iter, dict;
 356
 357         if (!reply)
 358                 goto out;
 359
 360         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 361                 error = dbus_message_get_error_name(reply);
 362                 goto done;
 363         }
 364
 365         if (!check_reply_has_dict(reply))
 366                 goto done;
 367
 368         values_received = true;
 369
 370         dbus_message_iter_init(reply, &iter);
 371         dbus_message_iter_recurse(&iter, &dict);
 372         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 373                 DBusMessageIter entry, value;
 374
 375                 dbus_message_iter_recurse(&dict, &entry);
 376                 if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
 377                         break;
 378
 379                 dbus_message_iter_get_basic(&entry, &key);
 380
 381                 if (g_str_equal(key, "Username")) {
 382                         dbus_message_iter_next(&entry);
 383                         if (dbus_message_iter_get_arg_type(&entry)
 384                                                         != DBUS_TYPE_VARIANT)
 385                                 break;
 386                         dbus_message_iter_recurse(&entry, &value);
 387                         dbus_message_iter_get_basic(&value, &username);
 388
 389                 } else if (g_str_equal(key, "Password")) {
 390                         dbus_message_iter_next(&entry);
 391                         if (dbus_message_iter_get_arg_type(&entry) !=
 392                                                         DBUS_TYPE_VARIANT)
 393                                 break;
 394                         dbus_message_iter_recurse(&entry, &value);
 395                         dbus_message_iter_get_basic(&value, &password);
 396                 }
 397
 398                 dbus_message_iter_next(&dict);
 399         }
 400
 401 done:
 402         username_password_reply->callback(username_password_reply->service,
 403                                         values_received, NULL, 0,
 404                                         username, password,
 405                                         FALSE, NULL, error,
 406                                         username_password_reply->user_data);
 407
 408 out:
 409         g_free(username_password_reply);
 410 }
 411
 412 int __connman_agent_request_passphrase_input(struct connman_service *service,
 413                                 authentication_cb_t callback,
 414                                 const char *dbus_sender, void *user_data)
 415 {
 416         DBusMessage *message;
 417         const char *path, *agent_sender, *agent_path;
 418         DBusMessageIter iter;
 419         DBusMessageIter dict;
 420         struct request_input_reply *passphrase_reply;
 421         int err;
 422         void *agent;
 423
 424         agent = connman_agent_get_info(dbus_sender, &agent_sender,
 425                                                         &agent_path);
 426
 427         DBG("agent %p service %p path %s", agent, service, agent_path);
 428
 429         if (!service || !agent || !agent_path || !callback)
 430                 return -ESRCH;
 431
 432         message = dbus_message_new_method_call(agent_sender, agent_path,
 433                                         CONNMAN_AGENT_INTERFACE,
 434                                         "RequestInput");
 435         if (!message)
 436                 return -ENOMEM;
 437
 438         dbus_message_iter_init_append(message, &iter);
 439
 440         path = __connman_service_get_path(service);
 441         dbus_message_iter_append_basic(&iter,
 442                                 DBUS_TYPE_OBJECT_PATH, &path);
 443
 444         connman_dbus_dict_open(&iter, &dict);
 445
 446         if (__connman_service_is_hidden(service)) {
 447                 connman_dbus_dict_append_dict(&dict, "Name",
 448                                         request_input_append_name, NULL);
 449                 connman_dbus_dict_append_dict(&dict, "SSID",
 450                                         request_input_append_ssid, NULL);
 451         }
 452
 453         if (__connman_service_get_security(service) ==
 454                         CONNMAN_SERVICE_SECURITY_8021X) {
 455                 connman_dbus_dict_append_dict(&dict, "Identity",
 456                                         request_input_append_identity, service);
 457         }
 458
 459         if (__connman_service_get_security(service) !=
 460                         CONNMAN_SERVICE_SECURITY_NONE) {
 461                 connman_dbus_dict_append_dict(&dict, "Passphrase",
 462                                 request_input_append_passphrase, service);
 463
 464                 previous_passphrase_handler(&dict, service);
 465         }
 466
 467         if (__connman_service_wps_enabled(service))
 468                 connman_dbus_dict_append_dict(&dict, "WPS",
 469                                 request_input_append_wps, NULL);
 470
 471         connman_dbus_dict_close(&iter, &dict);
 472
 473         passphrase_reply = g_try_new0(struct request_input_reply, 1);
 474         if (!passphrase_reply) {
 475                 dbus_message_unref(message);
 476                 return -ENOMEM;
 477         }
 478
 479         passphrase_reply->service = service;
 480         passphrase_reply->callback = callback;
 481         passphrase_reply->user_data = user_data;
 482
 483         err = connman_agent_queue_message(service, message,
 484                         connman_timeout_input_request(),
 485                         request_input_passphrase_reply,
 486                         passphrase_reply, agent);
 487
 488         if (err < 0 && err != -EBUSY) {
 489                 DBG("error %d sending agent message", err);
 490                 dbus_message_unref(message);
 491                 g_free(passphrase_reply);
 492                 return err;
 493         }
 494
 495         dbus_message_unref(message);
 496
 497         return -EINPROGRESS;
 498 }
 499
 500 int __connman_agent_request_login_input(struct connman_service *service,
 501                                 authentication_cb_t callback, void *user_data)
 502 {
 503         DBusMessage *message;
 504         const char *path, *agent_sender, *agent_path;
 505         DBusMessageIter iter;
 506         DBusMessageIter dict;
 507         struct request_input_reply *username_password_reply;
 508         int err;
 509         void *agent;
 510
 511         agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
 512
 513         if (!service || !agent || !agent_path || !callback)
 514                 return -ESRCH;
 515
 516         message = dbus_message_new_method_call(agent_sender, agent_path,
 517                                         CONNMAN_AGENT_INTERFACE,
 518                                         "RequestInput");
 519         if (!message)
 520                 return -ENOMEM;
 521
 522         dbus_message_iter_init_append(message, &iter);
 523
 524         path = __connman_service_get_path(service);
 525         dbus_message_iter_append_basic(&iter,
 526                                 DBUS_TYPE_OBJECT_PATH, &path);
 527
 528         connman_dbus_dict_open(&iter, &dict);
 529
 530         connman_dbus_dict_append_dict(&dict, "Username",
 531                                 request_input_append_identity, service);
 532
 533         connman_dbus_dict_append_dict(&dict, "Password",
 534                                 request_input_append_password, service);
 535
 536         connman_dbus_dict_close(&iter, &dict);
 537
 538         username_password_reply = g_try_new0(struct request_input_reply, 1);
 539         if (!username_password_reply) {
 540                 dbus_message_unref(message);
 541                 return -ENOMEM;
 542         }
 543
 544         username_password_reply->service = service;
 545         username_password_reply->callback = callback;
 546         username_password_reply->user_data = user_data;
 547
 548         err = connman_agent_queue_message(service, message,
 549                         connman_timeout_input_request(),
 550                         request_input_login_reply, username_password_reply,
 551                         agent);
 552         if (err < 0 && err != -EBUSY) {
 553                 DBG("error %d sending agent request", err);
 554                 dbus_message_unref(message);
 555                 g_free(username_password_reply);
 556                 return err;
 557         }
 558
 559         dbus_message_unref(message);
 560
 561         return -EINPROGRESS;
 562 }
 563
 564 struct request_browser_reply_data {
 565         struct connman_service *service;
 566         browser_authentication_cb_t callback;
 567         void *user_data;
 568 };
 569
 570 static void request_browser_reply(DBusMessage *reply, void *user_data)
 571 {
 572         struct request_browser_reply_data *browser_reply_data = user_data;
 573         bool result = false;
 574         const char *error = NULL;
 575
 576         if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 577                 error = dbus_message_get_error_name(reply);
 578                 goto done;
 579         }
 580
 581         result = true;
 582
 583 done:
 584         browser_reply_data->callback(browser_reply_data->service, result,
 585                                         error, browser_reply_data->user_data);
 586         g_free(browser_reply_data);
 587 }
 588
 589 int __connman_agent_request_browser(struct connman_service *service,
 590                                 browser_authentication_cb_t callback,
 591                                 const char *url, void *user_data)
 592 {
 593         struct request_browser_reply_data *browser_reply_data;
 594         DBusMessage *message;
 595         DBusMessageIter iter;
 596         const char *path, *agent_sender, *agent_path;
 597         int err;
 598         void *agent;
 599
 600         agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
 601
 602         if (!service || !agent || !agent_path || !callback)
 603                 return -ESRCH;
 604
 605         if (!url)
 606                 url = "";
 607
 608         message = dbus_message_new_method_call(agent_sender, agent_path,
 609                                         CONNMAN_AGENT_INTERFACE,
 610                                         "RequestBrowser");
 611         if (!message)
 612                 return -ENOMEM;
 613
 614         dbus_message_iter_init_append(message, &iter);
 615
 616         path = __connman_service_get_path(service);
 617         dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
 618
 619         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url);
 620
 621         browser_reply_data = g_try_new0(struct request_browser_reply_data, 1);
 622         if (!browser_reply_data) {
 623                 dbus_message_unref(message);
 624                 return -ENOMEM;
 625         }
 626
 627         browser_reply_data->service = service;
 628         browser_reply_data->callback = callback;
 629         browser_reply_data->user_data = user_data;
 630
 631         err = connman_agent_queue_message(service, message,
 632                                 connman_timeout_browser_launch(),
 633                                 request_browser_reply, browser_reply_data,
 634                                 agent);
 635
 636         if (err < 0 && err != -EBUSY) {
 637                 DBG("error %d sending browser request", err);
 638                 dbus_message_unref(message);
 639                 g_free(browser_reply_data);
 640                 return err;
 641         }
 642
 643         dbus_message_unref(message);
 644
 645         return -EINPROGRESS;
 646 }