plugins/iwd.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2016  BMW Car IT GmbH.
   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 <string.h>
  28 #include <stdbool.h>
  29 #include <linux/if_ether.h>
  30
  31 #define CONNMAN_API_SUBJECT_TO_CHANGE
  32 #include <connman/plugin.h>
  33 #include <connman/dbus.h>
  34 #include <connman/network.h>
  35 #include <connman/technology.h>
  36 #include <connman/inet.h>
  37 #include <gdbus.h>
  38
  39 static DBusConnection *connection;
  40 static GDBusClient *client;
  41 static GDBusProxy *agent_proxy;
  42 static GHashTable *adapters;
  43 static GHashTable *devices;
  44 static GHashTable *networks;
  45 static bool agent_registered;
  46
  47 #define IWD_SERVICE                     "net.connman.iwd"
  48 #define IWD_PATH                        "/"
  49 #define IWD_AGENT_MANAGER_INTERFACE     "net.connman.iwd.AgentManager"
  50 #define IWD_ADAPTER_INTERFACE           "net.connman.iwd.Adapter"
  51 #define IWD_DEVICE_INTERFACE            "net.connman.iwd.Device"
  52 #define IWD_NETWORK_INTERFACE           "net.connman.iwd.Network"
  53
  54 #define IWD_AGENT_INTERFACE             "net.connman.iwd.Agent"
  55 #define IWD_AGENT_ERROR_INTERFACE       "net.connman.iwd.Agent.Error"
  56 #define AGENT_PATH                      "/net/connman/iwd_agent"
  57
  58 enum iwd_device_state {
  59         IWD_DEVICE_STATE_UNKNOWN,
  60         IWD_DEVICE_STATE_CONNECTED,
  61         IWD_DEVICE_STATE_DISCONNECTED,
  62         IWD_DEVICE_STATE_CONNECTING,
  63         IWD_DEVICE_STATE_DISCONNECTING,
  64 };
  65
  66 struct iwd_adapter {
  67         GDBusProxy *proxy;
  68         char *path;
  69         char *vendor;
  70         char *model;
  71         bool powered;
  72 };
  73
  74 struct iwd_device {
  75         GDBusProxy *proxy;
  76         char *path;
  77         char *adapter;
  78         char *name;
  79         char *address;
  80         enum iwd_device_state state;
  81         bool powered;
  82         bool scanning;
  83
  84         struct connman_device *device;
  85 };
  86
  87 struct iwd_network {
  88         GDBusProxy *proxy;
  89         char *path;
  90         char *device;
  91         char *name;
  92         char *type;
  93         bool connected;
  94
  95         struct iwd_device *iwdd;
  96         struct connman_network *network;
  97 };
  98
  99 static enum iwd_device_state string2state(const char *str)
 100 {
 101         if (!strcmp(str, "connected"))
 102                 return IWD_DEVICE_STATE_CONNECTED;
 103         else if (!strcmp(str, "disconnected"))
 104                 return IWD_DEVICE_STATE_DISCONNECTED;
 105         else if (!strcmp(str, "connecting"))
 106                 return IWD_DEVICE_STATE_CONNECTING;
 107         else if (!strcmp(str, "disconnecting"))
 108                 return IWD_DEVICE_STATE_DISCONNECTING;
 109
 110         return IWD_DEVICE_STATE_UNKNOWN;
 111 }
 112
 113 static const char *state2string(enum iwd_device_state state)
 114 {
 115         switch (state) {
 116         case IWD_DEVICE_STATE_CONNECTED:
 117                 return "connected";
 118         case IWD_DEVICE_STATE_DISCONNECTED:
 119                 return "disconnected";
 120         case IWD_DEVICE_STATE_CONNECTING:
 121                 return "connecting";
 122         case IWD_DEVICE_STATE_DISCONNECTING:
 123                 return "disconnecting";
 124         default:
 125                 break;
 126         }
 127
 128         return "unknown";
 129 }
 130
 131 static const char *proxy_get_string(GDBusProxy *proxy, const char *property)
 132 {
 133         DBusMessageIter iter;
 134         const char *str;
 135
 136         if (!g_dbus_proxy_get_property(proxy, property, &iter))
 137                 return NULL;
 138
 139         dbus_message_iter_get_basic(&iter, &str);
 140
 141         return str;
 142 }
 143
 144 static bool proxy_get_bool(GDBusProxy *proxy, const char *property)
 145 {
 146         DBusMessageIter iter;
 147         dbus_bool_t value;
 148
 149         if (!g_dbus_proxy_get_property(proxy, property, &iter))
 150                 return false;
 151
 152         dbus_message_iter_get_basic(&iter, &value);
 153
 154         return value;
 155 }
 156
 157 static void address2ident(const char *address, char *ident)
 158 {
 159         int i;
 160
 161         for (i = 0; i < ETH_ALEN; i++) {
 162                 ident[i * 2] = address[i * 3];
 163                 ident[i * 2 + 1] = address[i * 3 + 1];
 164         }
 165         ident[ETH_ALEN * 2] = '\0';
 166 }
 167
 168 static int cm_network_probe(struct connman_network *network)
 169 {
 170         GHashTableIter iter;
 171         gpointer key, value;
 172
 173         g_hash_table_iter_init(&iter, networks);
 174
 175         while (g_hash_table_iter_next(&iter, &key, &value)) {
 176                 struct iwd_network *iwdn = value;
 177
 178                 if (network == iwdn->network)
 179                         return 0;
 180         }
 181
 182         return -EOPNOTSUPP;
 183 }
 184
 185 static void update_network_connected(struct iwd_network *iwdn)
 186 {
 187         struct iwd_device *iwdd;
 188         int index;
 189
 190         iwdd = g_hash_table_lookup(devices, iwdn->device);
 191         if (!iwdd)
 192                 return;
 193
 194         index = connman_inet_ifindex(iwdd->name);
 195         if (index < 0)
 196                 return;
 197
 198         DBG("interface name %s index %d", iwdd->name, index);
 199         connman_network_set_index(iwdn->network, index);
 200         connman_network_set_connected(iwdn->network, true);
 201 }
 202
 203 static void update_network_disconnected(struct iwd_network *iwdn)
 204 {
 205         DBG("interface name %s", iwdn->name);
 206         connman_network_set_connected(iwdn->network, false);
 207 }
 208
 209 static void cm_network_connect_cb(DBusMessage *message, void *user_data)
 210 {
 211         const char *path = user_data;
 212         struct iwd_network *iwdn;
 213
 214         iwdn = g_hash_table_lookup(networks, path);
 215         if (!iwdn)
 216                 return;
 217
 218         if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
 219                 const char *dbus_error = dbus_message_get_error_name(message);
 220
 221                 if (!strcmp(dbus_error, "net.connman.iwd.InProgress"))
 222                         return;
 223
 224                 DBG("%s connect failed: %s", path, dbus_error);
 225                 connman_network_set_error(iwdn->network,
 226                                         CONNMAN_NETWORK_ERROR_CONNECT_FAIL);
 227                 return;
 228         }
 229
 230         update_network_connected(iwdn);
 231 }
 232
 233 static int cm_network_connect(struct connman_network *network)
 234 {
 235         struct iwd_network *iwdn = connman_network_get_data(network);
 236
 237         if (!iwdn)
 238                 return -EINVAL;
 239
 240         if (!g_dbus_proxy_method_call(iwdn->proxy, "Connect",
 241                         NULL, cm_network_connect_cb,
 242                         g_strdup(iwdn->path), g_free))
 243                 return -EIO;
 244
 245         connman_network_set_associating(iwdn->network, true);
 246
 247         return -EINPROGRESS;
 248 }
 249
 250 static void cm_network_disconnect_cb(DBusMessage *message, void *user_data)
 251 {
 252         const char *path = user_data;
 253         struct iwd_network *iwdn;
 254
 255         iwdn = g_hash_table_lookup(networks, path);
 256         if (!iwdn)
 257                 return;
 258
 259         if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
 260                 const char *dbus_error = dbus_message_get_error_name(message);
 261
 262                 if (!strcmp(dbus_error, "net.connman.iwd.NotConnected")) {
 263                         /* fall through */
 264                 } else {
 265                         DBG("%s disconnect failed: %s", path, dbus_error);
 266                         return;
 267                 }
 268         }
 269
 270         /*
 271          * We end up in a tight loop in the error case. That is
 272          * when we can't connect, bail out in cm_network_connect_cb() with
 273          * an error.
 274          */
 275         if (connman_network_get_connected(iwdn->network))
 276                 update_network_disconnected(iwdn);
 277 }
 278
 279 static int cm_network_disconnect(struct connman_network *network)
 280 {
 281         struct iwd_network *iwdn = connman_network_get_data(network);
 282         struct iwd_device *iwdd;
 283
 284         if (!iwdn)
 285                 return -EINVAL;
 286
 287         iwdd = g_hash_table_lookup(devices, iwdn->device);
 288         if (!iwdd)
 289                 return -EIO;
 290
 291         if (!g_dbus_proxy_method_call(iwdd->proxy, "Disconnect",
 292                         NULL, cm_network_disconnect_cb, g_strdup(iwdn->path), g_free))
 293                 return -EIO;
 294
 295         return -EINPROGRESS;
 296 }
 297
 298 static struct connman_network_driver network_driver = {
 299         .name           = "iwd",
 300         .type           = CONNMAN_NETWORK_TYPE_WIFI,
 301         .probe          = cm_network_probe,
 302         .connect        = cm_network_connect,
 303         .disconnect     = cm_network_disconnect,
 304 };
 305
 306 static int cm_device_probe(struct connman_device *device)
 307 {
 308         GHashTableIter iter;
 309         gpointer key, value;
 310
 311         g_hash_table_iter_init(&iter, devices);
 312
 313         while (g_hash_table_iter_next(&iter, &key, &value)) {
 314                 struct iwd_device *iwdd = value;
 315
 316                 if (device == iwdd->device)
 317                         return 0;
 318         }
 319
 320         return -EOPNOTSUPP;
 321 }
 322
 323 static void cm_device_remove(struct connman_device *device)
 324 {
 325 }
 326
 327 struct dev_cb_data {
 328         char *path;
 329         bool powered;
 330 };
 331
 332 static void device_powered_cb(const DBusError *error, void *user_data)
 333 {
 334         struct dev_cb_data *cbd = user_data;
 335         struct iwd_device *iwdd;
 336
 337         iwdd = g_hash_table_lookup(devices, cbd->path);
 338         if (!iwdd)
 339                 goto out;
 340
 341         if (dbus_error_is_set(error)) {
 342                 connman_warn("WiFi device %s not enabled %s",
 343                                 cbd->path, error->message);
 344                 goto out;
 345         }
 346
 347         connman_device_set_powered(iwdd->device, cbd->powered);
 348 out:
 349         g_free(cbd->path);
 350         g_free(cbd);
 351 }
 352
 353 static int set_device_powered(struct connman_device *device, bool powered)
 354 {
 355         struct iwd_device *iwdd = connman_device_get_data(device);
 356         dbus_bool_t device_powered = powered;
 357         struct dev_cb_data *cbd;
 358
 359         if (proxy_get_bool(iwdd->proxy, "Powered"))
 360                 return -EALREADY;
 361
 362         cbd = g_new(struct dev_cb_data, 1);
 363         cbd->path = g_strdup(iwdd->path);
 364         cbd->powered = powered;
 365
 366         g_dbus_proxy_set_property_basic(iwdd->proxy, "Powered",
 367                         DBUS_TYPE_BOOLEAN, &device_powered,
 368                         device_powered_cb, cbd, NULL);
 369
 370         return -EINPROGRESS;
 371 }
 372
 373 static int cm_device_enable(struct connman_device *device)
 374 {
 375         return set_device_powered(device, true);
 376 }
 377
 378 static int cm_device_disable(struct connman_device *device)
 379 {
 380         return set_device_powered(device, false);
 381 }
 382
 383 static struct connman_device_driver device_driver = {
 384         .name           = "iwd",
 385         .type           = CONNMAN_DEVICE_TYPE_WIFI,
 386         .probe          = cm_device_probe,
 387         .remove         = cm_device_remove,
 388         .enable         = cm_device_enable,
 389         .disable        = cm_device_disable,
 390 };
 391
 392 static int cm_tech_probe(struct connman_technology *technology)
 393 {
 394         return 0;
 395 }
 396
 397 static void cm_tech_remove(struct connman_technology *technology)
 398 {
 399 }
 400
 401 static struct connman_technology_driver tech_driver = {
 402         .name           = "iwd",
 403         .type           = CONNMAN_SERVICE_TYPE_WIFI,
 404         .probe          = cm_tech_probe,
 405         .remove         = cm_tech_remove,
 406 };
 407
 408 static unsigned char calculate_strength(int strength)
 409 {
 410         unsigned char res;
 411
 412         /*
 413          * Network's maximum signal strength expressed in 100 * dBm.
 414          * The value is the range of 0 (strongest signal) to -10000
 415          * (weakest signal)
 416          *
 417          * ConnMan expects it in the range from 100 (strongest) to 0
 418          * (weakest).
 419          */
 420         res = (unsigned char)((strength * -10000) / 100);
 421
 422         return res;
 423 }
 424
 425 static void _update_signal_strength(const char *path, int16_t signal_strength)
 426 {
 427         struct iwd_network *iwdn;
 428
 429         iwdn = g_hash_table_lookup(networks, path);
 430         if (!iwdn)
 431                 return;
 432
 433         if (!iwdn->network)
 434                 return;
 435
 436         connman_network_set_strength(iwdn->network,
 437                                         calculate_strength(signal_strength));
 438 }
 439
 440 static void ordered_networks_cb(DBusMessage *message, void *user_data)
 441 {
 442         DBusMessageIter array, entry;
 443
 444         DBG("");
 445
 446         if (!dbus_message_iter_init(message, &array))
 447                 return;
 448
 449         if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
 450                 return;
 451
 452         dbus_message_iter_recurse(&array, &entry);
 453         while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRUCT) {
 454                 DBusMessageIter value;
 455                 const char *path, *name, *type;
 456                 int16_t signal_strength;
 457
 458
 459                 dbus_message_iter_recurse(&entry, &value);
 460
 461                 dbus_message_iter_get_basic(&value, &path);
 462
 463                 dbus_message_iter_next(&value);
 464                 dbus_message_iter_get_basic(&value, &name);
 465
 466                 dbus_message_iter_next(&value);
 467                 dbus_message_iter_get_basic(&value, &signal_strength);
 468
 469                 dbus_message_iter_next(&value);
 470                 dbus_message_iter_get_basic(&value, &type);
 471
 472                 _update_signal_strength(path, signal_strength);
 473
 474                 dbus_message_iter_next(&entry);
 475         }
 476 }
 477
 478 static void update_signal_strength(struct iwd_device *iwdd)
 479 {
 480         if (!g_dbus_proxy_method_call(iwdd->proxy,
 481                                         "GetOrderedNetworks",
 482                                         NULL, ordered_networks_cb,
 483                                         NULL, NULL))
 484                 DBG("GetOrderedNetworks() failed");
 485 }
 486
 487 static void add_network(const char *path, struct iwd_network *iwdn)
 488 {
 489         struct iwd_device *iwdd;
 490         const char *identifier;
 491
 492         iwdd = g_hash_table_lookup(devices, iwdn->device);
 493         if (!iwdd)
 494                 return;
 495
 496         identifier = strrchr(path, '/');
 497         identifier++; /* strip leading slash as well */
 498         iwdn->network = connman_network_create(identifier,
 499                                         CONNMAN_NETWORK_TYPE_WIFI);
 500         connman_network_set_data(iwdn->network, iwdn);
 501
 502         connman_network_set_name(iwdn->network, iwdn->name);
 503         connman_network_set_blob(iwdn->network, "WiFi.SSID", iwdn->name,
 504                                         strlen(iwdn->name));
 505         connman_network_set_string(iwdn->network, "WiFi.Security",
 506                                         iwdn->type);
 507
 508         if (connman_device_add_network(iwdd->device, iwdn->network) < 0) {
 509                 connman_network_unref(iwdn->network);
 510                 iwdn->network = NULL;
 511                 return;
 512         }
 513         iwdn->iwdd = iwdd;
 514
 515         connman_network_set_available(iwdn->network, true);
 516         connman_network_set_group(iwdn->network, identifier);
 517 }
 518
 519 static void remove_network(struct iwd_network *iwdn)
 520 {
 521         if (!iwdn->network)
 522                 return;
 523
 524         if (iwdn->iwdd)
 525                 connman_device_remove_network(iwdn->iwdd->device,
 526                                                 iwdn->network);
 527
 528         connman_network_unref(iwdn->network);
 529         iwdn->network = NULL;
 530 }
 531
 532 static void add_device(const char *path, struct iwd_device *iwdd)
 533 {
 534         char ident[ETH_ALEN * 2 + 1];
 535
 536         iwdd->device = connman_device_create("wifi", CONNMAN_DEVICE_TYPE_WIFI);
 537         if (!iwdd->device)
 538                 return;
 539
 540         connman_device_set_data(iwdd->device, iwdd);
 541
 542         address2ident(iwdd->address, ident);
 543         connman_device_set_ident(iwdd->device, ident);
 544
 545         if (connman_device_register(iwdd->device) < 0) {
 546                 g_hash_table_remove(devices, path);
 547                 return;
 548         }
 549
 550         connman_device_set_powered(iwdd->device, iwdd->powered);
 551 }
 552
 553 static void remove_device_networks(struct iwd_device *iwdd)
 554 {
 555         GHashTableIter iter;
 556         gpointer key, value;
 557         struct iwd_network *iwdn;
 558         GSList *list, *nets = NULL;
 559
 560         g_hash_table_iter_init(&iter, networks);
 561
 562         while (g_hash_table_iter_next(&iter, &key, &value)) {
 563                 iwdn = value;
 564
 565                 if (!strcmp(iwdd->path, iwdn->device))
 566                         nets = g_slist_prepend(nets, iwdn);
 567         }
 568
 569         for (list = nets; list; list = list->next) {
 570                 iwdn = list->data;
 571                 g_hash_table_remove(networks, iwdn->path);
 572         }
 573
 574         g_slist_free(nets);
 575 }
 576
 577 static void remove_device(struct iwd_device *iwdd)
 578 {
 579         if (!iwdd->device)
 580                 return;
 581
 582         remove_device_networks(iwdd);
 583         connman_device_unregister(iwdd->device);
 584         connman_device_unref(iwdd->device);
 585         iwdd->device = NULL;
 586 }
 587
 588 static void adapter_property_change(GDBusProxy *proxy, const char *name,
 589                 DBusMessageIter *iter, void *user_data)
 590 {
 591         struct iwd_adapter *adapter;
 592         const char *path;
 593
 594         path = g_dbus_proxy_get_path(proxy);
 595         adapter = g_hash_table_lookup(adapters, path);
 596         if (!adapter)
 597                 return;
 598
 599         if (!strcmp(name, "Powered")) {
 600                 dbus_bool_t powered;
 601
 602                 dbus_message_iter_get_basic(iter, &powered);
 603                 adapter->powered = powered;
 604
 605                 DBG("%p powered %d", path, adapter->powered);
 606         }
 607 }
 608
 609 static void device_property_change(GDBusProxy *proxy, const char *name,
 610                 DBusMessageIter *iter, void *user_data)
 611 {
 612         struct iwd_device *iwdd;
 613         const char *path;
 614
 615         path = g_dbus_proxy_get_path(proxy);
 616         iwdd = g_hash_table_lookup(devices, path);
 617         if (!iwdd)
 618                 return;
 619
 620         if (!strcmp(name, "Name")) {
 621                 const char *name;
 622
 623                 dbus_message_iter_get_basic(iter, &name);
 624                 g_free(iwdd->name);
 625                 iwdd->name = g_strdup(name);
 626
 627                 DBG("%p name %s", path, iwdd->name);
 628         } else if (!strcmp(name, "State")) {
 629                 const char *state;
 630
 631                 dbus_message_iter_get_basic(iter, &state);
 632                 iwdd->state = string2state(state);
 633
 634                 DBG("%s state %s", path, state2string(iwdd->state));
 635         } else if (!strcmp(name, "Powered")) {
 636                 dbus_bool_t powered;
 637
 638                 dbus_message_iter_get_basic(iter, &powered);
 639                 iwdd->powered = powered;
 640
 641                 DBG("%s powered %d", path, iwdd->powered);
 642         } else if (!strcmp(name, "Scanning")) {
 643                 dbus_bool_t scanning;
 644
 645                 dbus_message_iter_get_basic(iter, &scanning);
 646                 iwdd->scanning = scanning;
 647
 648                 DBG("%s scanning %d", path, iwdd->scanning);
 649
 650                 if (!iwdd->scanning)
 651                         update_signal_strength(iwdd);
 652
 653         }
 654 }
 655
 656 static void network_property_change(GDBusProxy *proxy, const char *name,
 657                 DBusMessageIter *iter, void *user_data)
 658 {
 659         struct iwd_network *iwdn;
 660         const char *path;
 661
 662         path = g_dbus_proxy_get_path(proxy);
 663         iwdn = g_hash_table_lookup(networks, path);
 664         if (!iwdn)
 665                 return;
 666
 667         if (!strcmp(name, "Connected")) {
 668                 dbus_bool_t connected;
 669
 670                 dbus_message_iter_get_basic(iter, &connected);
 671                 iwdn->connected = connected;
 672
 673                 DBG("%s connected %d", path, iwdn->connected);
 674
 675                 if (iwdn->connected)
 676                         update_network_connected(iwdn);
 677                 else
 678                         update_network_disconnected(iwdn);
 679         }
 680 }
 681
 682 static void adapter_free(gpointer data)
 683 {
 684         struct iwd_adapter *iwda = data;
 685
 686         if (iwda->proxy) {
 687                 g_dbus_proxy_unref(iwda->proxy);
 688                 iwda->proxy = NULL;
 689         }
 690
 691         g_free(iwda->path);
 692         g_free(iwda->vendor);
 693         g_free(iwda->model);
 694         g_free(iwda);
 695 }
 696
 697 static void device_free(gpointer data)
 698 {
 699         struct iwd_device *iwdd = data;
 700
 701         if (iwdd->proxy) {
 702                 g_dbus_proxy_unref(iwdd->proxy);
 703                 iwdd->proxy = NULL;
 704         }
 705
 706         remove_device(iwdd);
 707
 708         g_free(iwdd->path);
 709         g_free(iwdd->adapter);
 710         g_free(iwdd->name);
 711         g_free(iwdd->address);
 712         g_free(iwdd);
 713 }
 714
 715 static void network_free(gpointer data)
 716 {
 717         struct iwd_network *iwdn = data;
 718
 719         if (iwdn->proxy) {
 720                 g_dbus_proxy_unref(iwdn->proxy);
 721                 iwdn->proxy = NULL;
 722         }
 723
 724         remove_network(iwdn);
 725
 726         g_free(iwdn->path);
 727         g_free(iwdn->device);
 728         g_free(iwdn->name);
 729         g_free(iwdn->type);
 730         g_free(iwdn);
 731 }
 732
 733 static void create_adapter(GDBusProxy *proxy)
 734 {
 735         const char *path = g_dbus_proxy_get_path(proxy);
 736         struct iwd_adapter *iwda;
 737
 738         iwda = g_try_new0(struct iwd_adapter, 1);
 739
 740         if (!iwda) {
 741                 connman_error("Out of memory creating IWD adapter");
 742                 return;
 743         }
 744
 745         iwda->path = g_strdup(path);
 746         g_hash_table_replace(adapters, iwda->path, iwda);
 747
 748         iwda->proxy = g_dbus_proxy_ref(proxy);
 749
 750         if (!iwda->proxy) {
 751                 connman_error("Cannot create IWD adapter watcher %s", path);
 752                 g_hash_table_remove(adapters, path);
 753                 return;
 754         }
 755
 756         iwda->vendor = g_strdup(proxy_get_string(proxy, "Vendor"));
 757         iwda->model = g_strdup(proxy_get_string(proxy, "Model"));
 758         iwda->powered = proxy_get_bool(proxy, "Powered");
 759
 760         DBG("%s vendor '%s' model '%s' powered %d", path, iwda->vendor,
 761                 iwda->model, iwda->powered);
 762
 763         g_dbus_proxy_set_property_watch(iwda->proxy,
 764                         adapter_property_change, NULL);
 765 }
 766
 767 static void create_device(GDBusProxy *proxy)
 768 {
 769         const char *path = g_dbus_proxy_get_path(proxy);
 770         struct iwd_device *iwdd;
 771
 772         iwdd = g_try_new0(struct iwd_device, 1);
 773
 774         if (!iwdd) {
 775                 connman_error("Out of memory creating IWD device");
 776                 return;
 777         }
 778
 779         iwdd->path = g_strdup(path);
 780         g_hash_table_replace(devices, iwdd->path, iwdd);
 781
 782         iwdd->proxy = g_dbus_proxy_ref(proxy);
 783
 784         if (!iwdd->proxy) {
 785                 connman_error("Cannot create IWD device watcher %s", path);
 786                 g_hash_table_remove(devices, path);
 787                 return;
 788         }
 789
 790         iwdd->adapter = g_strdup(proxy_get_string(proxy, "Adapter"));
 791         iwdd->name = g_strdup(proxy_get_string(proxy, "Name"));
 792         iwdd->address = g_strdup(proxy_get_string(proxy, "Address"));
 793         iwdd->state = string2state(proxy_get_string(proxy, "State"));
 794         iwdd->powered = proxy_get_bool(proxy, "Powered");
 795         iwdd->scanning = proxy_get_bool(proxy, "Scanning");
 796
 797         DBG("adapter %s name %s address %s state %s powered %d scanning %d",
 798                 iwdd->adapter, iwdd->name, iwdd->address,
 799                 state2string(iwdd->state),
 800                 iwdd->powered, iwdd->scanning);
 801
 802         g_dbus_proxy_set_property_watch(iwdd->proxy,
 803                         device_property_change, NULL);
 804
 805         add_device(path, iwdd);
 806 }
 807
 808 static void unregister_agent();
 809
 810 static DBusMessage *agent_release_method(DBusConnection *dbus_conn,
 811                                         DBusMessage *message, void *user_data)
 812 {
 813         unregister_agent();
 814         return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
 815 }
 816
 817 static DBusMessage *get_reply_on_error(DBusMessage *message, int error)
 818 {
 819         return g_dbus_create_error(message,
 820                 IWD_AGENT_ERROR_INTERFACE ".Failed", "Invalid parameters");
 821 }
 822
 823 static DBusMessage *agent_request_passphrase(DBusConnection *dbus_conn,
 824                                                 DBusMessage *message,
 825                                                 void *user_data)
 826 {
 827         struct iwd_network *iwdn;
 828         DBusMessageIter iter;
 829         const char *path, *passwd;
 830
 831         DBG("");
 832
 833         dbus_message_iter_init(message, &iter);
 834
 835         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH)
 836                 return get_reply_on_error(message, EINVAL);
 837
 838         dbus_message_iter_get_basic(&iter, &path);
 839
 840         iwdn = g_hash_table_lookup(networks, path);
 841         if (!iwdn)
 842                 return get_reply_on_error(message, EINVAL);
 843
 844         passwd = connman_network_get_string(iwdn->network, "WiFi.Passphrase");
 845
 846         return g_dbus_create_reply(message, DBUS_TYPE_STRING, &passwd,
 847                                         DBUS_TYPE_INVALID);
 848 }
 849
 850 static DBusMessage *agent_cancel(DBusConnection *dbus_conn,
 851                                         DBusMessage *message, void *user_data)
 852 {
 853         DBusMessageIter iter;
 854         const char *reason;
 855
 856         dbus_message_iter_init(message, &iter);
 857
 858         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
 859                 return get_reply_on_error(message, EINVAL);
 860
 861         dbus_message_iter_get_basic(&iter, &reason);
 862
 863         DBG("cancel: %s", reason);
 864
 865         /*
 866          * We don't have to do anything here, because we asked the
 867          * user upfront for the passphrase. So
 868          * agent_request_passphrase() will always send a passphrase
 869          * immediately.
 870          */
 871
 872         return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
 873 }
 874
 875 static const GDBusMethodTable agent_methods[] = {
 876         { GDBUS_METHOD("Release", NULL, NULL, agent_release_method) },
 877         { GDBUS_METHOD("RequestPassphrase",
 878                         GDBUS_ARGS({ "path", "o" }),
 879                         GDBUS_ARGS({ "passphrase", "s" }),
 880                         agent_request_passphrase)},
 881         { GDBUS_METHOD("Cancel",
 882                         GDBUS_ARGS({ "reason", "s" }),
 883                         NULL, agent_cancel) },
 884         { },
 885 };
 886
 887 static void agent_register_builder(DBusMessageIter *iter, void *user_data)
 888 {
 889         const char *path = AGENT_PATH;
 890
 891         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
 892                                 &path);
 893 }
 894
 895 static void register_agent(GDBusProxy *proxy)
 896 {
 897         if (!g_dbus_proxy_method_call(proxy,
 898                                         "RegisterAgent",
 899                                         agent_register_builder,
 900                                         NULL, NULL, NULL))
 901                 return;
 902
 903         agent_proxy = g_dbus_proxy_ref(proxy);
 904 }
 905
 906 static void unregister_agent()
 907 {
 908         if (!agent_proxy)
 909                 return;
 910
 911         g_dbus_proxy_method_call(agent_proxy,
 912                                         "UnregisterAgent",
 913                                         agent_register_builder,
 914                                         NULL, NULL, NULL);
 915
 916         g_dbus_proxy_unref(agent_proxy);
 917         agent_proxy = NULL;
 918 }
 919
 920 static void iwd_is_present(DBusConnection *conn, void *user_data)
 921 {
 922         if (agent_registered)
 923                 return;
 924
 925         if (!g_dbus_register_interface(connection, AGENT_PATH,
 926                                         IWD_AGENT_INTERFACE, agent_methods,
 927                                         NULL, NULL, NULL, NULL))
 928                 return;
 929
 930         agent_registered = true;
 931 }
 932
 933 static void iwd_is_out(DBusConnection *conn, void *user_data)
 934 {
 935         if (agent_registered) {
 936                 g_dbus_unregister_interface(connection,
 937                                         AGENT_PATH, IWD_AGENT_INTERFACE);
 938                 agent_registered = false;
 939         }
 940 }
 941
 942 static void create_network(GDBusProxy *proxy)
 943 {
 944         const char *path = g_dbus_proxy_get_path(proxy);
 945         struct iwd_network *iwdn;
 946
 947         iwdn = g_try_new0(struct iwd_network, 1);
 948
 949         if (!iwdn) {
 950                 connman_error("Out of memory creating IWD network");
 951                 return;
 952         }
 953
 954         iwdn->path = g_strdup(path);
 955         g_hash_table_replace(networks, iwdn->path, iwdn);
 956
 957         iwdn->proxy = g_dbus_proxy_ref(proxy);
 958
 959         if (!iwdn->proxy) {
 960                 connman_error("Cannot create IWD network watcher %s", path);
 961                 g_hash_table_remove(networks, path);
 962                 return;
 963         }
 964
 965         iwdn->device = g_strdup(proxy_get_string(proxy, "Device"));
 966         iwdn->name = g_strdup(proxy_get_string(proxy, "Name"));
 967         iwdn->type = g_strdup(proxy_get_string(proxy, "Type"));
 968         iwdn->connected = proxy_get_bool(proxy, "Connected");
 969
 970         DBG("device %s name '%s' type %s connected %d",
 971                 iwdn->device,
 972                 iwdn->name,
 973                 iwdn->type,
 974                 iwdn->connected);
 975
 976         g_dbus_proxy_set_property_watch(iwdn->proxy,
 977                         network_property_change, NULL);
 978
 979         add_network(path, iwdn);
 980 }
 981
 982 static void object_added(GDBusProxy *proxy, void *user_data)
 983 {
 984         const char *interface;
 985
 986         interface = g_dbus_proxy_get_interface(proxy);
 987         if (!interface) {
 988                 connman_warn("Interface or proxy missing when adding "
 989                                                         "iwd object");
 990                 return;
 991         }
 992
 993         DBG("%s %s", interface, g_dbus_proxy_get_path(proxy));
 994
 995         if (!strcmp(interface, IWD_AGENT_MANAGER_INTERFACE))
 996                 register_agent(proxy);
 997         else if (!strcmp(interface, IWD_ADAPTER_INTERFACE))
 998                 create_adapter(proxy);
 999         else if (!strcmp(interface, IWD_DEVICE_INTERFACE))
1000                 create_device(proxy);
1001         else if (!strcmp(interface, IWD_NETWORK_INTERFACE))
1002                 create_network(proxy);
1003 }
1004
1005 static void object_removed(GDBusProxy *proxy, void *user_data)
1006 {
1007         const char *interface, *path;
1008
1009         interface = g_dbus_proxy_get_interface(proxy);
1010         if (!interface) {
1011                 connman_warn("Interface or proxy missing when removing "
1012                                                         "iwd object");
1013                 return;
1014         }
1015
1016         path = g_dbus_proxy_get_path(proxy);
1017         DBG("%s %s", interface, path);
1018
1019         if (!strcmp(interface, IWD_AGENT_MANAGER_INTERFACE))
1020                 unregister_agent();
1021         if (!strcmp(interface, IWD_ADAPTER_INTERFACE))
1022                 g_hash_table_remove(adapters, path);
1023         else if (!strcmp(interface, IWD_DEVICE_INTERFACE))
1024                 g_hash_table_remove(devices, path);
1025         else if (!strcmp(interface, IWD_NETWORK_INTERFACE))
1026                 g_hash_table_remove(networks, path);
1027 }
1028
1029 static int iwd_init(void)
1030 {
1031         connection = connman_dbus_get_connection();
1032         if (!connection)
1033                 goto out;
1034
1035         adapters = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1036                         adapter_free);
1037
1038         devices = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1039                         device_free);
1040
1041         networks = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1042                         network_free);
1043
1044         if (connman_technology_driver_register(&tech_driver) < 0) {
1045                 connman_warn("Failed to initialize technology for IWD");
1046                 goto out;
1047         }
1048
1049         if (connman_device_driver_register(&device_driver) < 0) {
1050                 connman_warn("Failed to initialize device driver for "
1051                                 IWD_SERVICE);
1052                 connman_technology_driver_unregister(&tech_driver);
1053                 goto out;
1054         }
1055
1056         if (connman_network_driver_register(&network_driver) < 0) {
1057                 connman_technology_driver_unregister(&tech_driver);
1058                 connman_device_driver_unregister(&device_driver);
1059                 goto out;
1060         }
1061
1062         client = g_dbus_client_new(connection, IWD_SERVICE, IWD_PATH);
1063         if (!client) {
1064                 connman_warn("Failed to initialize D-Bus client for "
1065                                 IWD_SERVICE);
1066                 goto out;
1067         }
1068
1069         g_dbus_client_set_connect_watch(client, iwd_is_present, NULL);
1070         g_dbus_client_set_disconnect_watch(client, iwd_is_out, NULL);
1071         g_dbus_client_set_proxy_handlers(client, object_added, object_removed,
1072                         NULL, NULL);
1073
1074         return 0;
1075
1076 out:
1077         if (devices)
1078                 g_hash_table_destroy(devices);
1079
1080         if (networks)
1081                 g_hash_table_destroy(networks);
1082
1083         if (adapters)
1084                 g_hash_table_destroy(adapters);
1085
1086         if (connection)
1087                 dbus_connection_unref(connection);
1088
1089         return -EIO;
1090 }
1091
1092 static void iwd_exit(void)
1093 {
1094         connman_network_driver_unregister(&network_driver);
1095         connman_device_driver_unregister(&device_driver);
1096         connman_technology_driver_unregister(&tech_driver);
1097
1098         g_dbus_client_unref(client);
1099
1100         g_hash_table_destroy(networks);
1101         g_hash_table_destroy(devices);
1102         g_hash_table_destroy(adapters);
1103
1104         dbus_connection_unref(connection);
1105 }
1106
1107 CONNMAN_PLUGIN_DEFINE(iwd, "IWD plugin", VERSION,
1108                 CONNMAN_PLUGIN_PRIORITY_DEFAULT, iwd_init, iwd_exit)