src/drivers/driver_prism54.c

   1 /*
   2  * WPA Supplicant - driver interaction with Linux Prism54.org driver
   3  * Copyright (c) 2002-2007, Jouni Malinen <j@w1.fi>
   4  * Copyright (c) 2004, Luis R. Rodriguez <mcgrof@ruslug.rutgers.edu>
   5  * Copyright (c) 2004, Bell Kin <bell_kin@pek.com.tw>
   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  * Alternatively, this software may be distributed under the terms of BSD
  12  * license.
  13  *
  14  * See README and COPYING for more details.
  15  */
  16
  17 #include "includes.h"
  18 #include <sys/ioctl.h>
  19
  20 #include "wireless_copy.h"
  21 #include "common.h"
  22 #include "driver.h"
  23 #include "driver_wext.h"
  24 #include "driver_hostap.h"
  25
  26 #ifdef HOSTAPD
  27
  28 #include <net/if_arp.h>
  29 #include <netpacket/packet.h>
  30
  31 #include "driver.h"
  32 #include "eloop.h"
  33 #include "prism54.h"
  34 #include "radius/radius.h"
  35 #include "../../hostapd/hostapd.h"
  36 #include "../../hostapd/config.h"
  37 #include "../../hostapd/ieee802_1x.h"
  38 #include "../../hostapd/ieee802_11.h"
  39 #include "../../hostapd/wpa.h"
  40 #include "../../hostapd/sta_info.h"
  41 #include "../../hostapd/accounting.h"
  42
  43
  44 const int PIM_BUF_SIZE = 4096;
  45
  46 struct prism54_driver_data {
  47         struct hostapd_data *hapd;
  48         char iface[IFNAMSIZ + 1];
  49         int sock; /* raw packet socket for 802.3 access */
  50         int pim_sock; /* socket for pimfor packet */
  51         char macs[2007][6];
  52 };
  53
  54
  55 static int mac_id_refresh(struct prism54_driver_data *data, int id, char *mac)
  56 {
  57         if (id < 0 || id > 2006) {
  58                 return -1;
  59         }
  60         memcpy(&data->macs[id][0], mac, ETH_ALEN);
  61         return 0;
  62 }
  63
  64
  65 static char * mac_id_get(struct prism54_driver_data *data, int id)
  66 {
  67         if (id < 0 || id > 2006) {
  68                 return NULL;
  69         }
  70         return &data->macs[id][0];
  71 }
  72
  73
  74 /* wait for a specific pimfor, timeout in 10ms resolution */
  75 /* pim_sock must be non-block to prevent dead lock from no response */
  76 /* or same response type in series */
  77 static int prism54_waitpim(void *priv, unsigned long oid, void *buf, int len,
  78                            int timeout)
  79 {
  80         struct prism54_driver_data *drv = priv;
  81         struct timeval tv, stv, ctv;
  82         fd_set pfd;
  83         int rlen;
  84         pimdev_hdr *pkt;
  85
  86         pkt = malloc(8192);
  87         if (pkt == NULL)
  88                 return -1;
  89
  90         FD_ZERO(&pfd);
  91         gettimeofday(&stv, NULL);
  92         do {
  93                 FD_SET(drv->pim_sock, &pfd);
  94                 tv.tv_sec = 0;
  95                 tv.tv_usec = 10000;
  96                 if (select(drv->pim_sock + 1, &pfd, NULL, NULL, &tv)) {
  97                         rlen = recv(drv->pim_sock, pkt, 8192, 0);
  98                         if (rlen > 0) {
  99                                 if (pkt->oid == htonl(oid)) {
 100                                         if (rlen <= len) {
 101                                                 if (buf != NULL) {
 102                                                         memcpy(buf, pkt, rlen);
 103                                                 }
 104                                                 free(pkt);
 105                                                 return rlen;
 106                                         } else {
 107                                                 printf("buffer too small\n");
 108                                                 free(pkt);
 109                                                 return -1;
 110                                         }
 111                                 } else {
 112                                         gettimeofday(&ctv, NULL);
 113                                         continue;
 114                                 }
 115                         }
 116                 }
 117                 gettimeofday(&ctv, NULL);
 118         } while (((ctv.tv_sec - stv.tv_sec) * 100 +
 119                   (ctv.tv_usec - stv.tv_usec) / 10000) > timeout);
 120         free(pkt);
 121         return 0;
 122 }
 123
 124
 125 /* send an eapol packet */
 126 static int prism54_send_eapol(void *priv, const u8 *addr,
 127                               const u8 *data, size_t data_len, int encrypt,
 128                               const u8 *own_addr)
 129 {
 130         struct prism54_driver_data *drv = priv;
 131         ieee802_3_hdr *hdr;
 132         size_t len;
 133         u8 *pos;
 134         int res;
 135
 136         len = sizeof(*hdr) + data_len;
 137         hdr = os_zalloc(len);
 138         if (hdr == NULL) {
 139                 printf("malloc() failed for prism54_send_data(len=%lu)\n",
 140                        (unsigned long) len);
 141                 return -1;
 142         }
 143
 144         memcpy(&hdr->da[0], addr, ETH_ALEN);
 145         memcpy(&hdr->sa[0], own_addr, ETH_ALEN);
 146         hdr->type = htons(ETH_P_PAE);
 147         pos = (u8 *) (hdr + 1);
 148         memcpy(pos, data, data_len);
 149
 150         res = send(drv->sock, hdr, len, 0);
 151         free(hdr);
 152
 153         if (res < 0) {
 154                 perror("hostapd_send_eapol: send");
 155                 printf("hostapd_send_eapol - packet len: %lu - failed\n",
 156                        (unsigned long) len);
 157         }
 158
 159         return res;
 160 }
 161
 162
 163 /* open data channel(auth-1) or eapol only(unauth-0) */
 164 static int prism54_set_sta_authorized(void *priv, const u8 *addr,
 165                                       int authorized)
 166 {
 167         struct prism54_driver_data *drv = priv;
 168         pimdev_hdr *hdr;
 169         char *pos;
 170
 171         hdr = os_zalloc(sizeof(*hdr) + ETH_ALEN);
 172         if (hdr == NULL)
 173                 return -1;
 174         hdr->op = htonl(PIMOP_SET);
 175         if (authorized) {
 176                 hdr->oid = htonl(DOT11_OID_EAPAUTHSTA);
 177         } else {
 178                 hdr->oid = htonl(DOT11_OID_EAPUNAUTHSTA);
 179         }
 180         pos = (char *) (hdr + 1);
 181         memcpy(pos, addr, ETH_ALEN);
 182         send(drv->pim_sock, hdr, sizeof(*hdr) + ETH_ALEN, 0);
 183         prism54_waitpim(priv, hdr->oid, hdr, sizeof(*hdr) + ETH_ALEN, 10);
 184         free(hdr);
 185         return 0;
 186 }
 187
 188
 189 static int
 190 prism54_sta_set_flags(void *priv, const u8 *addr, int total_flags,
 191                       int flags_or, int flags_and)
 192 {
 193         /* For now, only support setting Authorized flag */
 194         if (flags_or & WLAN_STA_AUTHORIZED)
 195                 return prism54_set_sta_authorized(priv, addr, 1);
 196         if (flags_and & WLAN_STA_AUTHORIZED)
 197                 return prism54_set_sta_authorized(priv, addr, 0);
 198         return 0;
 199 }
 200
 201
 202 static int wpa_driver_prism54_set_key(const char *ifname, void *priv,
 203                                       wpa_alg alg, const u8 *addr, int key_idx,
 204                                       int set_tx,
 205                                       const u8 *seq, size_t seq_len,
 206                                       const u8 *key, size_t key_len)
 207 {
 208         struct prism54_driver_data *drv = priv;
 209         pimdev_hdr *hdr;
 210         struct obj_stakey *keys;
 211         u8 *buf;
 212         size_t blen;
 213         int ret = 0;
 214
 215         blen = sizeof(struct obj_stakey) + sizeof(pimdev_hdr);
 216         hdr = os_zalloc(blen);
 217         if (hdr == NULL) {
 218                 printf("memory low\n");
 219                 return -1;
 220         }
 221         keys = (struct obj_stakey *) &hdr[1];
 222         if (!addr) {
 223                 memset(&keys->address[0], 0xff, ETH_ALEN);
 224         } else {
 225                 memcpy(&keys->address[0], addr, ETH_ALEN);
 226         }
 227         switch (alg) {
 228         case WPA_ALG_WEP:
 229                 keys->type = DOT11_PRIV_WEP;
 230                 break;
 231         case WPA_ALG_TKIP:
 232                 keys->type = DOT11_PRIV_TKIP;
 233                 break;
 234         case WPA_ALG_NONE:
 235                 /* the only way to clear the key is to deauth it */
 236                 /* and prism54 is capable to receive unencrypted packet */
 237                 /* so we do nothing here */
 238                 free(hdr);
 239                 return 0;
 240         default:
 241                 printf("bad auth type: %d\n", alg);
 242                 free(hdr);
 243                 return -1;
 244         }
 245         buf = (u8 *) &keys->key[0];
 246         keys->length = key_len;
 247         keys->keyid = key_idx;
 248         keys->options = htons(DOT11_STAKEY_OPTION_DEFAULTKEY);
 249         keys->reserved = 0;
 250
 251         hdr->op = htonl(PIMOP_SET);
 252         hdr->oid = htonl(DOT11_OID_STAKEY);
 253
 254         memcpy(buf, key, key_len);
 255
 256         ret = send(drv->pim_sock, hdr, blen, 0);
 257         if (ret < 0) {
 258                 free(hdr);
 259                 return ret;
 260         }
 261         prism54_waitpim(priv, hdr->oid, hdr, blen, 10);
 262
 263         free(hdr);
 264
 265         return 0;
 266 }
 267
 268
 269 /* get TKIP station sequence counter, prism54 is only 6 bytes */
 270 static int prism54_get_seqnum(const char *ifname, void *priv, const u8 *addr,
 271                               int idx, u8 *seq)
 272 {
 273         struct prism54_driver_data *drv = priv;
 274         struct obj_stasc *stasc;
 275         pimdev_hdr *hdr;
 276         size_t blen;
 277         int ret = 0;
 278
 279         blen = sizeof(*stasc) + sizeof(*hdr);
 280         hdr = os_zalloc(blen);
 281         if (hdr == NULL)
 282                 return -1;
 283
 284         stasc = (struct obj_stasc *) &hdr[1];
 285
 286         if (addr == NULL)
 287                 memset(&stasc->address[0], 0xff, ETH_ALEN);
 288         else
 289                 memcpy(&stasc->address[0], addr, ETH_ALEN);
 290
 291         hdr->oid = htonl(DOT11_OID_STASC);
 292         hdr->op = htonl(PIMOP_GET);
 293         stasc->keyid = idx;
 294         if (send(drv->pim_sock,hdr,blen,0) <= 0) {
 295                 free(hdr);
 296                 return -1;
 297         }
 298         if (prism54_waitpim(priv, DOT11_OID_STASC, hdr, blen, 10) <= 0) {
 299                 ret = -1;
 300         } else {
 301                 if (hdr->op == (int) htonl(PIMOP_RESPONSE)) {
 302                         memcpy(seq + 2, &stasc->sc_high, ETH_ALEN);
 303                         memset(seq, 0, 2);
 304                 } else {
 305                         ret = -1;
 306                 }
 307         }
 308         free(hdr);
 309
 310         return ret;
 311 }
 312
 313
 314 /* include unencrypted, set mlme autolevel to extended */
 315 static int prism54_init_1x(void *priv)
 316 {
 317         struct prism54_driver_data *drv = priv;
 318         pimdev_hdr *hdr;
 319         unsigned long *ul;
 320         int blen = sizeof(*hdr) + sizeof(*ul);
 321
 322         hdr = os_zalloc(blen);
 323         if (hdr == NULL)
 324                 return -1;
 325
 326         ul = (unsigned long *) &hdr[1];
 327         hdr->op = htonl(PIMOP_SET);
 328         hdr->oid = htonl(DOT11_OID_EXUNENCRYPTED);
 329         *ul = htonl(DOT11_BOOL_TRUE); /* not accept */
 330         send(drv->pim_sock, hdr, blen, 0);
 331         prism54_waitpim(priv, DOT11_OID_EXUNENCRYPTED, hdr, blen, 10);
 332         hdr->op = htonl(PIMOP_SET);
 333         hdr->oid = htonl(DOT11_OID_MLMEAUTOLEVEL);
 334         *ul = htonl(DOT11_MLME_EXTENDED);
 335         send(drv->pim_sock, hdr, blen, 0);
 336         prism54_waitpim(priv, DOT11_OID_MLMEAUTOLEVEL, hdr, blen, 10);
 337         hdr->op = htonl(PIMOP_SET);
 338         hdr->oid = htonl(DOT11_OID_DOT1XENABLE);
 339         *ul = htonl(DOT11_BOOL_TRUE);
 340         send(drv->pim_sock, hdr, blen, 0);
 341         prism54_waitpim(priv, DOT11_OID_DOT1XENABLE, hdr, blen, 10);
 342         hdr->op = htonl(PIMOP_SET);
 343         hdr->oid = htonl(DOT11_OID_AUTHENABLE);
 344         *ul = htonl(DOT11_AUTH_OS); /* OS */
 345         send(drv->pim_sock, hdr, blen, 0);
 346         prism54_waitpim(priv, DOT11_OID_AUTHENABLE, hdr, blen, 10);
 347         free(hdr);
 348         return 0;
 349 }
 350
 351
 352 static int prism54_set_privacy_invoked(const char *ifname, void *priv,
 353                                        int flag)
 354 {
 355         struct prism54_driver_data *drv = priv;
 356         pimdev_hdr *hdr;
 357         unsigned long *ul;
 358         int ret;
 359         int blen = sizeof(*hdr) + sizeof(*ul);
 360         hdr = os_zalloc(blen);
 361         if (hdr == NULL)
 362                 return -1;
 363         ul = (unsigned long *) &hdr[1];
 364         hdr->op = htonl(PIMOP_SET);
 365         hdr->oid = htonl(DOT11_OID_PRIVACYINVOKED);
 366         if (flag) {
 367                 *ul = htonl(DOT11_BOOL_TRUE); /* has privacy */
 368         } else {
 369                 *ul = 0;
 370         }
 371         ret = send(drv->pim_sock, hdr, blen, 0);
 372         if (ret >= 0) {
 373                 ret = prism54_waitpim(priv, DOT11_OID_PRIVACYINVOKED, hdr,
 374                                       blen, 10);
 375         }
 376         free(hdr);
 377         return ret;
 378 }
 379
 380
 381 static int prism54_ioctl_setiwessid(const char *ifname, void *priv,
 382                                     const u8 *buf, int len)
 383 {
 384 #if 0
 385         struct prism54_driver_data *drv = priv;
 386         struct iwreq iwr;
 387
 388         memset(&iwr, 0, sizeof(iwr));
 389         os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
 390         iwr.u.essid.flags = 1; /* SSID active */
 391         iwr.u.essid.pointer = (caddr_t) buf;
 392         iwr.u.essid.length = len + 1;
 393
 394         if (ioctl(drv->pim_sock, SIOCSIWESSID, &iwr) < 0) {
 395                 perror("ioctl[SIOCSIWESSID]");
 396                 printf("len=%d\n", len);
 397                 return -1;
 398         }
 399 #endif
 400         return 0;
 401 }
 402
 403
 404 /* kick all stations */
 405 /* does not work during init, but at least it won't crash firmware */
 406 static int prism54_flush(void *priv)
 407 {
 408         struct prism54_driver_data *drv = priv;
 409         struct obj_mlmeex *mlme;
 410         pimdev_hdr *hdr;
 411         int ret;
 412         unsigned int i;
 413         long *nsta;
 414         int blen = sizeof(*hdr) + sizeof(*mlme);
 415         char *mac_id;
 416
 417         hdr = os_zalloc(blen);
 418         if (hdr == NULL)
 419                 return -1;
 420
 421         mlme = (struct obj_mlmeex *) &hdr[1];
 422         nsta = (long *) &hdr[1];
 423         hdr->op = htonl(PIMOP_GET);
 424         hdr->oid = htonl(DOT11_OID_CLIENTS);
 425         ret = send(drv->pim_sock, hdr, sizeof(*hdr) + sizeof(long), 0);
 426         ret = prism54_waitpim(priv, DOT11_OID_CLIENTS, hdr, blen, 10);
 427         if ((ret < 0) || (hdr->op != (int) htonl(PIMOP_RESPONSE)) ||
 428             (le_to_host32(*nsta) > 2007)) {
 429                 free(hdr);
 430                 return 0;
 431         }
 432         for (i = 0; i < le_to_host32(*nsta); i++) {
 433                 mlme->id = -1;
 434                 mac_id = mac_id_get(drv, i);
 435                 if (mac_id)
 436                         memcpy(&mlme->address[0], mac_id, ETH_ALEN);
 437                 mlme->code = host_to_le16(WLAN_REASON_UNSPECIFIED);
 438                 mlme->state = htons(DOT11_STATE_NONE);
 439                 mlme->size = 0;
 440                 hdr->op = htonl(PIMOP_SET);
 441                 hdr->oid = htonl(DOT11_OID_DISASSOCIATEEX);
 442                 ret = send(drv->pim_sock, hdr, blen, 0);
 443                 prism54_waitpim(priv, DOT11_OID_DISASSOCIATEEX, hdr, blen,
 444                                 100);
 445         }
 446         for (i = 0; i < le_to_host32(*nsta); i++) {
 447                 mlme->id = -1;
 448                 mac_id = mac_id_get(drv, i);
 449                 if (mac_id)
 450                         memcpy(&mlme->address[0], mac_id, ETH_ALEN);
 451                 mlme->code = host_to_le16(WLAN_REASON_UNSPECIFIED);
 452                 mlme->state = htons(DOT11_STATE_NONE);
 453                 mlme->size = 0;
 454                 hdr->op = htonl(PIMOP_SET);
 455                 hdr->oid = htonl(DOT11_OID_DEAUTHENTICATEEX);
 456                 ret = send(drv->pim_sock, hdr, blen, 0);
 457                 prism54_waitpim(priv, DOT11_OID_DEAUTHENTICATEEX, hdr, blen,
 458                                 100);
 459         }
 460         free(hdr);
 461         return 0;
 462 }
 463
 464
 465 static int prism54_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr,
 466                               int reason)
 467 {
 468         struct prism54_driver_data *drv = priv;
 469         pimdev_hdr *hdr;
 470         struct obj_mlmeex *mlme;
 471         int ret;
 472         int blen = sizeof(*hdr) + sizeof(*mlme);
 473         hdr = os_zalloc(blen);
 474         if (hdr == NULL)
 475                 return -1;
 476         mlme = (struct obj_mlmeex *) &hdr[1];
 477         hdr->op = htonl(PIMOP_SET);
 478         hdr->oid = htonl(DOT11_OID_DEAUTHENTICATEEX);
 479         memcpy(&mlme->address[0], addr, ETH_ALEN);
 480         mlme->id = -1;
 481         mlme->state = htons(DOT11_STATE_NONE);
 482         mlme->code = host_to_le16(reason);
 483         mlme->size = 0;
 484         ret = send(drv->pim_sock, hdr, blen, 0);
 485         prism54_waitpim(priv, DOT11_OID_DEAUTHENTICATEEX, hdr, blen, 10);
 486         free(hdr);
 487         return ret;
 488 }
 489
 490
 491 static int prism54_sta_disassoc(void *priv, const u8 *own_addr, const u8 *addr,
 492                                 int reason)
 493 {
 494         struct prism54_driver_data *drv = priv;
 495         pimdev_hdr *hdr;
 496         struct obj_mlmeex *mlme;
 497         int ret;
 498         int blen = sizeof(*hdr) + sizeof(*mlme);
 499         hdr = os_zalloc(blen);
 500         if (hdr == NULL)
 501                 return -1;
 502         mlme = (struct obj_mlmeex *) &hdr[1];
 503         hdr->op = htonl(PIMOP_SET);
 504         hdr->oid = htonl(DOT11_OID_DISASSOCIATEEX);
 505         memcpy(&mlme->address[0], addr, ETH_ALEN);
 506         mlme->id = -1;
 507         mlme->state = htons(DOT11_STATE_NONE);
 508         mlme->code = host_to_le16(reason);
 509         mlme->size = 0;
 510         ret = send(drv->pim_sock, hdr, blen, 0);
 511         prism54_waitpim(priv, DOT11_OID_DISASSOCIATEEX, hdr, blen, 10);
 512         free(hdr);
 513         return ret;
 514 }
 515
 516
 517 static int prism54_get_inact_sec(void *priv, const u8 *addr)
 518 {
 519         struct prism54_driver_data *drv = priv;
 520         pimdev_hdr *hdr;
 521         struct obj_sta *sta;
 522         int blen = sizeof(*hdr) + sizeof(*sta);
 523         int ret;
 524
 525         hdr = os_zalloc(blen);
 526         if (hdr == NULL)
 527                 return -1;
 528         hdr->op = htonl(PIMOP_GET);
 529         hdr->oid = htonl(DOT11_OID_CLIENTFIND);
 530         sta = (struct obj_sta *) &hdr[1];
 531         memcpy(&sta->address[0], addr, ETH_ALEN);
 532         ret = send(drv->pim_sock, hdr, blen, 0);
 533         ret = prism54_waitpim(priv, DOT11_OID_CLIENTFIND, hdr, blen, 10);
 534         if (ret != blen) {
 535                 printf("get_inact_sec: bad return %d\n", ret);
 536                 free(hdr);
 537                 return -1;
 538         }
 539         if (hdr->op != (int) htonl(PIMOP_RESPONSE)) {
 540                 printf("get_inact_sec: bad resp\n");
 541                 free(hdr);
 542                 return -1;
 543         }
 544         free(hdr);
 545         return le_to_host16(sta->age);
 546 }
 547
 548
 549 /* set attachments */
 550 static int prism54_set_generic_elem(const char *ifname, void *priv,
 551                                     const u8 *elem, size_t elem_len)
 552 {
 553         struct prism54_driver_data *drv = priv;
 554         pimdev_hdr *hdr;
 555         char *pos;
 556         struct obj_attachment_hdr *attach;
 557         size_t blen = sizeof(*hdr) + sizeof(*attach) + elem_len;
 558         hdr = os_zalloc(blen);
 559         if (hdr == NULL) {
 560                 printf("%s: memory low\n", __func__);
 561                 return -1;
 562         }
 563         hdr->op = htonl(PIMOP_SET);
 564         hdr->oid = htonl(DOT11_OID_ATTACHMENT);
 565         attach = (struct obj_attachment_hdr *)&hdr[1];
 566         attach->type = DOT11_PKT_BEACON;
 567         attach->id = -1;
 568         attach->size = host_to_le16((short)elem_len);
 569         pos = ((char*) attach) + sizeof(*attach);
 570         if (elem)
 571                 memcpy(pos, elem, elem_len);
 572         send(drv->pim_sock, hdr, blen, 0);
 573         attach->type = DOT11_PKT_PROBE_RESP;
 574         send(drv->pim_sock, hdr, blen, 0);
 575         free(hdr);
 576         return 0;
 577 }
 578
 579
 580 /* tell the card to auth the sta */
 581 static void prism54_handle_probe(struct prism54_driver_data *drv,
 582                                  void *buf, size_t len)
 583 {
 584         struct obj_mlmeex *mlme;
 585         pimdev_hdr *hdr;
 586         struct sta_info *sta;
 587         hdr = (pimdev_hdr *)buf;
 588         mlme = (struct obj_mlmeex *) &hdr[1];
 589         sta = ap_get_sta(drv->hapd, (u8 *) &mlme->address[0]);
 590         if (sta != NULL) {
 591                 if (sta->flags & (WLAN_STA_AUTH | WLAN_STA_ASSOC))
 592                         return;
 593         }
 594         if (len < sizeof(*mlme)) {
 595                 printf("bad probe packet\n");
 596                 return;
 597         }
 598         mlme->state = htons(DOT11_STATE_AUTHING);
 599         mlme->code = 0;
 600         hdr->op = htonl(PIMOP_SET);
 601         hdr->oid = htonl(DOT11_OID_AUTHENTICATEEX);
 602         mlme->size = 0;
 603         send(drv->pim_sock, hdr, sizeof(*hdr)+sizeof(*mlme), 0);
 604 }
 605
 606
 607 static void prism54_handle_deauth(struct prism54_driver_data *drv,
 608                                   void *buf, size_t len)
 609 {
 610         struct obj_mlme *mlme;
 611         pimdev_hdr *hdr;
 612         struct sta_info *sta;
 613         char *mac_id;
 614
 615         hdr = (pimdev_hdr *) buf;
 616         mlme = (struct obj_mlme *) &hdr[1];
 617         sta = ap_get_sta(drv->hapd, (u8 *) &mlme->address[0]);
 618         mac_id = mac_id_get(drv, mlme->id);
 619         if (sta == NULL || mac_id == NULL)
 620                 return;
 621         memcpy(&mlme->address[0], mac_id, ETH_ALEN);
 622         sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC);
 623         wpa_auth_sm_event(sta->wpa_sm, WPA_DEAUTH);
 624         sta->acct_terminate_cause = RADIUS_ACCT_TERMINATE_CAUSE_USER_REQUEST;
 625         ieee802_1x_notify_port_enabled(sta->eapol_sm, 0);
 626         ap_free_sta(drv->hapd, sta);
 627 }
 628
 629
 630 static void prism54_handle_disassoc(struct prism54_driver_data *drv,
 631                                     void *buf, size_t len)
 632 {
 633         struct obj_mlme *mlme;
 634         pimdev_hdr *hdr;
 635         struct sta_info *sta;
 636         char *mac_id;
 637
 638         hdr = (pimdev_hdr *) buf;
 639         mlme = (struct obj_mlme *) &hdr[1];
 640         mac_id = mac_id_get(drv, mlme->id);
 641         if (mac_id == NULL)
 642                 return;
 643         memcpy(&mlme->address[0], mac_id, ETH_ALEN);
 644         sta = ap_get_sta(drv->hapd, (u8 *) &mlme->address[0]);
 645         if (sta == NULL) {
 646                 return;
 647         }
 648         sta->flags &= ~WLAN_STA_ASSOC;
 649         wpa_auth_sm_event(sta->wpa_sm, WPA_DISASSOC);
 650         sta->acct_terminate_cause = RADIUS_ACCT_TERMINATE_CAUSE_USER_REQUEST;
 651         ieee802_1x_notify_port_enabled(sta->eapol_sm, 0);
 652         accounting_sta_stop(drv->hapd, sta);
 653         ieee802_1x_free_station(sta);
 654 }
 655
 656
 657 /* to auth it, just allow it now, later for os/sk */
 658 static void prism54_handle_auth(struct prism54_driver_data *drv,
 659                                 void *buf, size_t len)
 660 {
 661         struct obj_mlmeex *mlme;
 662         pimdev_hdr *hdr;
 663         struct sta_info *sta;
 664         int resp;
 665
 666         hdr = (pimdev_hdr *) buf;
 667         mlme = (struct obj_mlmeex *) &hdr[1];
 668         if (len < sizeof(*mlme)) {
 669                 printf("bad auth packet\n");
 670                 return;
 671         }
 672
 673         if (mlme->state == htons(DOT11_STATE_AUTHING)) {
 674                 sta = ap_sta_add(drv->hapd, (u8 *) &mlme->address[0]);
 675                 if (drv->hapd->tkip_countermeasures) {
 676                         resp = WLAN_REASON_MICHAEL_MIC_FAILURE;
 677                         goto fail;
 678                 }
 679                 mac_id_refresh(drv, mlme->id, &mlme->address[0]);
 680                 if (!sta) {
 681                         resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
 682                         goto fail;
 683                 }
 684                 sta->flags &= ~WLAN_STA_PREAUTH;
 685
 686                 ieee802_1x_notify_pre_auth(sta->eapol_sm, 0);
 687                 sta->flags |= WLAN_STA_AUTH;
 688                 wpa_auth_sm_event(sta->wpa_sm, WPA_AUTH);
 689                 mlme->code = 0;
 690                 mlme->state=htons(DOT11_STATE_AUTH);
 691                 hdr->op = htonl(PIMOP_SET);
 692                 hdr->oid = htonl(DOT11_OID_AUTHENTICATEEX);
 693                 mlme->size = 0;
 694                 sta->timeout_next = STA_NULLFUNC;
 695                 send(drv->pim_sock, hdr, sizeof(*hdr) + sizeof(*mlme), 0);
 696         }
 697         return;
 698
 699 fail:
 700         printf("auth fail: %x\n", resp);
 701         mlme->code = host_to_le16(resp);
 702         mlme->size = 0;
 703         if (sta)
 704                 sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC);
 705         hdr->oid = htonl(DOT11_OID_DEAUTHENTICATEEX);
 706         hdr->op = htonl(PIMOP_SET);
 707         send(drv->pim_sock, hdr, sizeof(*hdr)+sizeof(*mlme), 0);
 708 }
 709
 710
 711 /* do the wpa thing */
 712 static void prism54_handle_assoc(struct prism54_driver_data *drv,
 713                                  void *buf, size_t len)
 714 {
 715         pimdev_hdr *hdr;
 716         struct obj_mlmeex *mlme;
 717         struct ieee802_11_elems elems;
 718         struct sta_info *sta;
 719         u8 *wpa_ie;
 720         u8 *cb;
 721         int ieofs = 0;
 722         size_t wpa_ie_len;
 723         int resp, new_assoc;
 724         char *mac_id;
 725
 726         resp = 0;
 727         hdr = (pimdev_hdr *) buf;
 728         mlme = (struct obj_mlmeex *) &hdr[1];
 729         switch (ntohl(hdr->oid)) {
 730                 case DOT11_OID_ASSOCIATE:
 731                 case DOT11_OID_REASSOCIATE:
 732                         mlme->size = 0;
 733                 default:
 734                         break;
 735         }
 736         if ((mlme->state == (int) htonl(DOT11_STATE_ASSOCING)) ||
 737             (mlme->state == (int) htonl(DOT11_STATE_REASSOCING))) {
 738                 if (len < sizeof(pimdev_hdr) + sizeof(struct obj_mlme)) {
 739                         printf("bad assoc packet\n");
 740                         return;
 741                 }
 742                 mac_id = mac_id_get(drv, mlme->id);
 743                 if (mac_id == NULL)
 744                         return;
 745                 memcpy(&mlme->address[0], mac_id, ETH_ALEN);
 746                 sta = ap_get_sta(drv->hapd, (u8 *) &mlme->address[0]);
 747                 if (sta == NULL) {
 748                         printf("cannot get sta\n");
 749                         return;
 750                 }
 751                 cb = (u8 *) &mlme->data[0];
 752                 if (hdr->oid == htonl(DOT11_OID_ASSOCIATEEX)) {
 753                         ieofs = 4;
 754                 } else if (hdr->oid == htonl(DOT11_OID_REASSOCIATEEX)) {
 755                         ieofs = 10;
 756                 }
 757                 if (le_to_host16(mlme->size) <= ieofs) {
 758                         printf("attach too small\n");
 759                         resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
 760                         goto fail;
 761                 }
 762                 if (ieee802_11_parse_elems(cb + ieofs,
 763                                            le_to_host16(mlme->size) - ieofs,
 764                                            &elems, 1) == ParseFailed) {
 765                         printf("STA " MACSTR " sent invalid association "
 766                                "request\n", MAC2STR(sta->addr));
 767                         resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
 768                         goto fail;
 769                 }
 770                 if ((drv->hapd->conf->wpa & WPA_PROTO_RSN) &&
 771                     elems.rsn_ie) {
 772                         wpa_ie = elems.rsn_ie;
 773                         wpa_ie_len = elems.rsn_ie_len;
 774                 } else if ((drv->hapd->conf->wpa & WPA_PROTO_WPA) &&
 775                            elems.wpa_ie) {
 776                         wpa_ie = elems.wpa_ie;
 777                         wpa_ie_len = elems.wpa_ie_len;
 778                 } else {
 779                         wpa_ie = NULL;
 780                         wpa_ie_len = 0;
 781                 }
 782                 if (drv->hapd->conf->wpa && wpa_ie == NULL) {
 783                         printf("STA " MACSTR ": No WPA/RSN IE in association "
 784                                "request\n", MAC2STR(sta->addr));
 785                         resp = WLAN_STATUS_INVALID_IE;
 786                         goto fail;
 787                 }
 788                 if (drv->hapd->conf->wpa) {
 789                         int res;
 790                         wpa_ie -= 2;
 791                         wpa_ie_len += 2;
 792                         if (sta->wpa_sm == NULL)
 793                                 sta->wpa_sm = wpa_auth_sta_init(
 794                                         drv->hapd->wpa_auth, sta->addr);
 795                         if (sta->wpa_sm == NULL) {
 796                                 printf("Failed to initialize WPA state "
 797                                        "machine\n");
 798                                 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
 799                                 goto fail;
 800                         }
 801                         res = wpa_validate_wpa_ie(drv->hapd->wpa_auth,
 802                                                   sta->wpa_sm,
 803                                                   wpa_ie, wpa_ie_len,
 804                                                   NULL, 0);
 805                         if (res == WPA_INVALID_GROUP)
 806                                 resp = WLAN_STATUS_GROUP_CIPHER_NOT_VALID;
 807                         else if (res == WPA_INVALID_PAIRWISE)
 808                                 resp = WLAN_STATUS_PAIRWISE_CIPHER_NOT_VALID;
 809                         else if (res == WPA_INVALID_AKMP)
 810                                 resp = WLAN_STATUS_AKMP_NOT_VALID;
 811                         else if (res == WPA_ALLOC_FAIL)
 812                                 resp = WLAN_STATUS_UNSPECIFIED_FAILURE;
 813                         else if (res != WPA_IE_OK)
 814                                 resp = WLAN_STATUS_INVALID_IE;
 815                         if (resp != WLAN_STATUS_SUCCESS)
 816                                 goto fail;
 817                 }
 818                 hdr->oid = (hdr->oid == htonl(DOT11_OID_ASSOCIATEEX)) ?
 819                         htonl(DOT11_OID_ASSOCIATEEX) :
 820                         htonl(DOT11_OID_REASSOCIATEEX);
 821                 hdr->op = htonl(PIMOP_SET);
 822                 mlme->code = 0;
 823                 mlme->state = htons(DOT11_STATE_ASSOC);
 824                 mlme->size = 0;
 825                 send(drv->pim_sock, hdr, sizeof(*hdr) + sizeof(*mlme), 0);
 826                 return;
 827         } else if (mlme->state==htons(DOT11_STATE_ASSOC)) {
 828                 if (len < sizeof(pimdev_hdr) + sizeof(struct obj_mlme)) {
 829                         printf("bad assoc packet\n");
 830                         return;
 831                 }
 832                 mac_id = mac_id_get(drv, mlme->id);
 833                 if (mac_id == NULL)
 834                         return;
 835                 memcpy(&mlme->address[0], mac_id, ETH_ALEN);
 836                 sta = ap_get_sta(drv->hapd, (u8 *) &mlme->address[0]);
 837                 if (sta == NULL) {
 838                         printf("cannot get sta\n");
 839                         return;
 840                 }
 841                 new_assoc = (sta->flags & WLAN_STA_ASSOC) == 0;
 842                 sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC;
 843                 wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC);
 844                 hostapd_new_assoc_sta(drv->hapd, sta, !new_assoc);
 845                 ieee802_1x_notify_port_enabled(sta->eapol_sm, 1);
 846                 sta->timeout_next = STA_NULLFUNC;
 847                 return;
 848         }
 849         return;
 850
 851 fail:
 852         printf("Prism54: assoc fail: %x\n", resp);
 853         mlme->code = host_to_le16(resp);
 854         mlme->size = 0;
 855         mlme->state = htons(DOT11_STATE_ASSOCING);
 856         hdr->oid = htonl(DOT11_OID_DISASSOCIATEEX);
 857         hdr->op = htonl(PIMOP_SET);
 858         sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC);
 859         send(drv->pim_sock, hdr, sizeof(*hdr) + sizeof(*mlme), 0);
 860 }
 861
 862
 863 static void handle_pim(int sock, void *eloop_ctx, void *sock_ctx)
 864 {
 865         struct prism54_driver_data *drv = eloop_ctx;
 866         int len;
 867         pimdev_hdr *hdr;
 868
 869         hdr = malloc(PIM_BUF_SIZE);
 870         if (hdr == NULL)
 871                 return;
 872         len = recv(sock, hdr, PIM_BUF_SIZE, 0);
 873         if (len < 0) {
 874                 perror("recv");
 875                 free(hdr);
 876                 return;
 877         }
 878         if (len < 8) {
 879                 printf("handle_pim: too short (%d)\n", len);
 880                 free(hdr);
 881                 return;
 882         }
 883
 884         if (hdr->op != (int) htonl(PIMOP_TRAP)) {
 885                 free(hdr);
 886                 return;
 887         }
 888         switch (ntohl(hdr->oid)) {
 889                 case DOT11_OID_PROBE:
 890                         prism54_handle_probe(drv, hdr, len);
 891                         break;
 892                 case DOT11_OID_DEAUTHENTICATEEX:
 893                 case DOT11_OID_DEAUTHENTICATE:
 894                         prism54_handle_deauth(drv, hdr, len);
 895                         break;
 896                 case DOT11_OID_DISASSOCIATEEX:
 897                 case DOT11_OID_DISASSOCIATE:
 898                         prism54_handle_disassoc(drv, hdr, len);
 899                         break;
 900                 case DOT11_OID_AUTHENTICATEEX:
 901                 case DOT11_OID_AUTHENTICATE:
 902                         prism54_handle_auth(drv, hdr, len);
 903                         break;
 904                 case DOT11_OID_ASSOCIATEEX:
 905                 case DOT11_OID_REASSOCIATEEX:
 906                 case DOT11_OID_ASSOCIATE:
 907                 case DOT11_OID_REASSOCIATE:
 908                         prism54_handle_assoc(drv, hdr, len);
 909                 default:
 910                         break;
 911         }
 912
 913         free(hdr);
 914 }
 915
 916
 917 static void handle_802_3(int sock, void *eloop_ctx, void *sock_ctx)
 918 {
 919         struct hostapd_data *hapd = (struct hostapd_data *) eloop_ctx;
 920         int len;
 921         ieee802_3_hdr *hdr;
 922
 923         hdr = malloc(PIM_BUF_SIZE);
 924         if (hdr == NULL)
 925                 return;
 926         len = recv(sock, hdr, PIM_BUF_SIZE, 0);
 927         if (len < 0) {
 928                 perror("recv");
 929                 free(hdr);
 930                 return;
 931         }
 932         if (len < 14) {
 933                 wpa_printf(MSG_MSGDUMP, "handle_802_3: too short (%d)", len);
 934                 free(hdr);
 935                 return;
 936         }
 937         if (hdr->type == htons(ETH_P_PAE)) {
 938                 hostapd_eapol_receive(hapd, (u8 *) &hdr->sa[0], (u8 *) &hdr[1],
 939                                       len - sizeof(*hdr));
 940         }
 941         free(hdr);
 942 }
 943
 944
 945 static int prism54_init_sockets(struct prism54_driver_data *drv,
 946                                 struct wpa_init_params *params)
 947 {
 948         struct ifreq ifr;
 949         struct sockaddr_ll addr;
 950
 951         drv->sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_PAE));
 952         if (drv->sock < 0) {
 953                 perror("socket[PF_PACKET,SOCK_RAW]");
 954                 return -1;
 955         }
 956
 957         if (eloop_register_read_sock(drv->sock, handle_802_3, drv->hapd, NULL))
 958         {
 959                 printf("Could not register read socket\n");
 960                 return -1;
 961         }
 962
 963         memset(&ifr, 0, sizeof(ifr));
 964         if (params->num_bridge && params->bridge[0]) {
 965                 printf("opening bridge: %s\n", params->bridge[0]);
 966                 os_strlcpy(ifr.ifr_name, params->bridge[0],
 967                            sizeof(ifr.ifr_name));
 968         } else {
 969                 os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name));
 970         }
 971         if (ioctl(drv->sock, SIOCGIFINDEX, &ifr) != 0) {
 972                 perror("ioctl(SIOCGIFINDEX)");
 973                 return -1;
 974         }
 975
 976         memset(&addr, 0, sizeof(addr));
 977         addr.sll_family = AF_PACKET;
 978         addr.sll_ifindex = ifr.ifr_ifindex;
 979         addr.sll_protocol = htons(ETH_P_PAE);
 980         wpa_printf(MSG_DEBUG, "Opening raw packet socket for ifindex %d",
 981                    addr.sll_ifindex);
 982
 983         if (bind(drv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 984                 perror("bind");
 985                 return -1;
 986         }
 987
 988         memset(&ifr, 0, sizeof(ifr));
 989         os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name));
 990         if (ioctl(drv->sock, SIOCGIFHWADDR, &ifr) != 0) {
 991                 perror("ioctl(SIOCGIFHWADDR)");
 992                 return -1;
 993         }
 994
 995         if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
 996                 printf("Invalid HW-addr family 0x%04x\n",
 997                        ifr.ifr_hwaddr.sa_family);
 998                 return -1;
 999         }
1000         memcpy(params->own_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
1001
1002         drv->pim_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
1003         if (drv->pim_sock < 0) {
1004                 perror("socket[PF_PACKET,SOCK_RAW]");
1005                 return -1;
1006         }
1007
1008         if (eloop_register_read_sock(drv->pim_sock, handle_pim, drv, NULL)) {
1009                 printf("Could not register read socket\n");
1010                 return -1;
1011         }
1012
1013         memset(&ifr, 0, sizeof(ifr));
1014         snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%sap", drv->iface);
1015         if (ioctl(drv->pim_sock, SIOCGIFINDEX, &ifr) != 0) {
1016                 perror("ioctl(SIOCGIFINDEX)");
1017                 return -1;
1018         }
1019
1020         memset(&addr, 0, sizeof(addr));
1021         addr.sll_family = AF_PACKET;
1022         addr.sll_ifindex = ifr.ifr_ifindex;
1023         addr.sll_protocol = htons(ETH_P_ALL);
1024         wpa_printf(MSG_DEBUG, "Opening raw packet socket for ifindex %d",
1025                    addr.sll_ifindex);
1026
1027         if (bind(drv->pim_sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1028                 perror("bind");
1029                 return -1;
1030         }
1031
1032         return 0;
1033 }
1034
1035
1036 static void * prism54_driver_init(struct hostapd_data *hapd,
1037                                   struct wpa_init_params *params)
1038 {
1039         struct prism54_driver_data *drv;
1040
1041         drv = os_zalloc(sizeof(struct prism54_driver_data));
1042         if (drv == NULL) {
1043                 printf("Could not allocate memory for hostapd Prism54 driver "
1044                        "data\n");
1045                 return NULL;
1046         }
1047
1048         drv->hapd = hapd;
1049         drv->pim_sock = drv->sock = -1;
1050         memcpy(drv->iface, params->ifname, sizeof(drv->iface));
1051
1052         if (prism54_init_sockets(drv, params)) {
1053                 free(drv);
1054                 return NULL;
1055         }
1056         prism54_init_1x(drv);
1057         /* must clean previous elems */
1058         prism54_set_generic_elem(drv->iface, drv, NULL, 0);
1059
1060         return drv;
1061 }
1062
1063
1064 static void prism54_driver_deinit(void *priv)
1065 {
1066         struct prism54_driver_data *drv = priv;
1067
1068         if (drv->pim_sock >= 0)
1069                 close(drv->pim_sock);
1070
1071         if (drv->sock >= 0)
1072                 close(drv->sock);
1073
1074         free(drv);
1075 }
1076
1077 #else /* HOSTAPD */
1078
1079 struct wpa_driver_prism54_data {
1080         void *wext; /* private data for driver_wext */
1081         void *ctx;
1082         char ifname[IFNAMSIZ + 1];
1083         int sock;
1084 };
1085
1086 #define PRISM54_SET_WPA                 SIOCIWFIRSTPRIV+12
1087 #define PRISM54_HOSTAPD                 SIOCIWFIRSTPRIV+25
1088 #define PRISM54_DROP_UNENCRYPTED        SIOCIWFIRSTPRIV+26
1089
1090 static void show_set_key_error(struct prism2_hostapd_param *);
1091
1092 static int hostapd_ioctl_prism54(struct wpa_driver_prism54_data *drv,
1093                                  struct prism2_hostapd_param *param,
1094                                  int len, int show_err)
1095 {
1096         struct iwreq iwr;
1097
1098         os_memset(&iwr, 0, sizeof(iwr));
1099         os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
1100         iwr.u.data.pointer = (caddr_t) param;
1101         iwr.u.data.length = len;
1102
1103         if (ioctl(drv->sock, PRISM54_HOSTAPD, &iwr) < 0) {
1104                 int ret = errno;
1105                 if (show_err)
1106                         perror("ioctl[PRISM54_HOSTAPD]");
1107                 return ret;
1108         }
1109
1110         return 0;
1111 }
1112
1113
1114 static int wpa_driver_prism54_set_wpa_ie(struct wpa_driver_prism54_data *drv,
1115                                          const u8 *wpa_ie,
1116                                          size_t wpa_ie_len)
1117 {
1118         struct prism2_hostapd_param *param;
1119         int res;
1120         size_t blen = PRISM2_HOSTAPD_GENERIC_ELEMENT_HDR_LEN + wpa_ie_len;
1121         if (blen < sizeof(*param))
1122                 blen = sizeof(*param);
1123
1124         param = os_zalloc(blen);
1125         if (param == NULL)
1126                 return -1;
1127
1128         param->cmd = PRISM2_HOSTAPD_SET_GENERIC_ELEMENT;
1129         param->u.generic_elem.len = wpa_ie_len;
1130         os_memcpy(param->u.generic_elem.data, wpa_ie, wpa_ie_len);
1131         res = hostapd_ioctl_prism54(drv, param, blen, 1);
1132
1133         os_free(param);
1134
1135         return res;
1136 }
1137
1138
1139 /* This is called at wpa_supplicant daemon init time */
1140 static int wpa_driver_prism54_set_wpa(void *priv, int enabled)
1141 {
1142         struct wpa_driver_prism54_data *drv = priv;
1143         struct prism2_hostapd_param *param;
1144         int res;
1145         size_t blen = PRISM2_HOSTAPD_GENERIC_ELEMENT_HDR_LEN;
1146         if (blen < sizeof(*param))
1147                 blen = sizeof(*param);
1148
1149         param = os_zalloc(blen);
1150         if (param == NULL)
1151                 return -1;
1152
1153         param->cmd = PRISM54_SET_WPA;
1154         param->u.generic_elem.len = 0;
1155         res = hostapd_ioctl_prism54(drv, param, blen, 1);
1156
1157         os_free(param);
1158
1159         return res;
1160 }
1161
1162
1163 static int wpa_driver_prism54_set_key(const char *ifname, void *priv,
1164                                       wpa_alg alg,
1165                                       const u8 *addr, int key_idx, int set_tx,
1166                                       const u8 *seq, size_t seq_len,
1167                                       const u8 *key, size_t key_len)
1168 {
1169         struct wpa_driver_prism54_data *drv = priv;
1170         struct prism2_hostapd_param *param;
1171         u8 *buf;
1172         size_t blen;
1173         int ret = 0;
1174         char *alg_name;
1175
1176         switch (alg) {
1177         case WPA_ALG_NONE:
1178                 alg_name = "none";
1179                 return -1;
1180                 break;
1181         case WPA_ALG_WEP:
1182                 alg_name = "WEP";
1183                 return -1;
1184                 break;
1185         case WPA_ALG_TKIP:
1186                 alg_name = "TKIP";
1187                 break;
1188         case WPA_ALG_CCMP:
1189                 alg_name = "CCMP";
1190                 return -1;
1191                 break;
1192         default:
1193                 return -1;
1194         }
1195
1196         wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%lu "
1197                    "key_len=%lu", __FUNCTION__, alg_name, key_idx, set_tx,
1198                    (unsigned long) seq_len, (unsigned long) key_len);
1199
1200         if (seq_len > 8)
1201                 return -2;
1202
1203         blen = sizeof(*param) + key_len;
1204         buf = os_zalloc(blen);
1205         if (buf == NULL)
1206                 return -1;
1207
1208         param = (struct prism2_hostapd_param *) buf;
1209         param->cmd = PRISM2_SET_ENCRYPTION;
1210         /* TODO: In theory, STA in client mode can use five keys; four default
1211          * keys for receiving (with keyidx 0..3) and one individual key for
1212          * both transmitting and receiving (keyidx 0) _unicast_ packets. Now,
1213          * keyidx 0 is reserved for this unicast use and default keys can only
1214          * use keyidx 1..3 (i.e., default key with keyidx 0 is not supported).
1215          * This should be fine for more or less all cases, but for completeness
1216          * sake, the driver could be enhanced to support the missing key. */
1217 #if 0
1218         if (addr == NULL)
1219                 os_memset(param->sta_addr, 0xff, ETH_ALEN);
1220         else
1221                 os_memcpy(param->sta_addr, addr, ETH_ALEN);
1222 #else
1223         os_memset(param->sta_addr, 0xff, ETH_ALEN);
1224 #endif
1225         os_strlcpy((char *) param->u.crypt.alg, alg_name,
1226                    HOSTAP_CRYPT_ALG_NAME_LEN);
1227         param->u.crypt.flags = set_tx ? HOSTAP_CRYPT_FLAG_SET_TX_KEY : 0;
1228         param->u.crypt.idx = key_idx;
1229         os_memcpy(param->u.crypt.seq, seq, seq_len);
1230         param->u.crypt.key_len = key_len;
1231         os_memcpy((u8 *) (param + 1), key, key_len);
1232
1233         if (hostapd_ioctl_prism54(drv, param, blen, 1)) {
1234                 wpa_printf(MSG_WARNING, "Failed to set encryption.");
1235                 show_set_key_error(param);
1236                 ret = -1;
1237         }
1238         os_free(buf);
1239
1240         return ret;
1241 }
1242
1243
1244 static int wpa_driver_prism54_set_countermeasures(void *priv,
1245                                                  int enabled)
1246 {
1247         /* FIX */
1248         printf("wpa_driver_prism54_set_countermeasures - not yet "
1249                "implemented\n");
1250         return 0;
1251 }
1252
1253
1254 static int wpa_driver_prism54_set_drop_unencrypted(void *priv,
1255                                                   int enabled)
1256 {
1257         struct wpa_driver_prism54_data *drv = priv;
1258         struct prism2_hostapd_param *param;
1259         int res;
1260         size_t blen = PRISM2_HOSTAPD_GENERIC_ELEMENT_HDR_LEN;
1261         if (blen < sizeof(*param))
1262                 blen = sizeof(*param);
1263
1264         param = os_zalloc(blen);
1265         if (param == NULL)
1266                 return -1;
1267
1268         param->cmd = PRISM54_DROP_UNENCRYPTED;
1269         param->u.generic_elem.len = 0;
1270         res = hostapd_ioctl_prism54(drv, param, blen, 1);
1271
1272         os_free(param);
1273
1274         return res;
1275 }
1276
1277
1278 static int wpa_driver_prism54_deauthenticate(void *priv, const u8 *addr,
1279                                              int reason_code)
1280 {
1281         /* FIX */
1282         printf("wpa_driver_prism54_deauthenticate - not yet implemented\n");
1283         return 0;
1284 }
1285
1286
1287 static int wpa_driver_prism54_disassociate(void *priv, const u8 *addr,
1288                                            int reason_code)
1289 {
1290         /* FIX */
1291         printf("wpa_driver_prism54_disassociate - not yet implemented\n");
1292         return 0;
1293 }
1294
1295
1296 static int
1297 wpa_driver_prism54_associate(void *priv,
1298                              struct wpa_driver_associate_params *params)
1299 {
1300         struct wpa_driver_prism54_data *drv = priv;
1301         int ret = 0;
1302
1303         if (wpa_driver_prism54_set_drop_unencrypted(drv,
1304                                                     params->drop_unencrypted)
1305             < 0)
1306                 ret = -1;
1307         if (wpa_driver_prism54_set_wpa_ie(drv, params->wpa_ie,
1308                                           params->wpa_ie_len) < 0)
1309                 ret = -1;
1310         if (wpa_driver_wext_set_freq(drv->wext, params->freq) < 0)
1311                 ret = -1;
1312         if (wpa_driver_wext_set_ssid(drv->wext, params->ssid,
1313                                      params->ssid_len) < 0)
1314                 ret = -1;
1315         if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0)
1316                 ret = -1;
1317
1318         return ret;
1319 }
1320
1321 static void show_set_key_error(struct prism2_hostapd_param *param)
1322 {
1323         switch (param->u.crypt.err) {
1324         case HOSTAP_CRYPT_ERR_UNKNOWN_ALG:
1325                 wpa_printf(MSG_INFO, "Unknown algorithm '%s'.",
1326                            param->u.crypt.alg);
1327                 wpa_printf(MSG_INFO, "You may need to load kernel module to "
1328                            "register that algorithm.");
1329                 wpa_printf(MSG_INFO, "E.g., 'modprobe hostap_crypt_wep' for "
1330                            "WEP.");
1331                 break;
1332         case HOSTAP_CRYPT_ERR_UNKNOWN_ADDR:
1333                 wpa_printf(MSG_INFO, "Unknown address " MACSTR ".",
1334                            MAC2STR(param->sta_addr));
1335                 break;
1336         case HOSTAP_CRYPT_ERR_CRYPT_INIT_FAILED:
1337                 wpa_printf(MSG_INFO, "Crypt algorithm initialization failed.");
1338                 break;
1339         case HOSTAP_CRYPT_ERR_KEY_SET_FAILED:
1340                 wpa_printf(MSG_INFO, "Key setting failed.");
1341                 break;
1342         case HOSTAP_CRYPT_ERR_TX_KEY_SET_FAILED:
1343                 wpa_printf(MSG_INFO, "TX key index setting failed.");
1344                 break;
1345         case HOSTAP_CRYPT_ERR_CARD_CONF_FAILED:
1346                 wpa_printf(MSG_INFO, "Card configuration failed.");
1347                 break;
1348         }
1349 }
1350
1351
1352 static int wpa_driver_prism54_get_bssid(void *priv, u8 *bssid)
1353 {
1354         struct wpa_driver_prism54_data *drv = priv;
1355         return wpa_driver_wext_get_bssid(drv->wext, bssid);
1356 }
1357
1358
1359 static int wpa_driver_prism54_get_ssid(void *priv, u8 *ssid)
1360 {
1361         struct wpa_driver_prism54_data *drv = priv;
1362         return wpa_driver_wext_get_ssid(drv->wext, ssid);
1363 }
1364
1365
1366 static int wpa_driver_prism54_scan(void *priv, const u8 *ssid, size_t ssid_len)
1367 {
1368         struct wpa_driver_prism54_data *drv = priv;
1369         return wpa_driver_wext_scan(drv->wext, ssid, ssid_len);
1370 }
1371
1372
1373 static struct wpa_scan_results *
1374 wpa_driver_prism54_get_scan_results(void *priv)
1375 {
1376         struct wpa_driver_prism54_data *drv = priv;
1377         return wpa_driver_wext_get_scan_results(drv->wext);
1378 }
1379
1380
1381 static int wpa_driver_prism54_set_operstate(void *priv, int state)
1382 {
1383         struct wpa_driver_prism54_data *drv = priv;
1384         return wpa_driver_wext_set_operstate(drv->wext, state);
1385 }
1386
1387
1388 static void * wpa_driver_prism54_init(void *ctx, const char *ifname)
1389 {
1390         struct wpa_driver_prism54_data *drv;
1391
1392         drv = os_zalloc(sizeof(*drv));
1393         if (drv == NULL)
1394                 return NULL;
1395         drv->wext = wpa_driver_wext_init(ctx, ifname);
1396         if (drv->wext == NULL) {
1397                 os_free(drv);
1398                 return NULL;
1399         }
1400
1401         drv->ctx = ctx;
1402         os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
1403         drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
1404         if (drv->sock < 0) {
1405                 wpa_driver_wext_deinit(drv->wext);
1406                 os_free(drv);
1407                 return NULL;
1408         }
1409
1410         wpa_driver_prism54_set_wpa(drv, 1);
1411
1412         return drv;
1413 }
1414
1415
1416 static void wpa_driver_prism54_deinit(void *priv)
1417 {
1418         struct wpa_driver_prism54_data *drv = priv;
1419         wpa_driver_prism54_set_wpa(drv, 0);
1420         wpa_driver_wext_deinit(drv->wext);
1421         close(drv->sock);
1422         os_free(drv);
1423 }
1424
1425 #endif /* HOSTAPD */
1426
1427
1428 const struct wpa_driver_ops wpa_driver_prism54_ops = {
1429         .name = "prism54",
1430         .desc = "Prism54.org driver (Intersil Prism GT/Duette/Indigo)",
1431         .set_key = wpa_driver_prism54_set_key,
1432 #ifdef HOSTAPD
1433         .hapd_init = prism54_driver_init,
1434         .hapd_deinit = prism54_driver_deinit,
1435         /* .set_ieee8021x = prism54_init_1x, */
1436         .set_privacy = prism54_set_privacy_invoked,
1437         .get_seqnum = prism54_get_seqnum,
1438         .flush = prism54_flush,
1439         .set_generic_elem = prism54_set_generic_elem,
1440         .hapd_send_eapol = prism54_send_eapol,
1441         .sta_set_flags = prism54_sta_set_flags,
1442         .sta_deauth = prism54_sta_deauth,
1443         .sta_disassoc = prism54_sta_disassoc,
1444         .hapd_set_ssid = prism54_ioctl_setiwessid,
1445         .get_inact_sec = prism54_get_inact_sec,
1446 #else /* HOSTAPD */
1447         .get_bssid = wpa_driver_prism54_get_bssid,
1448         .get_ssid = wpa_driver_prism54_get_ssid,
1449         .set_countermeasures = wpa_driver_prism54_set_countermeasures,
1450         .scan = wpa_driver_prism54_scan,
1451         .get_scan_results2 = wpa_driver_prism54_get_scan_results,
1452         .deauthenticate = wpa_driver_prism54_deauthenticate,
1453         .disassociate = wpa_driver_prism54_disassociate,
1454         .associate = wpa_driver_prism54_associate,
1455         .init = wpa_driver_prism54_init,
1456         .deinit = wpa_driver_prism54_deinit,
1457         .set_operstate = wpa_driver_prism54_set_operstate,
1458 #endif /* HOSTAPD */
1459 };