src/agent.c

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