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