workbench/network/WirelessManager/wpa_supplicant/wpa_priv.c

   1 /*
   2  * WPA Supplicant / privileged helper program
   3  * Copyright (c) 2007-2009, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16 #ifdef __linux__
  17 #include <fcntl.h>
  18 #endif /* __linux__ */
  19 #include <sys/un.h>
  20 #include <sys/stat.h>
  21
  22 #include "common.h"
  23 #include "eloop.h"
  24 #include "common/version.h"
  25 #include "drivers/driver.h"
  26 #include "l2_packet/l2_packet.h"
  27 #include "common/privsep_commands.h"
  28 #include "common/ieee802_11_defs.h"
  29
  30
  31 struct wpa_priv_interface {
  32         struct wpa_priv_interface *next;
  33         char *driver_name;
  34         char *ifname;
  35         char *sock_name;
  36         int fd;
  37
  38         struct wpa_driver_ops *driver;
  39         void *drv_priv;
  40         struct sockaddr_un drv_addr;
  41         int wpas_registered;
  42
  43         /* TODO: add support for multiple l2 connections */
  44         struct l2_packet_data *l2;
  45         struct sockaddr_un l2_addr;
  46 };
  47
  48
  49 static void wpa_priv_cmd_register(struct wpa_priv_interface *iface,
  50                                   struct sockaddr_un *from)
  51 {
  52         if (iface->drv_priv) {
  53                 wpa_printf(MSG_DEBUG, "Cleaning up forgotten driver instance");
  54                 if (iface->driver->deinit)
  55                         iface->driver->deinit(iface->drv_priv);
  56                 iface->drv_priv = NULL;
  57                 iface->wpas_registered = 0;
  58         }
  59
  60         if (iface->l2) {
  61                 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
  62                            "instance");
  63                 l2_packet_deinit(iface->l2);
  64                 iface->l2 = NULL;
  65         }
  66
  67         if (iface->driver->init == NULL)
  68                 return;
  69
  70         iface->drv_priv = iface->driver->init(iface, iface->ifname);
  71         if (iface->drv_priv == NULL) {
  72                 wpa_printf(MSG_DEBUG, "Failed to initialize driver wrapper");
  73                 return;
  74         }
  75
  76         wpa_printf(MSG_DEBUG, "Driver wrapper '%s' initialized for interface "
  77                    "'%s'", iface->driver_name, iface->ifname);
  78
  79         os_memcpy(&iface->drv_addr, from, sizeof(iface->drv_addr));
  80         iface->wpas_registered = 1;
  81
  82         if (iface->driver->set_param &&
  83             iface->driver->set_param(iface->drv_priv, NULL) < 0) {
  84                 wpa_printf(MSG_ERROR, "Driver interface rejected param");
  85         }
  86 }
  87
  88
  89 static void wpa_priv_cmd_unregister(struct wpa_priv_interface *iface,
  90                                     struct sockaddr_un *from)
  91 {
  92         if (iface->drv_priv) {
  93                 if (iface->driver->deinit)
  94                         iface->driver->deinit(iface->drv_priv);
  95                 iface->drv_priv = NULL;
  96                 iface->wpas_registered = 0;
  97         }
  98 }
  99
 100
 101 static void wpa_priv_cmd_scan(struct wpa_priv_interface *iface,
 102                               char *buf, size_t len)
 103 {
 104         struct wpa_driver_scan_params params;
 105
 106         if (iface->drv_priv == NULL)
 107                 return;
 108
 109         os_memset(&params, 0, sizeof(params));
 110         if (len) {
 111                 params.ssids[0].ssid = (u8 *) buf;
 112                 params.ssids[0].ssid_len = len;
 113                 params.num_ssids = 1;
 114         }
 115
 116         if (iface->driver->scan2)
 117                 iface->driver->scan2(iface->drv_priv, &params);
 118 }
 119
 120
 121 static void wpa_priv_get_scan_results2(struct wpa_priv_interface *iface,
 122                                        struct sockaddr_un *from)
 123 {
 124         struct wpa_scan_results *res;
 125         u8 *buf = NULL, *pos, *end;
 126         int val;
 127         size_t i;
 128
 129         res = iface->driver->get_scan_results2(iface->drv_priv);
 130         if (res == NULL)
 131                 goto fail;
 132
 133         buf = os_malloc(60000);
 134         if (buf == NULL)
 135                 goto fail;
 136         pos = buf;
 137         end = buf + 60000;
 138         val = res->num;
 139         os_memcpy(pos, &val, sizeof(int));
 140         pos += sizeof(int);
 141
 142         for (i = 0; i < res->num; i++) {
 143                 struct wpa_scan_res *r = res->res[i];
 144                 val = sizeof(*r) + r->ie_len;
 145                 if (end - pos < (int) sizeof(int) + val)
 146                         break;
 147                 os_memcpy(pos, &val, sizeof(int));
 148                 pos += sizeof(int);
 149                 os_memcpy(pos, r, val);
 150                 pos += val;
 151         }
 152
 153         sendto(iface->fd, buf, pos - buf, 0, (struct sockaddr *) from,
 154                sizeof(*from));
 155
 156         os_free(buf);
 157         wpa_scan_results_free(res);
 158         return;
 159
 160 fail:
 161         os_free(buf);
 162         wpa_scan_results_free(res);
 163         sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
 164 }
 165
 166
 167 static void wpa_priv_cmd_get_scan_results(struct wpa_priv_interface *iface,
 168                                           struct sockaddr_un *from)
 169 {
 170         if (iface->drv_priv == NULL)
 171                 return;
 172
 173         if (iface->driver->get_scan_results2)
 174                 wpa_priv_get_scan_results2(iface, from);
 175         else
 176                 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from,
 177                        sizeof(*from));
 178 }
 179
 180
 181 static void wpa_priv_cmd_associate(struct wpa_priv_interface *iface,
 182                                    void *buf, size_t len)
 183 {
 184         struct wpa_driver_associate_params params;
 185         struct privsep_cmd_associate *assoc;
 186         u8 *bssid;
 187         int res;
 188
 189         if (iface->drv_priv == NULL || iface->driver->associate == NULL)
 190                 return;
 191
 192         if (len < sizeof(*assoc)) {
 193                 wpa_printf(MSG_DEBUG, "Invalid association request");
 194                 return;
 195         }
 196
 197         assoc = buf;
 198         if (sizeof(*assoc) + assoc->wpa_ie_len > len) {
 199                 wpa_printf(MSG_DEBUG, "Association request overflow");
 200                 return;
 201         }
 202
 203         os_memset(&params, 0, sizeof(params));
 204         bssid = assoc->bssid;
 205         if (bssid[0] | bssid[1] | bssid[2] | bssid[3] | bssid[4] | bssid[5])
 206                 params.bssid = bssid;
 207         params.ssid = assoc->ssid;
 208         if (assoc->ssid_len > 32)
 209                 return;
 210         params.ssid_len = assoc->ssid_len;
 211         params.freq = assoc->freq;
 212         if (assoc->wpa_ie_len) {
 213                 params.wpa_ie = (u8 *) (assoc + 1);
 214                 params.wpa_ie_len = assoc->wpa_ie_len;
 215         }
 216         params.pairwise_suite = assoc->pairwise_suite;
 217         params.group_suite = assoc->group_suite;
 218         params.key_mgmt_suite = assoc->key_mgmt_suite;
 219         params.auth_alg = assoc->auth_alg;
 220         params.mode = assoc->mode;
 221
 222         res = iface->driver->associate(iface->drv_priv, &params);
 223         wpa_printf(MSG_DEBUG, "drv->associate: res=%d", res);
 224 }
 225
 226
 227 static void wpa_priv_cmd_get_bssid(struct wpa_priv_interface *iface,
 228                                    struct sockaddr_un *from)
 229 {
 230         u8 bssid[ETH_ALEN];
 231
 232         if (iface->drv_priv == NULL)
 233                 goto fail;
 234
 235         if (iface->driver->get_bssid == NULL ||
 236             iface->driver->get_bssid(iface->drv_priv, bssid) < 0)
 237                 goto fail;
 238
 239         sendto(iface->fd, bssid, ETH_ALEN, 0, (struct sockaddr *) from,
 240                sizeof(*from));
 241         return;
 242
 243 fail:
 244         sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
 245 }
 246
 247
 248 static void wpa_priv_cmd_get_ssid(struct wpa_priv_interface *iface,
 249                                   struct sockaddr_un *from)
 250 {
 251         u8 ssid[sizeof(int) + 32];
 252         int res;
 253
 254         if (iface->drv_priv == NULL)
 255                 goto fail;
 256
 257         if (iface->driver->get_ssid == NULL)
 258                 goto fail;
 259
 260         res = iface->driver->get_ssid(iface->drv_priv, &ssid[sizeof(int)]);
 261         if (res < 0 || res > 32)
 262                 goto fail;
 263         os_memcpy(ssid, &res, sizeof(int));
 264
 265         sendto(iface->fd, ssid, sizeof(ssid), 0, (struct sockaddr *) from,
 266                sizeof(*from));
 267         return;
 268
 269 fail:
 270         sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
 271 }
 272
 273
 274 static void wpa_priv_cmd_set_key(struct wpa_priv_interface *iface,
 275                                  void *buf, size_t len)
 276 {
 277         struct privsep_cmd_set_key *params;
 278         int res;
 279
 280         if (iface->drv_priv == NULL || iface->driver->set_key == NULL)
 281                 return;
 282
 283         if (len != sizeof(*params)) {
 284                 wpa_printf(MSG_DEBUG, "Invalid set_key request");
 285                 return;
 286         }
 287
 288         params = buf;
 289
 290         res = iface->driver->set_key(iface->ifname, iface->drv_priv,
 291                                      params->alg,
 292                                      params->addr, params->key_idx,
 293                                      params->set_tx,
 294                                      params->seq_len ? params->seq : NULL,
 295                                      params->seq_len,
 296                                      params->key_len ? params->key : NULL,
 297                                      params->key_len);
 298         wpa_printf(MSG_DEBUG, "drv->set_key: res=%d", res);
 299 }
 300
 301
 302 static void wpa_priv_cmd_get_capa(struct wpa_priv_interface *iface,
 303                                   struct sockaddr_un *from)
 304 {
 305         struct wpa_driver_capa capa;
 306
 307         if (iface->drv_priv == NULL)
 308                 goto fail;
 309
 310         if (iface->driver->get_capa == NULL ||
 311             iface->driver->get_capa(iface->drv_priv, &capa) < 0)
 312                 goto fail;
 313
 314         sendto(iface->fd, &capa, sizeof(capa), 0, (struct sockaddr *) from,
 315                sizeof(*from));
 316         return;
 317
 318 fail:
 319         sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
 320 }
 321
 322
 323 static void wpa_priv_l2_rx(void *ctx, const u8 *src_addr, const u8 *buf,
 324                            size_t len)
 325 {
 326         struct wpa_priv_interface *iface = ctx;
 327         struct msghdr msg;
 328         struct iovec io[2];
 329
 330         io[0].iov_base = (u8 *) src_addr;
 331         io[0].iov_len = ETH_ALEN;
 332         io[1].iov_base = (u8 *) buf;
 333         io[1].iov_len = len;
 334
 335         os_memset(&msg, 0, sizeof(msg));
 336         msg.msg_iov = io;
 337         msg.msg_iovlen = 2;
 338         msg.msg_name = &iface->l2_addr;
 339         msg.msg_namelen = sizeof(iface->l2_addr);
 340
 341         if (sendmsg(iface->fd, &msg, 0) < 0) {
 342                 perror("sendmsg(l2 rx)");
 343         }
 344 }
 345
 346
 347 static void wpa_priv_cmd_l2_register(struct wpa_priv_interface *iface,
 348                                      struct sockaddr_un *from,
 349                                      void *buf, size_t len)
 350 {
 351         int *reg_cmd = buf;
 352         u8 own_addr[ETH_ALEN];
 353         int res;
 354         u16 proto;
 355
 356         if (len != 2 * sizeof(int)) {
 357                 wpa_printf(MSG_DEBUG, "Invalid l2_register length %lu",
 358                            (unsigned long) len);
 359                 return;
 360         }
 361
 362         proto = reg_cmd[0];
 363         if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
 364                 wpa_printf(MSG_DEBUG, "Refused l2_packet connection for "
 365                            "ethertype 0x%x", proto);
 366                 return;
 367         }
 368
 369         if (iface->l2) {
 370                 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
 371                            "instance");
 372                 l2_packet_deinit(iface->l2);
 373                 iface->l2 = NULL;
 374         }
 375
 376         os_memcpy(&iface->l2_addr, from, sizeof(iface->l2_addr));
 377
 378         iface->l2 = l2_packet_init(iface->ifname, NULL, proto,
 379                                    wpa_priv_l2_rx, iface, reg_cmd[1]);
 380         if (iface->l2 == NULL) {
 381                 wpa_printf(MSG_DEBUG, "Failed to initialize l2_packet "
 382                            "instance for protocol %d", proto);
 383                 return;
 384         }
 385
 386         if (l2_packet_get_own_addr(iface->l2, own_addr) < 0) {
 387                 wpa_printf(MSG_DEBUG, "Failed to get own address from "
 388                            "l2_packet");
 389                 l2_packet_deinit(iface->l2);
 390                 iface->l2 = NULL;
 391                 return;
 392         }
 393
 394         res = sendto(iface->fd, own_addr, ETH_ALEN, 0,
 395                      (struct sockaddr *) from, sizeof(*from));
 396         wpa_printf(MSG_DEBUG, "L2 registration: res=%d", res);
 397 }
 398
 399
 400 static void wpa_priv_cmd_l2_unregister(struct wpa_priv_interface *iface,
 401                                        struct sockaddr_un *from)
 402 {
 403         if (iface->l2) {
 404                 l2_packet_deinit(iface->l2);
 405                 iface->l2 = NULL;
 406         }
 407 }
 408
 409
 410 static void wpa_priv_cmd_l2_notify_auth_start(struct wpa_priv_interface *iface,
 411                                               struct sockaddr_un *from)
 412 {
 413         if (iface->l2)
 414                 l2_packet_notify_auth_start(iface->l2);
 415 }
 416
 417
 418 static void wpa_priv_cmd_l2_send(struct wpa_priv_interface *iface,
 419                                  struct sockaddr_un *from,
 420                                  void *buf, size_t len)
 421 {
 422         u8 *dst_addr;
 423         u16 proto;
 424         int res;
 425
 426         if (iface->l2 == NULL)
 427                 return;
 428
 429         if (len < ETH_ALEN + 2) {
 430                 wpa_printf(MSG_DEBUG, "Too short L2 send packet (len=%lu)",
 431                            (unsigned long) len);
 432                 return;
 433         }
 434
 435         dst_addr = buf;
 436         os_memcpy(&proto, buf + ETH_ALEN, 2);
 437
 438         if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
 439                 wpa_printf(MSG_DEBUG, "Refused l2_packet send for ethertype "
 440                            "0x%x", proto);
 441                 return;
 442         }
 443
 444         res = l2_packet_send(iface->l2, dst_addr, proto, buf + ETH_ALEN + 2,
 445                              len - ETH_ALEN - 2);
 446         wpa_printf(MSG_DEBUG, "L2 send: res=%d", res);
 447 }
 448
 449
 450 static void wpa_priv_cmd_set_country(struct wpa_priv_interface *iface,
 451                                      char *buf)
 452 {
 453         if (iface->drv_priv == NULL || iface->driver->set_country == NULL ||
 454             *buf == '\0')
 455                 return;
 456
 457         iface->driver->set_country(iface->drv_priv, buf);
 458 }
 459
 460
 461 static void wpa_priv_receive(int sock, void *eloop_ctx, void *sock_ctx)
 462 {
 463         struct wpa_priv_interface *iface = eloop_ctx;
 464         char buf[2000], *pos;
 465         void *cmd_buf;
 466         size_t cmd_len;
 467         int res, cmd;
 468         struct sockaddr_un from;
 469         socklen_t fromlen = sizeof(from);
 470
 471         res = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &from,
 472                        &fromlen);
 473         if (res < 0) {
 474                 perror("recvfrom");
 475                 return;
 476         }
 477
 478         if (res < (int) sizeof(int)) {
 479                 wpa_printf(MSG_DEBUG, "Too short command (len=%d)", res);
 480                 return;
 481         }
 482
 483         os_memcpy(&cmd, buf, sizeof(int));
 484         wpa_printf(MSG_DEBUG, "Command %d for interface %s",
 485                    cmd, iface->ifname);
 486         cmd_buf = &buf[sizeof(int)];
 487         cmd_len = res - sizeof(int);
 488
 489         switch (cmd) {
 490         case PRIVSEP_CMD_REGISTER:
 491                 wpa_priv_cmd_register(iface, &from);
 492                 break;
 493         case PRIVSEP_CMD_UNREGISTER:
 494                 wpa_priv_cmd_unregister(iface, &from);
 495                 break;
 496         case PRIVSEP_CMD_SCAN:
 497                 wpa_priv_cmd_scan(iface, cmd_buf, cmd_len);
 498                 break;
 499         case PRIVSEP_CMD_GET_SCAN_RESULTS:
 500                 wpa_priv_cmd_get_scan_results(iface, &from);
 501                 break;
 502         case PRIVSEP_CMD_ASSOCIATE:
 503                 wpa_priv_cmd_associate(iface, cmd_buf, cmd_len);
 504                 break;
 505         case PRIVSEP_CMD_GET_BSSID:
 506                 wpa_priv_cmd_get_bssid(iface, &from);
 507                 break;
 508         case PRIVSEP_CMD_GET_SSID:
 509                 wpa_priv_cmd_get_ssid(iface, &from);
 510                 break;
 511         case PRIVSEP_CMD_SET_KEY:
 512                 wpa_priv_cmd_set_key(iface, cmd_buf, cmd_len);
 513                 break;
 514         case PRIVSEP_CMD_GET_CAPA:
 515                 wpa_priv_cmd_get_capa(iface, &from);
 516                 break;
 517         case PRIVSEP_CMD_L2_REGISTER:
 518                 wpa_priv_cmd_l2_register(iface, &from, cmd_buf, cmd_len);
 519                 break;
 520         case PRIVSEP_CMD_L2_UNREGISTER:
 521                 wpa_priv_cmd_l2_unregister(iface, &from);
 522                 break;
 523         case PRIVSEP_CMD_L2_NOTIFY_AUTH_START:
 524                 wpa_priv_cmd_l2_notify_auth_start(iface, &from);
 525                 break;
 526         case PRIVSEP_CMD_L2_SEND:
 527                 wpa_priv_cmd_l2_send(iface, &from, cmd_buf, cmd_len);
 528                 break;
 529         case PRIVSEP_CMD_SET_COUNTRY:
 530                 pos = cmd_buf;
 531                 if (pos + cmd_len >= buf + sizeof(buf))
 532                         break;
 533                 pos[cmd_len] = '\0';
 534                 wpa_priv_cmd_set_country(iface, pos);
 535                 break;
 536         }
 537 }
 538
 539
 540 static void wpa_priv_interface_deinit(struct wpa_priv_interface *iface)
 541 {
 542         if (iface->drv_priv && iface->driver->deinit)
 543                 iface->driver->deinit(iface->drv_priv);
 544
 545         if (iface->fd >= 0) {
 546                 eloop_unregister_read_sock(iface->fd);
 547                 close(iface->fd);
 548                 unlink(iface->sock_name);
 549         }
 550
 551         if (iface->l2)
 552                 l2_packet_deinit(iface->l2);
 553
 554         os_free(iface->ifname);
 555         os_free(iface->driver_name);
 556         os_free(iface->sock_name);
 557         os_free(iface);
 558 }
 559
 560
 561 extern struct wpa_driver_ops *wpa_drivers[];
 562
 563 static struct wpa_priv_interface *
 564 wpa_priv_interface_init(const char *dir, const char *params)
 565 {
 566         struct wpa_priv_interface *iface;
 567         char *pos;
 568         size_t len;
 569         struct sockaddr_un addr;
 570         int i;
 571
 572         pos = os_strchr(params, ':');
 573         if (pos == NULL)
 574                 return NULL;
 575
 576         iface = os_zalloc(sizeof(*iface));
 577         if (iface == NULL)
 578                 return NULL;
 579         iface->fd = -1;
 580
 581         len = pos - params;
 582         iface->driver_name = os_malloc(len + 1);
 583         if (iface->driver_name == NULL) {
 584                 wpa_priv_interface_deinit(iface);
 585                 return NULL;
 586         }
 587         os_memcpy(iface->driver_name, params, len);
 588         iface->driver_name[len] = '\0';
 589
 590         for (i = 0; wpa_drivers[i]; i++) {
 591                 if (os_strcmp(iface->driver_name,
 592                               wpa_drivers[i]->name) == 0) {
 593                         iface->driver = wpa_drivers[i];
 594                         break;
 595                 }
 596         }
 597         if (iface->driver == NULL) {
 598                 wpa_printf(MSG_ERROR, "Unsupported driver '%s'",
 599                            iface->driver_name);
 600                 wpa_priv_interface_deinit(iface);
 601                 return NULL;
 602         }
 603
 604         pos++;
 605         iface->ifname = os_strdup(pos);
 606         if (iface->ifname == NULL) {
 607                 wpa_priv_interface_deinit(iface);
 608                 return NULL;
 609         }
 610
 611         len = os_strlen(dir) + 1 + os_strlen(iface->ifname);
 612         iface->sock_name = os_malloc(len + 1);
 613         if (iface->sock_name == NULL) {
 614                 wpa_priv_interface_deinit(iface);
 615                 return NULL;
 616         }
 617
 618         os_snprintf(iface->sock_name, len + 1, "%s/%s", dir, iface->ifname);
 619         if (os_strlen(iface->sock_name) >= sizeof(addr.sun_path)) {
 620                 wpa_priv_interface_deinit(iface);
 621                 return NULL;
 622         }
 623
 624         iface->fd = socket(PF_UNIX, SOCK_DGRAM, 0);
 625         if (iface->fd < 0) {
 626                 perror("socket(PF_UNIX)");
 627                 wpa_priv_interface_deinit(iface);
 628                 return NULL;
 629         }
 630
 631         os_memset(&addr, 0, sizeof(addr));
 632         addr.sun_family = AF_UNIX;
 633         os_strlcpy(addr.sun_path, iface->sock_name, sizeof(addr.sun_path));
 634
 635         if (bind(iface->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 636                 wpa_printf(MSG_DEBUG, "bind(PF_UNIX) failed: %s",
 637                            strerror(errno));
 638                 if (connect(iface->fd, (struct sockaddr *) &addr,
 639                             sizeof(addr)) < 0) {
 640                         wpa_printf(MSG_DEBUG, "Socket exists, but does not "
 641                                    "allow connections - assuming it was "
 642                                    "leftover from forced program termination");
 643                         if (unlink(iface->sock_name) < 0) {
 644                                 perror("unlink[ctrl_iface]");
 645                                 wpa_printf(MSG_ERROR, "Could not unlink "
 646                                            "existing ctrl_iface socket '%s'",
 647                                            iface->sock_name);
 648                                 goto fail;
 649                         }
 650                         if (bind(iface->fd, (struct sockaddr *) &addr,
 651                                  sizeof(addr)) < 0) {
 652                                 perror("bind(PF_UNIX)");
 653                                 goto fail;
 654                         }
 655                         wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
 656                                    "socket '%s'", iface->sock_name);
 657                 } else {
 658                         wpa_printf(MSG_INFO, "Socket exists and seems to be "
 659                                    "in use - cannot override it");
 660                         wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
 661                                    "not used anymore", iface->sock_name);
 662                         goto fail;
 663                 }
 664         }
 665
 666         if (chmod(iface->sock_name, S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
 667                 perror("chmod");
 668                 goto fail;
 669         }
 670
 671         eloop_register_read_sock(iface->fd, wpa_priv_receive, iface, NULL);
 672
 673         return iface;
 674
 675 fail:
 676         wpa_priv_interface_deinit(iface);
 677         return NULL;
 678 }
 679
 680
 681 static int wpa_priv_send_event(struct wpa_priv_interface *iface, int event,
 682                                const void *data, size_t data_len)
 683 {
 684         struct msghdr msg;
 685         struct iovec io[2];
 686
 687         io[0].iov_base = &event;
 688         io[0].iov_len = sizeof(event);
 689         io[1].iov_base = (u8 *) data;
 690         io[1].iov_len = data_len;
 691
 692         os_memset(&msg, 0, sizeof(msg));
 693         msg.msg_iov = io;
 694         msg.msg_iovlen = data ? 2 : 1;
 695         msg.msg_name = &iface->drv_addr;
 696         msg.msg_namelen = sizeof(iface->drv_addr);
 697
 698         if (sendmsg(iface->fd, &msg, 0) < 0) {
 699                 perror("sendmsg(wpas_socket)");
 700                 return -1;
 701         }
 702
 703         return 0;
 704 }
 705
 706
 707 static void wpa_priv_send_assoc(struct wpa_priv_interface *iface, int event,
 708                                 union wpa_event_data *data)
 709 {
 710         size_t buflen = 3 * sizeof(int);
 711         u8 *buf, *pos;
 712         int len;
 713
 714         if (data) {
 715                 buflen += data->assoc_info.req_ies_len +
 716                         data->assoc_info.resp_ies_len +
 717                         data->assoc_info.beacon_ies_len;
 718         }
 719
 720         buf = os_malloc(buflen);
 721         if (buf == NULL)
 722                 return;
 723
 724         pos = buf;
 725
 726         if (data && data->assoc_info.req_ies) {
 727                 len = data->assoc_info.req_ies_len;
 728                 os_memcpy(pos, &len, sizeof(int));
 729                 pos += sizeof(int);
 730                 os_memcpy(pos, data->assoc_info.req_ies, len);
 731                 pos += len;
 732         } else {
 733                 len = 0;
 734                 os_memcpy(pos, &len, sizeof(int));
 735                 pos += sizeof(int);
 736         }
 737
 738         if (data && data->assoc_info.resp_ies) {
 739                 len = data->assoc_info.resp_ies_len;
 740                 os_memcpy(pos, &len, sizeof(int));
 741                 pos += sizeof(int);
 742                 os_memcpy(pos, data->assoc_info.resp_ies, len);
 743                 pos += len;
 744         } else {
 745                 len = 0;
 746                 os_memcpy(pos, &len, sizeof(int));
 747                 pos += sizeof(int);
 748         }
 749
 750         if (data && data->assoc_info.beacon_ies) {
 751                 len = data->assoc_info.beacon_ies_len;
 752                 os_memcpy(pos, &len, sizeof(int));
 753                 pos += sizeof(int);
 754                 os_memcpy(pos, data->assoc_info.beacon_ies, len);
 755                 pos += len;
 756         } else {
 757                 len = 0;
 758                 os_memcpy(pos, &len, sizeof(int));
 759                 pos += sizeof(int);
 760         }
 761
 762         wpa_priv_send_event(iface, event, buf, buflen);
 763
 764         os_free(buf);
 765 }
 766
 767
 768 static void wpa_priv_send_interface_status(struct wpa_priv_interface *iface,
 769                                            union wpa_event_data *data)
 770 {
 771         int ievent;
 772         size_t len, maxlen;
 773         u8 *buf;
 774         char *ifname;
 775
 776         if (data == NULL)
 777                 return;
 778
 779         ievent = data->interface_status.ievent;
 780         maxlen = sizeof(data->interface_status.ifname);
 781         ifname = data->interface_status.ifname;
 782         for (len = 0; len < maxlen && ifname[len]; len++)
 783                 ;
 784
 785         buf = os_malloc(sizeof(int) + len);
 786         if (buf == NULL)
 787                 return;
 788
 789         os_memcpy(buf, &ievent, sizeof(int));
 790         os_memcpy(buf + sizeof(int), ifname, len);
 791
 792         wpa_priv_send_event(iface, PRIVSEP_EVENT_INTERFACE_STATUS,
 793                             buf, sizeof(int) + len);
 794
 795         os_free(buf);
 796
 797 }
 798
 799
 800 static void wpa_priv_send_ft_response(struct wpa_priv_interface *iface,
 801                                       union wpa_event_data *data)
 802 {
 803         size_t len;
 804         u8 *buf, *pos;
 805
 806         if (data == NULL || data->ft_ies.ies == NULL)
 807                 return;
 808
 809         len = sizeof(int) + ETH_ALEN + data->ft_ies.ies_len;
 810         buf = os_malloc(len);
 811         if (buf == NULL)
 812                 return;
 813
 814         pos = buf;
 815         os_memcpy(pos, &data->ft_ies.ft_action, sizeof(int));
 816         pos += sizeof(int);
 817         os_memcpy(pos, data->ft_ies.target_ap, ETH_ALEN);
 818         pos += ETH_ALEN;
 819         os_memcpy(pos, data->ft_ies.ies, data->ft_ies.ies_len);
 820
 821         wpa_priv_send_event(iface, PRIVSEP_EVENT_FT_RESPONSE, buf, len);
 822
 823         os_free(buf);
 824
 825 }
 826
 827
 828 void wpa_supplicant_event(void *ctx, wpa_event_type event,
 829                           union wpa_event_data *data)
 830 {
 831         struct wpa_priv_interface *iface = ctx;
 832
 833         wpa_printf(MSG_DEBUG, "%s - event=%d", __func__, event);
 834
 835         if (!iface->wpas_registered) {
 836                 wpa_printf(MSG_DEBUG, "Driver event received, but "
 837                            "wpa_supplicant not registered");
 838                 return;
 839         }
 840
 841         switch (event) {
 842         case EVENT_ASSOC:
 843                 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOC, data);
 844                 break;
 845         case EVENT_DISASSOC:
 846                 wpa_priv_send_event(iface, PRIVSEP_EVENT_DISASSOC, NULL, 0);
 847                 break;
 848         case EVENT_ASSOCINFO:
 849                 if (data == NULL)
 850                         return;
 851                 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOCINFO, data);
 852                 break;
 853         case EVENT_MICHAEL_MIC_FAILURE:
 854                 if (data == NULL)
 855                         return;
 856                 wpa_priv_send_event(iface, PRIVSEP_EVENT_MICHAEL_MIC_FAILURE,
 857                                     &data->michael_mic_failure.unicast,
 858                                     sizeof(int));
 859                 break;
 860         case EVENT_SCAN_RESULTS:
 861                 wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_RESULTS, NULL,
 862                                     0);
 863                 break;
 864         case EVENT_INTERFACE_STATUS:
 865                 wpa_priv_send_interface_status(iface, data);
 866                 break;
 867         case EVENT_PMKID_CANDIDATE:
 868                 if (data == NULL)
 869                         return;
 870                 wpa_priv_send_event(iface, PRIVSEP_EVENT_PMKID_CANDIDATE,
 871                                     &data->pmkid_candidate,
 872                                     sizeof(struct pmkid_candidate));
 873                 break;
 874         case EVENT_STKSTART:
 875                 if (data == NULL)
 876                         return;
 877                 wpa_priv_send_event(iface, PRIVSEP_EVENT_STKSTART,
 878                                     &data->stkstart.peer, ETH_ALEN);
 879                 break;
 880         case EVENT_FT_RESPONSE:
 881                 wpa_priv_send_ft_response(iface, data);
 882                 break;
 883         default:
 884                 wpa_printf(MSG_DEBUG, "Unsupported driver event %d - TODO",
 885                            event);
 886                 break;
 887         }
 888 }
 889
 890
 891 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
 892                              const u8 *buf, size_t len)
 893 {
 894         struct wpa_priv_interface *iface = ctx;
 895         struct msghdr msg;
 896         struct iovec io[3];
 897         int event = PRIVSEP_EVENT_RX_EAPOL;
 898
 899         wpa_printf(MSG_DEBUG, "RX EAPOL from driver");
 900         io[0].iov_base = &event;
 901         io[0].iov_len = sizeof(event);
 902         io[1].iov_base = (u8 *) src_addr;
 903         io[1].iov_len = ETH_ALEN;
 904         io[2].iov_base = (u8 *) buf;
 905         io[2].iov_len = len;
 906
 907         os_memset(&msg, 0, sizeof(msg));
 908         msg.msg_iov = io;
 909         msg.msg_iovlen = 3;
 910         msg.msg_name = &iface->drv_addr;
 911         msg.msg_namelen = sizeof(iface->drv_addr);
 912
 913         if (sendmsg(iface->fd, &msg, 0) < 0)
 914                 perror("sendmsg(wpas_socket)");
 915 }
 916
 917
 918 static void wpa_priv_terminate(int sig, void *eloop_ctx, void *signal_ctx)
 919 {
 920         wpa_printf(MSG_DEBUG, "wpa_priv termination requested");
 921         eloop_terminate();
 922 }
 923
 924
 925 static void wpa_priv_fd_workaround(void)
 926 {
 927 #ifdef __linux__
 928         int s, i;
 929         /* When started from pcmcia-cs scripts, wpa_supplicant might start with
 930          * fd 0, 1, and 2 closed. This will cause some issues because many
 931          * places in wpa_supplicant are still printing out to stdout. As a
 932          * workaround, make sure that fd's 0, 1, and 2 are not used for other
 933          * sockets. */
 934         for (i = 0; i < 3; i++) {
 935                 s = open("/dev/null", O_RDWR);
 936                 if (s > 2) {
 937                         close(s);
 938                         break;
 939                 }
 940         }
 941 #endif /* __linux__ */
 942 }
 943
 944
 945 static void usage(void)
 946 {
 947         printf("wpa_priv v" VERSION_STR "\n"
 948                "Copyright (c) 2007-2009, Jouni Malinen <j@w1.fi> and "
 949                "contributors\n"
 950                "\n"
 951                "usage:\n"
 952                "  wpa_priv [-Bdd] [-P<pid file>] <driver:ifname> "
 953                "[driver:ifname ...]\n");
 954 }
 955
 956
 957 extern int wpa_debug_level;
 958
 959 int main(int argc, char *argv[])
 960 {
 961         int c, i;
 962         int ret = -1;
 963         char *pid_file = NULL;
 964         int daemonize = 0;
 965         char *ctrl_dir = "/var/run/wpa_priv";
 966         struct wpa_priv_interface *interfaces = NULL, *iface;
 967
 968         if (os_program_init())
 969                 return -1;
 970
 971         wpa_priv_fd_workaround();
 972
 973         for (;;) {
 974                 c = getopt(argc, argv, "Bc:dP:");
 975                 if (c < 0)
 976                         break;
 977                 switch (c) {
 978                 case 'B':
 979                         daemonize++;
 980                         break;
 981                 case 'c':
 982                         ctrl_dir = optarg;
 983                         break;
 984                 case 'd':
 985                         wpa_debug_level--;
 986                         break;
 987                 case 'P':
 988                         pid_file = os_rel2abs_path(optarg);
 989                         break;
 990                 default:
 991                         usage();
 992                         goto out;
 993                 }
 994         }
 995
 996         if (optind >= argc) {
 997                 usage();
 998                 goto out;
 999         }
1000
1001         wpa_printf(MSG_DEBUG, "wpa_priv control directory: '%s'", ctrl_dir);
1002
1003         if (eloop_init()) {
1004                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1005                 goto out;
1006         }
1007
1008         for (i = optind; i < argc; i++) {
1009                 wpa_printf(MSG_DEBUG, "Adding driver:interface %s", argv[i]);
1010                 iface = wpa_priv_interface_init(ctrl_dir, argv[i]);
1011                 if (iface == NULL)
1012                         goto out;
1013                 iface->next = interfaces;
1014                 interfaces = iface;
1015         }
1016
1017         if (daemonize && os_daemonize(pid_file))
1018                 goto out;
1019
1020         eloop_register_signal_terminate(wpa_priv_terminate, NULL);
1021         eloop_run();
1022
1023         ret = 0;
1024
1025 out:
1026         iface = interfaces;
1027         while (iface) {
1028                 struct wpa_priv_interface *prev = iface;
1029                 iface = iface->next;
1030                 wpa_priv_interface_deinit(prev);
1031         }
1032
1033         eloop_destroy();
1034
1035         os_daemonize_terminate(pid_file);
1036         os_free(pid_file);
1037         os_program_deinit();
1038
1039         return ret;
1040 }