29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/mbuf.h>
33#include <sys/malloc.h>
34#include <sys/endian.h>
35#include <sys/kernel.h>
36
37#include <sys/socket.h>
38
39#include <net/if.h>
40#include <net/if_media.h>
41#include <net/ethernet.h>
42#include <net/if_llc.h>
43#include <net/if_vlan_var.h>
44
45#include <net80211/ieee80211_var.h>
46
47#include <net/bpf.h>
48
49#ifdef IEEE80211_DEBUG
50#include <machine/stdarg.h>
51
52/*
53 * Decide if a received management frame should be
54 * printed when debugging is enabled. This filters some
55 * of the less interesting frames that come frequently
56 * (e.g. beacons).
57 */
58static __inline int
59doprint(struct ieee80211com *ic, int subtype)
60{
61 switch (subtype) {
62 case IEEE80211_FC0_SUBTYPE_BEACON:
63 return (ic->ic_flags & IEEE80211_F_SCAN);
64 case IEEE80211_FC0_SUBTYPE_PROBE_REQ:
65 return (ic->ic_opmode == IEEE80211_M_IBSS);
66 }
67 return 1;
68}
69
70static const uint8_t *ieee80211_getbssid(struct ieee80211com *,
71 const struct ieee80211_frame *);
72#endif /* IEEE80211_DEBUG */
73
74static struct mbuf *ieee80211_defrag(struct ieee80211com *,
75 struct ieee80211_node *, struct mbuf *, int);
76static struct mbuf *ieee80211_decap(struct ieee80211com *, struct mbuf *, int);
77static void ieee80211_send_error(struct ieee80211com *, struct ieee80211_node *,
78 const uint8_t *mac, int subtype, int arg);
79static struct mbuf *ieee80211_decap_fastframe(struct ieee80211com *,
80 struct ieee80211_node *, struct mbuf *);
81static void ieee80211_recv_pspoll(struct ieee80211com *,
82 struct ieee80211_node *, struct mbuf *);
83
84/*
85 * Process a received frame. The node associated with the sender
86 * should be supplied. If nothing was found in the node table then
87 * the caller is assumed to supply a reference to ic_bss instead.
88 * The RSSI and a timestamp are also supplied. The RSSI data is used
89 * during AP scanning to select a AP to associate with; it can have
90 * any units so long as values have consistent units and higher values
91 * mean ``better signal''. The receive timestamp is currently not used
92 * by the 802.11 layer.
93 */
94int
95ieee80211_input(struct ieee80211com *ic, struct mbuf *m,
96 struct ieee80211_node *ni, int rssi, int noise, uint32_t rstamp)
97{
98#define SEQ_LEQ(a,b) ((int)((a)-(b)) <= 0)
99#define HAS_SEQ(type) ((type & 0x4) == 0)
100 struct ifnet *ifp = ic->ic_ifp;
101 struct ieee80211_frame *wh;
102 struct ieee80211_key *key;
103 struct ether_header *eh;
104 int hdrspace, need_tap;
105 uint8_t dir, type, subtype, qos;
106 uint8_t *bssid;
107 uint16_t rxseq;
108
109 if (m->m_flags & M_AMPDU) {
110 /*
111 * Fastpath for A-MPDU reorder q resubmission. Frames
112 * w/ M_AMPDU marked have already passed through here
113 * but were received out of order and been held on the
114 * reorder queue. When resubmitted they are marked
115 * with the M_AMPDU flag and we can bypass most of the
116 * normal processing.
117 */
118 wh = mtod(m, struct ieee80211_frame *);
119 type = IEEE80211_FC0_TYPE_DATA;
120 dir = wh->i_fc[1] & IEEE80211_FC1_DIR_MASK;
121 subtype = IEEE80211_FC0_SUBTYPE_QOS;
122 hdrspace = ieee80211_hdrspace(ic, wh); /* XXX optimize? */
123 need_tap = 0;
124 goto resubmit_ampdu;
125 }
126
127 KASSERT(ni != NULL, ("null node"));
128 ni->ni_inact = ni->ni_inact_reload;
129
130 need_tap = 1; /* mbuf need to be tapped. */
131 type = -1; /* undefined */
132 /*
133 * In monitor mode, send everything directly to bpf.
134 * XXX may want to include the CRC
135 */
136 if (ic->ic_opmode == IEEE80211_M_MONITOR)
137 goto out;
138
139 if (m->m_pkthdr.len < sizeof(struct ieee80211_frame_min)) {
140 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
141 ni->ni_macaddr, NULL,
142 "too short (1): len %u", m->m_pkthdr.len);
143 ic->ic_stats.is_rx_tooshort++;
144 goto out;
145 }
146 /*
147 * Bit of a cheat here, we use a pointer for a 3-address
148 * frame format but don't reference fields past outside
149 * ieee80211_frame_min w/o first validating the data is
150 * present.
151 */
152 wh = mtod(m, struct ieee80211_frame *);
153
154 if ((wh->i_fc[0] & IEEE80211_FC0_VERSION_MASK) !=
155 IEEE80211_FC0_VERSION_0) {
156 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
157 ni->ni_macaddr, NULL, "wrong version %x", wh->i_fc[0]);
158 ic->ic_stats.is_rx_badversion++;
159 goto err;
160 }
161
162 dir = wh->i_fc[1] & IEEE80211_FC1_DIR_MASK;
163 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
164 subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
165 if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) {
166 switch (ic->ic_opmode) {
167 case IEEE80211_M_STA:
168 bssid = wh->i_addr2;
169 if (!IEEE80211_ADDR_EQ(bssid, ni->ni_bssid)) {
170 /* not interested in */
171 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
172 bssid, NULL, "%s", "not to bss");
173 ic->ic_stats.is_rx_wrongbss++;
174 goto out;
175 }
176 break;
177 case IEEE80211_M_IBSS:
178 case IEEE80211_M_AHDEMO:
179 case IEEE80211_M_HOSTAP:
180 if (dir != IEEE80211_FC1_DIR_NODS)
181 bssid = wh->i_addr1;
182 else if (type == IEEE80211_FC0_TYPE_CTL)
183 bssid = wh->i_addr1;
184 else {
185 if (m->m_pkthdr.len < sizeof(struct ieee80211_frame)) {
186 IEEE80211_DISCARD_MAC(ic,
187 IEEE80211_MSG_ANY, ni->ni_macaddr,
188 NULL, "too short (2): len %u",
189 m->m_pkthdr.len);
190 ic->ic_stats.is_rx_tooshort++;
191 goto out;
192 }
193 bssid = wh->i_addr3;
194 }
195 if (type != IEEE80211_FC0_TYPE_DATA)
196 break;
197 /*
198 * Data frame, validate the bssid.
199 */
200 if (!IEEE80211_ADDR_EQ(bssid, ic->ic_bss->ni_bssid) &&
201 !IEEE80211_ADDR_EQ(bssid, ifp->if_broadcastaddr)) {
202 /* not interested in */
203 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
204 bssid, NULL, "%s", "not to bss");
205 ic->ic_stats.is_rx_wrongbss++;
206 goto out;
207 }
208 /*
209 * For adhoc mode we cons up a node when it doesn't
210 * exist. This should probably done after an ACL check.
211 */
212 if (ni == ic->ic_bss &&
213 ic->ic_opmode != IEEE80211_M_HOSTAP &&
214 !IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) {
215 /*
216 * Fake up a node for this newly
217 * discovered member of the IBSS.
218 */
219 ni = ieee80211_fakeup_adhoc_node(&ic->ic_sta,
220 wh->i_addr2);
221 if (ni == NULL) {
222 /* NB: stat kept for alloc failure */
223 goto err;
224 }
225 }
226 break;
227 default:
228 goto out;
229 }
230 ni->ni_rssi = rssi;
231 ni->ni_noise = noise;
232 ni->ni_rstamp = rstamp;
233 if (HAS_SEQ(type)) {
234 uint8_t tid;
235 if (IEEE80211_QOS_HAS_SEQ(wh)) {
236 tid = ((struct ieee80211_qosframe *)wh)->
237 i_qos[0] & IEEE80211_QOS_TID;
238 if (TID_TO_WME_AC(tid) >= WME_AC_VI)
239 ic->ic_wme.wme_hipri_traffic++;
240 tid++;
241 } else
242 tid = IEEE80211_NONQOS_TID;
243 rxseq = le16toh(*(uint16_t *)wh->i_seq);
244 if ((ni->ni_flags & IEEE80211_NODE_HT) == 0 &&
245 (wh->i_fc[1] & IEEE80211_FC1_RETRY) &&
246 SEQ_LEQ(rxseq, ni->ni_rxseqs[tid])) {
247 /* duplicate, discard */
248 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
249 bssid, "duplicate",
250 "seqno <%u,%u> fragno <%u,%u> tid %u",
251 rxseq >> IEEE80211_SEQ_SEQ_SHIFT,
252 ni->ni_rxseqs[tid] >>
253 IEEE80211_SEQ_SEQ_SHIFT,
254 rxseq & IEEE80211_SEQ_FRAG_MASK,
255 ni->ni_rxseqs[tid] &
256 IEEE80211_SEQ_FRAG_MASK,
257 tid);
258 ic->ic_stats.is_rx_dup++;
259 IEEE80211_NODE_STAT(ni, rx_dup);
260 goto out;
261 }
262 ni->ni_rxseqs[tid] = rxseq;
263 }
264 }
265
266 switch (type) {
267 case IEEE80211_FC0_TYPE_DATA:
268 hdrspace = ieee80211_hdrspace(ic, wh);
269 if (m->m_len < hdrspace &&
270 (m = m_pullup(m, hdrspace)) == NULL) {
271 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
272 ni->ni_macaddr, NULL,
273 "data too short: expecting %u", hdrspace);
274 ic->ic_stats.is_rx_tooshort++;
275 goto out; /* XXX */
276 }
277 switch (ic->ic_opmode) {
278 case IEEE80211_M_STA:
279 if (dir != IEEE80211_FC1_DIR_FROMDS) {
280 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
281 wh, "data", "unknown dir 0x%x", dir);
282 ic->ic_stats.is_rx_wrongdir++;
283 goto out;
284 }
285 if ((ifp->if_flags & IFF_SIMPLEX) &&
286 IEEE80211_IS_MULTICAST(wh->i_addr1) &&
287 IEEE80211_ADDR_EQ(wh->i_addr3, ic->ic_myaddr)) {
288 /*
289 * In IEEE802.11 network, multicast packet
290 * sent from me is broadcasted from AP.
291 * It should be silently discarded for
292 * SIMPLEX interface.
293 */
294 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
295 wh, NULL, "%s", "multicast echo");
296 ic->ic_stats.is_rx_mcastecho++;
297 goto out;
298 }
299 break;
300 case IEEE80211_M_IBSS:
301 case IEEE80211_M_AHDEMO:
302 if (dir != IEEE80211_FC1_DIR_NODS) {
303 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
304 wh, "data", "unknown dir 0x%x", dir);
305 ic->ic_stats.is_rx_wrongdir++;
306 goto out;
307 }
308 /* XXX no power-save support */
309 break;
310 case IEEE80211_M_HOSTAP:
311 if (dir != IEEE80211_FC1_DIR_TODS) {
312 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
313 wh, "data", "unknown dir 0x%x", dir);
314 ic->ic_stats.is_rx_wrongdir++;
315 goto out;
316 }
317 /* check if source STA is associated */
318 if (ni == ic->ic_bss) {
319 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
320 wh, "data", "%s", "unknown src");
321 ieee80211_send_error(ic, ni, wh->i_addr2,
322 IEEE80211_FC0_SUBTYPE_DEAUTH,
323 IEEE80211_REASON_NOT_AUTHED);
324 ic->ic_stats.is_rx_notassoc++;
325 goto err;
326 }
327 if (ni->ni_associd == 0) {
328 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
329 wh, "data", "%s", "unassoc src");
330 IEEE80211_SEND_MGMT(ic, ni,
331 IEEE80211_FC0_SUBTYPE_DISASSOC,
332 IEEE80211_REASON_NOT_ASSOCED);
333 ic->ic_stats.is_rx_notassoc++;
334 goto err;
335 }
336
337 /*
338 * Check for power save state change.
339 * XXX out-of-order A-MPDU frames?
340 */
341 if (((wh->i_fc[1] & IEEE80211_FC1_PWR_MGT) ^
342 (ni->ni_flags & IEEE80211_NODE_PWR_MGT)))
343 ieee80211_node_pwrsave(ni,
344 wh->i_fc[1] & IEEE80211_FC1_PWR_MGT);
345 break;
346 default:
347 /* XXX here to keep compiler happy */
348 goto out;
349 }
350
351 /*
352 * Handle A-MPDU re-ordering. The station must be
353 * associated and negotiated HT. The frame must be
354 * a QoS frame (not QoS null data) and not previously
355 * processed for A-MPDU re-ordering. If the frame is
356 * to be processed directly then ieee80211_ampdu_reorder
357 * will return 0; otherwise it has consumed the mbuf
358 * and we should do nothing more with it.
359 */
360 if ((ni->ni_flags & IEEE80211_NODE_HT) &&
361 subtype == IEEE80211_FC0_SUBTYPE_QOS &&
362 ieee80211_ampdu_reorder(ni, m) != 0) {
363 m = NULL;
364 goto out;
365 }
366 resubmit_ampdu:
367
368 /*
369 * Handle privacy requirements. Note that we
370 * must not be preempted from here until after
371 * we (potentially) call ieee80211_crypto_demic;
372 * otherwise we may violate assumptions in the
373 * crypto cipher modules used to do delayed update
374 * of replay sequence numbers.
375 */
376 if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
377 if ((ic->ic_flags & IEEE80211_F_PRIVACY) == 0) {
378 /*
379 * Discard encrypted frames when privacy is off.
380 */
381 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
382 wh, "WEP", "%s", "PRIVACY off");
383 ic->ic_stats.is_rx_noprivacy++;
384 IEEE80211_NODE_STAT(ni, rx_noprivacy);
385 goto out;
386 }
387 key = ieee80211_crypto_decap(ic, ni, m, hdrspace);
388 if (key == NULL) {
389 /* NB: stats+msgs handled in crypto_decap */
390 IEEE80211_NODE_STAT(ni, rx_wepfail);
391 goto out;
392 }
393 wh = mtod(m, struct ieee80211_frame *);
394 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
395 } else {
396 /* XXX M_WEP and IEEE80211_F_PRIVACY */
397 key = NULL;
398 }
399
400 /*
401 * Save QoS bits for use below--before we strip the header.
402 */
403 if (subtype == IEEE80211_FC0_SUBTYPE_QOS) {
404 qos = (dir == IEEE80211_FC1_DIR_DSTODS) ?
405 ((struct ieee80211_qosframe_addr4 *)wh)->i_qos[0] :
406 ((struct ieee80211_qosframe *)wh)->i_qos[0];
407 } else
408 qos = 0;
409
410 /*
411 * Next up, any fragmentation.
412 */
413 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
414 m = ieee80211_defrag(ic, ni, m, hdrspace);
415 if (m == NULL) {
416 /* Fragment dropped or frame not complete yet */
417 goto out;
418 }
419 }
420 wh = NULL; /* no longer valid, catch any uses */
421
422 /*
423 * Next strip any MSDU crypto bits.
424 */
425 if (key != NULL && !ieee80211_crypto_demic(ic, key, m, 0)) {
426 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
427 ni->ni_macaddr, "data", "%s", "demic error");
428 ic->ic_stats.is_rx_demicfail++;
429 IEEE80211_NODE_STAT(ni, rx_demicfail);
430 goto out;
431 }
432
433 /* copy to listener after decrypt */
434 if (bpf_peers_present(ic->ic_rawbpf))
435 bpf_mtap(ic->ic_rawbpf, m);
436 need_tap = 0;
437
438 /*
439 * Finally, strip the 802.11 header.
440 */
441 m = ieee80211_decap(ic, m, hdrspace);
442 if (m == NULL) {
443 /* don't count Null data frames as errors */
444 if (subtype == IEEE80211_FC0_SUBTYPE_NODATA ||
445 subtype == IEEE80211_FC0_SUBTYPE_QOS_NULL)
446 goto out;
447 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
448 ni->ni_macaddr, "data", "%s", "decap error");
449 ic->ic_stats.is_rx_decap++;
450 IEEE80211_NODE_STAT(ni, rx_decap);
451 goto err;
452 }
453 eh = mtod(m, struct ether_header *);
454 if (!ieee80211_node_is_authorized(ni)) {
455 /*
456 * Deny any non-PAE frames received prior to
457 * authorization. For open/shared-key
458 * authentication the port is mark authorized
459 * after authentication completes. For 802.1x
460 * the port is not marked authorized by the
461 * authenticator until the handshake has completed.
462 */
463 if (eh->ether_type != htons(ETHERTYPE_PAE)) {
464 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
465 eh->ether_shost, "data",
466 "unauthorized port: ether type 0x%x len %u",
467 eh->ether_type, m->m_pkthdr.len);
468 ic->ic_stats.is_rx_unauth++;
469 IEEE80211_NODE_STAT(ni, rx_unauth);
470 goto err;
471 }
472 } else {
473 /*
474 * When denying unencrypted frames, discard
475 * any non-PAE frames received without encryption.
476 */
477 if ((ic->ic_flags & IEEE80211_F_DROPUNENC) &&
478 (key == NULL && (m->m_flags & M_WEP) == 0) &&
479 eh->ether_type != htons(ETHERTYPE_PAE)) {
480 /*
481 * Drop unencrypted frames.
482 */
483 ic->ic_stats.is_rx_unencrypted++;
484 IEEE80211_NODE_STAT(ni, rx_unencrypted);
485 goto out;
486 }
487 }
488 /* XXX require HT? */
489 if (qos & IEEE80211_QOS_AMSDU) {
490 m = ieee80211_decap_amsdu(ni, m);
491 if (m == NULL)
492 return IEEE80211_FC0_TYPE_DATA;
493 } else if ((ni->ni_ath_flags & IEEE80211_NODE_FF) &&
494#define FF_LLC_SIZE (sizeof(struct ether_header) + sizeof(struct llc))
495 m->m_pkthdr.len >= 3*FF_LLC_SIZE) {
496 struct llc *llc;
497
498 /*
499 * Check for fast-frame tunnel encapsulation.
500 */
501 if (m->m_len < FF_LLC_SIZE &&
502 (m = m_pullup(m, FF_LLC_SIZE)) == NULL) {
503 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
504 ni->ni_macaddr, "fast-frame",
505 "%s", "m_pullup(llc) failed");
506 ic->ic_stats.is_rx_tooshort++;
507 return IEEE80211_FC0_TYPE_DATA;
508 }
509 llc = (struct llc *)(mtod(m, uint8_t *) +
510 sizeof(struct ether_header));
511 if (llc->llc_snap.ether_type == htons(ATH_FF_ETH_TYPE)) {
512 m_adj(m, FF_LLC_SIZE);
513 m = ieee80211_decap_fastframe(ic, ni, m);
514 if (m == NULL)
515 return IEEE80211_FC0_TYPE_DATA;
516 }
517 }
518#undef FF_LLC_SIZE
519 ieee80211_deliver_data(ic, ni, m);
520 return IEEE80211_FC0_TYPE_DATA;
521
522 case IEEE80211_FC0_TYPE_MGT:
523 ic->ic_stats.is_rx_mgmt++;
524 IEEE80211_NODE_STAT(ni, rx_mgmt);
525 if (dir != IEEE80211_FC1_DIR_NODS) {
526 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
527 wh, "data", "unknown dir 0x%x", dir);
528 ic->ic_stats.is_rx_wrongdir++;
529 goto err;
530 }
531 if (m->m_pkthdr.len < sizeof(struct ieee80211_frame)) {
532 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
533 ni->ni_macaddr, "mgt", "too short: len %u",
534 m->m_pkthdr.len);
535 ic->ic_stats.is_rx_tooshort++;
536 goto out;
537 }
538#ifdef IEEE80211_DEBUG
539 if ((ieee80211_msg_debug(ic) && doprint(ic, subtype)) ||
540 ieee80211_msg_dumppkts(ic)) {
541 if_printf(ic->ic_ifp, "received %s from %s rssi %d\n",
542 ieee80211_mgt_subtype_name[subtype >>
543 IEEE80211_FC0_SUBTYPE_SHIFT],
544 ether_sprintf(wh->i_addr2), rssi);
545 }
546#endif
547 if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
548 if (subtype != IEEE80211_FC0_SUBTYPE_AUTH) {
549 /*
550 * Only shared key auth frames with a challenge
551 * should be encrypted, discard all others.
552 */
553 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
554 wh, ieee80211_mgt_subtype_name[subtype >>
555 IEEE80211_FC0_SUBTYPE_SHIFT],
556 "%s", "WEP set but not permitted");
557 ic->ic_stats.is_rx_mgtdiscard++; /* XXX */
558 goto out;
559 }
560 if ((ic->ic_flags & IEEE80211_F_PRIVACY) == 0) {
561 /*
562 * Discard encrypted frames when privacy is off.
563 */
564 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
565 wh, "mgt", "%s", "WEP set but PRIVACY off");
566 ic->ic_stats.is_rx_noprivacy++;
567 goto out;
568 }
569 hdrspace = ieee80211_hdrspace(ic, wh);
570 key = ieee80211_crypto_decap(ic, ni, m, hdrspace);
571 if (key == NULL) {
572 /* NB: stats+msgs handled in crypto_decap */
573 goto out;
574 }
575 wh = mtod(m, struct ieee80211_frame *);
576 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
577 }
578 if (bpf_peers_present(ic->ic_rawbpf))
579 bpf_mtap(ic->ic_rawbpf, m);
580 (*ic->ic_recv_mgmt)(ic, m, ni, subtype, rssi, noise, rstamp);
581 m_freem(m);
582 return IEEE80211_FC0_TYPE_MGT;
583
584 case IEEE80211_FC0_TYPE_CTL:
585 ic->ic_stats.is_rx_ctl++;
586 IEEE80211_NODE_STAT(ni, rx_ctrl);
587 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
588 switch (subtype) {
589 case IEEE80211_FC0_SUBTYPE_PS_POLL:
590 ieee80211_recv_pspoll(ic, ni, m);
591 break;
592 case IEEE80211_FC0_SUBTYPE_BAR:
593 ieee80211_recv_bar(ni, m);
594 break;
595 }
596 }
597 goto out;
598 default:
599 IEEE80211_DISCARD(ic, IEEE80211_MSG_ANY,
600 wh, NULL, "bad frame type 0x%x", type);
601 /* should not come here */
602 break;
603 }
604err:
605 ifp->if_ierrors++;
606out:
607 if (m != NULL) {
608 if (bpf_peers_present(ic->ic_rawbpf) && need_tap)
609 bpf_mtap(ic->ic_rawbpf, m);
610 m_freem(m);
611 }
612 return type;
613#undef SEQ_LEQ
614}
615
616/*
617 * This function reassemble fragments.
618 */
619static struct mbuf *
620ieee80211_defrag(struct ieee80211com *ic, struct ieee80211_node *ni,
621 struct mbuf *m, int hdrspace)
622{
623 struct ieee80211_frame *wh = mtod(m, struct ieee80211_frame *);
624 struct ieee80211_frame *lwh;
625 uint16_t rxseq;
626 uint8_t fragno;
627 uint8_t more_frag = wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG;
628 struct mbuf *mfrag;
629
630 KASSERT(!IEEE80211_IS_MULTICAST(wh->i_addr1), ("multicast fragm?"));
631
632 rxseq = le16toh(*(uint16_t *)wh->i_seq);
633 fragno = rxseq & IEEE80211_SEQ_FRAG_MASK;
634
635 /* Quick way out, if there's nothing to defragment */
636 if (!more_frag && fragno == 0 && ni->ni_rxfrag[0] == NULL)
637 return m;
638
639 /*
640 * Remove frag to insure it doesn't get reaped by timer.
641 */
642 if (ni->ni_table == NULL) {
643 /*
644 * Should never happen. If the node is orphaned (not in
645 * the table) then input packets should not reach here.
646 * Otherwise, a concurrent request that yanks the table
647 * should be blocked by other interlocking and/or by first
648 * shutting the driver down. Regardless, be defensive
649 * here and just bail
650 */
651 /* XXX need msg+stat */
652 m_freem(m);
653 return NULL;
654 }
655 IEEE80211_NODE_LOCK(ni->ni_table);
656 mfrag = ni->ni_rxfrag[0];
657 ni->ni_rxfrag[0] = NULL;
658 IEEE80211_NODE_UNLOCK(ni->ni_table);
659
660 /*
661 * Validate new fragment is in order and
662 * related to the previous ones.
663 */
664 if (mfrag != NULL) {
665 uint16_t last_rxseq;
666
667 lwh = mtod(mfrag, struct ieee80211_frame *);
668 last_rxseq = le16toh(*(uint16_t *)lwh->i_seq);
669 /* NB: check seq # and frag together */
670 if (rxseq != last_rxseq+1 ||
671 !IEEE80211_ADDR_EQ(wh->i_addr1, lwh->i_addr1) ||
672 !IEEE80211_ADDR_EQ(wh->i_addr2, lwh->i_addr2)) {
673 /*
674 * Unrelated fragment or no space for it,
675 * clear current fragments.
676 */
677 m_freem(mfrag);
678 mfrag = NULL;
679 }
680 }
681
682 if (mfrag == NULL) {
683 if (fragno != 0) { /* !first fragment, discard */
684 ic->ic_stats.is_rx_defrag++;
685 IEEE80211_NODE_STAT(ni, rx_defrag);
686 m_freem(m);
687 return NULL;
688 }
689 mfrag = m;
690 } else { /* concatenate */
691 m_adj(m, hdrspace); /* strip header */
692 m_cat(mfrag, m);
693 /* NB: m_cat doesn't update the packet header */
694 mfrag->m_pkthdr.len += m->m_pkthdr.len;
695 /* track last seqnum and fragno */
696 lwh = mtod(mfrag, struct ieee80211_frame *);
697 *(uint16_t *) lwh->i_seq = *(uint16_t *) wh->i_seq;
698 }
699 if (more_frag) { /* more to come, save */
700 ni->ni_rxfragstamp = ticks;
701 ni->ni_rxfrag[0] = mfrag;
702 mfrag = NULL;
703 }
704 return mfrag;
705}
706
707void
708ieee80211_deliver_data(struct ieee80211com *ic,
709 struct ieee80211_node *ni, struct mbuf *m)
710{
711 struct ether_header *eh = mtod(m, struct ether_header *);
712 struct ifnet *ifp = ic->ic_ifp;
713
714 /*
715 * Do accounting.
716 */
717 ifp->if_ipackets++;
718 IEEE80211_NODE_STAT(ni, rx_data);
719 IEEE80211_NODE_STAT_ADD(ni, rx_bytes, m->m_pkthdr.len);
720 if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
721 m->m_flags |= M_MCAST; /* XXX M_BCAST? */
722 IEEE80211_NODE_STAT(ni, rx_mcast);
723 } else
724 IEEE80211_NODE_STAT(ni, rx_ucast);
725
726 /* clear driver/net80211 flags before passing up */
727 m->m_flags &= ~M_80211_RX;
728
729 /* perform as a bridge within the AP */
730 if (ic->ic_opmode == IEEE80211_M_HOSTAP &&
731 (ic->ic_flags & IEEE80211_F_NOBRIDGE) == 0) {
732 struct mbuf *m1 = NULL;
733
734 if (m->m_flags & M_MCAST) {
735 m1 = m_dup(m, M_DONTWAIT);
736 if (m1 == NULL)
737 ifp->if_oerrors++;
738 else
739 m1->m_flags |= M_MCAST;
740 } else {
741 /*
742 * Check if the destination is known; if so
743 * and the port is authorized dispatch directly.
744 */
745 struct ieee80211_node *sta =
746 ieee80211_find_node(&ic->ic_sta, eh->ether_dhost);
747 if (sta != NULL) {
748 if (ieee80211_node_is_authorized(sta)) {
749 /*
750 * Beware of sending to ourself; this
751 * needs to happen via the normal
752 * input path.
753 */
754 if (sta != ic->ic_bss) {
755 m1 = m;
756 m = NULL;
757 }
758 } else {
759 ic->ic_stats.is_rx_unauth++;
760 IEEE80211_NODE_STAT(sta, rx_unauth);
761 }
762 ieee80211_free_node(sta);
763 }
764 }
| 29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/mbuf.h>
33#include <sys/malloc.h>
34#include <sys/endian.h>
35#include <sys/kernel.h>
36
37#include <sys/socket.h>
38
39#include <net/if.h>
40#include <net/if_media.h>
41#include <net/ethernet.h>
42#include <net/if_llc.h>
43#include <net/if_vlan_var.h>
44
45#include <net80211/ieee80211_var.h>
46
47#include <net/bpf.h>
48
49#ifdef IEEE80211_DEBUG
50#include <machine/stdarg.h>
51
52/*
53 * Decide if a received management frame should be
54 * printed when debugging is enabled. This filters some
55 * of the less interesting frames that come frequently
56 * (e.g. beacons).
57 */
58static __inline int
59doprint(struct ieee80211com *ic, int subtype)
60{
61 switch (subtype) {
62 case IEEE80211_FC0_SUBTYPE_BEACON:
63 return (ic->ic_flags & IEEE80211_F_SCAN);
64 case IEEE80211_FC0_SUBTYPE_PROBE_REQ:
65 return (ic->ic_opmode == IEEE80211_M_IBSS);
66 }
67 return 1;
68}
69
70static const uint8_t *ieee80211_getbssid(struct ieee80211com *,
71 const struct ieee80211_frame *);
72#endif /* IEEE80211_DEBUG */
73
74static struct mbuf *ieee80211_defrag(struct ieee80211com *,
75 struct ieee80211_node *, struct mbuf *, int);
76static struct mbuf *ieee80211_decap(struct ieee80211com *, struct mbuf *, int);
77static void ieee80211_send_error(struct ieee80211com *, struct ieee80211_node *,
78 const uint8_t *mac, int subtype, int arg);
79static struct mbuf *ieee80211_decap_fastframe(struct ieee80211com *,
80 struct ieee80211_node *, struct mbuf *);
81static void ieee80211_recv_pspoll(struct ieee80211com *,
82 struct ieee80211_node *, struct mbuf *);
83
84/*
85 * Process a received frame. The node associated with the sender
86 * should be supplied. If nothing was found in the node table then
87 * the caller is assumed to supply a reference to ic_bss instead.
88 * The RSSI and a timestamp are also supplied. The RSSI data is used
89 * during AP scanning to select a AP to associate with; it can have
90 * any units so long as values have consistent units and higher values
91 * mean ``better signal''. The receive timestamp is currently not used
92 * by the 802.11 layer.
93 */
94int
95ieee80211_input(struct ieee80211com *ic, struct mbuf *m,
96 struct ieee80211_node *ni, int rssi, int noise, uint32_t rstamp)
97{
98#define SEQ_LEQ(a,b) ((int)((a)-(b)) <= 0)
99#define HAS_SEQ(type) ((type & 0x4) == 0)
100 struct ifnet *ifp = ic->ic_ifp;
101 struct ieee80211_frame *wh;
102 struct ieee80211_key *key;
103 struct ether_header *eh;
104 int hdrspace, need_tap;
105 uint8_t dir, type, subtype, qos;
106 uint8_t *bssid;
107 uint16_t rxseq;
108
109 if (m->m_flags & M_AMPDU) {
110 /*
111 * Fastpath for A-MPDU reorder q resubmission. Frames
112 * w/ M_AMPDU marked have already passed through here
113 * but were received out of order and been held on the
114 * reorder queue. When resubmitted they are marked
115 * with the M_AMPDU flag and we can bypass most of the
116 * normal processing.
117 */
118 wh = mtod(m, struct ieee80211_frame *);
119 type = IEEE80211_FC0_TYPE_DATA;
120 dir = wh->i_fc[1] & IEEE80211_FC1_DIR_MASK;
121 subtype = IEEE80211_FC0_SUBTYPE_QOS;
122 hdrspace = ieee80211_hdrspace(ic, wh); /* XXX optimize? */
123 need_tap = 0;
124 goto resubmit_ampdu;
125 }
126
127 KASSERT(ni != NULL, ("null node"));
128 ni->ni_inact = ni->ni_inact_reload;
129
130 need_tap = 1; /* mbuf need to be tapped. */
131 type = -1; /* undefined */
132 /*
133 * In monitor mode, send everything directly to bpf.
134 * XXX may want to include the CRC
135 */
136 if (ic->ic_opmode == IEEE80211_M_MONITOR)
137 goto out;
138
139 if (m->m_pkthdr.len < sizeof(struct ieee80211_frame_min)) {
140 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
141 ni->ni_macaddr, NULL,
142 "too short (1): len %u", m->m_pkthdr.len);
143 ic->ic_stats.is_rx_tooshort++;
144 goto out;
145 }
146 /*
147 * Bit of a cheat here, we use a pointer for a 3-address
148 * frame format but don't reference fields past outside
149 * ieee80211_frame_min w/o first validating the data is
150 * present.
151 */
152 wh = mtod(m, struct ieee80211_frame *);
153
154 if ((wh->i_fc[0] & IEEE80211_FC0_VERSION_MASK) !=
155 IEEE80211_FC0_VERSION_0) {
156 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
157 ni->ni_macaddr, NULL, "wrong version %x", wh->i_fc[0]);
158 ic->ic_stats.is_rx_badversion++;
159 goto err;
160 }
161
162 dir = wh->i_fc[1] & IEEE80211_FC1_DIR_MASK;
163 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
164 subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
165 if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) {
166 switch (ic->ic_opmode) {
167 case IEEE80211_M_STA:
168 bssid = wh->i_addr2;
169 if (!IEEE80211_ADDR_EQ(bssid, ni->ni_bssid)) {
170 /* not interested in */
171 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
172 bssid, NULL, "%s", "not to bss");
173 ic->ic_stats.is_rx_wrongbss++;
174 goto out;
175 }
176 break;
177 case IEEE80211_M_IBSS:
178 case IEEE80211_M_AHDEMO:
179 case IEEE80211_M_HOSTAP:
180 if (dir != IEEE80211_FC1_DIR_NODS)
181 bssid = wh->i_addr1;
182 else if (type == IEEE80211_FC0_TYPE_CTL)
183 bssid = wh->i_addr1;
184 else {
185 if (m->m_pkthdr.len < sizeof(struct ieee80211_frame)) {
186 IEEE80211_DISCARD_MAC(ic,
187 IEEE80211_MSG_ANY, ni->ni_macaddr,
188 NULL, "too short (2): len %u",
189 m->m_pkthdr.len);
190 ic->ic_stats.is_rx_tooshort++;
191 goto out;
192 }
193 bssid = wh->i_addr3;
194 }
195 if (type != IEEE80211_FC0_TYPE_DATA)
196 break;
197 /*
198 * Data frame, validate the bssid.
199 */
200 if (!IEEE80211_ADDR_EQ(bssid, ic->ic_bss->ni_bssid) &&
201 !IEEE80211_ADDR_EQ(bssid, ifp->if_broadcastaddr)) {
202 /* not interested in */
203 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
204 bssid, NULL, "%s", "not to bss");
205 ic->ic_stats.is_rx_wrongbss++;
206 goto out;
207 }
208 /*
209 * For adhoc mode we cons up a node when it doesn't
210 * exist. This should probably done after an ACL check.
211 */
212 if (ni == ic->ic_bss &&
213 ic->ic_opmode != IEEE80211_M_HOSTAP &&
214 !IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) {
215 /*
216 * Fake up a node for this newly
217 * discovered member of the IBSS.
218 */
219 ni = ieee80211_fakeup_adhoc_node(&ic->ic_sta,
220 wh->i_addr2);
221 if (ni == NULL) {
222 /* NB: stat kept for alloc failure */
223 goto err;
224 }
225 }
226 break;
227 default:
228 goto out;
229 }
230 ni->ni_rssi = rssi;
231 ni->ni_noise = noise;
232 ni->ni_rstamp = rstamp;
233 if (HAS_SEQ(type)) {
234 uint8_t tid;
235 if (IEEE80211_QOS_HAS_SEQ(wh)) {
236 tid = ((struct ieee80211_qosframe *)wh)->
237 i_qos[0] & IEEE80211_QOS_TID;
238 if (TID_TO_WME_AC(tid) >= WME_AC_VI)
239 ic->ic_wme.wme_hipri_traffic++;
240 tid++;
241 } else
242 tid = IEEE80211_NONQOS_TID;
243 rxseq = le16toh(*(uint16_t *)wh->i_seq);
244 if ((ni->ni_flags & IEEE80211_NODE_HT) == 0 &&
245 (wh->i_fc[1] & IEEE80211_FC1_RETRY) &&
246 SEQ_LEQ(rxseq, ni->ni_rxseqs[tid])) {
247 /* duplicate, discard */
248 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
249 bssid, "duplicate",
250 "seqno <%u,%u> fragno <%u,%u> tid %u",
251 rxseq >> IEEE80211_SEQ_SEQ_SHIFT,
252 ni->ni_rxseqs[tid] >>
253 IEEE80211_SEQ_SEQ_SHIFT,
254 rxseq & IEEE80211_SEQ_FRAG_MASK,
255 ni->ni_rxseqs[tid] &
256 IEEE80211_SEQ_FRAG_MASK,
257 tid);
258 ic->ic_stats.is_rx_dup++;
259 IEEE80211_NODE_STAT(ni, rx_dup);
260 goto out;
261 }
262 ni->ni_rxseqs[tid] = rxseq;
263 }
264 }
265
266 switch (type) {
267 case IEEE80211_FC0_TYPE_DATA:
268 hdrspace = ieee80211_hdrspace(ic, wh);
269 if (m->m_len < hdrspace &&
270 (m = m_pullup(m, hdrspace)) == NULL) {
271 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
272 ni->ni_macaddr, NULL,
273 "data too short: expecting %u", hdrspace);
274 ic->ic_stats.is_rx_tooshort++;
275 goto out; /* XXX */
276 }
277 switch (ic->ic_opmode) {
278 case IEEE80211_M_STA:
279 if (dir != IEEE80211_FC1_DIR_FROMDS) {
280 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
281 wh, "data", "unknown dir 0x%x", dir);
282 ic->ic_stats.is_rx_wrongdir++;
283 goto out;
284 }
285 if ((ifp->if_flags & IFF_SIMPLEX) &&
286 IEEE80211_IS_MULTICAST(wh->i_addr1) &&
287 IEEE80211_ADDR_EQ(wh->i_addr3, ic->ic_myaddr)) {
288 /*
289 * In IEEE802.11 network, multicast packet
290 * sent from me is broadcasted from AP.
291 * It should be silently discarded for
292 * SIMPLEX interface.
293 */
294 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
295 wh, NULL, "%s", "multicast echo");
296 ic->ic_stats.is_rx_mcastecho++;
297 goto out;
298 }
299 break;
300 case IEEE80211_M_IBSS:
301 case IEEE80211_M_AHDEMO:
302 if (dir != IEEE80211_FC1_DIR_NODS) {
303 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
304 wh, "data", "unknown dir 0x%x", dir);
305 ic->ic_stats.is_rx_wrongdir++;
306 goto out;
307 }
308 /* XXX no power-save support */
309 break;
310 case IEEE80211_M_HOSTAP:
311 if (dir != IEEE80211_FC1_DIR_TODS) {
312 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
313 wh, "data", "unknown dir 0x%x", dir);
314 ic->ic_stats.is_rx_wrongdir++;
315 goto out;
316 }
317 /* check if source STA is associated */
318 if (ni == ic->ic_bss) {
319 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
320 wh, "data", "%s", "unknown src");
321 ieee80211_send_error(ic, ni, wh->i_addr2,
322 IEEE80211_FC0_SUBTYPE_DEAUTH,
323 IEEE80211_REASON_NOT_AUTHED);
324 ic->ic_stats.is_rx_notassoc++;
325 goto err;
326 }
327 if (ni->ni_associd == 0) {
328 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
329 wh, "data", "%s", "unassoc src");
330 IEEE80211_SEND_MGMT(ic, ni,
331 IEEE80211_FC0_SUBTYPE_DISASSOC,
332 IEEE80211_REASON_NOT_ASSOCED);
333 ic->ic_stats.is_rx_notassoc++;
334 goto err;
335 }
336
337 /*
338 * Check for power save state change.
339 * XXX out-of-order A-MPDU frames?
340 */
341 if (((wh->i_fc[1] & IEEE80211_FC1_PWR_MGT) ^
342 (ni->ni_flags & IEEE80211_NODE_PWR_MGT)))
343 ieee80211_node_pwrsave(ni,
344 wh->i_fc[1] & IEEE80211_FC1_PWR_MGT);
345 break;
346 default:
347 /* XXX here to keep compiler happy */
348 goto out;
349 }
350
351 /*
352 * Handle A-MPDU re-ordering. The station must be
353 * associated and negotiated HT. The frame must be
354 * a QoS frame (not QoS null data) and not previously
355 * processed for A-MPDU re-ordering. If the frame is
356 * to be processed directly then ieee80211_ampdu_reorder
357 * will return 0; otherwise it has consumed the mbuf
358 * and we should do nothing more with it.
359 */
360 if ((ni->ni_flags & IEEE80211_NODE_HT) &&
361 subtype == IEEE80211_FC0_SUBTYPE_QOS &&
362 ieee80211_ampdu_reorder(ni, m) != 0) {
363 m = NULL;
364 goto out;
365 }
366 resubmit_ampdu:
367
368 /*
369 * Handle privacy requirements. Note that we
370 * must not be preempted from here until after
371 * we (potentially) call ieee80211_crypto_demic;
372 * otherwise we may violate assumptions in the
373 * crypto cipher modules used to do delayed update
374 * of replay sequence numbers.
375 */
376 if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
377 if ((ic->ic_flags & IEEE80211_F_PRIVACY) == 0) {
378 /*
379 * Discard encrypted frames when privacy is off.
380 */
381 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
382 wh, "WEP", "%s", "PRIVACY off");
383 ic->ic_stats.is_rx_noprivacy++;
384 IEEE80211_NODE_STAT(ni, rx_noprivacy);
385 goto out;
386 }
387 key = ieee80211_crypto_decap(ic, ni, m, hdrspace);
388 if (key == NULL) {
389 /* NB: stats+msgs handled in crypto_decap */
390 IEEE80211_NODE_STAT(ni, rx_wepfail);
391 goto out;
392 }
393 wh = mtod(m, struct ieee80211_frame *);
394 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
395 } else {
396 /* XXX M_WEP and IEEE80211_F_PRIVACY */
397 key = NULL;
398 }
399
400 /*
401 * Save QoS bits for use below--before we strip the header.
402 */
403 if (subtype == IEEE80211_FC0_SUBTYPE_QOS) {
404 qos = (dir == IEEE80211_FC1_DIR_DSTODS) ?
405 ((struct ieee80211_qosframe_addr4 *)wh)->i_qos[0] :
406 ((struct ieee80211_qosframe *)wh)->i_qos[0];
407 } else
408 qos = 0;
409
410 /*
411 * Next up, any fragmentation.
412 */
413 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
414 m = ieee80211_defrag(ic, ni, m, hdrspace);
415 if (m == NULL) {
416 /* Fragment dropped or frame not complete yet */
417 goto out;
418 }
419 }
420 wh = NULL; /* no longer valid, catch any uses */
421
422 /*
423 * Next strip any MSDU crypto bits.
424 */
425 if (key != NULL && !ieee80211_crypto_demic(ic, key, m, 0)) {
426 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
427 ni->ni_macaddr, "data", "%s", "demic error");
428 ic->ic_stats.is_rx_demicfail++;
429 IEEE80211_NODE_STAT(ni, rx_demicfail);
430 goto out;
431 }
432
433 /* copy to listener after decrypt */
434 if (bpf_peers_present(ic->ic_rawbpf))
435 bpf_mtap(ic->ic_rawbpf, m);
436 need_tap = 0;
437
438 /*
439 * Finally, strip the 802.11 header.
440 */
441 m = ieee80211_decap(ic, m, hdrspace);
442 if (m == NULL) {
443 /* don't count Null data frames as errors */
444 if (subtype == IEEE80211_FC0_SUBTYPE_NODATA ||
445 subtype == IEEE80211_FC0_SUBTYPE_QOS_NULL)
446 goto out;
447 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
448 ni->ni_macaddr, "data", "%s", "decap error");
449 ic->ic_stats.is_rx_decap++;
450 IEEE80211_NODE_STAT(ni, rx_decap);
451 goto err;
452 }
453 eh = mtod(m, struct ether_header *);
454 if (!ieee80211_node_is_authorized(ni)) {
455 /*
456 * Deny any non-PAE frames received prior to
457 * authorization. For open/shared-key
458 * authentication the port is mark authorized
459 * after authentication completes. For 802.1x
460 * the port is not marked authorized by the
461 * authenticator until the handshake has completed.
462 */
463 if (eh->ether_type != htons(ETHERTYPE_PAE)) {
464 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_INPUT,
465 eh->ether_shost, "data",
466 "unauthorized port: ether type 0x%x len %u",
467 eh->ether_type, m->m_pkthdr.len);
468 ic->ic_stats.is_rx_unauth++;
469 IEEE80211_NODE_STAT(ni, rx_unauth);
470 goto err;
471 }
472 } else {
473 /*
474 * When denying unencrypted frames, discard
475 * any non-PAE frames received without encryption.
476 */
477 if ((ic->ic_flags & IEEE80211_F_DROPUNENC) &&
478 (key == NULL && (m->m_flags & M_WEP) == 0) &&
479 eh->ether_type != htons(ETHERTYPE_PAE)) {
480 /*
481 * Drop unencrypted frames.
482 */
483 ic->ic_stats.is_rx_unencrypted++;
484 IEEE80211_NODE_STAT(ni, rx_unencrypted);
485 goto out;
486 }
487 }
488 /* XXX require HT? */
489 if (qos & IEEE80211_QOS_AMSDU) {
490 m = ieee80211_decap_amsdu(ni, m);
491 if (m == NULL)
492 return IEEE80211_FC0_TYPE_DATA;
493 } else if ((ni->ni_ath_flags & IEEE80211_NODE_FF) &&
494#define FF_LLC_SIZE (sizeof(struct ether_header) + sizeof(struct llc))
495 m->m_pkthdr.len >= 3*FF_LLC_SIZE) {
496 struct llc *llc;
497
498 /*
499 * Check for fast-frame tunnel encapsulation.
500 */
501 if (m->m_len < FF_LLC_SIZE &&
502 (m = m_pullup(m, FF_LLC_SIZE)) == NULL) {
503 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
504 ni->ni_macaddr, "fast-frame",
505 "%s", "m_pullup(llc) failed");
506 ic->ic_stats.is_rx_tooshort++;
507 return IEEE80211_FC0_TYPE_DATA;
508 }
509 llc = (struct llc *)(mtod(m, uint8_t *) +
510 sizeof(struct ether_header));
511 if (llc->llc_snap.ether_type == htons(ATH_FF_ETH_TYPE)) {
512 m_adj(m, FF_LLC_SIZE);
513 m = ieee80211_decap_fastframe(ic, ni, m);
514 if (m == NULL)
515 return IEEE80211_FC0_TYPE_DATA;
516 }
517 }
518#undef FF_LLC_SIZE
519 ieee80211_deliver_data(ic, ni, m);
520 return IEEE80211_FC0_TYPE_DATA;
521
522 case IEEE80211_FC0_TYPE_MGT:
523 ic->ic_stats.is_rx_mgmt++;
524 IEEE80211_NODE_STAT(ni, rx_mgmt);
525 if (dir != IEEE80211_FC1_DIR_NODS) {
526 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
527 wh, "data", "unknown dir 0x%x", dir);
528 ic->ic_stats.is_rx_wrongdir++;
529 goto err;
530 }
531 if (m->m_pkthdr.len < sizeof(struct ieee80211_frame)) {
532 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
533 ni->ni_macaddr, "mgt", "too short: len %u",
534 m->m_pkthdr.len);
535 ic->ic_stats.is_rx_tooshort++;
536 goto out;
537 }
538#ifdef IEEE80211_DEBUG
539 if ((ieee80211_msg_debug(ic) && doprint(ic, subtype)) ||
540 ieee80211_msg_dumppkts(ic)) {
541 if_printf(ic->ic_ifp, "received %s from %s rssi %d\n",
542 ieee80211_mgt_subtype_name[subtype >>
543 IEEE80211_FC0_SUBTYPE_SHIFT],
544 ether_sprintf(wh->i_addr2), rssi);
545 }
546#endif
547 if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
548 if (subtype != IEEE80211_FC0_SUBTYPE_AUTH) {
549 /*
550 * Only shared key auth frames with a challenge
551 * should be encrypted, discard all others.
552 */
553 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
554 wh, ieee80211_mgt_subtype_name[subtype >>
555 IEEE80211_FC0_SUBTYPE_SHIFT],
556 "%s", "WEP set but not permitted");
557 ic->ic_stats.is_rx_mgtdiscard++; /* XXX */
558 goto out;
559 }
560 if ((ic->ic_flags & IEEE80211_F_PRIVACY) == 0) {
561 /*
562 * Discard encrypted frames when privacy is off.
563 */
564 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
565 wh, "mgt", "%s", "WEP set but PRIVACY off");
566 ic->ic_stats.is_rx_noprivacy++;
567 goto out;
568 }
569 hdrspace = ieee80211_hdrspace(ic, wh);
570 key = ieee80211_crypto_decap(ic, ni, m, hdrspace);
571 if (key == NULL) {
572 /* NB: stats+msgs handled in crypto_decap */
573 goto out;
574 }
575 wh = mtod(m, struct ieee80211_frame *);
576 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
577 }
578 if (bpf_peers_present(ic->ic_rawbpf))
579 bpf_mtap(ic->ic_rawbpf, m);
580 (*ic->ic_recv_mgmt)(ic, m, ni, subtype, rssi, noise, rstamp);
581 m_freem(m);
582 return IEEE80211_FC0_TYPE_MGT;
583
584 case IEEE80211_FC0_TYPE_CTL:
585 ic->ic_stats.is_rx_ctl++;
586 IEEE80211_NODE_STAT(ni, rx_ctrl);
587 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
588 switch (subtype) {
589 case IEEE80211_FC0_SUBTYPE_PS_POLL:
590 ieee80211_recv_pspoll(ic, ni, m);
591 break;
592 case IEEE80211_FC0_SUBTYPE_BAR:
593 ieee80211_recv_bar(ni, m);
594 break;
595 }
596 }
597 goto out;
598 default:
599 IEEE80211_DISCARD(ic, IEEE80211_MSG_ANY,
600 wh, NULL, "bad frame type 0x%x", type);
601 /* should not come here */
602 break;
603 }
604err:
605 ifp->if_ierrors++;
606out:
607 if (m != NULL) {
608 if (bpf_peers_present(ic->ic_rawbpf) && need_tap)
609 bpf_mtap(ic->ic_rawbpf, m);
610 m_freem(m);
611 }
612 return type;
613#undef SEQ_LEQ
614}
615
616/*
617 * This function reassemble fragments.
618 */
619static struct mbuf *
620ieee80211_defrag(struct ieee80211com *ic, struct ieee80211_node *ni,
621 struct mbuf *m, int hdrspace)
622{
623 struct ieee80211_frame *wh = mtod(m, struct ieee80211_frame *);
624 struct ieee80211_frame *lwh;
625 uint16_t rxseq;
626 uint8_t fragno;
627 uint8_t more_frag = wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG;
628 struct mbuf *mfrag;
629
630 KASSERT(!IEEE80211_IS_MULTICAST(wh->i_addr1), ("multicast fragm?"));
631
632 rxseq = le16toh(*(uint16_t *)wh->i_seq);
633 fragno = rxseq & IEEE80211_SEQ_FRAG_MASK;
634
635 /* Quick way out, if there's nothing to defragment */
636 if (!more_frag && fragno == 0 && ni->ni_rxfrag[0] == NULL)
637 return m;
638
639 /*
640 * Remove frag to insure it doesn't get reaped by timer.
641 */
642 if (ni->ni_table == NULL) {
643 /*
644 * Should never happen. If the node is orphaned (not in
645 * the table) then input packets should not reach here.
646 * Otherwise, a concurrent request that yanks the table
647 * should be blocked by other interlocking and/or by first
648 * shutting the driver down. Regardless, be defensive
649 * here and just bail
650 */
651 /* XXX need msg+stat */
652 m_freem(m);
653 return NULL;
654 }
655 IEEE80211_NODE_LOCK(ni->ni_table);
656 mfrag = ni->ni_rxfrag[0];
657 ni->ni_rxfrag[0] = NULL;
658 IEEE80211_NODE_UNLOCK(ni->ni_table);
659
660 /*
661 * Validate new fragment is in order and
662 * related to the previous ones.
663 */
664 if (mfrag != NULL) {
665 uint16_t last_rxseq;
666
667 lwh = mtod(mfrag, struct ieee80211_frame *);
668 last_rxseq = le16toh(*(uint16_t *)lwh->i_seq);
669 /* NB: check seq # and frag together */
670 if (rxseq != last_rxseq+1 ||
671 !IEEE80211_ADDR_EQ(wh->i_addr1, lwh->i_addr1) ||
672 !IEEE80211_ADDR_EQ(wh->i_addr2, lwh->i_addr2)) {
673 /*
674 * Unrelated fragment or no space for it,
675 * clear current fragments.
676 */
677 m_freem(mfrag);
678 mfrag = NULL;
679 }
680 }
681
682 if (mfrag == NULL) {
683 if (fragno != 0) { /* !first fragment, discard */
684 ic->ic_stats.is_rx_defrag++;
685 IEEE80211_NODE_STAT(ni, rx_defrag);
686 m_freem(m);
687 return NULL;
688 }
689 mfrag = m;
690 } else { /* concatenate */
691 m_adj(m, hdrspace); /* strip header */
692 m_cat(mfrag, m);
693 /* NB: m_cat doesn't update the packet header */
694 mfrag->m_pkthdr.len += m->m_pkthdr.len;
695 /* track last seqnum and fragno */
696 lwh = mtod(mfrag, struct ieee80211_frame *);
697 *(uint16_t *) lwh->i_seq = *(uint16_t *) wh->i_seq;
698 }
699 if (more_frag) { /* more to come, save */
700 ni->ni_rxfragstamp = ticks;
701 ni->ni_rxfrag[0] = mfrag;
702 mfrag = NULL;
703 }
704 return mfrag;
705}
706
707void
708ieee80211_deliver_data(struct ieee80211com *ic,
709 struct ieee80211_node *ni, struct mbuf *m)
710{
711 struct ether_header *eh = mtod(m, struct ether_header *);
712 struct ifnet *ifp = ic->ic_ifp;
713
714 /*
715 * Do accounting.
716 */
717 ifp->if_ipackets++;
718 IEEE80211_NODE_STAT(ni, rx_data);
719 IEEE80211_NODE_STAT_ADD(ni, rx_bytes, m->m_pkthdr.len);
720 if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
721 m->m_flags |= M_MCAST; /* XXX M_BCAST? */
722 IEEE80211_NODE_STAT(ni, rx_mcast);
723 } else
724 IEEE80211_NODE_STAT(ni, rx_ucast);
725
726 /* clear driver/net80211 flags before passing up */
727 m->m_flags &= ~M_80211_RX;
728
729 /* perform as a bridge within the AP */
730 if (ic->ic_opmode == IEEE80211_M_HOSTAP &&
731 (ic->ic_flags & IEEE80211_F_NOBRIDGE) == 0) {
732 struct mbuf *m1 = NULL;
733
734 if (m->m_flags & M_MCAST) {
735 m1 = m_dup(m, M_DONTWAIT);
736 if (m1 == NULL)
737 ifp->if_oerrors++;
738 else
739 m1->m_flags |= M_MCAST;
740 } else {
741 /*
742 * Check if the destination is known; if so
743 * and the port is authorized dispatch directly.
744 */
745 struct ieee80211_node *sta =
746 ieee80211_find_node(&ic->ic_sta, eh->ether_dhost);
747 if (sta != NULL) {
748 if (ieee80211_node_is_authorized(sta)) {
749 /*
750 * Beware of sending to ourself; this
751 * needs to happen via the normal
752 * input path.
753 */
754 if (sta != ic->ic_bss) {
755 m1 = m;
756 m = NULL;
757 }
758 } else {
759 ic->ic_stats.is_rx_unauth++;
760 IEEE80211_NODE_STAT(sta, rx_unauth);
761 }
762 ieee80211_free_node(sta);
763 }
764 }
|
767 }
768 if (m != NULL) {
769 m->m_pkthdr.rcvif = ifp;
770 if (ni->ni_vlan != 0) {
771 /* attach vlan tag */
772 m->m_pkthdr.ether_vtag = ni->ni_vlan;
773 m->m_flags |= M_VLANTAG;
774 }
775 (*ifp->if_input)(ifp, m);
776 }
777}
778
779static struct mbuf *
780ieee80211_decap(struct ieee80211com *ic, struct mbuf *m, int hdrlen)
781{
782 struct ieee80211_qosframe_addr4 wh; /* Max size address frames */
783 struct ether_header *eh;
784 struct llc *llc;
785
786 if (m->m_len < hdrlen + sizeof(*llc) &&
787 (m = m_pullup(m, hdrlen + sizeof(*llc))) == NULL) {
788 /* XXX stat, msg */
789 return NULL;
790 }
791 memcpy(&wh, mtod(m, caddr_t), hdrlen);
792 llc = (struct llc *)(mtod(m, caddr_t) + hdrlen);
793 if (llc->llc_dsap == LLC_SNAP_LSAP && llc->llc_ssap == LLC_SNAP_LSAP &&
794 llc->llc_control == LLC_UI && llc->llc_snap.org_code[0] == 0 &&
795 llc->llc_snap.org_code[1] == 0 && llc->llc_snap.org_code[2] == 0) {
796 m_adj(m, hdrlen + sizeof(struct llc) - sizeof(*eh));
797 llc = NULL;
798 } else {
799 m_adj(m, hdrlen - sizeof(*eh));
800 }
801 eh = mtod(m, struct ether_header *);
802 switch (wh.i_fc[1] & IEEE80211_FC1_DIR_MASK) {
803 case IEEE80211_FC1_DIR_NODS:
804 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr1);
805 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr2);
806 break;
807 case IEEE80211_FC1_DIR_TODS:
808 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr3);
809 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr2);
810 break;
811 case IEEE80211_FC1_DIR_FROMDS:
812 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr1);
813 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr3);
814 break;
815 case IEEE80211_FC1_DIR_DSTODS:
816 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr3);
817 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr4);
818 break;
819 }
820#ifdef ALIGNED_POINTER
821 if (!ALIGNED_POINTER(mtod(m, caddr_t) + sizeof(*eh), uint32_t)) {
822 struct mbuf *n, *n0, **np;
823 caddr_t newdata;
824 int off, pktlen;
825
826 n0 = NULL;
827 np = &n0;
828 off = 0;
829 pktlen = m->m_pkthdr.len;
830 while (pktlen > off) {
831 if (n0 == NULL) {
832 MGETHDR(n, M_DONTWAIT, MT_DATA);
833 if (n == NULL) {
834 m_freem(m);
835 return NULL;
836 }
837 M_MOVE_PKTHDR(n, m);
838 n->m_len = MHLEN;
839 } else {
840 MGET(n, M_DONTWAIT, MT_DATA);
841 if (n == NULL) {
842 m_freem(m);
843 m_freem(n0);
844 return NULL;
845 }
846 n->m_len = MLEN;
847 }
848 if (pktlen - off >= MINCLSIZE) {
849 MCLGET(n, M_DONTWAIT);
850 if (n->m_flags & M_EXT)
851 n->m_len = n->m_ext.ext_size;
852 }
853 if (n0 == NULL) {
854 newdata =
855 (caddr_t)ALIGN(n->m_data + sizeof(*eh)) -
856 sizeof(*eh);
857 n->m_len -= newdata - n->m_data;
858 n->m_data = newdata;
859 }
860 if (n->m_len > pktlen - off)
861 n->m_len = pktlen - off;
862 m_copydata(m, off, n->m_len, mtod(n, caddr_t));
863 off += n->m_len;
864 *np = n;
865 np = &n->m_next;
866 }
867 m_freem(m);
868 m = n0;
869 }
870#endif /* ALIGNED_POINTER */
871 if (llc != NULL) {
872 eh = mtod(m, struct ether_header *);
873 eh->ether_type = htons(m->m_pkthdr.len - sizeof(*eh));
874 }
875 return m;
876}
877
878/*
879 * Decap a frame encapsulated in a fast-frame/A-MSDU.
880 */
881struct mbuf *
882ieee80211_decap1(struct mbuf *m, int *framelen)
883{
884#define FF_LLC_SIZE (sizeof(struct ether_header) + sizeof(struct llc))
885 struct ether_header *eh;
886 struct llc *llc;
887
888 /*
889 * The frame has an 802.3 header followed by an 802.2
890 * LLC header. The encapsulated frame length is in the
891 * first header type field; save that and overwrite it
892 * with the true type field found in the second. Then
893 * copy the 802.3 header up to where it belongs and
894 * adjust the mbuf contents to remove the void.
895 */
896 if (m->m_len < FF_LLC_SIZE && (m = m_pullup(m, FF_LLC_SIZE)) == NULL)
897 return NULL;
898 eh = mtod(m, struct ether_header *); /* 802.3 header is first */
899 llc = (struct llc *)&eh[1]; /* 802.2 header follows */
900 *framelen = ntohs(eh->ether_type) /* encap'd frame size */
901 + sizeof(struct ether_header) - sizeof(struct llc);
902 eh->ether_type = llc->llc_un.type_snap.ether_type;
903 ovbcopy(eh, mtod(m, uint8_t *) + sizeof(struct llc),
904 sizeof(struct ether_header));
905 m_adj(m, sizeof(struct llc));
906 return m;
907#undef FF_LLC_SIZE
908}
909
910/*
911 * Decap the encapsulated frame pair and dispatch the first
912 * for delivery. The second frame is returned for delivery
913 * via the normal path.
914 */
915static struct mbuf *
916ieee80211_decap_fastframe(struct ieee80211com *ic,
917 struct ieee80211_node *ni, struct mbuf *m)
918{
919#define MS(x,f) (((x) & f) >> f##_S)
920 uint32_t ath;
921 struct mbuf *n;
922 int framelen;
923
924 m_copydata(m, 0, sizeof(uint32_t), (caddr_t) &ath);
925 if (MS(ath, ATH_FF_PROTO) != ATH_FF_PROTO_L2TUNNEL) {
926 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
927 ni->ni_macaddr, "fast-frame",
928 "unsupport tunnel protocol, header 0x%x", ath);
929 ic->ic_stats.is_ff_badhdr++;
930 m_freem(m);
931 return NULL;
932 }
933 /* NB: skip header and alignment padding */
934 m_adj(m, roundup(sizeof(uint32_t) - 2, 4) + 2);
935
936 ic->ic_stats.is_ff_decap++;
937
938 /*
939 * Decap the first frame, bust it apart from the
940 * second and deliver; then decap the second frame
941 * and return it to the caller for normal delivery.
942 */
943 m = ieee80211_decap1(m, &framelen);
944 if (m == NULL) {
945 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
946 ni->ni_macaddr, "fast-frame", "%s", "first decap failed");
947 ic->ic_stats.is_ff_tooshort++;
948 return NULL;
949 }
950 n = m_split(m, framelen, M_NOWAIT);
951 if (n == NULL) {
952 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
953 ni->ni_macaddr, "fast-frame",
954 "%s", "unable to split encapsulated frames");
955 ic->ic_stats.is_ff_split++;
956 m_freem(m); /* NB: must reclaim */
957 return NULL;
958 }
959 ieee80211_deliver_data(ic, ni, m); /* 1st of pair */
960
961 /*
962 * Decap second frame.
963 */
964 m_adj(n, roundup2(framelen, 4) - framelen); /* padding */
965 n = ieee80211_decap1(n, &framelen);
966 if (n == NULL) {
967 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
968 ni->ni_macaddr, "fast-frame", "%s", "second decap failed");
969 ic->ic_stats.is_ff_tooshort++;
970 }
971 /* XXX verify framelen against mbuf contents */
972 return n; /* 2nd delivered by caller */
973#undef MS
974}
975
976/*
977 * Install received rate set information in the node's state block.
978 */
979int
980ieee80211_setup_rates(struct ieee80211_node *ni,
981 const uint8_t *rates, const uint8_t *xrates, int flags)
982{
983 struct ieee80211com *ic = ni->ni_ic;
984 struct ieee80211_rateset *rs = &ni->ni_rates;
985
986 memset(rs, 0, sizeof(*rs));
987 rs->rs_nrates = rates[1];
988 memcpy(rs->rs_rates, rates + 2, rs->rs_nrates);
989 if (xrates != NULL) {
990 uint8_t nxrates;
991 /*
992 * Tack on 11g extended supported rate element.
993 */
994 nxrates = xrates[1];
995 if (rs->rs_nrates + nxrates > IEEE80211_RATE_MAXSIZE) {
996 nxrates = IEEE80211_RATE_MAXSIZE - rs->rs_nrates;
997 IEEE80211_DPRINTF(ic, IEEE80211_MSG_XRATE,
998 "[%s] extended rate set too large;"
999 " only using %u of %u rates\n",
1000 ether_sprintf(ni->ni_macaddr), nxrates, xrates[1]);
1001 ic->ic_stats.is_rx_rstoobig++;
1002 }
1003 memcpy(rs->rs_rates + rs->rs_nrates, xrates+2, nxrates);
1004 rs->rs_nrates += nxrates;
1005 }
1006 return ieee80211_fix_rate(ni, rs, flags);
1007}
1008
1009static void
1010ieee80211_auth_open(struct ieee80211com *ic, struct ieee80211_frame *wh,
1011 struct ieee80211_node *ni, int rssi, int noise, uint32_t rstamp,
1012 uint16_t seq, uint16_t status)
1013{
1014
1015 if (ni->ni_authmode == IEEE80211_AUTH_SHARED) {
1016 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1017 ni->ni_macaddr, "open auth",
1018 "bad sta auth mode %u", ni->ni_authmode);
1019 ic->ic_stats.is_rx_bad_auth++; /* XXX */
1020 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
1021 /*
1022 * Clear any challenge text that may be there if
1023 * a previous shared key auth failed and then an
1024 * open auth is attempted.
1025 */
1026 if (ni->ni_challenge != NULL) {
1027 FREE(ni->ni_challenge, M_80211_NODE);
1028 ni->ni_challenge = NULL;
1029 }
1030 /* XXX hack to workaround calling convention */
1031 ieee80211_send_error(ic, ni, wh->i_addr2,
1032 IEEE80211_FC0_SUBTYPE_AUTH,
1033 (seq + 1) | (IEEE80211_STATUS_ALG<<16));
1034 }
1035 return;
1036 }
1037 switch (ic->ic_opmode) {
1038 case IEEE80211_M_IBSS:
1039 case IEEE80211_M_AHDEMO:
1040 case IEEE80211_M_MONITOR:
1041 case IEEE80211_M_WDS:
1042 /* should not come here */
1043 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1044 ni->ni_macaddr, "open auth",
1045 "bad operating mode %u", ic->ic_opmode);
1046 break;
1047
1048 case IEEE80211_M_HOSTAP:
1049 if (ic->ic_state != IEEE80211_S_RUN ||
1050 seq != IEEE80211_AUTH_OPEN_REQUEST) {
1051 ic->ic_stats.is_rx_bad_auth++;
1052 return;
1053 }
1054 /* always accept open authentication requests */
1055 if (ni == ic->ic_bss) {
1056 ni = ieee80211_dup_bss(&ic->ic_sta, wh->i_addr2);
1057 if (ni == NULL)
1058 return;
1059 } else if ((ni->ni_flags & IEEE80211_NODE_AREF) == 0)
1060 (void) ieee80211_ref_node(ni);
1061 /*
1062 * Mark the node as referenced to reflect that it's
1063 * reference count has been bumped to insure it remains
1064 * after the transaction completes.
1065 */
1066 ni->ni_flags |= IEEE80211_NODE_AREF;
1067
1068 IEEE80211_SEND_MGMT(ic, ni,
1069 IEEE80211_FC0_SUBTYPE_AUTH, seq + 1);
1070 IEEE80211_DPRINTF(ic, IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1071 "[%s] station authenticated (open)\n",
1072 ether_sprintf(ni->ni_macaddr));
1073 /*
1074 * When 802.1x is not in use mark the port
1075 * authorized at this point so traffic can flow.
1076 */
1077 if (ni->ni_authmode != IEEE80211_AUTH_8021X)
1078 ieee80211_node_authorize(ni);
1079 break;
1080
1081 case IEEE80211_M_STA:
1082 if (ic->ic_state != IEEE80211_S_AUTH ||
1083 seq != IEEE80211_AUTH_OPEN_RESPONSE) {
1084 ic->ic_stats.is_rx_bad_auth++;
1085 return;
1086 }
1087 if (status != 0) {
1088 IEEE80211_DPRINTF(ic,
1089 IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1090 "[%s] open auth failed (reason %d)\n",
1091 ether_sprintf(ni->ni_macaddr), status);
1092 /* XXX can this happen? */
1093 if (ni != ic->ic_bss)
1094 ni->ni_fails++;
1095 ic->ic_stats.is_rx_auth_fail++;
1096 ieee80211_new_state(ic, IEEE80211_S_SCAN,
1097 IEEE80211_SCAN_FAIL_STATUS);
1098 } else
1099 ieee80211_new_state(ic, IEEE80211_S_ASSOC, 0);
1100 break;
1101 }
1102}
1103
1104/*
1105 * Send a management frame error response to the specified
1106 * station. If ni is associated with the station then use
1107 * it; otherwise allocate a temporary node suitable for
1108 * transmitting the frame and then free the reference so
1109 * it will go away as soon as the frame has been transmitted.
1110 */
1111static void
1112ieee80211_send_error(struct ieee80211com *ic, struct ieee80211_node *ni,
1113 const uint8_t *mac, int subtype, int arg)
1114{
1115 int istmp;
1116
1117 if (ni == ic->ic_bss) {
1118 ni = ieee80211_tmp_node(ic, mac);
1119 if (ni == NULL) {
1120 /* XXX msg */
1121 return;
1122 }
1123 istmp = 1;
1124 } else
1125 istmp = 0;
1126 IEEE80211_SEND_MGMT(ic, ni, subtype, arg);
1127 if (istmp)
1128 ieee80211_free_node(ni);
1129}
1130
1131static int
1132alloc_challenge(struct ieee80211com *ic, struct ieee80211_node *ni)
1133{
1134 if (ni->ni_challenge == NULL)
1135 MALLOC(ni->ni_challenge, uint32_t*, IEEE80211_CHALLENGE_LEN,
1136 M_80211_NODE, M_NOWAIT);
1137 if (ni->ni_challenge == NULL) {
1138 IEEE80211_DPRINTF(ic, IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1139 "[%s] shared key challenge alloc failed\n",
1140 ether_sprintf(ni->ni_macaddr));
1141 /* XXX statistic */
1142 }
1143 return (ni->ni_challenge != NULL);
1144}
1145
1146/* XXX TODO: add statistics */
1147static void
1148ieee80211_auth_shared(struct ieee80211com *ic, struct ieee80211_frame *wh,
1149 uint8_t *frm, uint8_t *efrm, struct ieee80211_node *ni,
1150 int rssi, int noise, uint32_t rstamp, uint16_t seq, uint16_t status)
1151{
1152 uint8_t *challenge;
1153 int allocbs, estatus;
1154
1155 /*
1156 * NB: this can happen as we allow pre-shared key
1157 * authentication to be enabled w/o wep being turned
1158 * on so that configuration of these can be done
1159 * in any order. It may be better to enforce the
1160 * ordering in which case this check would just be
1161 * for sanity/consistency.
1162 */
1163 if ((ic->ic_flags & IEEE80211_F_PRIVACY) == 0) {
1164 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1165 ni->ni_macaddr, "shared key auth",
1166 "%s", " PRIVACY is disabled");
1167 estatus = IEEE80211_STATUS_ALG;
1168 goto bad;
1169 }
1170 /*
1171 * Pre-shared key authentication is evil; accept
1172 * it only if explicitly configured (it is supported
1173 * mainly for compatibility with clients like OS X).
1174 */
1175 if (ni->ni_authmode != IEEE80211_AUTH_AUTO &&
1176 ni->ni_authmode != IEEE80211_AUTH_SHARED) {
1177 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1178 ni->ni_macaddr, "shared key auth",
1179 "bad sta auth mode %u", ni->ni_authmode);
1180 ic->ic_stats.is_rx_bad_auth++; /* XXX maybe a unique error? */
1181 estatus = IEEE80211_STATUS_ALG;
1182 goto bad;
1183 }
1184
1185 challenge = NULL;
1186 if (frm + 1 < efrm) {
1187 if ((frm[1] + 2) > (efrm - frm)) {
1188 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1189 ni->ni_macaddr, "shared key auth",
1190 "ie %d/%d too long",
1191 frm[0], (frm[1] + 2) - (efrm - frm));
1192 ic->ic_stats.is_rx_bad_auth++;
1193 estatus = IEEE80211_STATUS_CHALLENGE;
1194 goto bad;
1195 }
1196 if (*frm == IEEE80211_ELEMID_CHALLENGE)
1197 challenge = frm;
1198 frm += frm[1] + 2;
1199 }
1200 switch (seq) {
1201 case IEEE80211_AUTH_SHARED_CHALLENGE:
1202 case IEEE80211_AUTH_SHARED_RESPONSE:
1203 if (challenge == NULL) {
1204 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1205 ni->ni_macaddr, "shared key auth",
1206 "%s", "no challenge");
1207 ic->ic_stats.is_rx_bad_auth++;
1208 estatus = IEEE80211_STATUS_CHALLENGE;
1209 goto bad;
1210 }
1211 if (challenge[1] != IEEE80211_CHALLENGE_LEN) {
1212 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1213 ni->ni_macaddr, "shared key auth",
1214 "bad challenge len %d", challenge[1]);
1215 ic->ic_stats.is_rx_bad_auth++;
1216 estatus = IEEE80211_STATUS_CHALLENGE;
1217 goto bad;
1218 }
1219 default:
1220 break;
1221 }
1222 switch (ic->ic_opmode) {
1223 case IEEE80211_M_MONITOR:
1224 case IEEE80211_M_AHDEMO:
1225 case IEEE80211_M_IBSS:
1226 case IEEE80211_M_WDS:
1227 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1228 ni->ni_macaddr, "shared key auth",
1229 "bad operating mode %u", ic->ic_opmode);
1230 return;
1231 case IEEE80211_M_HOSTAP:
1232 if (ic->ic_state != IEEE80211_S_RUN) {
1233 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1234 ni->ni_macaddr, "shared key auth",
1235 "bad state %u", ic->ic_state);
1236 estatus = IEEE80211_STATUS_ALG; /* XXX */
1237 goto bad;
1238 }
1239 switch (seq) {
1240 case IEEE80211_AUTH_SHARED_REQUEST:
1241 if (ni == ic->ic_bss) {
1242 ni = ieee80211_dup_bss(&ic->ic_sta, wh->i_addr2);
1243 if (ni == NULL) {
1244 /* NB: no way to return an error */
1245 return;
1246 }
1247 allocbs = 1;
1248 } else {
1249 if ((ni->ni_flags & IEEE80211_NODE_AREF) == 0)
1250 (void) ieee80211_ref_node(ni);
1251 allocbs = 0;
1252 }
1253 /*
1254 * Mark the node as referenced to reflect that it's
1255 * reference count has been bumped to insure it remains
1256 * after the transaction completes.
1257 */
1258 ni->ni_flags |= IEEE80211_NODE_AREF;
1259 ni->ni_rssi = rssi;
1260 ni->ni_noise = noise;
1261 ni->ni_rstamp = rstamp;
1262 if (!alloc_challenge(ic, ni)) {
1263 /* NB: don't return error so they rexmit */
1264 return;
1265 }
1266 get_random_bytes(ni->ni_challenge,
1267 IEEE80211_CHALLENGE_LEN);
1268 IEEE80211_DPRINTF(ic,
1269 IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1270 "[%s] shared key %sauth request\n",
1271 ether_sprintf(ni->ni_macaddr),
1272 allocbs ? "" : "re");
1273 break;
1274 case IEEE80211_AUTH_SHARED_RESPONSE:
1275 if (ni == ic->ic_bss) {
1276 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1277 ni->ni_macaddr, "shared key response",
1278 "%s", "unknown station");
1279 /* NB: don't send a response */
1280 return;
1281 }
1282 if (ni->ni_challenge == NULL) {
1283 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1284 ni->ni_macaddr, "shared key response",
1285 "%s", "no challenge recorded");
1286 ic->ic_stats.is_rx_bad_auth++;
1287 estatus = IEEE80211_STATUS_CHALLENGE;
1288 goto bad;
1289 }
1290 if (memcmp(ni->ni_challenge, &challenge[2],
1291 challenge[1]) != 0) {
1292 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1293 ni->ni_macaddr, "shared key response",
1294 "%s", "challenge mismatch");
1295 ic->ic_stats.is_rx_auth_fail++;
1296 estatus = IEEE80211_STATUS_CHALLENGE;
1297 goto bad;
1298 }
1299 IEEE80211_DPRINTF(ic,
1300 IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1301 "[%s] station authenticated (shared key)\n",
1302 ether_sprintf(ni->ni_macaddr));
1303 ieee80211_node_authorize(ni);
1304 break;
1305 default:
1306 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1307 ni->ni_macaddr, "shared key auth",
1308 "bad seq %d", seq);
1309 ic->ic_stats.is_rx_bad_auth++;
1310 estatus = IEEE80211_STATUS_SEQUENCE;
1311 goto bad;
1312 }
1313 IEEE80211_SEND_MGMT(ic, ni,
1314 IEEE80211_FC0_SUBTYPE_AUTH, seq + 1);
1315 break;
1316
1317 case IEEE80211_M_STA:
1318 if (ic->ic_state != IEEE80211_S_AUTH)
1319 return;
1320 switch (seq) {
1321 case IEEE80211_AUTH_SHARED_PASS:
1322 if (ni->ni_challenge != NULL) {
1323 FREE(ni->ni_challenge, M_80211_NODE);
1324 ni->ni_challenge = NULL;
1325 }
1326 if (status != 0) {
1327 IEEE80211_DPRINTF(ic,
1328 IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1329 "[%s] shared key auth failed (reason %d)\n",
1330 ether_sprintf(ieee80211_getbssid(ic, wh)),
1331 status);
1332 /* XXX can this happen? */
1333 if (ni != ic->ic_bss)
1334 ni->ni_fails++;
1335 ic->ic_stats.is_rx_auth_fail++;
1336 return;
1337 }
1338 ieee80211_new_state(ic, IEEE80211_S_ASSOC, 0);
1339 break;
1340 case IEEE80211_AUTH_SHARED_CHALLENGE:
1341 if (!alloc_challenge(ic, ni))
1342 return;
1343 /* XXX could optimize by passing recvd challenge */
1344 memcpy(ni->ni_challenge, &challenge[2], challenge[1]);
1345 IEEE80211_SEND_MGMT(ic, ni,
1346 IEEE80211_FC0_SUBTYPE_AUTH, seq + 1);
1347 break;
1348 default:
1349 IEEE80211_DISCARD(ic, IEEE80211_MSG_AUTH,
1350 wh, "shared key auth", "bad seq %d", seq);
1351 ic->ic_stats.is_rx_bad_auth++;
1352 return;
1353 }
1354 break;
1355 }
1356 return;
1357bad:
1358 /*
1359 * Send an error response; but only when operating as an AP.
1360 */
1361 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
1362 /* XXX hack to workaround calling convention */
1363 ieee80211_send_error(ic, ni, wh->i_addr2,
1364 IEEE80211_FC0_SUBTYPE_AUTH,
1365 (seq + 1) | (estatus<<16));
1366 } else if (ic->ic_opmode == IEEE80211_M_STA) {
1367 /*
1368 * Kick the state machine. This short-circuits
1369 * using the mgt frame timeout to trigger the
1370 * state transition.
1371 */
1372 if (ic->ic_state == IEEE80211_S_AUTH)
1373 ieee80211_new_state(ic, IEEE80211_S_SCAN,
1374 IEEE80211_SCAN_FAIL_STATUS);
1375 }
1376}
1377
1378/* Verify the existence and length of __elem or get out. */
1379#define IEEE80211_VERIFY_ELEMENT(__elem, __maxlen) do { \
1380 if ((__elem) == NULL) { \
1381 IEEE80211_DISCARD(ic, IEEE80211_MSG_ELEMID, \
1382 wh, ieee80211_mgt_subtype_name[subtype >> \
1383 IEEE80211_FC0_SUBTYPE_SHIFT], \
1384 "%s", "no " #__elem ); \
1385 ic->ic_stats.is_rx_elem_missing++; \
1386 return; \
1387 } \
1388 if ((__elem)[1] > (__maxlen)) { \
1389 IEEE80211_DISCARD(ic, IEEE80211_MSG_ELEMID, \
1390 wh, ieee80211_mgt_subtype_name[subtype >> \
1391 IEEE80211_FC0_SUBTYPE_SHIFT], \
1392 "bad " #__elem " len %d", (__elem)[1]); \
1393 ic->ic_stats.is_rx_elem_toobig++; \
1394 return; \
1395 } \
1396} while (0)
1397
1398#define IEEE80211_VERIFY_LENGTH(_len, _minlen, _action) do { \
1399 if ((_len) < (_minlen)) { \
1400 IEEE80211_DISCARD(ic, IEEE80211_MSG_ELEMID, \
1401 wh, ieee80211_mgt_subtype_name[subtype >> \
1402 IEEE80211_FC0_SUBTYPE_SHIFT], \
1403 "ie too short, got %d, expected %d", \
1404 (_len), (_minlen)); \
1405 ic->ic_stats.is_rx_elem_toosmall++; \
1406 _action; \
1407 } \
1408} while (0)
1409
1410#ifdef IEEE80211_DEBUG
1411static void
1412ieee80211_ssid_mismatch(struct ieee80211com *ic, const char *tag,
1413 uint8_t mac[IEEE80211_ADDR_LEN], uint8_t *ssid)
1414{
1415 printf("[%s] discard %s frame, ssid mismatch: ",
1416 ether_sprintf(mac), tag);
1417 ieee80211_print_essid(ssid + 2, ssid[1]);
1418 printf("\n");
1419}
1420
1421#define IEEE80211_VERIFY_SSID(_ni, _ssid) do { \
1422 if ((_ssid)[1] != 0 && \
1423 ((_ssid)[1] != (_ni)->ni_esslen || \
1424 memcmp((_ssid) + 2, (_ni)->ni_essid, (_ssid)[1]) != 0)) { \
1425 if (ieee80211_msg_input(ic)) \
1426 ieee80211_ssid_mismatch(ic, \
1427 ieee80211_mgt_subtype_name[subtype >> \
1428 IEEE80211_FC0_SUBTYPE_SHIFT], \
1429 wh->i_addr2, _ssid); \
1430 ic->ic_stats.is_rx_ssidmismatch++; \
1431 return; \
1432 } \
1433} while (0)
1434#else /* !IEEE80211_DEBUG */
1435#define IEEE80211_VERIFY_SSID(_ni, _ssid) do { \
1436 if ((_ssid)[1] != 0 && \
1437 ((_ssid)[1] != (_ni)->ni_esslen || \
1438 memcmp((_ssid) + 2, (_ni)->ni_essid, (_ssid)[1]) != 0)) { \
1439 ic->ic_stats.is_rx_ssidmismatch++; \
1440 return; \
1441 } \
1442} while (0)
1443#endif /* !IEEE80211_DEBUG */
1444
1445/* unalligned little endian access */
1446#define LE_READ_2(p) \
1447 ((uint16_t) \
1448 ((((const uint8_t *)(p))[0] ) | \
1449 (((const uint8_t *)(p))[1] << 8)))
1450#define LE_READ_4(p) \
1451 ((uint32_t) \
1452 ((((const uint8_t *)(p))[0] ) | \
1453 (((const uint8_t *)(p))[1] << 8) | \
1454 (((const uint8_t *)(p))[2] << 16) | \
1455 (((const uint8_t *)(p))[3] << 24)))
1456
1457static __inline int
1458iswpaoui(const uint8_t *frm)
1459{
1460 return frm[1] > 3 && LE_READ_4(frm+2) == ((WPA_OUI_TYPE<<24)|WPA_OUI);
1461}
1462
1463static __inline int
1464iswmeoui(const uint8_t *frm)
1465{
1466 return frm[1] > 3 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI);
1467}
1468
1469static __inline int
1470iswmeparam(const uint8_t *frm)
1471{
1472 return frm[1] > 5 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI) &&
1473 frm[6] == WME_PARAM_OUI_SUBTYPE;
1474}
1475
1476static __inline int
1477iswmeinfo(const uint8_t *frm)
1478{
1479 return frm[1] > 5 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI) &&
1480 frm[6] == WME_INFO_OUI_SUBTYPE;
1481}
1482
1483static __inline int
1484isatherosoui(const uint8_t *frm)
1485{
1486 return frm[1] > 3 && LE_READ_4(frm+2) == ((ATH_OUI_TYPE<<24)|ATH_OUI);
1487}
1488
1489static __inline int
1490ishtcapoui(const uint8_t *frm)
1491{
1492 return frm[1] > 3 && LE_READ_4(frm+2) == ((BCM_OUI_HTCAP<<24)|BCM_OUI);
1493}
1494
1495static __inline int
1496ishtinfooui(const uint8_t *frm)
1497{
1498 return frm[1] > 3 && LE_READ_4(frm+2) == ((BCM_OUI_HTINFO<<24)|BCM_OUI);
1499}
1500
1501/*
1502 * Convert a WPA cipher selector OUI to an internal
1503 * cipher algorithm. Where appropriate we also
1504 * record any key length.
1505 */
1506static int
1507wpa_cipher(uint8_t *sel, uint8_t *keylen)
1508{
1509#define WPA_SEL(x) (((x)<<24)|WPA_OUI)
1510 uint32_t w = LE_READ_4(sel);
1511
1512 switch (w) {
1513 case WPA_SEL(WPA_CSE_NULL):
1514 return IEEE80211_CIPHER_NONE;
1515 case WPA_SEL(WPA_CSE_WEP40):
1516 if (keylen)
1517 *keylen = 40 / NBBY;
1518 return IEEE80211_CIPHER_WEP;
1519 case WPA_SEL(WPA_CSE_WEP104):
1520 if (keylen)
1521 *keylen = 104 / NBBY;
1522 return IEEE80211_CIPHER_WEP;
1523 case WPA_SEL(WPA_CSE_TKIP):
1524 return IEEE80211_CIPHER_TKIP;
1525 case WPA_SEL(WPA_CSE_CCMP):
1526 return IEEE80211_CIPHER_AES_CCM;
1527 }
1528 return 32; /* NB: so 1<< is discarded */
1529#undef WPA_SEL
1530}
1531
1532/*
1533 * Convert a WPA key management/authentication algorithm
1534 * to an internal code.
1535 */
1536static int
1537wpa_keymgmt(uint8_t *sel)
1538{
1539#define WPA_SEL(x) (((x)<<24)|WPA_OUI)
1540 uint32_t w = LE_READ_4(sel);
1541
1542 switch (w) {
1543 case WPA_SEL(WPA_ASE_8021X_UNSPEC):
1544 return WPA_ASE_8021X_UNSPEC;
1545 case WPA_SEL(WPA_ASE_8021X_PSK):
1546 return WPA_ASE_8021X_PSK;
1547 case WPA_SEL(WPA_ASE_NONE):
1548 return WPA_ASE_NONE;
1549 }
1550 return 0; /* NB: so is discarded */
1551#undef WPA_SEL
1552}
1553
1554/*
1555 * Parse a WPA information element to collect parameters
1556 * and validate the parameters against what has been
1557 * configured for the system.
1558 */
1559static int
1560ieee80211_parse_wpa(struct ieee80211com *ic, uint8_t *frm,
1561 struct ieee80211_rsnparms *rsn, const struct ieee80211_frame *wh)
1562{
1563 uint8_t len = frm[1];
1564 uint32_t w;
1565 int n;
1566
1567 /*
1568 * Check the length once for fixed parts: OUI, type,
1569 * version, mcast cipher, and 2 selector counts.
1570 * Other, variable-length data, must be checked separately.
1571 */
1572 if ((ic->ic_flags & IEEE80211_F_WPA1) == 0) {
1573 IEEE80211_DISCARD_IE(ic,
1574 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1575 wh, "WPA", "not WPA, flags 0x%x", ic->ic_flags);
1576 return IEEE80211_REASON_IE_INVALID;
1577 }
1578 if (len < 14) {
1579 IEEE80211_DISCARD_IE(ic,
1580 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1581 wh, "WPA", "too short, len %u", len);
1582 return IEEE80211_REASON_IE_INVALID;
1583 }
1584 frm += 6, len -= 4; /* NB: len is payload only */
1585 /* NB: iswapoui already validated the OUI and type */
1586 w = LE_READ_2(frm);
1587 if (w != WPA_VERSION) {
1588 IEEE80211_DISCARD_IE(ic,
1589 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1590 wh, "WPA", "bad version %u", w);
1591 return IEEE80211_REASON_IE_INVALID;
1592 }
1593 frm += 2, len -= 2;
1594
1595 /* multicast/group cipher */
1596 w = wpa_cipher(frm, &rsn->rsn_mcastkeylen);
1597 if (w != rsn->rsn_mcastcipher) {
1598 IEEE80211_DISCARD_IE(ic,
1599 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1600 wh, "WPA", "mcast cipher mismatch; got %u, expected %u",
1601 w, rsn->rsn_mcastcipher);
1602 return IEEE80211_REASON_IE_INVALID;
1603 }
1604 frm += 4, len -= 4;
1605
1606 /* unicast ciphers */
1607 n = LE_READ_2(frm);
1608 frm += 2, len -= 2;
1609 if (len < n*4+2) {
1610 IEEE80211_DISCARD_IE(ic,
1611 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1612 wh, "WPA", "ucast cipher data too short; len %u, n %u",
1613 len, n);
1614 return IEEE80211_REASON_IE_INVALID;
1615 }
1616 w = 0;
1617 for (; n > 0; n--) {
1618 w |= 1<<wpa_cipher(frm, &rsn->rsn_ucastkeylen);
1619 frm += 4, len -= 4;
1620 }
1621 w &= rsn->rsn_ucastcipherset;
1622 if (w == 0) {
1623 IEEE80211_DISCARD_IE(ic,
1624 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1625 wh, "WPA", "%s", "ucast cipher set empty");
1626 return IEEE80211_REASON_IE_INVALID;
1627 }
1628 if (w & (1<<IEEE80211_CIPHER_TKIP))
1629 rsn->rsn_ucastcipher = IEEE80211_CIPHER_TKIP;
1630 else
1631 rsn->rsn_ucastcipher = IEEE80211_CIPHER_AES_CCM;
1632
1633 /* key management algorithms */
1634 n = LE_READ_2(frm);
1635 frm += 2, len -= 2;
1636 if (len < n*4) {
1637 IEEE80211_DISCARD_IE(ic,
1638 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1639 wh, "WPA", "key mgmt alg data too short; len %u, n %u",
1640 len, n);
1641 return IEEE80211_REASON_IE_INVALID;
1642 }
1643 w = 0;
1644 for (; n > 0; n--) {
1645 w |= wpa_keymgmt(frm);
1646 frm += 4, len -= 4;
1647 }
1648 w &= rsn->rsn_keymgmtset;
1649 if (w == 0) {
1650 IEEE80211_DISCARD_IE(ic,
1651 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1652 wh, "WPA", "%s", "no acceptable key mgmt alg");
1653 return IEEE80211_REASON_IE_INVALID;
1654 }
1655 if (w & WPA_ASE_8021X_UNSPEC)
1656 rsn->rsn_keymgmt = WPA_ASE_8021X_UNSPEC;
1657 else
1658 rsn->rsn_keymgmt = WPA_ASE_8021X_PSK;
1659
1660 if (len > 2) /* optional capabilities */
1661 rsn->rsn_caps = LE_READ_2(frm);
1662
1663 return 0;
1664}
1665
1666/*
1667 * Convert an RSN cipher selector OUI to an internal
1668 * cipher algorithm. Where appropriate we also
1669 * record any key length.
1670 */
1671static int
1672rsn_cipher(uint8_t *sel, uint8_t *keylen)
1673{
1674#define RSN_SEL(x) (((x)<<24)|RSN_OUI)
1675 uint32_t w = LE_READ_4(sel);
1676
1677 switch (w) {
1678 case RSN_SEL(RSN_CSE_NULL):
1679 return IEEE80211_CIPHER_NONE;
1680 case RSN_SEL(RSN_CSE_WEP40):
1681 if (keylen)
1682 *keylen = 40 / NBBY;
1683 return IEEE80211_CIPHER_WEP;
1684 case RSN_SEL(RSN_CSE_WEP104):
1685 if (keylen)
1686 *keylen = 104 / NBBY;
1687 return IEEE80211_CIPHER_WEP;
1688 case RSN_SEL(RSN_CSE_TKIP):
1689 return IEEE80211_CIPHER_TKIP;
1690 case RSN_SEL(RSN_CSE_CCMP):
1691 return IEEE80211_CIPHER_AES_CCM;
1692 case RSN_SEL(RSN_CSE_WRAP):
1693 return IEEE80211_CIPHER_AES_OCB;
1694 }
1695 return 32; /* NB: so 1<< is discarded */
1696#undef WPA_SEL
1697}
1698
1699/*
1700 * Convert an RSN key management/authentication algorithm
1701 * to an internal code.
1702 */
1703static int
1704rsn_keymgmt(uint8_t *sel)
1705{
1706#define RSN_SEL(x) (((x)<<24)|RSN_OUI)
1707 uint32_t w = LE_READ_4(sel);
1708
1709 switch (w) {
1710 case RSN_SEL(RSN_ASE_8021X_UNSPEC):
1711 return RSN_ASE_8021X_UNSPEC;
1712 case RSN_SEL(RSN_ASE_8021X_PSK):
1713 return RSN_ASE_8021X_PSK;
1714 case RSN_SEL(RSN_ASE_NONE):
1715 return RSN_ASE_NONE;
1716 }
1717 return 0; /* NB: so is discarded */
1718#undef RSN_SEL
1719}
1720
1721/*
1722 * Parse a WPA/RSN information element to collect parameters
1723 * and validate the parameters against what has been
1724 * configured for the system.
1725 */
1726static int
1727ieee80211_parse_rsn(struct ieee80211com *ic, uint8_t *frm,
1728 struct ieee80211_rsnparms *rsn, const struct ieee80211_frame *wh)
1729{
1730 uint8_t len = frm[1];
1731 uint32_t w;
1732 int n;
1733
1734 /*
1735 * Check the length once for fixed parts:
1736 * version, mcast cipher, and 2 selector counts.
1737 * Other, variable-length data, must be checked separately.
1738 */
1739 if ((ic->ic_flags & IEEE80211_F_WPA2) == 0) {
1740 IEEE80211_DISCARD_IE(ic,
1741 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1742 wh, "WPA", "not RSN, flags 0x%x", ic->ic_flags);
1743 return IEEE80211_REASON_IE_INVALID;
1744 }
1745 if (len < 10) {
1746 IEEE80211_DISCARD_IE(ic,
1747 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1748 wh, "RSN", "too short, len %u", len);
1749 return IEEE80211_REASON_IE_INVALID;
1750 }
1751 frm += 2;
1752 w = LE_READ_2(frm);
1753 if (w != RSN_VERSION) {
1754 IEEE80211_DISCARD_IE(ic,
1755 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1756 wh, "RSN", "bad version %u", w);
1757 return IEEE80211_REASON_IE_INVALID;
1758 }
1759 frm += 2, len -= 2;
1760
1761 /* multicast/group cipher */
1762 w = rsn_cipher(frm, &rsn->rsn_mcastkeylen);
1763 if (w != rsn->rsn_mcastcipher) {
1764 IEEE80211_DISCARD_IE(ic,
1765 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1766 wh, "RSN", "mcast cipher mismatch; got %u, expected %u",
1767 w, rsn->rsn_mcastcipher);
1768 return IEEE80211_REASON_IE_INVALID;
1769 }
1770 frm += 4, len -= 4;
1771
1772 /* unicast ciphers */
1773 n = LE_READ_2(frm);
1774 frm += 2, len -= 2;
1775 if (len < n*4+2) {
1776 IEEE80211_DISCARD_IE(ic,
1777 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1778 wh, "RSN", "ucast cipher data too short; len %u, n %u",
1779 len, n);
1780 return IEEE80211_REASON_IE_INVALID;
1781 }
1782 w = 0;
1783 for (; n > 0; n--) {
1784 w |= 1<<rsn_cipher(frm, &rsn->rsn_ucastkeylen);
1785 frm += 4, len -= 4;
1786 }
1787 w &= rsn->rsn_ucastcipherset;
1788 if (w == 0) {
1789 IEEE80211_DISCARD_IE(ic,
1790 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1791 wh, "RSN", "%s", "ucast cipher set empty");
1792 return IEEE80211_REASON_IE_INVALID;
1793 }
1794 if (w & (1<<IEEE80211_CIPHER_TKIP))
1795 rsn->rsn_ucastcipher = IEEE80211_CIPHER_TKIP;
1796 else
1797 rsn->rsn_ucastcipher = IEEE80211_CIPHER_AES_CCM;
1798
1799 /* key management algorithms */
1800 n = LE_READ_2(frm);
1801 frm += 2, len -= 2;
1802 if (len < n*4) {
1803 IEEE80211_DISCARD_IE(ic,
1804 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1805 wh, "RSN", "key mgmt alg data too short; len %u, n %u",
1806 len, n);
1807 return IEEE80211_REASON_IE_INVALID;
1808 }
1809 w = 0;
1810 for (; n > 0; n--) {
1811 w |= rsn_keymgmt(frm);
1812 frm += 4, len -= 4;
1813 }
1814 w &= rsn->rsn_keymgmtset;
1815 if (w == 0) {
1816 IEEE80211_DISCARD_IE(ic,
1817 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1818 wh, "RSN", "%s", "no acceptable key mgmt alg");
1819 return IEEE80211_REASON_IE_INVALID;
1820 }
1821 if (w & RSN_ASE_8021X_UNSPEC)
1822 rsn->rsn_keymgmt = RSN_ASE_8021X_UNSPEC;
1823 else
1824 rsn->rsn_keymgmt = RSN_ASE_8021X_PSK;
1825
1826 /* optional RSN capabilities */
1827 if (len > 2)
1828 rsn->rsn_caps = LE_READ_2(frm);
1829 /* XXXPMKID */
1830
1831 return 0;
1832}
1833
1834static int
1835ieee80211_parse_wmeparams(struct ieee80211com *ic, uint8_t *frm,
1836 const struct ieee80211_frame *wh)
1837{
1838#define MS(_v, _f) (((_v) & _f) >> _f##_S)
1839 struct ieee80211_wme_state *wme = &ic->ic_wme;
1840 u_int len = frm[1], qosinfo;
1841 int i;
1842
1843 if (len < sizeof(struct ieee80211_wme_param)-2) {
1844 IEEE80211_DISCARD_IE(ic,
1845 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WME,
1846 wh, "WME", "too short, len %u", len);
1847 return -1;
1848 }
1849 qosinfo = frm[__offsetof(struct ieee80211_wme_param, param_qosInfo)];
1850 qosinfo &= WME_QOSINFO_COUNT;
1851 /* XXX do proper check for wraparound */
1852 if (qosinfo == wme->wme_wmeChanParams.cap_info)
1853 return 0;
1854 frm += __offsetof(struct ieee80211_wme_param, params_acParams);
1855 for (i = 0; i < WME_NUM_AC; i++) {
1856 struct wmeParams *wmep =
1857 &wme->wme_wmeChanParams.cap_wmeParams[i];
1858 /* NB: ACI not used */
1859 wmep->wmep_acm = MS(frm[0], WME_PARAM_ACM);
1860 wmep->wmep_aifsn = MS(frm[0], WME_PARAM_AIFSN);
1861 wmep->wmep_logcwmin = MS(frm[1], WME_PARAM_LOGCWMIN);
1862 wmep->wmep_logcwmax = MS(frm[1], WME_PARAM_LOGCWMAX);
1863 wmep->wmep_txopLimit = LE_READ_2(frm+2);
1864 frm += 4;
1865 }
1866 wme->wme_wmeChanParams.cap_info = qosinfo;
1867 return 1;
1868#undef MS
1869}
1870
1871static int
1872ieee80211_parse_athparams(struct ieee80211_node *ni, uint8_t *frm,
1873 const struct ieee80211_frame *wh)
1874{
1875 struct ieee80211com *ic = ni->ni_ic;
1876 const struct ieee80211_ath_ie *ath;
1877 u_int len = frm[1];
1878 int capschanged;
1879 uint16_t defkeyix;
1880
1881 if (len < sizeof(struct ieee80211_ath_ie)-2) {
1882 IEEE80211_DISCARD_IE(ic,
1883 IEEE80211_MSG_ELEMID | IEEE80211_MSG_SUPERG,
1884 wh, "Atheros", "too short, len %u", len);
1885 return -1;
1886 }
1887 ath = (const struct ieee80211_ath_ie *)frm;
1888 capschanged = (ni->ni_ath_flags != ath->ath_capability);
1889 defkeyix = LE_READ_2(ath->ath_defkeyix);
1890 if (capschanged || defkeyix != ni->ni_ath_defkeyix) {
1891 ni->ni_ath_flags = ath->ath_capability;
1892 ni->ni_ath_defkeyix = defkeyix;
1893 IEEE80211_DPRINTF(ic, IEEE80211_MSG_SUPERG,
1894 "[%s] ath ie change: new caps 0x%x defkeyix 0x%x\n",
1895 ether_sprintf(ni->ni_macaddr),
1896 ni->ni_ath_flags, ni->ni_ath_defkeyix);
1897 }
1898 if (IEEE80211_ATH_CAP(ic, ni, ATHEROS_CAP_TURBO_PRIME)) {
1899 uint16_t curflags, newflags;
1900
1901 /*
1902 * Check for turbo mode switch. Calculate flags
1903 * for the new mode and effect the switch.
1904 */
1905 newflags = curflags = ic->ic_bsschan->ic_flags;
1906 /* NB: BOOST is not in ic_flags, so get it from the ie */
1907 if (ath->ath_capability & ATHEROS_CAP_BOOST)
1908 newflags |= IEEE80211_CHAN_TURBO;
1909 else
1910 newflags &= ~IEEE80211_CHAN_TURBO;
1911 if (newflags != curflags)
1912 ieee80211_dturbo_switch(ic, newflags);
1913 }
1914 return capschanged;
1915}
1916
1917void
1918ieee80211_saveath(struct ieee80211_node *ni, uint8_t *ie)
1919{
1920 const struct ieee80211_ath_ie *ath =
1921 (const struct ieee80211_ath_ie *) ie;
1922
1923 ni->ni_ath_flags = ath->ath_capability;
1924 ni->ni_ath_defkeyix = LE_READ_2(&ath->ath_defkeyix);
1925 ieee80211_saveie(&ni->ni_ath_ie, ie);
1926}
1927
1928void
1929ieee80211_saveie(uint8_t **iep, const uint8_t *ie)
1930{
1931 u_int ielen = ie[1]+2;
1932 /*
1933 * Record information element for later use.
1934 */
1935 if (*iep == NULL || (*iep)[1] != ie[1]) {
1936 if (*iep != NULL)
1937 FREE(*iep, M_80211_NODE);
1938 MALLOC(*iep, void*, ielen, M_80211_NODE, M_NOWAIT);
1939 }
1940 if (*iep != NULL)
1941 memcpy(*iep, ie, ielen);
1942 /* XXX note failure */
1943}
1944
1945/* XXX find a better place for definition */
1946struct l2_update_frame {
1947 struct ether_header eh;
1948 uint8_t dsap;
1949 uint8_t ssap;
1950 uint8_t control;
1951 uint8_t xid[3];
1952} __packed;
1953
1954/*
1955 * Deliver a TGf L2UF frame on behalf of a station.
1956 * This primes any bridge when the station is roaming
1957 * between ap's on the same wired network.
1958 */
1959static void
1960ieee80211_deliver_l2uf(struct ieee80211_node *ni)
1961{
1962 struct ieee80211com *ic = ni->ni_ic;
1963 struct ifnet *ifp = ic->ic_ifp;
1964 struct mbuf *m;
1965 struct l2_update_frame *l2uf;
1966 struct ether_header *eh;
1967
1968 m = m_gethdr(M_NOWAIT, MT_DATA);
1969 if (m == NULL) {
1970 IEEE80211_NOTE(ic, IEEE80211_MSG_ASSOC, ni,
1971 "%s", "no mbuf for l2uf frame");
1972 ic->ic_stats.is_rx_nobuf++; /* XXX not right */
1973 return;
1974 }
1975 l2uf = mtod(m, struct l2_update_frame *);
1976 eh = &l2uf->eh;
1977 /* dst: Broadcast address */
1978 IEEE80211_ADDR_COPY(eh->ether_dhost, ifp->if_broadcastaddr);
1979 /* src: associated STA */
1980 IEEE80211_ADDR_COPY(eh->ether_shost, ni->ni_macaddr);
1981 eh->ether_type = htons(sizeof(*l2uf) - sizeof(*eh));
1982
1983 l2uf->dsap = 0;
1984 l2uf->ssap = 0;
1985 l2uf->control = 0xf5;
1986 l2uf->xid[0] = 0x81;
1987 l2uf->xid[1] = 0x80;
1988 l2uf->xid[2] = 0x00;
1989
1990 m->m_pkthdr.len = m->m_len = sizeof(*l2uf);
1991 ieee80211_deliver_data(ic, ni, m);
1992}
1993
1994static __inline int
1995contbgscan(struct ieee80211com *ic)
1996{
1997 return ((ic->ic_flags_ext & IEEE80211_FEXT_BGSCAN) &&
1998 time_after(ticks, ic->ic_lastdata + ic->ic_bgscanidle));
1999}
2000
2001static __inline int
2002startbgscan(struct ieee80211com *ic)
2003{
2004 return ((ic->ic_flags & IEEE80211_F_BGSCAN) &&
2005 !IEEE80211_IS_CHAN_DTURBO(ic->ic_curchan) &&
2006 time_after(ticks, ic->ic_lastscan + ic->ic_bgscanintvl) &&
2007 time_after(ticks, ic->ic_lastdata + ic->ic_bgscanidle));
2008}
2009
2010static void
2011ratesetmismatch(struct ieee80211_node *ni, const struct ieee80211_frame *wh,
2012 int reassoc, int resp, const char *tag, int rate)
2013{
2014 struct ieee80211com *ic = ni->ni_ic;
2015
2016 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
2017 "[%s] deny %s request, %s rate set mismatch, rate 0x%x\n",
2018 ether_sprintf(wh->i_addr2),
2019 reassoc ? "reassoc" : "assoc", tag, rate);
2020 IEEE80211_SEND_MGMT(ic, ni, resp, IEEE80211_STATUS_BASIC_RATE);
2021 ieee80211_node_leave(ic, ni);
2022 ic->ic_stats.is_rx_assoc_norate++;
2023}
2024
2025static void
2026capinfomismatch(struct ieee80211_node *ni, const struct ieee80211_frame *wh,
2027 int reassoc, int resp, const char *tag, int capinfo)
2028{
2029 struct ieee80211com *ic = ni->ni_ic;
2030
2031 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
2032 "[%s] deny %s request, %s mismatch 0x%x\n",
2033 ether_sprintf(wh->i_addr2),
2034 reassoc ? "reassoc" : "assoc", tag, capinfo);
2035 IEEE80211_SEND_MGMT(ic, ni, resp, IEEE80211_STATUS_CAPINFO);
2036 ieee80211_node_leave(ic, ni);
2037 ic->ic_stats.is_rx_assoc_capmismatch++;
2038}
2039
2040static void
2041htcapmismatch(struct ieee80211_node *ni, const struct ieee80211_frame *wh,
2042 int reassoc, int resp)
2043{
2044 struct ieee80211com *ic = ni->ni_ic;
2045
2046 IEEE80211_NOTE_MAC(ic, IEEE80211_MSG_ANY, wh->i_addr2,
2047 "deny %s request, %s missing HT ie", reassoc ? "reassoc" : "assoc");
2048 /* XXX no better code */
2049 IEEE80211_SEND_MGMT(ic, ni, resp, IEEE80211_STATUS_OTHER);
2050 ieee80211_node_leave(ic, ni);
2051}
2052
2053void
2054ieee80211_recv_mgmt(struct ieee80211com *ic, struct mbuf *m0,
2055 struct ieee80211_node *ni,
2056 int subtype, int rssi, int noise, uint32_t rstamp)
2057{
2058#define ISPROBE(_st) ((_st) == IEEE80211_FC0_SUBTYPE_PROBE_RESP)
2059#define ISREASSOC(_st) ((_st) == IEEE80211_FC0_SUBTYPE_REASSOC_RESP)
2060 struct ieee80211_frame *wh;
2061 uint8_t *frm, *efrm;
2062 uint8_t *ssid, *rates, *xrates, *wpa, *rsn, *wme, *ath, *htcap, *htinfo;
2063 int reassoc, resp, allocbs;
2064 uint8_t rate;
2065
2066 wh = mtod(m0, struct ieee80211_frame *);
2067 frm = (uint8_t *)&wh[1];
2068 efrm = mtod(m0, uint8_t *) + m0->m_len;
2069 switch (subtype) {
2070 case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
2071 case IEEE80211_FC0_SUBTYPE_BEACON: {
2072 struct ieee80211_scanparams scan;
2073
2074 /*
2075 * We process beacon/probe response frames:
2076 * o when scanning, or
2077 * o station mode when associated (to collect state
2078 * updates such as 802.11g slot time), or
2079 * o adhoc mode (to discover neighbors)
2080 * Frames otherwise received are discarded.
2081 */
2082 if (!((ic->ic_flags & IEEE80211_F_SCAN) ||
2083 (ic->ic_opmode == IEEE80211_M_STA && ni->ni_associd) ||
2084 ic->ic_opmode == IEEE80211_M_IBSS)) {
2085 ic->ic_stats.is_rx_mgtdiscard++;
2086 return;
2087 }
2088 /*
2089 * beacon/probe response frame format
2090 * [8] time stamp
2091 * [2] beacon interval
2092 * [2] capability information
2093 * [tlv] ssid
2094 * [tlv] supported rates
2095 * [tlv] country information
2096 * [tlv] parameter set (FH/DS)
2097 * [tlv] erp information
2098 * [tlv] extended supported rates
2099 * [tlv] WME
2100 * [tlv] WPA or RSN
2101 * [tlv] HT capabilities
2102 * [tlv] HT information
2103 * [tlv] Atheros capabilities
2104 */
2105 IEEE80211_VERIFY_LENGTH(efrm - frm, 12, return);
2106 memset(&scan, 0, sizeof(scan));
2107 scan.tstamp = frm; frm += 8;
2108 scan.bintval = le16toh(*(uint16_t *)frm); frm += 2;
2109 scan.capinfo = le16toh(*(uint16_t *)frm); frm += 2;
2110 scan.bchan = IEEE80211_CHAN2IEEE(ic->ic_curchan);
2111 scan.curchan = ic->ic_curchan;
2112
2113 while (efrm - frm > 1) {
2114 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2, return);
2115 switch (*frm) {
2116 case IEEE80211_ELEMID_SSID:
2117 scan.ssid = frm;
2118 break;
2119 case IEEE80211_ELEMID_RATES:
2120 scan.rates = frm;
2121 break;
2122 case IEEE80211_ELEMID_COUNTRY:
2123 scan.country = frm;
2124 break;
2125 case IEEE80211_ELEMID_FHPARMS:
2126 if (ic->ic_phytype == IEEE80211_T_FH) {
2127 scan.fhdwell = LE_READ_2(&frm[2]);
2128 scan.bchan = IEEE80211_FH_CHAN(frm[4], frm[5]);
2129 scan.fhindex = frm[6];
2130 }
2131 break;
2132 case IEEE80211_ELEMID_DSPARMS:
2133 /*
2134 * XXX hack this since depending on phytype
2135 * is problematic for multi-mode devices.
2136 */
2137 if (ic->ic_phytype != IEEE80211_T_FH)
2138 scan.bchan = frm[2];
2139 break;
2140 case IEEE80211_ELEMID_TIM:
2141 /* XXX ATIM? */
2142 scan.tim = frm;
2143 scan.timoff = frm - mtod(m0, uint8_t *);
2144 break;
2145 case IEEE80211_ELEMID_IBSSPARMS:
2146 break;
2147 case IEEE80211_ELEMID_XRATES:
2148 scan.xrates = frm;
2149 break;
2150 case IEEE80211_ELEMID_ERP:
2151 if (frm[1] != 1) {
2152 IEEE80211_DISCARD_IE(ic,
2153 IEEE80211_MSG_ELEMID, wh, "ERP",
2154 "bad len %u", frm[1]);
2155 ic->ic_stats.is_rx_elem_toobig++;
2156 break;
2157 }
2158 scan.erp = frm[2];
2159 break;
2160 case IEEE80211_ELEMID_HTCAP:
2161 scan.htcap = frm;
2162 break;
2163 case IEEE80211_ELEMID_RSN:
2164 scan.rsn = frm;
2165 break;
2166 case IEEE80211_ELEMID_HTINFO:
2167 scan.htinfo = frm;
2168 break;
2169 case IEEE80211_ELEMID_VENDOR:
2170 if (iswpaoui(frm))
2171 scan.wpa = frm;
2172 else if (iswmeparam(frm) || iswmeinfo(frm))
2173 scan.wme = frm;
2174 else if (isatherosoui(frm))
2175 scan.ath = frm;
2176 else if (ic->ic_flags_ext & IEEE80211_FEXT_HTCOMPAT) {
2177 /*
2178 * Accept pre-draft HT ie's if the
2179 * standard ones have not been seen.
2180 */
2181 if (ishtcapoui(frm)) {
2182 if (scan.htcap == NULL)
2183 scan.htcap = frm;
2184 } else if (ishtinfooui(frm)) {
2185 if (scan.htinfo == NULL)
2186 scan.htcap = frm;
2187 }
2188 }
2189 break;
2190 default:
2191 IEEE80211_DISCARD_IE(ic, IEEE80211_MSG_ELEMID,
2192 wh, "unhandled",
2193 "id %u, len %u", *frm, frm[1]);
2194 ic->ic_stats.is_rx_elem_unknown++;
2195 break;
2196 }
2197 frm += frm[1] + 2;
2198 }
2199 IEEE80211_VERIFY_ELEMENT(scan.rates, IEEE80211_RATE_MAXSIZE);
2200 if (scan.xrates != NULL)
2201 IEEE80211_VERIFY_ELEMENT(scan.xrates,
2202 IEEE80211_RATE_MAXSIZE - scan.rates[1]);
2203 IEEE80211_VERIFY_ELEMENT(scan.ssid, IEEE80211_NWID_LEN);
2204#if IEEE80211_CHAN_MAX < 255
2205 if (scan.chan > IEEE80211_CHAN_MAX) {
2206 IEEE80211_DISCARD(ic, IEEE80211_MSG_ELEMID,
2207 wh, ieee80211_mgt_subtype_name[subtype >>
2208 IEEE80211_FC0_SUBTYPE_SHIFT],
2209 "invalid channel %u", scan.chan);
2210 ic->ic_stats.is_rx_badchan++;
2211 return;
2212 }
2213#endif
2214 if (IEEE80211_CHAN2IEEE(scan.curchan) != scan.bchan &&
2215 ic->ic_phytype != IEEE80211_T_FH) {
2216 /*
2217 * Frame was received on a channel different from the
2218 * one indicated in the DS params element id;
2219 * silently discard it.
2220 *
2221 * NB: this can happen due to signal leakage.
2222 * But we should take it for FH phy because
2223 * the rssi value should be correct even for
2224 * different hop pattern in FH.
2225 */
2226 IEEE80211_DISCARD(ic,
2227 IEEE80211_MSG_ELEMID | IEEE80211_MSG_INPUT,
2228 wh, ieee80211_mgt_subtype_name[subtype >>
2229 IEEE80211_FC0_SUBTYPE_SHIFT],
2230 "for off-channel %u",
2231 IEEE80211_CHAN2IEEE(scan.curchan));
2232 ic->ic_stats.is_rx_chanmismatch++;
2233 return;
2234 }
2235 if (!(IEEE80211_BINTVAL_MIN <= scan.bintval &&
2236 scan.bintval <= IEEE80211_BINTVAL_MAX)) {
2237 IEEE80211_DISCARD(ic,
2238 IEEE80211_MSG_ELEMID | IEEE80211_MSG_INPUT,
2239 wh, ieee80211_mgt_subtype_name[subtype >>
2240 IEEE80211_FC0_SUBTYPE_SHIFT],
2241 "bogus beacon interval", scan.bintval);
2242 ic->ic_stats.is_rx_badbintval++;
2243 return;
2244 }
2245 /*
2246 * Process HT ie's. This is complicated by our
2247 * accepting both the standard ie's and the pre-draft
2248 * vendor OUI ie's that some vendors still use/require.
2249 */
2250 if (scan.htcap != NULL) {
2251 IEEE80211_VERIFY_LENGTH(scan.htcap[1],
2252 scan.htcap[0] == IEEE80211_ELEMID_VENDOR ?
2253 4 + sizeof(struct ieee80211_ie_htcap)-2 :
2254 sizeof(struct ieee80211_ie_htcap)-2,
2255 scan.htcap = NULL);
2256 }
2257 if (scan.htinfo != NULL) {
2258 IEEE80211_VERIFY_LENGTH(scan.htinfo[1],
2259 scan.htinfo[0] == IEEE80211_ELEMID_VENDOR ?
2260 4 + sizeof(struct ieee80211_ie_htinfo)-2 :
2261 sizeof(struct ieee80211_ie_htinfo)-2,
2262 scan.htinfo = NULL);
2263 }
2264
2265 /*
2266 * Count frame now that we know it's to be processed.
2267 */
2268 if (subtype == IEEE80211_FC0_SUBTYPE_BEACON) {
2269 ic->ic_stats.is_rx_beacon++; /* XXX remove */
2270 IEEE80211_NODE_STAT(ni, rx_beacons);
2271 } else
2272 IEEE80211_NODE_STAT(ni, rx_proberesp);
2273
2274 /*
2275 * When operating in station mode, check for state updates.
2276 * Be careful to ignore beacons received while doing a
2277 * background scan. We consider only 11g/WMM stuff right now.
2278 */
2279 if (ic->ic_opmode == IEEE80211_M_STA &&
2280 ni->ni_associd != 0 &&
2281 ((ic->ic_flags & IEEE80211_F_SCAN) == 0 ||
2282 IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_bssid))) {
2283 /* record tsf of last beacon */
2284 memcpy(ni->ni_tstamp.data, scan.tstamp,
2285 sizeof(ni->ni_tstamp));
2286 /* count beacon frame for s/w bmiss handling */
2287 ic->ic_swbmiss_count++;
2288 ic->ic_bmiss_count = 0;
2289 if (ni->ni_erp != scan.erp) {
2290 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
2291 "[%s] erp change: was 0x%x, now 0x%x\n",
2292 ether_sprintf(wh->i_addr2),
2293 ni->ni_erp, scan.erp);
2294 if (IEEE80211_IS_CHAN_ANYG(ic->ic_curchan) &&
2295 (ni->ni_erp & IEEE80211_ERP_USE_PROTECTION))
2296 ic->ic_flags |= IEEE80211_F_USEPROT;
2297 else
2298 ic->ic_flags &= ~IEEE80211_F_USEPROT;
2299 ni->ni_erp = scan.erp;
2300 /* XXX statistic */
2301 }
2302 if ((ni->ni_capinfo ^ scan.capinfo) & IEEE80211_CAPINFO_SHORT_SLOTTIME) {
2303 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
2304 "[%s] capabilities change: before 0x%x,"
2305 " now 0x%x\n",
2306 ether_sprintf(wh->i_addr2),
2307 ni->ni_capinfo, scan.capinfo);
2308 /*
2309 * NB: we assume short preamble doesn't
2310 * change dynamically
2311 */
2312 ieee80211_set_shortslottime(ic,
2313 IEEE80211_IS_CHAN_A(ic->ic_bsschan) ||
2314 (scan.capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME));
2315 ni->ni_capinfo = (ni->ni_capinfo &~ IEEE80211_CAPINFO_SHORT_SLOTTIME)
2316 | (scan.capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME);
2317 /* XXX statistic */
2318 }
2319 if (scan.wme != NULL &&
2320 (ni->ni_flags & IEEE80211_NODE_QOS) &&
2321 ieee80211_parse_wmeparams(ic, scan.wme, wh) > 0)
2322 ieee80211_wme_updateparams(ic);
2323 if (scan.ath != NULL)
2324 ieee80211_parse_athparams(ni, scan.ath, wh);
2325 if (scan.htcap != NULL)
2326 ieee80211_parse_htcap(ni, scan.htcap);
2327 if (scan.htinfo != NULL) {
2328 ieee80211_parse_htinfo(ni, scan.htinfo);
2329 if (ni->ni_chan != ic->ic_bsschan) {
2330 /*
2331 * Channel has been adjusted based on
2332 * negotiated HT parameters; force the
2333 * channel state to follow.
2334 */
2335 ieee80211_setbsschan(ic, ni->ni_chan);
2336 }
2337 }
2338 if (scan.tim != NULL) {
2339 struct ieee80211_tim_ie *tim =
2340 (struct ieee80211_tim_ie *) scan.tim;
2341#if 0
2342 int aid = IEEE80211_AID(ni->ni_associd);
2343 int ix = aid / NBBY;
2344 int min = tim->tim_bitctl &~ 1;
2345 int max = tim->tim_len + min - 4;
2346 if ((tim->tim_bitctl&1) ||
2347 (min <= ix && ix <= max &&
2348 isset(tim->tim_bitmap - min, aid))) {
2349 /*
2350 * XXX Do not let bg scan kick off
2351 * we are expecting data.
2352 */
2353 ic->ic_lastdata = ticks;
2354 ieee80211_sta_pwrsave(ic, 0);
2355 }
2356#endif
2357 ni->ni_dtim_count = tim->tim_count;
2358 ni->ni_dtim_period = tim->tim_period;
2359 }
2360 /*
2361 * If scanning, pass the info to the scan module.
2362 * Otherwise, check if it's the right time to do
2363 * a background scan. Background scanning must
2364 * be enabled and we must not be operating in the
2365 * turbo phase of dynamic turbo mode. Then,
2366 * it's been a while since the last background
2367 * scan and if no data frames have come through
2368 * recently, kick off a scan. Note that this
2369 * is the mechanism by which a background scan
2370 * is started _and_ continued each time we
2371 * return on-channel to receive a beacon from
2372 * our ap.
2373 */
2374 if (ic->ic_flags & IEEE80211_F_SCAN) {
2375 ieee80211_add_scan(ic, &scan, wh,
2376 subtype, rssi, noise, rstamp);
2377 } else if (contbgscan(ic)) {
2378 ieee80211_bg_scan(ic);
2379 } else if (startbgscan(ic)) {
2380#if 0
2381 /* wakeup if we are sleeing */
2382 ieee80211_set_pwrsave(ic, 0);
2383#endif
2384 ieee80211_bg_scan(ic);
2385 }
2386 return;
2387 }
2388 /*
2389 * If scanning, just pass information to the scan module.
2390 */
2391 if (ic->ic_flags & IEEE80211_F_SCAN) {
2392 if (ic->ic_flags_ext & IEEE80211_FEXT_PROBECHAN) {
2393 /*
2394 * Actively scanning a channel marked passive;
2395 * send a probe request now that we know there
2396 * is 802.11 traffic present.
2397 *
2398 * XXX check if the beacon we recv'd gives
2399 * us what we need and suppress the probe req
2400 */
2401 ieee80211_probe_curchan(ic, 1);
2402 ic->ic_flags_ext &= ~IEEE80211_FEXT_PROBECHAN;
2403 }
2404 ieee80211_add_scan(ic, &scan, wh,
2405 subtype, rssi, noise, rstamp);
2406 return;
2407 }
2408 if (scan.capinfo & IEEE80211_CAPINFO_IBSS) {
2409 if (!IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) {
2410 /*
2411 * Create a new entry in the neighbor table.
2412 */
2413 ni = ieee80211_add_neighbor(ic, wh, &scan);
2414 } else if (ni->ni_capinfo == 0) {
2415 /*
2416 * Update faked node created on transmit.
2417 * Note this also updates the tsf.
2418 */
2419 ieee80211_init_neighbor(ni, wh, &scan);
2420 } else {
2421 /*
2422 * Record tsf for potential resync.
2423 */
2424 memcpy(ni->ni_tstamp.data, scan.tstamp,
2425 sizeof(ni->ni_tstamp));
2426 }
2427 if (ni != NULL) {
2428 ni->ni_rssi = rssi;
2429 ni->ni_noise = noise;
2430 ni->ni_rstamp = rstamp;
2431 }
2432 }
2433 break;
2434 }
2435
2436 case IEEE80211_FC0_SUBTYPE_PROBE_REQ:
2437 if (ic->ic_opmode == IEEE80211_M_STA ||
2438 ic->ic_state != IEEE80211_S_RUN) {
2439 ic->ic_stats.is_rx_mgtdiscard++;
2440 return;
2441 }
2442 if (IEEE80211_IS_MULTICAST(wh->i_addr2)) {
2443 /* frame must be directed */
2444 ic->ic_stats.is_rx_mgtdiscard++; /* XXX stat */
2445 return;
2446 }
2447
2448 /*
2449 * prreq frame format
2450 * [tlv] ssid
2451 * [tlv] supported rates
2452 * [tlv] extended supported rates
2453 * [tlv] Atheros capabilities
2454 */
2455 ssid = rates = xrates = ath = NULL;
2456 while (efrm - frm > 1) {
2457 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2, return);
2458 switch (*frm) {
2459 case IEEE80211_ELEMID_SSID:
2460 ssid = frm;
2461 break;
2462 case IEEE80211_ELEMID_RATES:
2463 rates = frm;
2464 break;
2465 case IEEE80211_ELEMID_XRATES:
2466 xrates = frm;
2467 break;
2468 case IEEE80211_ELEMID_VENDOR:
2469 if (isatherosoui(frm))
2470 ath = frm;
2471 break;
2472 }
2473 frm += frm[1] + 2;
2474 }
2475 IEEE80211_VERIFY_ELEMENT(rates, IEEE80211_RATE_MAXSIZE);
2476 if (xrates != NULL)
2477 IEEE80211_VERIFY_ELEMENT(xrates,
2478 IEEE80211_RATE_MAXSIZE - rates[1]);
2479 IEEE80211_VERIFY_ELEMENT(ssid, IEEE80211_NWID_LEN);
2480 IEEE80211_VERIFY_SSID(ic->ic_bss, ssid);
2481 if ((ic->ic_flags & IEEE80211_F_HIDESSID) && ssid[1] == 0) {
2482 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
2483 wh, ieee80211_mgt_subtype_name[subtype >>
2484 IEEE80211_FC0_SUBTYPE_SHIFT],
2485 "%s", "no ssid with ssid suppression enabled");
2486 ic->ic_stats.is_rx_ssidmismatch++; /*XXX*/
2487 return;
2488 }
2489
2490 allocbs = 0;
2491 if (ni == ic->ic_bss) {
2492 if (ic->ic_opmode != IEEE80211_M_IBSS) {
2493 ni = ieee80211_tmp_node(ic, wh->i_addr2);
2494 allocbs = 1;
2495 } else if (!IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) {
2496 /*
2497 * XXX Cannot tell if the sender is operating
2498 * in ibss mode. But we need a new node to
2499 * send the response so blindly add them to the
2500 * neighbor table.
2501 */
2502 ni = ieee80211_fakeup_adhoc_node(&ic->ic_sta,
2503 wh->i_addr2);
2504 }
2505 if (ni == NULL)
2506 return;
2507 }
2508 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
2509 "[%s] recv probe req\n", ether_sprintf(wh->i_addr2));
2510 ni->ni_rssi = rssi;
2511 ni->ni_rstamp = rstamp;
2512 rate = ieee80211_setup_rates(ni, rates, xrates,
2513 IEEE80211_F_DOSORT | IEEE80211_F_DOFRATE
2514 | IEEE80211_F_DONEGO | IEEE80211_F_DODEL);
2515 if (rate & IEEE80211_RATE_BASIC) {
2516 IEEE80211_DISCARD(ic, IEEE80211_MSG_XRATE,
2517 wh, ieee80211_mgt_subtype_name[subtype >>
2518 IEEE80211_FC0_SUBTYPE_SHIFT],
2519 "%s", "recv'd rate set invalid");
2520 } else {
2521 IEEE80211_SEND_MGMT(ic, ni,
2522 IEEE80211_FC0_SUBTYPE_PROBE_RESP, 0);
2523 }
2524 if (allocbs) {
2525 /*
2526 * Temporary node created just to send a
2527 * response, reclaim immediately.
2528 */
2529 ieee80211_free_node(ni);
2530 } else if (ath != NULL)
2531 ieee80211_saveath(ni, ath);
2532 break;
2533
2534 case IEEE80211_FC0_SUBTYPE_AUTH: {
2535 uint16_t algo, seq, status;
2536 /*
2537 * auth frame format
2538 * [2] algorithm
2539 * [2] sequence
2540 * [2] status
2541 * [tlv*] challenge
2542 */
2543 IEEE80211_VERIFY_LENGTH(efrm - frm, 6, return);
2544 algo = le16toh(*(uint16_t *)frm);
2545 seq = le16toh(*(uint16_t *)(frm + 2));
2546 status = le16toh(*(uint16_t *)(frm + 4));
2547 IEEE80211_DPRINTF(ic, IEEE80211_MSG_AUTH,
2548 "[%s] recv auth frame with algorithm %d seq %d\n",
2549 ether_sprintf(wh->i_addr2), algo, seq);
2550 /*
2551 * Consult the ACL policy module if setup.
2552 */
2553 if (ic->ic_acl != NULL &&
2554 !ic->ic_acl->iac_check(ic, wh->i_addr2)) {
2555 IEEE80211_DISCARD(ic, IEEE80211_MSG_ACL,
2556 wh, "auth", "%s", "disallowed by ACL");
2557 ic->ic_stats.is_rx_acl++;
2558 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
2559 IEEE80211_SEND_MGMT(ic, ni,
2560 IEEE80211_FC0_SUBTYPE_AUTH,
2561 (seq+1) | (IEEE80211_STATUS_UNSPECIFIED<<16));
2562 }
2563 return;
2564 }
2565 if (ic->ic_flags & IEEE80211_F_COUNTERM) {
2566 IEEE80211_DISCARD(ic,
2567 IEEE80211_MSG_AUTH | IEEE80211_MSG_CRYPTO,
2568 wh, "auth", "%s", "TKIP countermeasures enabled");
2569 ic->ic_stats.is_rx_auth_countermeasures++;
2570 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
2571 IEEE80211_SEND_MGMT(ic, ni,
2572 IEEE80211_FC0_SUBTYPE_AUTH,
2573 IEEE80211_REASON_MIC_FAILURE);
2574 }
2575 return;
2576 }
2577 if (algo == IEEE80211_AUTH_ALG_SHARED)
2578 ieee80211_auth_shared(ic, wh, frm + 6, efrm, ni, rssi,
2579 noise, rstamp, seq, status);
2580 else if (algo == IEEE80211_AUTH_ALG_OPEN)
2581 ieee80211_auth_open(ic, wh, ni, rssi, noise, rstamp,
2582 seq, status);
2583 else {
2584 IEEE80211_DISCARD(ic, IEEE80211_MSG_ANY,
2585 wh, "auth", "unsupported alg %d", algo);
2586 ic->ic_stats.is_rx_auth_unsupported++;
2587 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
2588 /* XXX not right */
2589 IEEE80211_SEND_MGMT(ic, ni,
2590 IEEE80211_FC0_SUBTYPE_AUTH,
2591 (seq+1) | (IEEE80211_STATUS_ALG<<16));
2592 }
2593 return;
2594 }
2595 break;
2596 }
2597
2598 case IEEE80211_FC0_SUBTYPE_ASSOC_REQ:
2599 case IEEE80211_FC0_SUBTYPE_REASSOC_REQ: {
2600 uint16_t capinfo, lintval;
2601 struct ieee80211_rsnparms rsnparms;
2602 uint8_t reason;
2603 int badwparsn;
2604
2605 if (ic->ic_opmode != IEEE80211_M_HOSTAP ||
2606 ic->ic_state != IEEE80211_S_RUN) {
2607 ic->ic_stats.is_rx_mgtdiscard++;
2608 return;
2609 }
2610
2611 if (subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) {
2612 reassoc = 1;
2613 resp = IEEE80211_FC0_SUBTYPE_REASSOC_RESP;
2614 } else {
2615 reassoc = 0;
2616 resp = IEEE80211_FC0_SUBTYPE_ASSOC_RESP;
2617 }
2618 /*
2619 * asreq frame format
2620 * [2] capability information
2621 * [2] listen interval
2622 * [6*] current AP address (reassoc only)
2623 * [tlv] ssid
2624 * [tlv] supported rates
2625 * [tlv] extended supported rates
2626 * [tlv] WPA or RSN
2627 * [tlv] HT capabilities
2628 * [tlv] Atheros capabilities
2629 */
2630 IEEE80211_VERIFY_LENGTH(efrm - frm, (reassoc ? 10 : 4), return);
2631 if (!IEEE80211_ADDR_EQ(wh->i_addr3, ic->ic_bss->ni_bssid)) {
2632 IEEE80211_DISCARD(ic, IEEE80211_MSG_ANY,
2633 wh, ieee80211_mgt_subtype_name[subtype >>
2634 IEEE80211_FC0_SUBTYPE_SHIFT],
2635 "%s", "wrong bssid");
2636 ic->ic_stats.is_rx_assoc_bss++;
2637 return;
2638 }
2639 capinfo = le16toh(*(uint16_t *)frm); frm += 2;
2640 lintval = le16toh(*(uint16_t *)frm); frm += 2;
2641 if (reassoc)
2642 frm += 6; /* ignore current AP info */
2643 ssid = rates = xrates = wpa = rsn = wme = ath = htcap = NULL;
2644 while (efrm - frm > 1) {
2645 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2, return);
2646 switch (*frm) {
2647 case IEEE80211_ELEMID_SSID:
2648 ssid = frm;
2649 break;
2650 case IEEE80211_ELEMID_RATES:
2651 rates = frm;
2652 break;
2653 case IEEE80211_ELEMID_XRATES:
2654 xrates = frm;
2655 break;
2656 /* XXX verify only one of RSN and WPA ie's? */
2657 case IEEE80211_ELEMID_RSN:
2658 rsn = frm;
2659 break;
2660 case IEEE80211_ELEMID_HTCAP:
2661 htcap = frm;
2662 break;
2663 case IEEE80211_ELEMID_VENDOR:
2664 if (iswpaoui(frm))
2665 wpa = frm;
2666 else if (iswmeinfo(frm))
2667 wme = frm;
2668 else if (isatherosoui(frm))
2669 ath = frm;
2670 else if (ic->ic_flags_ext & IEEE80211_FEXT_HTCOMPAT) {
2671 if (ishtcapoui(frm) && htcap == NULL)
2672 htcap = frm;
2673 }
2674 break;
2675 }
2676 frm += frm[1] + 2;
2677 }
2678 IEEE80211_VERIFY_ELEMENT(rates, IEEE80211_RATE_MAXSIZE);
2679 if (xrates != NULL)
2680 IEEE80211_VERIFY_ELEMENT(xrates,
2681 IEEE80211_RATE_MAXSIZE - rates[1]);
2682 IEEE80211_VERIFY_ELEMENT(ssid, IEEE80211_NWID_LEN);
2683 IEEE80211_VERIFY_SSID(ic->ic_bss, ssid);
2684 if (htcap != NULL) {
2685 IEEE80211_VERIFY_LENGTH(htcap[1],
2686 htcap[0] == IEEE80211_ELEMID_VENDOR ?
2687 4 + sizeof(struct ieee80211_ie_htcap)-2 :
2688 sizeof(struct ieee80211_ie_htcap)-2,
2689 return); /* XXX just NULL out? */
2690 }
2691
2692 if (ni == ic->ic_bss) {
2693 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
2694 "[%s] deny %s request, sta not authenticated\n",
2695 ether_sprintf(wh->i_addr2),
2696 reassoc ? "reassoc" : "assoc");
2697 ieee80211_send_error(ic, ni, wh->i_addr2,
2698 IEEE80211_FC0_SUBTYPE_DEAUTH,
2699 IEEE80211_REASON_ASSOC_NOT_AUTHED);
2700 ic->ic_stats.is_rx_assoc_notauth++;
2701 return;
2702 }
2703 /* assert right association security credentials */
2704 badwparsn = 0;
2705 switch (ic->ic_flags & IEEE80211_F_WPA) {
2706 case IEEE80211_F_WPA1:
2707 if (wpa == NULL)
2708 badwparsn = 1;
2709 break;
2710 case IEEE80211_F_WPA2:
2711 if (rsn == NULL)
2712 badwparsn = 1;
2713 break;
2714 case IEEE80211_F_WPA1|IEEE80211_F_WPA2:
2715 if (wpa == NULL && rsn == NULL)
2716 badwparsn = 1;
2717 break;
2718 }
2719 if (badwparsn) {
2720 IEEE80211_DPRINTF(ic,
2721 IEEE80211_MSG_ASSOC | IEEE80211_MSG_WPA,
2722 "[%s] no WPA/RSN IE in association request\n",
2723 ether_sprintf(wh->i_addr2));
2724 IEEE80211_SEND_MGMT(ic, ni,
2725 IEEE80211_FC0_SUBTYPE_DEAUTH,
2726 IEEE80211_REASON_IE_INVALID);
2727 ieee80211_node_leave(ic, ni);
2728 ic->ic_stats.is_rx_assoc_badwpaie++;
2729 return;
2730 }
2731 if (wpa != NULL || rsn != NULL) {
2732 /*
2733 * Parse WPA/RSN information element. Note that
2734 * we initialize the param block from the node
2735 * state so that information in the IE overrides
2736 * our defaults. The resulting parameters are
2737 * installed below after the association is assured.
2738 */
2739 rsnparms = ni->ni_rsn;
2740 if (wpa != NULL)
2741 reason = ieee80211_parse_wpa(ic, wpa, &rsnparms, wh);
2742 else
2743 reason = ieee80211_parse_rsn(ic, rsn, &rsnparms, wh);
2744 if (reason != 0) {
2745 IEEE80211_SEND_MGMT(ic, ni,
2746 IEEE80211_FC0_SUBTYPE_DEAUTH, reason);
2747 ieee80211_node_leave(ic, ni);
2748 /* XXX distinguish WPA/RSN? */
2749 ic->ic_stats.is_rx_assoc_badwpaie++;
2750 return;
2751 }
2752 IEEE80211_DPRINTF(ic,
2753 IEEE80211_MSG_ASSOC | IEEE80211_MSG_WPA,
2754 "[%s] %s ie: mc %u/%u uc %u/%u key %u caps 0x%x\n",
2755 ether_sprintf(wh->i_addr2),
2756 wpa != NULL ? "WPA" : "RSN",
2757 rsnparms.rsn_mcastcipher, rsnparms.rsn_mcastkeylen,
2758 rsnparms.rsn_ucastcipher, rsnparms.rsn_ucastkeylen,
2759 rsnparms.rsn_keymgmt, rsnparms.rsn_caps);
2760 }
2761 /* discard challenge after association */
2762 if (ni->ni_challenge != NULL) {
2763 FREE(ni->ni_challenge, M_80211_NODE);
2764 ni->ni_challenge = NULL;
2765 }
2766 /* NB: 802.11 spec says to ignore station's privacy bit */
2767 if ((capinfo & IEEE80211_CAPINFO_ESS) == 0) {
2768 capinfomismatch(ni, wh, reassoc, resp,
2769 "capability", capinfo);
2770 return;
2771 }
2772 /*
2773 * Disallow re-associate w/ invalid slot time setting.
2774 */
2775 if (ni->ni_associd != 0 &&
2776 IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan) &&
2777 ((ni->ni_capinfo ^ capinfo) & IEEE80211_CAPINFO_SHORT_SLOTTIME)) {
2778 capinfomismatch(ni, wh, reassoc, resp,
2779 "slot time", capinfo);
2780 return;
2781 }
2782 rate = ieee80211_setup_rates(ni, rates, xrates,
2783 IEEE80211_F_DOSORT | IEEE80211_F_DOFRATE |
2784 IEEE80211_F_DONEGO | IEEE80211_F_DODEL);
2785 if (rate & IEEE80211_RATE_BASIC) {
2786 ratesetmismatch(ni, wh, reassoc, resp, "basic", rate);
2787 return;
2788 }
2789 /*
2790 * If constrained to 11g-only stations reject an
2791 * 11b-only station. We cheat a bit here by looking
2792 * at the max negotiated xmit rate and assuming anyone
2793 * with a best rate <24Mb/s is an 11b station.
2794 */
2795 if ((ic->ic_flags & IEEE80211_F_PUREG) && rate < 48) {
2796 ratesetmismatch(ni, wh, reassoc, resp, "11g", rate);
2797 return;
2798 }
2799 /* XXX enforce PUREN */
2800 /* 802.11n-specific rateset handling */
2801 if (IEEE80211_IS_CHAN_HT(ic->ic_curchan) && htcap != NULL) {
2802 rate = ieee80211_setup_htrates(ni, htcap,
2803 IEEE80211_F_DOFRATE | IEEE80211_F_DONEGO |
2804 IEEE80211_F_DOBRS);
2805 if (rate & IEEE80211_RATE_BASIC) {
2806 /* XXX 11n-specific stat */
2807 ratesetmismatch(ni, wh, reassoc, resp,
2808 "HT", rate);
2809 return;
2810 }
2811 ieee80211_ht_node_init(ni, htcap);
2812 } else if (ni->ni_flags & IEEE80211_NODE_HT)
2813 ieee80211_ht_node_cleanup(ni);
2814 /*
2815 * Allow AMPDU operation only with unencrypted traffic
2816 * or AES-CCM; the 11n spec only specifies these ciphers
2817 * so permitting any others is undefined and can lead
2818 * to interoperability problems.
2819 *
2820 * NB: We check for AES by looking at the GTK cipher
2821 * since the WPA/11i specs say the PTK cipher has
2822 * to be "as good or better".
2823 */
2824 if ((ni->ni_flags & IEEE80211_NODE_HT) &&
2825 (((ic->ic_flags & IEEE80211_F_WPA) &&
2826 rsnparms.rsn_mcastcipher != IEEE80211_CIPHER_AES_CCM) ||
2827 (ic->ic_flags & (IEEE80211_F_WPA|IEEE80211_F_PRIVACY)) == IEEE80211_F_PRIVACY)) {
2828 IEEE80211_NOTE(ic,
2829 IEEE80211_MSG_ASSOC | IEEE80211_MSG_11N, ni,
2830 "disallow HT use because WEP or TKIP requested, "
2831 "capinfo 0x%x mcastcipher %d", capinfo,
2832 rsnparms.rsn_mcastcipher);
2833 ieee80211_ht_node_cleanup(ni);
2834 ic->ic_stats.is_ht_assoc_downgrade++;
2835 }
2836 /*
2837 * If constrained to 11n-only stations reject legacy stations.
2838 */
2839 if ((ic->ic_flags_ext & IEEE80211_FEXT_PUREN) &&
2840 (ni->ni_flags & IEEE80211_NODE_HT) == 0) {
2841 htcapmismatch(ni, wh, reassoc, resp);
2842 ic->ic_stats.is_ht_assoc_nohtcap++;
2843 return;
2844 }
2845 ni->ni_rssi = rssi;
2846 ni->ni_noise = noise;
2847 ni->ni_rstamp = rstamp;
2848 ni->ni_intval = lintval;
2849 ni->ni_capinfo = capinfo;
2850 ni->ni_chan = ic->ic_bsschan;
2851 ni->ni_fhdwell = ic->ic_bss->ni_fhdwell;
2852 ni->ni_fhindex = ic->ic_bss->ni_fhindex;
2853 if (wpa != NULL) {
2854 /*
2855 * Record WPA parameters for station, mark
2856 * node as using WPA and record information element
2857 * for applications that require it.
2858 */
2859 ni->ni_rsn = rsnparms;
2860 ieee80211_saveie(&ni->ni_wpa_ie, wpa);
2861 } else if (ni->ni_wpa_ie != NULL) {
2862 /*
2863 * Flush any state from a previous association.
2864 */
2865 FREE(ni->ni_wpa_ie, M_80211_NODE);
2866 ni->ni_wpa_ie = NULL;
2867 }
2868 if (rsn != NULL) {
2869 /*
2870 * Record RSN parameters for station, mark
2871 * node as using WPA and record information element
2872 * for applications that require it.
2873 */
2874 ni->ni_rsn = rsnparms;
2875 ieee80211_saveie(&ni->ni_rsn_ie, rsn);
2876 } else if (ni->ni_rsn_ie != NULL) {
2877 /*
2878 * Flush any state from a previous association.
2879 */
2880 FREE(ni->ni_rsn_ie, M_80211_NODE);
2881 ni->ni_rsn_ie = NULL;
2882 }
2883 if (wme != NULL) {
2884 /*
2885 * Record WME parameters for station, mark node
2886 * as capable of QoS and record information
2887 * element for applications that require it.
2888 */
2889 ieee80211_saveie(&ni->ni_wme_ie, wme);
2890 ni->ni_flags |= IEEE80211_NODE_QOS;
2891 } else if (ni->ni_wme_ie != NULL) {
2892 /*
2893 * Flush any state from a previous association.
2894 */
2895 FREE(ni->ni_wme_ie, M_80211_NODE);
2896 ni->ni_wme_ie = NULL;
2897 ni->ni_flags &= ~IEEE80211_NODE_QOS;
2898 }
2899 if (ath != NULL) {
2900 /*
2901 * Record ATH parameters for station, mark
2902 * node with appropriate capabilities, and
2903 * record the information element for
2904 * applications that require it.
2905 */
2906 ieee80211_saveath(ni, ath);
2907 } else if (ni->ni_ath_ie != NULL) {
2908 /*
2909 * Flush any state from a previous association.
2910 */
2911 FREE(ni->ni_ath_ie, M_80211_NODE);
2912 ni->ni_ath_ie = NULL;
2913 ni->ni_ath_flags = 0;
2914 }
2915 ieee80211_node_join(ic, ni, resp);
2916 ieee80211_deliver_l2uf(ni);
2917 break;
2918 }
2919
2920 case IEEE80211_FC0_SUBTYPE_ASSOC_RESP:
2921 case IEEE80211_FC0_SUBTYPE_REASSOC_RESP: {
2922 uint16_t capinfo, associd;
2923 uint16_t status;
2924
2925 if (ic->ic_opmode != IEEE80211_M_STA ||
2926 ic->ic_state != IEEE80211_S_ASSOC) {
2927 ic->ic_stats.is_rx_mgtdiscard++;
2928 return;
2929 }
2930
2931 /*
2932 * asresp frame format
2933 * [2] capability information
2934 * [2] status
2935 * [2] association ID
2936 * [tlv] supported rates
2937 * [tlv] extended supported rates
2938 * [tlv] WME
2939 * [tlv] HT capabilities
2940 * [tlv] HT info
2941 */
2942 IEEE80211_VERIFY_LENGTH(efrm - frm, 6, return);
2943 ni = ic->ic_bss;
2944 capinfo = le16toh(*(uint16_t *)frm);
2945 frm += 2;
2946 status = le16toh(*(uint16_t *)frm);
2947 frm += 2;
2948 if (status != 0) {
2949 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
2950 "[%s] %sassoc failed (reason %d)\n",
2951 ether_sprintf(wh->i_addr2),
2952 ISREASSOC(subtype) ? "re" : "", status);
2953 if (ni != ic->ic_bss) /* XXX never true? */
2954 ni->ni_fails++;
2955 ic->ic_stats.is_rx_auth_fail++; /* XXX */
2956 return;
2957 }
2958 associd = le16toh(*(uint16_t *)frm);
2959 frm += 2;
2960
2961 rates = xrates = wme = htcap = htinfo = NULL;
2962 while (efrm - frm > 1) {
2963 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2, return);
2964 switch (*frm) {
2965 case IEEE80211_ELEMID_RATES:
2966 rates = frm;
2967 break;
2968 case IEEE80211_ELEMID_XRATES:
2969 xrates = frm;
2970 break;
2971 case IEEE80211_ELEMID_HTCAP:
2972 htcap = frm;
2973 break;
2974 case IEEE80211_ELEMID_HTINFO:
2975 htinfo = frm;
2976 break;
2977 case IEEE80211_ELEMID_VENDOR:
2978 if (iswmeoui(frm))
2979 wme = frm;
2980 else if (ic->ic_flags_ext & IEEE80211_FEXT_HTCOMPAT) {
2981 /*
2982 * Accept pre-draft HT ie's if the
2983 * standard ones have not been seen.
2984 */
2985 if (ishtcapoui(frm)) {
2986 if (htcap == NULL)
2987 htcap = frm;
2988 } else if (ishtinfooui(frm)) {
2989 if (htinfo == NULL)
2990 htcap = frm;
2991 }
2992 }
2993 /* XXX Atheros OUI support */
2994 break;
2995 }
2996 frm += frm[1] + 2;
2997 }
2998
2999 IEEE80211_VERIFY_ELEMENT(rates, IEEE80211_RATE_MAXSIZE);
3000 if (xrates != NULL)
3001 IEEE80211_VERIFY_ELEMENT(xrates,
3002 IEEE80211_RATE_MAXSIZE - rates[1]);
3003 rate = ieee80211_setup_rates(ni, rates, xrates,
3004 IEEE80211_F_JOIN |
3005 IEEE80211_F_DOSORT | IEEE80211_F_DOFRATE |
3006 IEEE80211_F_DONEGO | IEEE80211_F_DODEL);
3007 if (rate & IEEE80211_RATE_BASIC) {
3008 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
3009 "[%s] %sassoc failed (rate set mismatch)\n",
3010 ether_sprintf(wh->i_addr2),
3011 ISREASSOC(subtype) ? "re" : "");
3012 if (ni != ic->ic_bss) /* XXX never true? */
3013 ni->ni_fails++;
3014 ic->ic_stats.is_rx_assoc_norate++;
3015 ieee80211_new_state(ic, IEEE80211_S_SCAN,
3016 IEEE80211_SCAN_FAIL_STATUS);
3017 return;
3018 }
3019
3020 ni->ni_capinfo = capinfo;
3021 ni->ni_associd = associd;
3022 if (wme != NULL &&
3023 ieee80211_parse_wmeparams(ic, wme, wh) >= 0) {
3024 ni->ni_flags |= IEEE80211_NODE_QOS;
3025 ieee80211_wme_updateparams(ic);
3026 } else
3027 ni->ni_flags &= ~IEEE80211_NODE_QOS;
3028 /*
3029 * Setup HT state according to the negotiation.
3030 */
3031 if ((ic->ic_htcaps & IEEE80211_HTC_HT) &&
3032 htcap != NULL && htinfo != NULL) {
3033 ieee80211_ht_node_init(ni, htcap);
3034 ieee80211_parse_htinfo(ni, htinfo);
3035 ieee80211_setup_htrates(ni,
3036 htcap, IEEE80211_F_JOIN | IEEE80211_F_DOBRS);
3037 ieee80211_setup_basic_htrates(ni, htinfo);
3038 if (ni->ni_chan != ic->ic_bsschan) {
3039 /*
3040 * Channel has been adjusted based on
3041 * negotiated HT parameters; force the
3042 * channel state to follow.
3043 */
3044 ieee80211_setbsschan(ic, ni->ni_chan);
3045 }
3046 }
3047 /*
3048 * Configure state now that we are associated.
3049 *
3050 * XXX may need different/additional driver callbacks?
3051 */
3052 if (IEEE80211_IS_CHAN_A(ic->ic_curchan) ||
3053 (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE)) {
3054 ic->ic_flags |= IEEE80211_F_SHPREAMBLE;
3055 ic->ic_flags &= ~IEEE80211_F_USEBARKER;
3056 } else {
3057 ic->ic_flags &= ~IEEE80211_F_SHPREAMBLE;
3058 ic->ic_flags |= IEEE80211_F_USEBARKER;
3059 }
3060 ieee80211_set_shortslottime(ic,
3061 IEEE80211_IS_CHAN_A(ic->ic_curchan) ||
3062 (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME));
3063 /*
3064 * Honor ERP protection.
3065 *
3066 * NB: ni_erp should zero for non-11g operation.
3067 */
3068 if (IEEE80211_IS_CHAN_ANYG(ic->ic_curchan) &&
3069 (ni->ni_erp & IEEE80211_ERP_USE_PROTECTION))
3070 ic->ic_flags |= IEEE80211_F_USEPROT;
3071 else
3072 ic->ic_flags &= ~IEEE80211_F_USEPROT;
3073 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
3074 "[%s] %sassoc success: %s preamble, %s slot time%s%s%s%s\n",
3075 ether_sprintf(wh->i_addr2),
3076 ISREASSOC(subtype) ? "re" : "",
3077 ic->ic_flags&IEEE80211_F_SHPREAMBLE ? "short" : "long",
3078 ic->ic_flags&IEEE80211_F_SHSLOT ? "short" : "long",
3079 ic->ic_flags&IEEE80211_F_USEPROT ? ", protection" : "",
3080 ni->ni_flags & IEEE80211_NODE_QOS ? ", QoS" : "",
3081 ni->ni_flags & IEEE80211_NODE_HT ?
3082 (ni->ni_chw == 20 ? ", HT20" : ", HT40") : "",
3083 ni->ni_flags & IEEE80211_NODE_AMPDU ? " (+AMPDU)" : "",
3084 IEEE80211_ATH_CAP(ic, ni, IEEE80211_NODE_FF) ?
3085 ", fast-frames" : "",
3086 IEEE80211_ATH_CAP(ic, ni, IEEE80211_NODE_TURBOP) ?
3087 ", turbo" : ""
3088 );
3089 ieee80211_new_state(ic, IEEE80211_S_RUN, subtype);
3090 break;
3091 }
3092
3093 case IEEE80211_FC0_SUBTYPE_DEAUTH: {
3094 uint16_t reason;
3095
3096 if (ic->ic_state == IEEE80211_S_SCAN) {
3097 ic->ic_stats.is_rx_mgtdiscard++;
3098 return;
3099 }
3100 /*
3101 * deauth frame format
3102 * [2] reason
3103 */
3104 IEEE80211_VERIFY_LENGTH(efrm - frm, 2, return);
3105 reason = le16toh(*(uint16_t *)frm);
3106 ic->ic_stats.is_rx_deauth++;
3107 IEEE80211_NODE_STAT(ni, rx_deauth);
3108
3109 if (!IEEE80211_ADDR_EQ(wh->i_addr1, ic->ic_myaddr)) {
3110 /* NB: can happen when in promiscuous mode */
3111 ic->ic_stats.is_rx_mgtdiscard++;
3112 break;
3113 }
3114 IEEE80211_DPRINTF(ic, IEEE80211_MSG_AUTH,
3115 "[%s] recv deauthenticate (reason %d)\n",
3116 ether_sprintf(ni->ni_macaddr), reason);
3117 switch (ic->ic_opmode) {
3118 case IEEE80211_M_STA:
3119 ieee80211_new_state(ic, IEEE80211_S_AUTH,
3120 (reason << 8) | IEEE80211_FC0_SUBTYPE_DEAUTH);
3121 break;
3122 case IEEE80211_M_HOSTAP:
3123 if (ni != ic->ic_bss)
3124 ieee80211_node_leave(ic, ni);
3125 break;
3126 default:
3127 ic->ic_stats.is_rx_mgtdiscard++;
3128 break;
3129 }
3130 break;
3131 }
3132
3133 case IEEE80211_FC0_SUBTYPE_DISASSOC: {
3134 uint16_t reason;
3135
3136 if (ic->ic_state != IEEE80211_S_RUN &&
3137 ic->ic_state != IEEE80211_S_ASSOC &&
3138 ic->ic_state != IEEE80211_S_AUTH) {
3139 ic->ic_stats.is_rx_mgtdiscard++;
3140 return;
3141 }
3142 /*
3143 * disassoc frame format
3144 * [2] reason
3145 */
3146 IEEE80211_VERIFY_LENGTH(efrm - frm, 2, return);
3147 reason = le16toh(*(uint16_t *)frm);
3148 ic->ic_stats.is_rx_disassoc++;
3149 IEEE80211_NODE_STAT(ni, rx_disassoc);
3150
3151 if (!IEEE80211_ADDR_EQ(wh->i_addr1, ic->ic_myaddr)) {
3152 /* NB: can happen when in promiscuous mode */
3153 ic->ic_stats.is_rx_mgtdiscard++;
3154 break;
3155 }
3156 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
3157 "[%s] recv disassociate (reason %d)\n",
3158 ether_sprintf(ni->ni_macaddr), reason);
3159 switch (ic->ic_opmode) {
3160 case IEEE80211_M_STA:
3161 ieee80211_new_state(ic, IEEE80211_S_ASSOC, 0);
3162 break;
3163 case IEEE80211_M_HOSTAP:
3164 if (ni != ic->ic_bss)
3165 ieee80211_node_leave(ic, ni);
3166 break;
3167 default:
3168 ic->ic_stats.is_rx_mgtdiscard++;
3169 break;
3170 }
3171 break;
3172 }
3173
3174 case IEEE80211_FC0_SUBTYPE_ACTION: {
3175 const struct ieee80211_action *ia;
3176
3177 if (ic->ic_state != IEEE80211_S_RUN &&
3178 ic->ic_state != IEEE80211_S_ASSOC &&
3179 ic->ic_state != IEEE80211_S_AUTH) {
3180 ic->ic_stats.is_rx_mgtdiscard++;
3181 return;
3182 }
3183 /*
3184 * action frame format:
3185 * [1] category
3186 * [1] action
3187 * [tlv] parameters
3188 */
3189 IEEE80211_VERIFY_LENGTH(efrm - frm,
3190 sizeof(struct ieee80211_action), return);
3191 ia = (const struct ieee80211_action *) frm;
3192
3193 ic->ic_stats.is_rx_action++;
3194 IEEE80211_NODE_STAT(ni, rx_action);
3195
3196 /* verify frame payloads but defer processing */
3197 /* XXX maybe push this to method */
3198 switch (ia->ia_category) {
3199 case IEEE80211_ACTION_CAT_BA:
3200 switch (ia->ia_action) {
3201 case IEEE80211_ACTION_BA_ADDBA_REQUEST:
3202 IEEE80211_VERIFY_LENGTH(efrm - frm,
3203 sizeof(struct ieee80211_action_ba_addbarequest),
3204 return);
3205 break;
3206 case IEEE80211_ACTION_BA_ADDBA_RESPONSE:
3207 IEEE80211_VERIFY_LENGTH(efrm - frm,
3208 sizeof(struct ieee80211_action_ba_addbaresponse),
3209 return);
3210 break;
3211 case IEEE80211_ACTION_BA_DELBA:
3212 IEEE80211_VERIFY_LENGTH(efrm - frm,
3213 sizeof(struct ieee80211_action_ba_delba),
3214 return);
3215 break;
3216 }
3217 break;
3218 case IEEE80211_ACTION_CAT_HT:
3219 switch (ia->ia_action) {
3220 case IEEE80211_ACTION_HT_TXCHWIDTH:
3221 IEEE80211_VERIFY_LENGTH(efrm - frm,
3222 sizeof(struct ieee80211_action_ht_txchwidth),
3223 return);
3224 break;
3225 }
3226 break;
3227 }
3228 ic->ic_recv_action(ni, frm, efrm);
3229 break;
3230 }
3231
3232 default:
3233 IEEE80211_DISCARD(ic, IEEE80211_MSG_ANY,
3234 wh, "mgt", "subtype 0x%x not handled", subtype);
3235 ic->ic_stats.is_rx_badsubtype++;
3236 break;
3237 }
3238#undef ISREASSOC
3239#undef ISPROBE
3240}
3241#undef IEEE80211_VERIFY_LENGTH
3242#undef IEEE80211_VERIFY_ELEMENT
3243
3244/*
3245 * Process a received ps-poll frame.
3246 */
3247static void
3248ieee80211_recv_pspoll(struct ieee80211com *ic,
3249 struct ieee80211_node *ni, struct mbuf *m0)
3250{
3251 struct ieee80211_frame_min *wh;
3252 struct mbuf *m;
3253 uint16_t aid;
3254 int qlen;
3255
3256 wh = mtod(m0, struct ieee80211_frame_min *);
3257 if (ni->ni_associd == 0) {
3258 IEEE80211_DISCARD(ic, IEEE80211_MSG_POWER | IEEE80211_MSG_DEBUG,
3259 (struct ieee80211_frame *) wh, "ps-poll",
3260 "%s", "unassociated station");
3261 ic->ic_stats.is_ps_unassoc++;
3262 IEEE80211_SEND_MGMT(ic, ni, IEEE80211_FC0_SUBTYPE_DEAUTH,
3263 IEEE80211_REASON_NOT_ASSOCED);
3264 return;
3265 }
3266
3267 aid = le16toh(*(uint16_t *)wh->i_dur);
3268 if (aid != ni->ni_associd) {
3269 IEEE80211_DISCARD(ic, IEEE80211_MSG_POWER | IEEE80211_MSG_DEBUG,
3270 (struct ieee80211_frame *) wh, "ps-poll",
3271 "aid mismatch: sta aid 0x%x poll aid 0x%x",
3272 ni->ni_associd, aid);
3273 ic->ic_stats.is_ps_badaid++;
3274 IEEE80211_SEND_MGMT(ic, ni, IEEE80211_FC0_SUBTYPE_DEAUTH,
3275 IEEE80211_REASON_NOT_ASSOCED);
3276 return;
3277 }
3278
3279 /* Okay, take the first queued packet and put it out... */
3280 IEEE80211_NODE_SAVEQ_DEQUEUE(ni, m, qlen);
3281 if (m == NULL) {
3282 IEEE80211_DPRINTF(ic, IEEE80211_MSG_POWER,
3283 "[%s] recv ps-poll, but queue empty\n",
3284 ether_sprintf(wh->i_addr2));
3285 ieee80211_send_nulldata(ieee80211_ref_node(ni));
3286 ic->ic_stats.is_ps_qempty++; /* XXX node stat */
3287 if (ic->ic_set_tim != NULL)
3288 ic->ic_set_tim(ni, 0); /* just in case */
3289 return;
3290 }
3291 /*
3292 * If there are more packets, set the more packets bit
3293 * in the packet dispatched to the station; otherwise
3294 * turn off the TIM bit.
3295 */
3296 if (qlen != 0) {
3297 IEEE80211_DPRINTF(ic, IEEE80211_MSG_POWER,
3298 "[%s] recv ps-poll, send packet, %u still queued\n",
3299 ether_sprintf(ni->ni_macaddr), qlen);
3300 m->m_flags |= M_MORE_DATA;
3301 } else {
3302 IEEE80211_DPRINTF(ic, IEEE80211_MSG_POWER,
3303 "[%s] recv ps-poll, send packet, queue empty\n",
3304 ether_sprintf(ni->ni_macaddr));
3305 if (ic->ic_set_tim != NULL)
3306 ic->ic_set_tim(ni, 0);
3307 }
3308 m->m_flags |= M_PWR_SAV; /* bypass PS handling */
3309 IF_ENQUEUE(&ic->ic_ifp->if_snd, m);
3310}
3311
3312#ifdef IEEE80211_DEBUG
3313/*
3314 * Debugging support.
3315 */
3316
3317/*
3318 * Return the bssid of a frame.
3319 */
3320static const uint8_t *
3321ieee80211_getbssid(struct ieee80211com *ic, const struct ieee80211_frame *wh)
3322{
3323 if (ic->ic_opmode == IEEE80211_M_STA)
3324 return wh->i_addr2;
3325 if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) != IEEE80211_FC1_DIR_NODS)
3326 return wh->i_addr1;
3327 if ((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) == IEEE80211_FC0_SUBTYPE_PS_POLL)
3328 return wh->i_addr1;
3329 return wh->i_addr3;
3330}
3331
3332void
3333ieee80211_note(struct ieee80211com *ic, const char *fmt, ...)
3334{
3335 char buf[128]; /* XXX */
3336 va_list ap;
3337
3338 va_start(ap, fmt);
3339 vsnprintf(buf, sizeof(buf), fmt, ap);
3340 va_end(ap);
3341
3342 if_printf(ic->ic_ifp, "%s", buf); /* NB: no \n */
3343}
3344
3345void
3346ieee80211_note_frame(struct ieee80211com *ic,
3347 const struct ieee80211_frame *wh,
3348 const char *fmt, ...)
3349{
3350 char buf[128]; /* XXX */
3351 va_list ap;
3352
3353 va_start(ap, fmt);
3354 vsnprintf(buf, sizeof(buf), fmt, ap);
3355 va_end(ap);
3356 if_printf(ic->ic_ifp, "[%s] %s\n",
3357 ether_sprintf(ieee80211_getbssid(ic, wh)), buf);
3358}
3359
3360void
3361ieee80211_note_mac(struct ieee80211com *ic,
3362 const uint8_t mac[IEEE80211_ADDR_LEN],
3363 const char *fmt, ...)
3364{
3365 char buf[128]; /* XXX */
3366 va_list ap;
3367
3368 va_start(ap, fmt);
3369 vsnprintf(buf, sizeof(buf), fmt, ap);
3370 va_end(ap);
3371 if_printf(ic->ic_ifp, "[%s] %s\n", ether_sprintf(mac), buf);
3372}
3373
3374void
3375ieee80211_discard_frame(struct ieee80211com *ic,
3376 const struct ieee80211_frame *wh,
3377 const char *type, const char *fmt, ...)
3378{
3379 va_list ap;
3380
3381 printf("[%s:%s] discard ", ic->ic_ifp->if_xname,
3382 ether_sprintf(ieee80211_getbssid(ic, wh)));
3383 if (type != NULL)
3384 printf("%s frame, ", type);
3385 else
3386 printf("frame, ");
3387 va_start(ap, fmt);
3388 vprintf(fmt, ap);
3389 va_end(ap);
3390 printf("\n");
3391}
3392
3393void
3394ieee80211_discard_ie(struct ieee80211com *ic,
3395 const struct ieee80211_frame *wh,
3396 const char *type, const char *fmt, ...)
3397{
3398 va_list ap;
3399
3400 printf("[%s:%s] discard ", ic->ic_ifp->if_xname,
3401 ether_sprintf(ieee80211_getbssid(ic, wh)));
3402 if (type != NULL)
3403 printf("%s information element, ", type);
3404 else
3405 printf("information element, ");
3406 va_start(ap, fmt);
3407 vprintf(fmt, ap);
3408 va_end(ap);
3409 printf("\n");
3410}
3411
3412void
3413ieee80211_discard_mac(struct ieee80211com *ic,
3414 const uint8_t mac[IEEE80211_ADDR_LEN],
3415 const char *type, const char *fmt, ...)
3416{
3417 va_list ap;
3418
3419 printf("[%s:%s] discard ", ic->ic_ifp->if_xname, ether_sprintf(mac));
3420 if (type != NULL)
3421 printf("%s frame, ", type);
3422 else
3423 printf("frame, ");
3424 va_start(ap, fmt);
3425 vprintf(fmt, ap);
3426 va_end(ap);
3427 printf("\n");
3428}
3429#endif /* IEEE80211_DEBUG */
| 771 }
772 if (m != NULL) {
773 m->m_pkthdr.rcvif = ifp;
774 if (ni->ni_vlan != 0) {
775 /* attach vlan tag */
776 m->m_pkthdr.ether_vtag = ni->ni_vlan;
777 m->m_flags |= M_VLANTAG;
778 }
779 (*ifp->if_input)(ifp, m);
780 }
781}
782
783static struct mbuf *
784ieee80211_decap(struct ieee80211com *ic, struct mbuf *m, int hdrlen)
785{
786 struct ieee80211_qosframe_addr4 wh; /* Max size address frames */
787 struct ether_header *eh;
788 struct llc *llc;
789
790 if (m->m_len < hdrlen + sizeof(*llc) &&
791 (m = m_pullup(m, hdrlen + sizeof(*llc))) == NULL) {
792 /* XXX stat, msg */
793 return NULL;
794 }
795 memcpy(&wh, mtod(m, caddr_t), hdrlen);
796 llc = (struct llc *)(mtod(m, caddr_t) + hdrlen);
797 if (llc->llc_dsap == LLC_SNAP_LSAP && llc->llc_ssap == LLC_SNAP_LSAP &&
798 llc->llc_control == LLC_UI && llc->llc_snap.org_code[0] == 0 &&
799 llc->llc_snap.org_code[1] == 0 && llc->llc_snap.org_code[2] == 0) {
800 m_adj(m, hdrlen + sizeof(struct llc) - sizeof(*eh));
801 llc = NULL;
802 } else {
803 m_adj(m, hdrlen - sizeof(*eh));
804 }
805 eh = mtod(m, struct ether_header *);
806 switch (wh.i_fc[1] & IEEE80211_FC1_DIR_MASK) {
807 case IEEE80211_FC1_DIR_NODS:
808 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr1);
809 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr2);
810 break;
811 case IEEE80211_FC1_DIR_TODS:
812 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr3);
813 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr2);
814 break;
815 case IEEE80211_FC1_DIR_FROMDS:
816 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr1);
817 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr3);
818 break;
819 case IEEE80211_FC1_DIR_DSTODS:
820 IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr3);
821 IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr4);
822 break;
823 }
824#ifdef ALIGNED_POINTER
825 if (!ALIGNED_POINTER(mtod(m, caddr_t) + sizeof(*eh), uint32_t)) {
826 struct mbuf *n, *n0, **np;
827 caddr_t newdata;
828 int off, pktlen;
829
830 n0 = NULL;
831 np = &n0;
832 off = 0;
833 pktlen = m->m_pkthdr.len;
834 while (pktlen > off) {
835 if (n0 == NULL) {
836 MGETHDR(n, M_DONTWAIT, MT_DATA);
837 if (n == NULL) {
838 m_freem(m);
839 return NULL;
840 }
841 M_MOVE_PKTHDR(n, m);
842 n->m_len = MHLEN;
843 } else {
844 MGET(n, M_DONTWAIT, MT_DATA);
845 if (n == NULL) {
846 m_freem(m);
847 m_freem(n0);
848 return NULL;
849 }
850 n->m_len = MLEN;
851 }
852 if (pktlen - off >= MINCLSIZE) {
853 MCLGET(n, M_DONTWAIT);
854 if (n->m_flags & M_EXT)
855 n->m_len = n->m_ext.ext_size;
856 }
857 if (n0 == NULL) {
858 newdata =
859 (caddr_t)ALIGN(n->m_data + sizeof(*eh)) -
860 sizeof(*eh);
861 n->m_len -= newdata - n->m_data;
862 n->m_data = newdata;
863 }
864 if (n->m_len > pktlen - off)
865 n->m_len = pktlen - off;
866 m_copydata(m, off, n->m_len, mtod(n, caddr_t));
867 off += n->m_len;
868 *np = n;
869 np = &n->m_next;
870 }
871 m_freem(m);
872 m = n0;
873 }
874#endif /* ALIGNED_POINTER */
875 if (llc != NULL) {
876 eh = mtod(m, struct ether_header *);
877 eh->ether_type = htons(m->m_pkthdr.len - sizeof(*eh));
878 }
879 return m;
880}
881
882/*
883 * Decap a frame encapsulated in a fast-frame/A-MSDU.
884 */
885struct mbuf *
886ieee80211_decap1(struct mbuf *m, int *framelen)
887{
888#define FF_LLC_SIZE (sizeof(struct ether_header) + sizeof(struct llc))
889 struct ether_header *eh;
890 struct llc *llc;
891
892 /*
893 * The frame has an 802.3 header followed by an 802.2
894 * LLC header. The encapsulated frame length is in the
895 * first header type field; save that and overwrite it
896 * with the true type field found in the second. Then
897 * copy the 802.3 header up to where it belongs and
898 * adjust the mbuf contents to remove the void.
899 */
900 if (m->m_len < FF_LLC_SIZE && (m = m_pullup(m, FF_LLC_SIZE)) == NULL)
901 return NULL;
902 eh = mtod(m, struct ether_header *); /* 802.3 header is first */
903 llc = (struct llc *)&eh[1]; /* 802.2 header follows */
904 *framelen = ntohs(eh->ether_type) /* encap'd frame size */
905 + sizeof(struct ether_header) - sizeof(struct llc);
906 eh->ether_type = llc->llc_un.type_snap.ether_type;
907 ovbcopy(eh, mtod(m, uint8_t *) + sizeof(struct llc),
908 sizeof(struct ether_header));
909 m_adj(m, sizeof(struct llc));
910 return m;
911#undef FF_LLC_SIZE
912}
913
914/*
915 * Decap the encapsulated frame pair and dispatch the first
916 * for delivery. The second frame is returned for delivery
917 * via the normal path.
918 */
919static struct mbuf *
920ieee80211_decap_fastframe(struct ieee80211com *ic,
921 struct ieee80211_node *ni, struct mbuf *m)
922{
923#define MS(x,f) (((x) & f) >> f##_S)
924 uint32_t ath;
925 struct mbuf *n;
926 int framelen;
927
928 m_copydata(m, 0, sizeof(uint32_t), (caddr_t) &ath);
929 if (MS(ath, ATH_FF_PROTO) != ATH_FF_PROTO_L2TUNNEL) {
930 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
931 ni->ni_macaddr, "fast-frame",
932 "unsupport tunnel protocol, header 0x%x", ath);
933 ic->ic_stats.is_ff_badhdr++;
934 m_freem(m);
935 return NULL;
936 }
937 /* NB: skip header and alignment padding */
938 m_adj(m, roundup(sizeof(uint32_t) - 2, 4) + 2);
939
940 ic->ic_stats.is_ff_decap++;
941
942 /*
943 * Decap the first frame, bust it apart from the
944 * second and deliver; then decap the second frame
945 * and return it to the caller for normal delivery.
946 */
947 m = ieee80211_decap1(m, &framelen);
948 if (m == NULL) {
949 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
950 ni->ni_macaddr, "fast-frame", "%s", "first decap failed");
951 ic->ic_stats.is_ff_tooshort++;
952 return NULL;
953 }
954 n = m_split(m, framelen, M_NOWAIT);
955 if (n == NULL) {
956 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
957 ni->ni_macaddr, "fast-frame",
958 "%s", "unable to split encapsulated frames");
959 ic->ic_stats.is_ff_split++;
960 m_freem(m); /* NB: must reclaim */
961 return NULL;
962 }
963 ieee80211_deliver_data(ic, ni, m); /* 1st of pair */
964
965 /*
966 * Decap second frame.
967 */
968 m_adj(n, roundup2(framelen, 4) - framelen); /* padding */
969 n = ieee80211_decap1(n, &framelen);
970 if (n == NULL) {
971 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_ANY,
972 ni->ni_macaddr, "fast-frame", "%s", "second decap failed");
973 ic->ic_stats.is_ff_tooshort++;
974 }
975 /* XXX verify framelen against mbuf contents */
976 return n; /* 2nd delivered by caller */
977#undef MS
978}
979
980/*
981 * Install received rate set information in the node's state block.
982 */
983int
984ieee80211_setup_rates(struct ieee80211_node *ni,
985 const uint8_t *rates, const uint8_t *xrates, int flags)
986{
987 struct ieee80211com *ic = ni->ni_ic;
988 struct ieee80211_rateset *rs = &ni->ni_rates;
989
990 memset(rs, 0, sizeof(*rs));
991 rs->rs_nrates = rates[1];
992 memcpy(rs->rs_rates, rates + 2, rs->rs_nrates);
993 if (xrates != NULL) {
994 uint8_t nxrates;
995 /*
996 * Tack on 11g extended supported rate element.
997 */
998 nxrates = xrates[1];
999 if (rs->rs_nrates + nxrates > IEEE80211_RATE_MAXSIZE) {
1000 nxrates = IEEE80211_RATE_MAXSIZE - rs->rs_nrates;
1001 IEEE80211_DPRINTF(ic, IEEE80211_MSG_XRATE,
1002 "[%s] extended rate set too large;"
1003 " only using %u of %u rates\n",
1004 ether_sprintf(ni->ni_macaddr), nxrates, xrates[1]);
1005 ic->ic_stats.is_rx_rstoobig++;
1006 }
1007 memcpy(rs->rs_rates + rs->rs_nrates, xrates+2, nxrates);
1008 rs->rs_nrates += nxrates;
1009 }
1010 return ieee80211_fix_rate(ni, rs, flags);
1011}
1012
1013static void
1014ieee80211_auth_open(struct ieee80211com *ic, struct ieee80211_frame *wh,
1015 struct ieee80211_node *ni, int rssi, int noise, uint32_t rstamp,
1016 uint16_t seq, uint16_t status)
1017{
1018
1019 if (ni->ni_authmode == IEEE80211_AUTH_SHARED) {
1020 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1021 ni->ni_macaddr, "open auth",
1022 "bad sta auth mode %u", ni->ni_authmode);
1023 ic->ic_stats.is_rx_bad_auth++; /* XXX */
1024 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
1025 /*
1026 * Clear any challenge text that may be there if
1027 * a previous shared key auth failed and then an
1028 * open auth is attempted.
1029 */
1030 if (ni->ni_challenge != NULL) {
1031 FREE(ni->ni_challenge, M_80211_NODE);
1032 ni->ni_challenge = NULL;
1033 }
1034 /* XXX hack to workaround calling convention */
1035 ieee80211_send_error(ic, ni, wh->i_addr2,
1036 IEEE80211_FC0_SUBTYPE_AUTH,
1037 (seq + 1) | (IEEE80211_STATUS_ALG<<16));
1038 }
1039 return;
1040 }
1041 switch (ic->ic_opmode) {
1042 case IEEE80211_M_IBSS:
1043 case IEEE80211_M_AHDEMO:
1044 case IEEE80211_M_MONITOR:
1045 case IEEE80211_M_WDS:
1046 /* should not come here */
1047 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1048 ni->ni_macaddr, "open auth",
1049 "bad operating mode %u", ic->ic_opmode);
1050 break;
1051
1052 case IEEE80211_M_HOSTAP:
1053 if (ic->ic_state != IEEE80211_S_RUN ||
1054 seq != IEEE80211_AUTH_OPEN_REQUEST) {
1055 ic->ic_stats.is_rx_bad_auth++;
1056 return;
1057 }
1058 /* always accept open authentication requests */
1059 if (ni == ic->ic_bss) {
1060 ni = ieee80211_dup_bss(&ic->ic_sta, wh->i_addr2);
1061 if (ni == NULL)
1062 return;
1063 } else if ((ni->ni_flags & IEEE80211_NODE_AREF) == 0)
1064 (void) ieee80211_ref_node(ni);
1065 /*
1066 * Mark the node as referenced to reflect that it's
1067 * reference count has been bumped to insure it remains
1068 * after the transaction completes.
1069 */
1070 ni->ni_flags |= IEEE80211_NODE_AREF;
1071
1072 IEEE80211_SEND_MGMT(ic, ni,
1073 IEEE80211_FC0_SUBTYPE_AUTH, seq + 1);
1074 IEEE80211_DPRINTF(ic, IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1075 "[%s] station authenticated (open)\n",
1076 ether_sprintf(ni->ni_macaddr));
1077 /*
1078 * When 802.1x is not in use mark the port
1079 * authorized at this point so traffic can flow.
1080 */
1081 if (ni->ni_authmode != IEEE80211_AUTH_8021X)
1082 ieee80211_node_authorize(ni);
1083 break;
1084
1085 case IEEE80211_M_STA:
1086 if (ic->ic_state != IEEE80211_S_AUTH ||
1087 seq != IEEE80211_AUTH_OPEN_RESPONSE) {
1088 ic->ic_stats.is_rx_bad_auth++;
1089 return;
1090 }
1091 if (status != 0) {
1092 IEEE80211_DPRINTF(ic,
1093 IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1094 "[%s] open auth failed (reason %d)\n",
1095 ether_sprintf(ni->ni_macaddr), status);
1096 /* XXX can this happen? */
1097 if (ni != ic->ic_bss)
1098 ni->ni_fails++;
1099 ic->ic_stats.is_rx_auth_fail++;
1100 ieee80211_new_state(ic, IEEE80211_S_SCAN,
1101 IEEE80211_SCAN_FAIL_STATUS);
1102 } else
1103 ieee80211_new_state(ic, IEEE80211_S_ASSOC, 0);
1104 break;
1105 }
1106}
1107
1108/*
1109 * Send a management frame error response to the specified
1110 * station. If ni is associated with the station then use
1111 * it; otherwise allocate a temporary node suitable for
1112 * transmitting the frame and then free the reference so
1113 * it will go away as soon as the frame has been transmitted.
1114 */
1115static void
1116ieee80211_send_error(struct ieee80211com *ic, struct ieee80211_node *ni,
1117 const uint8_t *mac, int subtype, int arg)
1118{
1119 int istmp;
1120
1121 if (ni == ic->ic_bss) {
1122 ni = ieee80211_tmp_node(ic, mac);
1123 if (ni == NULL) {
1124 /* XXX msg */
1125 return;
1126 }
1127 istmp = 1;
1128 } else
1129 istmp = 0;
1130 IEEE80211_SEND_MGMT(ic, ni, subtype, arg);
1131 if (istmp)
1132 ieee80211_free_node(ni);
1133}
1134
1135static int
1136alloc_challenge(struct ieee80211com *ic, struct ieee80211_node *ni)
1137{
1138 if (ni->ni_challenge == NULL)
1139 MALLOC(ni->ni_challenge, uint32_t*, IEEE80211_CHALLENGE_LEN,
1140 M_80211_NODE, M_NOWAIT);
1141 if (ni->ni_challenge == NULL) {
1142 IEEE80211_DPRINTF(ic, IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1143 "[%s] shared key challenge alloc failed\n",
1144 ether_sprintf(ni->ni_macaddr));
1145 /* XXX statistic */
1146 }
1147 return (ni->ni_challenge != NULL);
1148}
1149
1150/* XXX TODO: add statistics */
1151static void
1152ieee80211_auth_shared(struct ieee80211com *ic, struct ieee80211_frame *wh,
1153 uint8_t *frm, uint8_t *efrm, struct ieee80211_node *ni,
1154 int rssi, int noise, uint32_t rstamp, uint16_t seq, uint16_t status)
1155{
1156 uint8_t *challenge;
1157 int allocbs, estatus;
1158
1159 /*
1160 * NB: this can happen as we allow pre-shared key
1161 * authentication to be enabled w/o wep being turned
1162 * on so that configuration of these can be done
1163 * in any order. It may be better to enforce the
1164 * ordering in which case this check would just be
1165 * for sanity/consistency.
1166 */
1167 if ((ic->ic_flags & IEEE80211_F_PRIVACY) == 0) {
1168 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1169 ni->ni_macaddr, "shared key auth",
1170 "%s", " PRIVACY is disabled");
1171 estatus = IEEE80211_STATUS_ALG;
1172 goto bad;
1173 }
1174 /*
1175 * Pre-shared key authentication is evil; accept
1176 * it only if explicitly configured (it is supported
1177 * mainly for compatibility with clients like OS X).
1178 */
1179 if (ni->ni_authmode != IEEE80211_AUTH_AUTO &&
1180 ni->ni_authmode != IEEE80211_AUTH_SHARED) {
1181 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1182 ni->ni_macaddr, "shared key auth",
1183 "bad sta auth mode %u", ni->ni_authmode);
1184 ic->ic_stats.is_rx_bad_auth++; /* XXX maybe a unique error? */
1185 estatus = IEEE80211_STATUS_ALG;
1186 goto bad;
1187 }
1188
1189 challenge = NULL;
1190 if (frm + 1 < efrm) {
1191 if ((frm[1] + 2) > (efrm - frm)) {
1192 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1193 ni->ni_macaddr, "shared key auth",
1194 "ie %d/%d too long",
1195 frm[0], (frm[1] + 2) - (efrm - frm));
1196 ic->ic_stats.is_rx_bad_auth++;
1197 estatus = IEEE80211_STATUS_CHALLENGE;
1198 goto bad;
1199 }
1200 if (*frm == IEEE80211_ELEMID_CHALLENGE)
1201 challenge = frm;
1202 frm += frm[1] + 2;
1203 }
1204 switch (seq) {
1205 case IEEE80211_AUTH_SHARED_CHALLENGE:
1206 case IEEE80211_AUTH_SHARED_RESPONSE:
1207 if (challenge == NULL) {
1208 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1209 ni->ni_macaddr, "shared key auth",
1210 "%s", "no challenge");
1211 ic->ic_stats.is_rx_bad_auth++;
1212 estatus = IEEE80211_STATUS_CHALLENGE;
1213 goto bad;
1214 }
1215 if (challenge[1] != IEEE80211_CHALLENGE_LEN) {
1216 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1217 ni->ni_macaddr, "shared key auth",
1218 "bad challenge len %d", challenge[1]);
1219 ic->ic_stats.is_rx_bad_auth++;
1220 estatus = IEEE80211_STATUS_CHALLENGE;
1221 goto bad;
1222 }
1223 default:
1224 break;
1225 }
1226 switch (ic->ic_opmode) {
1227 case IEEE80211_M_MONITOR:
1228 case IEEE80211_M_AHDEMO:
1229 case IEEE80211_M_IBSS:
1230 case IEEE80211_M_WDS:
1231 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1232 ni->ni_macaddr, "shared key auth",
1233 "bad operating mode %u", ic->ic_opmode);
1234 return;
1235 case IEEE80211_M_HOSTAP:
1236 if (ic->ic_state != IEEE80211_S_RUN) {
1237 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1238 ni->ni_macaddr, "shared key auth",
1239 "bad state %u", ic->ic_state);
1240 estatus = IEEE80211_STATUS_ALG; /* XXX */
1241 goto bad;
1242 }
1243 switch (seq) {
1244 case IEEE80211_AUTH_SHARED_REQUEST:
1245 if (ni == ic->ic_bss) {
1246 ni = ieee80211_dup_bss(&ic->ic_sta, wh->i_addr2);
1247 if (ni == NULL) {
1248 /* NB: no way to return an error */
1249 return;
1250 }
1251 allocbs = 1;
1252 } else {
1253 if ((ni->ni_flags & IEEE80211_NODE_AREF) == 0)
1254 (void) ieee80211_ref_node(ni);
1255 allocbs = 0;
1256 }
1257 /*
1258 * Mark the node as referenced to reflect that it's
1259 * reference count has been bumped to insure it remains
1260 * after the transaction completes.
1261 */
1262 ni->ni_flags |= IEEE80211_NODE_AREF;
1263 ni->ni_rssi = rssi;
1264 ni->ni_noise = noise;
1265 ni->ni_rstamp = rstamp;
1266 if (!alloc_challenge(ic, ni)) {
1267 /* NB: don't return error so they rexmit */
1268 return;
1269 }
1270 get_random_bytes(ni->ni_challenge,
1271 IEEE80211_CHALLENGE_LEN);
1272 IEEE80211_DPRINTF(ic,
1273 IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1274 "[%s] shared key %sauth request\n",
1275 ether_sprintf(ni->ni_macaddr),
1276 allocbs ? "" : "re");
1277 break;
1278 case IEEE80211_AUTH_SHARED_RESPONSE:
1279 if (ni == ic->ic_bss) {
1280 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1281 ni->ni_macaddr, "shared key response",
1282 "%s", "unknown station");
1283 /* NB: don't send a response */
1284 return;
1285 }
1286 if (ni->ni_challenge == NULL) {
1287 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1288 ni->ni_macaddr, "shared key response",
1289 "%s", "no challenge recorded");
1290 ic->ic_stats.is_rx_bad_auth++;
1291 estatus = IEEE80211_STATUS_CHALLENGE;
1292 goto bad;
1293 }
1294 if (memcmp(ni->ni_challenge, &challenge[2],
1295 challenge[1]) != 0) {
1296 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1297 ni->ni_macaddr, "shared key response",
1298 "%s", "challenge mismatch");
1299 ic->ic_stats.is_rx_auth_fail++;
1300 estatus = IEEE80211_STATUS_CHALLENGE;
1301 goto bad;
1302 }
1303 IEEE80211_DPRINTF(ic,
1304 IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1305 "[%s] station authenticated (shared key)\n",
1306 ether_sprintf(ni->ni_macaddr));
1307 ieee80211_node_authorize(ni);
1308 break;
1309 default:
1310 IEEE80211_DISCARD_MAC(ic, IEEE80211_MSG_AUTH,
1311 ni->ni_macaddr, "shared key auth",
1312 "bad seq %d", seq);
1313 ic->ic_stats.is_rx_bad_auth++;
1314 estatus = IEEE80211_STATUS_SEQUENCE;
1315 goto bad;
1316 }
1317 IEEE80211_SEND_MGMT(ic, ni,
1318 IEEE80211_FC0_SUBTYPE_AUTH, seq + 1);
1319 break;
1320
1321 case IEEE80211_M_STA:
1322 if (ic->ic_state != IEEE80211_S_AUTH)
1323 return;
1324 switch (seq) {
1325 case IEEE80211_AUTH_SHARED_PASS:
1326 if (ni->ni_challenge != NULL) {
1327 FREE(ni->ni_challenge, M_80211_NODE);
1328 ni->ni_challenge = NULL;
1329 }
1330 if (status != 0) {
1331 IEEE80211_DPRINTF(ic,
1332 IEEE80211_MSG_DEBUG | IEEE80211_MSG_AUTH,
1333 "[%s] shared key auth failed (reason %d)\n",
1334 ether_sprintf(ieee80211_getbssid(ic, wh)),
1335 status);
1336 /* XXX can this happen? */
1337 if (ni != ic->ic_bss)
1338 ni->ni_fails++;
1339 ic->ic_stats.is_rx_auth_fail++;
1340 return;
1341 }
1342 ieee80211_new_state(ic, IEEE80211_S_ASSOC, 0);
1343 break;
1344 case IEEE80211_AUTH_SHARED_CHALLENGE:
1345 if (!alloc_challenge(ic, ni))
1346 return;
1347 /* XXX could optimize by passing recvd challenge */
1348 memcpy(ni->ni_challenge, &challenge[2], challenge[1]);
1349 IEEE80211_SEND_MGMT(ic, ni,
1350 IEEE80211_FC0_SUBTYPE_AUTH, seq + 1);
1351 break;
1352 default:
1353 IEEE80211_DISCARD(ic, IEEE80211_MSG_AUTH,
1354 wh, "shared key auth", "bad seq %d", seq);
1355 ic->ic_stats.is_rx_bad_auth++;
1356 return;
1357 }
1358 break;
1359 }
1360 return;
1361bad:
1362 /*
1363 * Send an error response; but only when operating as an AP.
1364 */
1365 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
1366 /* XXX hack to workaround calling convention */
1367 ieee80211_send_error(ic, ni, wh->i_addr2,
1368 IEEE80211_FC0_SUBTYPE_AUTH,
1369 (seq + 1) | (estatus<<16));
1370 } else if (ic->ic_opmode == IEEE80211_M_STA) {
1371 /*
1372 * Kick the state machine. This short-circuits
1373 * using the mgt frame timeout to trigger the
1374 * state transition.
1375 */
1376 if (ic->ic_state == IEEE80211_S_AUTH)
1377 ieee80211_new_state(ic, IEEE80211_S_SCAN,
1378 IEEE80211_SCAN_FAIL_STATUS);
1379 }
1380}
1381
1382/* Verify the existence and length of __elem or get out. */
1383#define IEEE80211_VERIFY_ELEMENT(__elem, __maxlen) do { \
1384 if ((__elem) == NULL) { \
1385 IEEE80211_DISCARD(ic, IEEE80211_MSG_ELEMID, \
1386 wh, ieee80211_mgt_subtype_name[subtype >> \
1387 IEEE80211_FC0_SUBTYPE_SHIFT], \
1388 "%s", "no " #__elem ); \
1389 ic->ic_stats.is_rx_elem_missing++; \
1390 return; \
1391 } \
1392 if ((__elem)[1] > (__maxlen)) { \
1393 IEEE80211_DISCARD(ic, IEEE80211_MSG_ELEMID, \
1394 wh, ieee80211_mgt_subtype_name[subtype >> \
1395 IEEE80211_FC0_SUBTYPE_SHIFT], \
1396 "bad " #__elem " len %d", (__elem)[1]); \
1397 ic->ic_stats.is_rx_elem_toobig++; \
1398 return; \
1399 } \
1400} while (0)
1401
1402#define IEEE80211_VERIFY_LENGTH(_len, _minlen, _action) do { \
1403 if ((_len) < (_minlen)) { \
1404 IEEE80211_DISCARD(ic, IEEE80211_MSG_ELEMID, \
1405 wh, ieee80211_mgt_subtype_name[subtype >> \
1406 IEEE80211_FC0_SUBTYPE_SHIFT], \
1407 "ie too short, got %d, expected %d", \
1408 (_len), (_minlen)); \
1409 ic->ic_stats.is_rx_elem_toosmall++; \
1410 _action; \
1411 } \
1412} while (0)
1413
1414#ifdef IEEE80211_DEBUG
1415static void
1416ieee80211_ssid_mismatch(struct ieee80211com *ic, const char *tag,
1417 uint8_t mac[IEEE80211_ADDR_LEN], uint8_t *ssid)
1418{
1419 printf("[%s] discard %s frame, ssid mismatch: ",
1420 ether_sprintf(mac), tag);
1421 ieee80211_print_essid(ssid + 2, ssid[1]);
1422 printf("\n");
1423}
1424
1425#define IEEE80211_VERIFY_SSID(_ni, _ssid) do { \
1426 if ((_ssid)[1] != 0 && \
1427 ((_ssid)[1] != (_ni)->ni_esslen || \
1428 memcmp((_ssid) + 2, (_ni)->ni_essid, (_ssid)[1]) != 0)) { \
1429 if (ieee80211_msg_input(ic)) \
1430 ieee80211_ssid_mismatch(ic, \
1431 ieee80211_mgt_subtype_name[subtype >> \
1432 IEEE80211_FC0_SUBTYPE_SHIFT], \
1433 wh->i_addr2, _ssid); \
1434 ic->ic_stats.is_rx_ssidmismatch++; \
1435 return; \
1436 } \
1437} while (0)
1438#else /* !IEEE80211_DEBUG */
1439#define IEEE80211_VERIFY_SSID(_ni, _ssid) do { \
1440 if ((_ssid)[1] != 0 && \
1441 ((_ssid)[1] != (_ni)->ni_esslen || \
1442 memcmp((_ssid) + 2, (_ni)->ni_essid, (_ssid)[1]) != 0)) { \
1443 ic->ic_stats.is_rx_ssidmismatch++; \
1444 return; \
1445 } \
1446} while (0)
1447#endif /* !IEEE80211_DEBUG */
1448
1449/* unalligned little endian access */
1450#define LE_READ_2(p) \
1451 ((uint16_t) \
1452 ((((const uint8_t *)(p))[0] ) | \
1453 (((const uint8_t *)(p))[1] << 8)))
1454#define LE_READ_4(p) \
1455 ((uint32_t) \
1456 ((((const uint8_t *)(p))[0] ) | \
1457 (((const uint8_t *)(p))[1] << 8) | \
1458 (((const uint8_t *)(p))[2] << 16) | \
1459 (((const uint8_t *)(p))[3] << 24)))
1460
1461static __inline int
1462iswpaoui(const uint8_t *frm)
1463{
1464 return frm[1] > 3 && LE_READ_4(frm+2) == ((WPA_OUI_TYPE<<24)|WPA_OUI);
1465}
1466
1467static __inline int
1468iswmeoui(const uint8_t *frm)
1469{
1470 return frm[1] > 3 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI);
1471}
1472
1473static __inline int
1474iswmeparam(const uint8_t *frm)
1475{
1476 return frm[1] > 5 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI) &&
1477 frm[6] == WME_PARAM_OUI_SUBTYPE;
1478}
1479
1480static __inline int
1481iswmeinfo(const uint8_t *frm)
1482{
1483 return frm[1] > 5 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI) &&
1484 frm[6] == WME_INFO_OUI_SUBTYPE;
1485}
1486
1487static __inline int
1488isatherosoui(const uint8_t *frm)
1489{
1490 return frm[1] > 3 && LE_READ_4(frm+2) == ((ATH_OUI_TYPE<<24)|ATH_OUI);
1491}
1492
1493static __inline int
1494ishtcapoui(const uint8_t *frm)
1495{
1496 return frm[1] > 3 && LE_READ_4(frm+2) == ((BCM_OUI_HTCAP<<24)|BCM_OUI);
1497}
1498
1499static __inline int
1500ishtinfooui(const uint8_t *frm)
1501{
1502 return frm[1] > 3 && LE_READ_4(frm+2) == ((BCM_OUI_HTINFO<<24)|BCM_OUI);
1503}
1504
1505/*
1506 * Convert a WPA cipher selector OUI to an internal
1507 * cipher algorithm. Where appropriate we also
1508 * record any key length.
1509 */
1510static int
1511wpa_cipher(uint8_t *sel, uint8_t *keylen)
1512{
1513#define WPA_SEL(x) (((x)<<24)|WPA_OUI)
1514 uint32_t w = LE_READ_4(sel);
1515
1516 switch (w) {
1517 case WPA_SEL(WPA_CSE_NULL):
1518 return IEEE80211_CIPHER_NONE;
1519 case WPA_SEL(WPA_CSE_WEP40):
1520 if (keylen)
1521 *keylen = 40 / NBBY;
1522 return IEEE80211_CIPHER_WEP;
1523 case WPA_SEL(WPA_CSE_WEP104):
1524 if (keylen)
1525 *keylen = 104 / NBBY;
1526 return IEEE80211_CIPHER_WEP;
1527 case WPA_SEL(WPA_CSE_TKIP):
1528 return IEEE80211_CIPHER_TKIP;
1529 case WPA_SEL(WPA_CSE_CCMP):
1530 return IEEE80211_CIPHER_AES_CCM;
1531 }
1532 return 32; /* NB: so 1<< is discarded */
1533#undef WPA_SEL
1534}
1535
1536/*
1537 * Convert a WPA key management/authentication algorithm
1538 * to an internal code.
1539 */
1540static int
1541wpa_keymgmt(uint8_t *sel)
1542{
1543#define WPA_SEL(x) (((x)<<24)|WPA_OUI)
1544 uint32_t w = LE_READ_4(sel);
1545
1546 switch (w) {
1547 case WPA_SEL(WPA_ASE_8021X_UNSPEC):
1548 return WPA_ASE_8021X_UNSPEC;
1549 case WPA_SEL(WPA_ASE_8021X_PSK):
1550 return WPA_ASE_8021X_PSK;
1551 case WPA_SEL(WPA_ASE_NONE):
1552 return WPA_ASE_NONE;
1553 }
1554 return 0; /* NB: so is discarded */
1555#undef WPA_SEL
1556}
1557
1558/*
1559 * Parse a WPA information element to collect parameters
1560 * and validate the parameters against what has been
1561 * configured for the system.
1562 */
1563static int
1564ieee80211_parse_wpa(struct ieee80211com *ic, uint8_t *frm,
1565 struct ieee80211_rsnparms *rsn, const struct ieee80211_frame *wh)
1566{
1567 uint8_t len = frm[1];
1568 uint32_t w;
1569 int n;
1570
1571 /*
1572 * Check the length once for fixed parts: OUI, type,
1573 * version, mcast cipher, and 2 selector counts.
1574 * Other, variable-length data, must be checked separately.
1575 */
1576 if ((ic->ic_flags & IEEE80211_F_WPA1) == 0) {
1577 IEEE80211_DISCARD_IE(ic,
1578 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1579 wh, "WPA", "not WPA, flags 0x%x", ic->ic_flags);
1580 return IEEE80211_REASON_IE_INVALID;
1581 }
1582 if (len < 14) {
1583 IEEE80211_DISCARD_IE(ic,
1584 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1585 wh, "WPA", "too short, len %u", len);
1586 return IEEE80211_REASON_IE_INVALID;
1587 }
1588 frm += 6, len -= 4; /* NB: len is payload only */
1589 /* NB: iswapoui already validated the OUI and type */
1590 w = LE_READ_2(frm);
1591 if (w != WPA_VERSION) {
1592 IEEE80211_DISCARD_IE(ic,
1593 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1594 wh, "WPA", "bad version %u", w);
1595 return IEEE80211_REASON_IE_INVALID;
1596 }
1597 frm += 2, len -= 2;
1598
1599 /* multicast/group cipher */
1600 w = wpa_cipher(frm, &rsn->rsn_mcastkeylen);
1601 if (w != rsn->rsn_mcastcipher) {
1602 IEEE80211_DISCARD_IE(ic,
1603 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1604 wh, "WPA", "mcast cipher mismatch; got %u, expected %u",
1605 w, rsn->rsn_mcastcipher);
1606 return IEEE80211_REASON_IE_INVALID;
1607 }
1608 frm += 4, len -= 4;
1609
1610 /* unicast ciphers */
1611 n = LE_READ_2(frm);
1612 frm += 2, len -= 2;
1613 if (len < n*4+2) {
1614 IEEE80211_DISCARD_IE(ic,
1615 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1616 wh, "WPA", "ucast cipher data too short; len %u, n %u",
1617 len, n);
1618 return IEEE80211_REASON_IE_INVALID;
1619 }
1620 w = 0;
1621 for (; n > 0; n--) {
1622 w |= 1<<wpa_cipher(frm, &rsn->rsn_ucastkeylen);
1623 frm += 4, len -= 4;
1624 }
1625 w &= rsn->rsn_ucastcipherset;
1626 if (w == 0) {
1627 IEEE80211_DISCARD_IE(ic,
1628 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1629 wh, "WPA", "%s", "ucast cipher set empty");
1630 return IEEE80211_REASON_IE_INVALID;
1631 }
1632 if (w & (1<<IEEE80211_CIPHER_TKIP))
1633 rsn->rsn_ucastcipher = IEEE80211_CIPHER_TKIP;
1634 else
1635 rsn->rsn_ucastcipher = IEEE80211_CIPHER_AES_CCM;
1636
1637 /* key management algorithms */
1638 n = LE_READ_2(frm);
1639 frm += 2, len -= 2;
1640 if (len < n*4) {
1641 IEEE80211_DISCARD_IE(ic,
1642 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1643 wh, "WPA", "key mgmt alg data too short; len %u, n %u",
1644 len, n);
1645 return IEEE80211_REASON_IE_INVALID;
1646 }
1647 w = 0;
1648 for (; n > 0; n--) {
1649 w |= wpa_keymgmt(frm);
1650 frm += 4, len -= 4;
1651 }
1652 w &= rsn->rsn_keymgmtset;
1653 if (w == 0) {
1654 IEEE80211_DISCARD_IE(ic,
1655 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1656 wh, "WPA", "%s", "no acceptable key mgmt alg");
1657 return IEEE80211_REASON_IE_INVALID;
1658 }
1659 if (w & WPA_ASE_8021X_UNSPEC)
1660 rsn->rsn_keymgmt = WPA_ASE_8021X_UNSPEC;
1661 else
1662 rsn->rsn_keymgmt = WPA_ASE_8021X_PSK;
1663
1664 if (len > 2) /* optional capabilities */
1665 rsn->rsn_caps = LE_READ_2(frm);
1666
1667 return 0;
1668}
1669
1670/*
1671 * Convert an RSN cipher selector OUI to an internal
1672 * cipher algorithm. Where appropriate we also
1673 * record any key length.
1674 */
1675static int
1676rsn_cipher(uint8_t *sel, uint8_t *keylen)
1677{
1678#define RSN_SEL(x) (((x)<<24)|RSN_OUI)
1679 uint32_t w = LE_READ_4(sel);
1680
1681 switch (w) {
1682 case RSN_SEL(RSN_CSE_NULL):
1683 return IEEE80211_CIPHER_NONE;
1684 case RSN_SEL(RSN_CSE_WEP40):
1685 if (keylen)
1686 *keylen = 40 / NBBY;
1687 return IEEE80211_CIPHER_WEP;
1688 case RSN_SEL(RSN_CSE_WEP104):
1689 if (keylen)
1690 *keylen = 104 / NBBY;
1691 return IEEE80211_CIPHER_WEP;
1692 case RSN_SEL(RSN_CSE_TKIP):
1693 return IEEE80211_CIPHER_TKIP;
1694 case RSN_SEL(RSN_CSE_CCMP):
1695 return IEEE80211_CIPHER_AES_CCM;
1696 case RSN_SEL(RSN_CSE_WRAP):
1697 return IEEE80211_CIPHER_AES_OCB;
1698 }
1699 return 32; /* NB: so 1<< is discarded */
1700#undef WPA_SEL
1701}
1702
1703/*
1704 * Convert an RSN key management/authentication algorithm
1705 * to an internal code.
1706 */
1707static int
1708rsn_keymgmt(uint8_t *sel)
1709{
1710#define RSN_SEL(x) (((x)<<24)|RSN_OUI)
1711 uint32_t w = LE_READ_4(sel);
1712
1713 switch (w) {
1714 case RSN_SEL(RSN_ASE_8021X_UNSPEC):
1715 return RSN_ASE_8021X_UNSPEC;
1716 case RSN_SEL(RSN_ASE_8021X_PSK):
1717 return RSN_ASE_8021X_PSK;
1718 case RSN_SEL(RSN_ASE_NONE):
1719 return RSN_ASE_NONE;
1720 }
1721 return 0; /* NB: so is discarded */
1722#undef RSN_SEL
1723}
1724
1725/*
1726 * Parse a WPA/RSN information element to collect parameters
1727 * and validate the parameters against what has been
1728 * configured for the system.
1729 */
1730static int
1731ieee80211_parse_rsn(struct ieee80211com *ic, uint8_t *frm,
1732 struct ieee80211_rsnparms *rsn, const struct ieee80211_frame *wh)
1733{
1734 uint8_t len = frm[1];
1735 uint32_t w;
1736 int n;
1737
1738 /*
1739 * Check the length once for fixed parts:
1740 * version, mcast cipher, and 2 selector counts.
1741 * Other, variable-length data, must be checked separately.
1742 */
1743 if ((ic->ic_flags & IEEE80211_F_WPA2) == 0) {
1744 IEEE80211_DISCARD_IE(ic,
1745 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1746 wh, "WPA", "not RSN, flags 0x%x", ic->ic_flags);
1747 return IEEE80211_REASON_IE_INVALID;
1748 }
1749 if (len < 10) {
1750 IEEE80211_DISCARD_IE(ic,
1751 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1752 wh, "RSN", "too short, len %u", len);
1753 return IEEE80211_REASON_IE_INVALID;
1754 }
1755 frm += 2;
1756 w = LE_READ_2(frm);
1757 if (w != RSN_VERSION) {
1758 IEEE80211_DISCARD_IE(ic,
1759 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1760 wh, "RSN", "bad version %u", w);
1761 return IEEE80211_REASON_IE_INVALID;
1762 }
1763 frm += 2, len -= 2;
1764
1765 /* multicast/group cipher */
1766 w = rsn_cipher(frm, &rsn->rsn_mcastkeylen);
1767 if (w != rsn->rsn_mcastcipher) {
1768 IEEE80211_DISCARD_IE(ic,
1769 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1770 wh, "RSN", "mcast cipher mismatch; got %u, expected %u",
1771 w, rsn->rsn_mcastcipher);
1772 return IEEE80211_REASON_IE_INVALID;
1773 }
1774 frm += 4, len -= 4;
1775
1776 /* unicast ciphers */
1777 n = LE_READ_2(frm);
1778 frm += 2, len -= 2;
1779 if (len < n*4+2) {
1780 IEEE80211_DISCARD_IE(ic,
1781 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1782 wh, "RSN", "ucast cipher data too short; len %u, n %u",
1783 len, n);
1784 return IEEE80211_REASON_IE_INVALID;
1785 }
1786 w = 0;
1787 for (; n > 0; n--) {
1788 w |= 1<<rsn_cipher(frm, &rsn->rsn_ucastkeylen);
1789 frm += 4, len -= 4;
1790 }
1791 w &= rsn->rsn_ucastcipherset;
1792 if (w == 0) {
1793 IEEE80211_DISCARD_IE(ic,
1794 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1795 wh, "RSN", "%s", "ucast cipher set empty");
1796 return IEEE80211_REASON_IE_INVALID;
1797 }
1798 if (w & (1<<IEEE80211_CIPHER_TKIP))
1799 rsn->rsn_ucastcipher = IEEE80211_CIPHER_TKIP;
1800 else
1801 rsn->rsn_ucastcipher = IEEE80211_CIPHER_AES_CCM;
1802
1803 /* key management algorithms */
1804 n = LE_READ_2(frm);
1805 frm += 2, len -= 2;
1806 if (len < n*4) {
1807 IEEE80211_DISCARD_IE(ic,
1808 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1809 wh, "RSN", "key mgmt alg data too short; len %u, n %u",
1810 len, n);
1811 return IEEE80211_REASON_IE_INVALID;
1812 }
1813 w = 0;
1814 for (; n > 0; n--) {
1815 w |= rsn_keymgmt(frm);
1816 frm += 4, len -= 4;
1817 }
1818 w &= rsn->rsn_keymgmtset;
1819 if (w == 0) {
1820 IEEE80211_DISCARD_IE(ic,
1821 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WPA,
1822 wh, "RSN", "%s", "no acceptable key mgmt alg");
1823 return IEEE80211_REASON_IE_INVALID;
1824 }
1825 if (w & RSN_ASE_8021X_UNSPEC)
1826 rsn->rsn_keymgmt = RSN_ASE_8021X_UNSPEC;
1827 else
1828 rsn->rsn_keymgmt = RSN_ASE_8021X_PSK;
1829
1830 /* optional RSN capabilities */
1831 if (len > 2)
1832 rsn->rsn_caps = LE_READ_2(frm);
1833 /* XXXPMKID */
1834
1835 return 0;
1836}
1837
1838static int
1839ieee80211_parse_wmeparams(struct ieee80211com *ic, uint8_t *frm,
1840 const struct ieee80211_frame *wh)
1841{
1842#define MS(_v, _f) (((_v) & _f) >> _f##_S)
1843 struct ieee80211_wme_state *wme = &ic->ic_wme;
1844 u_int len = frm[1], qosinfo;
1845 int i;
1846
1847 if (len < sizeof(struct ieee80211_wme_param)-2) {
1848 IEEE80211_DISCARD_IE(ic,
1849 IEEE80211_MSG_ELEMID | IEEE80211_MSG_WME,
1850 wh, "WME", "too short, len %u", len);
1851 return -1;
1852 }
1853 qosinfo = frm[__offsetof(struct ieee80211_wme_param, param_qosInfo)];
1854 qosinfo &= WME_QOSINFO_COUNT;
1855 /* XXX do proper check for wraparound */
1856 if (qosinfo == wme->wme_wmeChanParams.cap_info)
1857 return 0;
1858 frm += __offsetof(struct ieee80211_wme_param, params_acParams);
1859 for (i = 0; i < WME_NUM_AC; i++) {
1860 struct wmeParams *wmep =
1861 &wme->wme_wmeChanParams.cap_wmeParams[i];
1862 /* NB: ACI not used */
1863 wmep->wmep_acm = MS(frm[0], WME_PARAM_ACM);
1864 wmep->wmep_aifsn = MS(frm[0], WME_PARAM_AIFSN);
1865 wmep->wmep_logcwmin = MS(frm[1], WME_PARAM_LOGCWMIN);
1866 wmep->wmep_logcwmax = MS(frm[1], WME_PARAM_LOGCWMAX);
1867 wmep->wmep_txopLimit = LE_READ_2(frm+2);
1868 frm += 4;
1869 }
1870 wme->wme_wmeChanParams.cap_info = qosinfo;
1871 return 1;
1872#undef MS
1873}
1874
1875static int
1876ieee80211_parse_athparams(struct ieee80211_node *ni, uint8_t *frm,
1877 const struct ieee80211_frame *wh)
1878{
1879 struct ieee80211com *ic = ni->ni_ic;
1880 const struct ieee80211_ath_ie *ath;
1881 u_int len = frm[1];
1882 int capschanged;
1883 uint16_t defkeyix;
1884
1885 if (len < sizeof(struct ieee80211_ath_ie)-2) {
1886 IEEE80211_DISCARD_IE(ic,
1887 IEEE80211_MSG_ELEMID | IEEE80211_MSG_SUPERG,
1888 wh, "Atheros", "too short, len %u", len);
1889 return -1;
1890 }
1891 ath = (const struct ieee80211_ath_ie *)frm;
1892 capschanged = (ni->ni_ath_flags != ath->ath_capability);
1893 defkeyix = LE_READ_2(ath->ath_defkeyix);
1894 if (capschanged || defkeyix != ni->ni_ath_defkeyix) {
1895 ni->ni_ath_flags = ath->ath_capability;
1896 ni->ni_ath_defkeyix = defkeyix;
1897 IEEE80211_DPRINTF(ic, IEEE80211_MSG_SUPERG,
1898 "[%s] ath ie change: new caps 0x%x defkeyix 0x%x\n",
1899 ether_sprintf(ni->ni_macaddr),
1900 ni->ni_ath_flags, ni->ni_ath_defkeyix);
1901 }
1902 if (IEEE80211_ATH_CAP(ic, ni, ATHEROS_CAP_TURBO_PRIME)) {
1903 uint16_t curflags, newflags;
1904
1905 /*
1906 * Check for turbo mode switch. Calculate flags
1907 * for the new mode and effect the switch.
1908 */
1909 newflags = curflags = ic->ic_bsschan->ic_flags;
1910 /* NB: BOOST is not in ic_flags, so get it from the ie */
1911 if (ath->ath_capability & ATHEROS_CAP_BOOST)
1912 newflags |= IEEE80211_CHAN_TURBO;
1913 else
1914 newflags &= ~IEEE80211_CHAN_TURBO;
1915 if (newflags != curflags)
1916 ieee80211_dturbo_switch(ic, newflags);
1917 }
1918 return capschanged;
1919}
1920
1921void
1922ieee80211_saveath(struct ieee80211_node *ni, uint8_t *ie)
1923{
1924 const struct ieee80211_ath_ie *ath =
1925 (const struct ieee80211_ath_ie *) ie;
1926
1927 ni->ni_ath_flags = ath->ath_capability;
1928 ni->ni_ath_defkeyix = LE_READ_2(&ath->ath_defkeyix);
1929 ieee80211_saveie(&ni->ni_ath_ie, ie);
1930}
1931
1932void
1933ieee80211_saveie(uint8_t **iep, const uint8_t *ie)
1934{
1935 u_int ielen = ie[1]+2;
1936 /*
1937 * Record information element for later use.
1938 */
1939 if (*iep == NULL || (*iep)[1] != ie[1]) {
1940 if (*iep != NULL)
1941 FREE(*iep, M_80211_NODE);
1942 MALLOC(*iep, void*, ielen, M_80211_NODE, M_NOWAIT);
1943 }
1944 if (*iep != NULL)
1945 memcpy(*iep, ie, ielen);
1946 /* XXX note failure */
1947}
1948
1949/* XXX find a better place for definition */
1950struct l2_update_frame {
1951 struct ether_header eh;
1952 uint8_t dsap;
1953 uint8_t ssap;
1954 uint8_t control;
1955 uint8_t xid[3];
1956} __packed;
1957
1958/*
1959 * Deliver a TGf L2UF frame on behalf of a station.
1960 * This primes any bridge when the station is roaming
1961 * between ap's on the same wired network.
1962 */
1963static void
1964ieee80211_deliver_l2uf(struct ieee80211_node *ni)
1965{
1966 struct ieee80211com *ic = ni->ni_ic;
1967 struct ifnet *ifp = ic->ic_ifp;
1968 struct mbuf *m;
1969 struct l2_update_frame *l2uf;
1970 struct ether_header *eh;
1971
1972 m = m_gethdr(M_NOWAIT, MT_DATA);
1973 if (m == NULL) {
1974 IEEE80211_NOTE(ic, IEEE80211_MSG_ASSOC, ni,
1975 "%s", "no mbuf for l2uf frame");
1976 ic->ic_stats.is_rx_nobuf++; /* XXX not right */
1977 return;
1978 }
1979 l2uf = mtod(m, struct l2_update_frame *);
1980 eh = &l2uf->eh;
1981 /* dst: Broadcast address */
1982 IEEE80211_ADDR_COPY(eh->ether_dhost, ifp->if_broadcastaddr);
1983 /* src: associated STA */
1984 IEEE80211_ADDR_COPY(eh->ether_shost, ni->ni_macaddr);
1985 eh->ether_type = htons(sizeof(*l2uf) - sizeof(*eh));
1986
1987 l2uf->dsap = 0;
1988 l2uf->ssap = 0;
1989 l2uf->control = 0xf5;
1990 l2uf->xid[0] = 0x81;
1991 l2uf->xid[1] = 0x80;
1992 l2uf->xid[2] = 0x00;
1993
1994 m->m_pkthdr.len = m->m_len = sizeof(*l2uf);
1995 ieee80211_deliver_data(ic, ni, m);
1996}
1997
1998static __inline int
1999contbgscan(struct ieee80211com *ic)
2000{
2001 return ((ic->ic_flags_ext & IEEE80211_FEXT_BGSCAN) &&
2002 time_after(ticks, ic->ic_lastdata + ic->ic_bgscanidle));
2003}
2004
2005static __inline int
2006startbgscan(struct ieee80211com *ic)
2007{
2008 return ((ic->ic_flags & IEEE80211_F_BGSCAN) &&
2009 !IEEE80211_IS_CHAN_DTURBO(ic->ic_curchan) &&
2010 time_after(ticks, ic->ic_lastscan + ic->ic_bgscanintvl) &&
2011 time_after(ticks, ic->ic_lastdata + ic->ic_bgscanidle));
2012}
2013
2014static void
2015ratesetmismatch(struct ieee80211_node *ni, const struct ieee80211_frame *wh,
2016 int reassoc, int resp, const char *tag, int rate)
2017{
2018 struct ieee80211com *ic = ni->ni_ic;
2019
2020 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
2021 "[%s] deny %s request, %s rate set mismatch, rate 0x%x\n",
2022 ether_sprintf(wh->i_addr2),
2023 reassoc ? "reassoc" : "assoc", tag, rate);
2024 IEEE80211_SEND_MGMT(ic, ni, resp, IEEE80211_STATUS_BASIC_RATE);
2025 ieee80211_node_leave(ic, ni);
2026 ic->ic_stats.is_rx_assoc_norate++;
2027}
2028
2029static void
2030capinfomismatch(struct ieee80211_node *ni, const struct ieee80211_frame *wh,
2031 int reassoc, int resp, const char *tag, int capinfo)
2032{
2033 struct ieee80211com *ic = ni->ni_ic;
2034
2035 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
2036 "[%s] deny %s request, %s mismatch 0x%x\n",
2037 ether_sprintf(wh->i_addr2),
2038 reassoc ? "reassoc" : "assoc", tag, capinfo);
2039 IEEE80211_SEND_MGMT(ic, ni, resp, IEEE80211_STATUS_CAPINFO);
2040 ieee80211_node_leave(ic, ni);
2041 ic->ic_stats.is_rx_assoc_capmismatch++;
2042}
2043
2044static void
2045htcapmismatch(struct ieee80211_node *ni, const struct ieee80211_frame *wh,
2046 int reassoc, int resp)
2047{
2048 struct ieee80211com *ic = ni->ni_ic;
2049
2050 IEEE80211_NOTE_MAC(ic, IEEE80211_MSG_ANY, wh->i_addr2,
2051 "deny %s request, %s missing HT ie", reassoc ? "reassoc" : "assoc");
2052 /* XXX no better code */
2053 IEEE80211_SEND_MGMT(ic, ni, resp, IEEE80211_STATUS_OTHER);
2054 ieee80211_node_leave(ic, ni);
2055}
2056
2057void
2058ieee80211_recv_mgmt(struct ieee80211com *ic, struct mbuf *m0,
2059 struct ieee80211_node *ni,
2060 int subtype, int rssi, int noise, uint32_t rstamp)
2061{
2062#define ISPROBE(_st) ((_st) == IEEE80211_FC0_SUBTYPE_PROBE_RESP)
2063#define ISREASSOC(_st) ((_st) == IEEE80211_FC0_SUBTYPE_REASSOC_RESP)
2064 struct ieee80211_frame *wh;
2065 uint8_t *frm, *efrm;
2066 uint8_t *ssid, *rates, *xrates, *wpa, *rsn, *wme, *ath, *htcap, *htinfo;
2067 int reassoc, resp, allocbs;
2068 uint8_t rate;
2069
2070 wh = mtod(m0, struct ieee80211_frame *);
2071 frm = (uint8_t *)&wh[1];
2072 efrm = mtod(m0, uint8_t *) + m0->m_len;
2073 switch (subtype) {
2074 case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
2075 case IEEE80211_FC0_SUBTYPE_BEACON: {
2076 struct ieee80211_scanparams scan;
2077
2078 /*
2079 * We process beacon/probe response frames:
2080 * o when scanning, or
2081 * o station mode when associated (to collect state
2082 * updates such as 802.11g slot time), or
2083 * o adhoc mode (to discover neighbors)
2084 * Frames otherwise received are discarded.
2085 */
2086 if (!((ic->ic_flags & IEEE80211_F_SCAN) ||
2087 (ic->ic_opmode == IEEE80211_M_STA && ni->ni_associd) ||
2088 ic->ic_opmode == IEEE80211_M_IBSS)) {
2089 ic->ic_stats.is_rx_mgtdiscard++;
2090 return;
2091 }
2092 /*
2093 * beacon/probe response frame format
2094 * [8] time stamp
2095 * [2] beacon interval
2096 * [2] capability information
2097 * [tlv] ssid
2098 * [tlv] supported rates
2099 * [tlv] country information
2100 * [tlv] parameter set (FH/DS)
2101 * [tlv] erp information
2102 * [tlv] extended supported rates
2103 * [tlv] WME
2104 * [tlv] WPA or RSN
2105 * [tlv] HT capabilities
2106 * [tlv] HT information
2107 * [tlv] Atheros capabilities
2108 */
2109 IEEE80211_VERIFY_LENGTH(efrm - frm, 12, return);
2110 memset(&scan, 0, sizeof(scan));
2111 scan.tstamp = frm; frm += 8;
2112 scan.bintval = le16toh(*(uint16_t *)frm); frm += 2;
2113 scan.capinfo = le16toh(*(uint16_t *)frm); frm += 2;
2114 scan.bchan = IEEE80211_CHAN2IEEE(ic->ic_curchan);
2115 scan.curchan = ic->ic_curchan;
2116
2117 while (efrm - frm > 1) {
2118 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2, return);
2119 switch (*frm) {
2120 case IEEE80211_ELEMID_SSID:
2121 scan.ssid = frm;
2122 break;
2123 case IEEE80211_ELEMID_RATES:
2124 scan.rates = frm;
2125 break;
2126 case IEEE80211_ELEMID_COUNTRY:
2127 scan.country = frm;
2128 break;
2129 case IEEE80211_ELEMID_FHPARMS:
2130 if (ic->ic_phytype == IEEE80211_T_FH) {
2131 scan.fhdwell = LE_READ_2(&frm[2]);
2132 scan.bchan = IEEE80211_FH_CHAN(frm[4], frm[5]);
2133 scan.fhindex = frm[6];
2134 }
2135 break;
2136 case IEEE80211_ELEMID_DSPARMS:
2137 /*
2138 * XXX hack this since depending on phytype
2139 * is problematic for multi-mode devices.
2140 */
2141 if (ic->ic_phytype != IEEE80211_T_FH)
2142 scan.bchan = frm[2];
2143 break;
2144 case IEEE80211_ELEMID_TIM:
2145 /* XXX ATIM? */
2146 scan.tim = frm;
2147 scan.timoff = frm - mtod(m0, uint8_t *);
2148 break;
2149 case IEEE80211_ELEMID_IBSSPARMS:
2150 break;
2151 case IEEE80211_ELEMID_XRATES:
2152 scan.xrates = frm;
2153 break;
2154 case IEEE80211_ELEMID_ERP:
2155 if (frm[1] != 1) {
2156 IEEE80211_DISCARD_IE(ic,
2157 IEEE80211_MSG_ELEMID, wh, "ERP",
2158 "bad len %u", frm[1]);
2159 ic->ic_stats.is_rx_elem_toobig++;
2160 break;
2161 }
2162 scan.erp = frm[2];
2163 break;
2164 case IEEE80211_ELEMID_HTCAP:
2165 scan.htcap = frm;
2166 break;
2167 case IEEE80211_ELEMID_RSN:
2168 scan.rsn = frm;
2169 break;
2170 case IEEE80211_ELEMID_HTINFO:
2171 scan.htinfo = frm;
2172 break;
2173 case IEEE80211_ELEMID_VENDOR:
2174 if (iswpaoui(frm))
2175 scan.wpa = frm;
2176 else if (iswmeparam(frm) || iswmeinfo(frm))
2177 scan.wme = frm;
2178 else if (isatherosoui(frm))
2179 scan.ath = frm;
2180 else if (ic->ic_flags_ext & IEEE80211_FEXT_HTCOMPAT) {
2181 /*
2182 * Accept pre-draft HT ie's if the
2183 * standard ones have not been seen.
2184 */
2185 if (ishtcapoui(frm)) {
2186 if (scan.htcap == NULL)
2187 scan.htcap = frm;
2188 } else if (ishtinfooui(frm)) {
2189 if (scan.htinfo == NULL)
2190 scan.htcap = frm;
2191 }
2192 }
2193 break;
2194 default:
2195 IEEE80211_DISCARD_IE(ic, IEEE80211_MSG_ELEMID,
2196 wh, "unhandled",
2197 "id %u, len %u", *frm, frm[1]);
2198 ic->ic_stats.is_rx_elem_unknown++;
2199 break;
2200 }
2201 frm += frm[1] + 2;
2202 }
2203 IEEE80211_VERIFY_ELEMENT(scan.rates, IEEE80211_RATE_MAXSIZE);
2204 if (scan.xrates != NULL)
2205 IEEE80211_VERIFY_ELEMENT(scan.xrates,
2206 IEEE80211_RATE_MAXSIZE - scan.rates[1]);
2207 IEEE80211_VERIFY_ELEMENT(scan.ssid, IEEE80211_NWID_LEN);
2208#if IEEE80211_CHAN_MAX < 255
2209 if (scan.chan > IEEE80211_CHAN_MAX) {
2210 IEEE80211_DISCARD(ic, IEEE80211_MSG_ELEMID,
2211 wh, ieee80211_mgt_subtype_name[subtype >>
2212 IEEE80211_FC0_SUBTYPE_SHIFT],
2213 "invalid channel %u", scan.chan);
2214 ic->ic_stats.is_rx_badchan++;
2215 return;
2216 }
2217#endif
2218 if (IEEE80211_CHAN2IEEE(scan.curchan) != scan.bchan &&
2219 ic->ic_phytype != IEEE80211_T_FH) {
2220 /*
2221 * Frame was received on a channel different from the
2222 * one indicated in the DS params element id;
2223 * silently discard it.
2224 *
2225 * NB: this can happen due to signal leakage.
2226 * But we should take it for FH phy because
2227 * the rssi value should be correct even for
2228 * different hop pattern in FH.
2229 */
2230 IEEE80211_DISCARD(ic,
2231 IEEE80211_MSG_ELEMID | IEEE80211_MSG_INPUT,
2232 wh, ieee80211_mgt_subtype_name[subtype >>
2233 IEEE80211_FC0_SUBTYPE_SHIFT],
2234 "for off-channel %u",
2235 IEEE80211_CHAN2IEEE(scan.curchan));
2236 ic->ic_stats.is_rx_chanmismatch++;
2237 return;
2238 }
2239 if (!(IEEE80211_BINTVAL_MIN <= scan.bintval &&
2240 scan.bintval <= IEEE80211_BINTVAL_MAX)) {
2241 IEEE80211_DISCARD(ic,
2242 IEEE80211_MSG_ELEMID | IEEE80211_MSG_INPUT,
2243 wh, ieee80211_mgt_subtype_name[subtype >>
2244 IEEE80211_FC0_SUBTYPE_SHIFT],
2245 "bogus beacon interval", scan.bintval);
2246 ic->ic_stats.is_rx_badbintval++;
2247 return;
2248 }
2249 /*
2250 * Process HT ie's. This is complicated by our
2251 * accepting both the standard ie's and the pre-draft
2252 * vendor OUI ie's that some vendors still use/require.
2253 */
2254 if (scan.htcap != NULL) {
2255 IEEE80211_VERIFY_LENGTH(scan.htcap[1],
2256 scan.htcap[0] == IEEE80211_ELEMID_VENDOR ?
2257 4 + sizeof(struct ieee80211_ie_htcap)-2 :
2258 sizeof(struct ieee80211_ie_htcap)-2,
2259 scan.htcap = NULL);
2260 }
2261 if (scan.htinfo != NULL) {
2262 IEEE80211_VERIFY_LENGTH(scan.htinfo[1],
2263 scan.htinfo[0] == IEEE80211_ELEMID_VENDOR ?
2264 4 + sizeof(struct ieee80211_ie_htinfo)-2 :
2265 sizeof(struct ieee80211_ie_htinfo)-2,
2266 scan.htinfo = NULL);
2267 }
2268
2269 /*
2270 * Count frame now that we know it's to be processed.
2271 */
2272 if (subtype == IEEE80211_FC0_SUBTYPE_BEACON) {
2273 ic->ic_stats.is_rx_beacon++; /* XXX remove */
2274 IEEE80211_NODE_STAT(ni, rx_beacons);
2275 } else
2276 IEEE80211_NODE_STAT(ni, rx_proberesp);
2277
2278 /*
2279 * When operating in station mode, check for state updates.
2280 * Be careful to ignore beacons received while doing a
2281 * background scan. We consider only 11g/WMM stuff right now.
2282 */
2283 if (ic->ic_opmode == IEEE80211_M_STA &&
2284 ni->ni_associd != 0 &&
2285 ((ic->ic_flags & IEEE80211_F_SCAN) == 0 ||
2286 IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_bssid))) {
2287 /* record tsf of last beacon */
2288 memcpy(ni->ni_tstamp.data, scan.tstamp,
2289 sizeof(ni->ni_tstamp));
2290 /* count beacon frame for s/w bmiss handling */
2291 ic->ic_swbmiss_count++;
2292 ic->ic_bmiss_count = 0;
2293 if (ni->ni_erp != scan.erp) {
2294 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
2295 "[%s] erp change: was 0x%x, now 0x%x\n",
2296 ether_sprintf(wh->i_addr2),
2297 ni->ni_erp, scan.erp);
2298 if (IEEE80211_IS_CHAN_ANYG(ic->ic_curchan) &&
2299 (ni->ni_erp & IEEE80211_ERP_USE_PROTECTION))
2300 ic->ic_flags |= IEEE80211_F_USEPROT;
2301 else
2302 ic->ic_flags &= ~IEEE80211_F_USEPROT;
2303 ni->ni_erp = scan.erp;
2304 /* XXX statistic */
2305 }
2306 if ((ni->ni_capinfo ^ scan.capinfo) & IEEE80211_CAPINFO_SHORT_SLOTTIME) {
2307 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
2308 "[%s] capabilities change: before 0x%x,"
2309 " now 0x%x\n",
2310 ether_sprintf(wh->i_addr2),
2311 ni->ni_capinfo, scan.capinfo);
2312 /*
2313 * NB: we assume short preamble doesn't
2314 * change dynamically
2315 */
2316 ieee80211_set_shortslottime(ic,
2317 IEEE80211_IS_CHAN_A(ic->ic_bsschan) ||
2318 (scan.capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME));
2319 ni->ni_capinfo = (ni->ni_capinfo &~ IEEE80211_CAPINFO_SHORT_SLOTTIME)
2320 | (scan.capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME);
2321 /* XXX statistic */
2322 }
2323 if (scan.wme != NULL &&
2324 (ni->ni_flags & IEEE80211_NODE_QOS) &&
2325 ieee80211_parse_wmeparams(ic, scan.wme, wh) > 0)
2326 ieee80211_wme_updateparams(ic);
2327 if (scan.ath != NULL)
2328 ieee80211_parse_athparams(ni, scan.ath, wh);
2329 if (scan.htcap != NULL)
2330 ieee80211_parse_htcap(ni, scan.htcap);
2331 if (scan.htinfo != NULL) {
2332 ieee80211_parse_htinfo(ni, scan.htinfo);
2333 if (ni->ni_chan != ic->ic_bsschan) {
2334 /*
2335 * Channel has been adjusted based on
2336 * negotiated HT parameters; force the
2337 * channel state to follow.
2338 */
2339 ieee80211_setbsschan(ic, ni->ni_chan);
2340 }
2341 }
2342 if (scan.tim != NULL) {
2343 struct ieee80211_tim_ie *tim =
2344 (struct ieee80211_tim_ie *) scan.tim;
2345#if 0
2346 int aid = IEEE80211_AID(ni->ni_associd);
2347 int ix = aid / NBBY;
2348 int min = tim->tim_bitctl &~ 1;
2349 int max = tim->tim_len + min - 4;
2350 if ((tim->tim_bitctl&1) ||
2351 (min <= ix && ix <= max &&
2352 isset(tim->tim_bitmap - min, aid))) {
2353 /*
2354 * XXX Do not let bg scan kick off
2355 * we are expecting data.
2356 */
2357 ic->ic_lastdata = ticks;
2358 ieee80211_sta_pwrsave(ic, 0);
2359 }
2360#endif
2361 ni->ni_dtim_count = tim->tim_count;
2362 ni->ni_dtim_period = tim->tim_period;
2363 }
2364 /*
2365 * If scanning, pass the info to the scan module.
2366 * Otherwise, check if it's the right time to do
2367 * a background scan. Background scanning must
2368 * be enabled and we must not be operating in the
2369 * turbo phase of dynamic turbo mode. Then,
2370 * it's been a while since the last background
2371 * scan and if no data frames have come through
2372 * recently, kick off a scan. Note that this
2373 * is the mechanism by which a background scan
2374 * is started _and_ continued each time we
2375 * return on-channel to receive a beacon from
2376 * our ap.
2377 */
2378 if (ic->ic_flags & IEEE80211_F_SCAN) {
2379 ieee80211_add_scan(ic, &scan, wh,
2380 subtype, rssi, noise, rstamp);
2381 } else if (contbgscan(ic)) {
2382 ieee80211_bg_scan(ic);
2383 } else if (startbgscan(ic)) {
2384#if 0
2385 /* wakeup if we are sleeing */
2386 ieee80211_set_pwrsave(ic, 0);
2387#endif
2388 ieee80211_bg_scan(ic);
2389 }
2390 return;
2391 }
2392 /*
2393 * If scanning, just pass information to the scan module.
2394 */
2395 if (ic->ic_flags & IEEE80211_F_SCAN) {
2396 if (ic->ic_flags_ext & IEEE80211_FEXT_PROBECHAN) {
2397 /*
2398 * Actively scanning a channel marked passive;
2399 * send a probe request now that we know there
2400 * is 802.11 traffic present.
2401 *
2402 * XXX check if the beacon we recv'd gives
2403 * us what we need and suppress the probe req
2404 */
2405 ieee80211_probe_curchan(ic, 1);
2406 ic->ic_flags_ext &= ~IEEE80211_FEXT_PROBECHAN;
2407 }
2408 ieee80211_add_scan(ic, &scan, wh,
2409 subtype, rssi, noise, rstamp);
2410 return;
2411 }
2412 if (scan.capinfo & IEEE80211_CAPINFO_IBSS) {
2413 if (!IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) {
2414 /*
2415 * Create a new entry in the neighbor table.
2416 */
2417 ni = ieee80211_add_neighbor(ic, wh, &scan);
2418 } else if (ni->ni_capinfo == 0) {
2419 /*
2420 * Update faked node created on transmit.
2421 * Note this also updates the tsf.
2422 */
2423 ieee80211_init_neighbor(ni, wh, &scan);
2424 } else {
2425 /*
2426 * Record tsf for potential resync.
2427 */
2428 memcpy(ni->ni_tstamp.data, scan.tstamp,
2429 sizeof(ni->ni_tstamp));
2430 }
2431 if (ni != NULL) {
2432 ni->ni_rssi = rssi;
2433 ni->ni_noise = noise;
2434 ni->ni_rstamp = rstamp;
2435 }
2436 }
2437 break;
2438 }
2439
2440 case IEEE80211_FC0_SUBTYPE_PROBE_REQ:
2441 if (ic->ic_opmode == IEEE80211_M_STA ||
2442 ic->ic_state != IEEE80211_S_RUN) {
2443 ic->ic_stats.is_rx_mgtdiscard++;
2444 return;
2445 }
2446 if (IEEE80211_IS_MULTICAST(wh->i_addr2)) {
2447 /* frame must be directed */
2448 ic->ic_stats.is_rx_mgtdiscard++; /* XXX stat */
2449 return;
2450 }
2451
2452 /*
2453 * prreq frame format
2454 * [tlv] ssid
2455 * [tlv] supported rates
2456 * [tlv] extended supported rates
2457 * [tlv] Atheros capabilities
2458 */
2459 ssid = rates = xrates = ath = NULL;
2460 while (efrm - frm > 1) {
2461 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2, return);
2462 switch (*frm) {
2463 case IEEE80211_ELEMID_SSID:
2464 ssid = frm;
2465 break;
2466 case IEEE80211_ELEMID_RATES:
2467 rates = frm;
2468 break;
2469 case IEEE80211_ELEMID_XRATES:
2470 xrates = frm;
2471 break;
2472 case IEEE80211_ELEMID_VENDOR:
2473 if (isatherosoui(frm))
2474 ath = frm;
2475 break;
2476 }
2477 frm += frm[1] + 2;
2478 }
2479 IEEE80211_VERIFY_ELEMENT(rates, IEEE80211_RATE_MAXSIZE);
2480 if (xrates != NULL)
2481 IEEE80211_VERIFY_ELEMENT(xrates,
2482 IEEE80211_RATE_MAXSIZE - rates[1]);
2483 IEEE80211_VERIFY_ELEMENT(ssid, IEEE80211_NWID_LEN);
2484 IEEE80211_VERIFY_SSID(ic->ic_bss, ssid);
2485 if ((ic->ic_flags & IEEE80211_F_HIDESSID) && ssid[1] == 0) {
2486 IEEE80211_DISCARD(ic, IEEE80211_MSG_INPUT,
2487 wh, ieee80211_mgt_subtype_name[subtype >>
2488 IEEE80211_FC0_SUBTYPE_SHIFT],
2489 "%s", "no ssid with ssid suppression enabled");
2490 ic->ic_stats.is_rx_ssidmismatch++; /*XXX*/
2491 return;
2492 }
2493
2494 allocbs = 0;
2495 if (ni == ic->ic_bss) {
2496 if (ic->ic_opmode != IEEE80211_M_IBSS) {
2497 ni = ieee80211_tmp_node(ic, wh->i_addr2);
2498 allocbs = 1;
2499 } else if (!IEEE80211_ADDR_EQ(wh->i_addr2, ni->ni_macaddr)) {
2500 /*
2501 * XXX Cannot tell if the sender is operating
2502 * in ibss mode. But we need a new node to
2503 * send the response so blindly add them to the
2504 * neighbor table.
2505 */
2506 ni = ieee80211_fakeup_adhoc_node(&ic->ic_sta,
2507 wh->i_addr2);
2508 }
2509 if (ni == NULL)
2510 return;
2511 }
2512 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
2513 "[%s] recv probe req\n", ether_sprintf(wh->i_addr2));
2514 ni->ni_rssi = rssi;
2515 ni->ni_rstamp = rstamp;
2516 rate = ieee80211_setup_rates(ni, rates, xrates,
2517 IEEE80211_F_DOSORT | IEEE80211_F_DOFRATE
2518 | IEEE80211_F_DONEGO | IEEE80211_F_DODEL);
2519 if (rate & IEEE80211_RATE_BASIC) {
2520 IEEE80211_DISCARD(ic, IEEE80211_MSG_XRATE,
2521 wh, ieee80211_mgt_subtype_name[subtype >>
2522 IEEE80211_FC0_SUBTYPE_SHIFT],
2523 "%s", "recv'd rate set invalid");
2524 } else {
2525 IEEE80211_SEND_MGMT(ic, ni,
2526 IEEE80211_FC0_SUBTYPE_PROBE_RESP, 0);
2527 }
2528 if (allocbs) {
2529 /*
2530 * Temporary node created just to send a
2531 * response, reclaim immediately.
2532 */
2533 ieee80211_free_node(ni);
2534 } else if (ath != NULL)
2535 ieee80211_saveath(ni, ath);
2536 break;
2537
2538 case IEEE80211_FC0_SUBTYPE_AUTH: {
2539 uint16_t algo, seq, status;
2540 /*
2541 * auth frame format
2542 * [2] algorithm
2543 * [2] sequence
2544 * [2] status
2545 * [tlv*] challenge
2546 */
2547 IEEE80211_VERIFY_LENGTH(efrm - frm, 6, return);
2548 algo = le16toh(*(uint16_t *)frm);
2549 seq = le16toh(*(uint16_t *)(frm + 2));
2550 status = le16toh(*(uint16_t *)(frm + 4));
2551 IEEE80211_DPRINTF(ic, IEEE80211_MSG_AUTH,
2552 "[%s] recv auth frame with algorithm %d seq %d\n",
2553 ether_sprintf(wh->i_addr2), algo, seq);
2554 /*
2555 * Consult the ACL policy module if setup.
2556 */
2557 if (ic->ic_acl != NULL &&
2558 !ic->ic_acl->iac_check(ic, wh->i_addr2)) {
2559 IEEE80211_DISCARD(ic, IEEE80211_MSG_ACL,
2560 wh, "auth", "%s", "disallowed by ACL");
2561 ic->ic_stats.is_rx_acl++;
2562 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
2563 IEEE80211_SEND_MGMT(ic, ni,
2564 IEEE80211_FC0_SUBTYPE_AUTH,
2565 (seq+1) | (IEEE80211_STATUS_UNSPECIFIED<<16));
2566 }
2567 return;
2568 }
2569 if (ic->ic_flags & IEEE80211_F_COUNTERM) {
2570 IEEE80211_DISCARD(ic,
2571 IEEE80211_MSG_AUTH | IEEE80211_MSG_CRYPTO,
2572 wh, "auth", "%s", "TKIP countermeasures enabled");
2573 ic->ic_stats.is_rx_auth_countermeasures++;
2574 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
2575 IEEE80211_SEND_MGMT(ic, ni,
2576 IEEE80211_FC0_SUBTYPE_AUTH,
2577 IEEE80211_REASON_MIC_FAILURE);
2578 }
2579 return;
2580 }
2581 if (algo == IEEE80211_AUTH_ALG_SHARED)
2582 ieee80211_auth_shared(ic, wh, frm + 6, efrm, ni, rssi,
2583 noise, rstamp, seq, status);
2584 else if (algo == IEEE80211_AUTH_ALG_OPEN)
2585 ieee80211_auth_open(ic, wh, ni, rssi, noise, rstamp,
2586 seq, status);
2587 else {
2588 IEEE80211_DISCARD(ic, IEEE80211_MSG_ANY,
2589 wh, "auth", "unsupported alg %d", algo);
2590 ic->ic_stats.is_rx_auth_unsupported++;
2591 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
2592 /* XXX not right */
2593 IEEE80211_SEND_MGMT(ic, ni,
2594 IEEE80211_FC0_SUBTYPE_AUTH,
2595 (seq+1) | (IEEE80211_STATUS_ALG<<16));
2596 }
2597 return;
2598 }
2599 break;
2600 }
2601
2602 case IEEE80211_FC0_SUBTYPE_ASSOC_REQ:
2603 case IEEE80211_FC0_SUBTYPE_REASSOC_REQ: {
2604 uint16_t capinfo, lintval;
2605 struct ieee80211_rsnparms rsnparms;
2606 uint8_t reason;
2607 int badwparsn;
2608
2609 if (ic->ic_opmode != IEEE80211_M_HOSTAP ||
2610 ic->ic_state != IEEE80211_S_RUN) {
2611 ic->ic_stats.is_rx_mgtdiscard++;
2612 return;
2613 }
2614
2615 if (subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) {
2616 reassoc = 1;
2617 resp = IEEE80211_FC0_SUBTYPE_REASSOC_RESP;
2618 } else {
2619 reassoc = 0;
2620 resp = IEEE80211_FC0_SUBTYPE_ASSOC_RESP;
2621 }
2622 /*
2623 * asreq frame format
2624 * [2] capability information
2625 * [2] listen interval
2626 * [6*] current AP address (reassoc only)
2627 * [tlv] ssid
2628 * [tlv] supported rates
2629 * [tlv] extended supported rates
2630 * [tlv] WPA or RSN
2631 * [tlv] HT capabilities
2632 * [tlv] Atheros capabilities
2633 */
2634 IEEE80211_VERIFY_LENGTH(efrm - frm, (reassoc ? 10 : 4), return);
2635 if (!IEEE80211_ADDR_EQ(wh->i_addr3, ic->ic_bss->ni_bssid)) {
2636 IEEE80211_DISCARD(ic, IEEE80211_MSG_ANY,
2637 wh, ieee80211_mgt_subtype_name[subtype >>
2638 IEEE80211_FC0_SUBTYPE_SHIFT],
2639 "%s", "wrong bssid");
2640 ic->ic_stats.is_rx_assoc_bss++;
2641 return;
2642 }
2643 capinfo = le16toh(*(uint16_t *)frm); frm += 2;
2644 lintval = le16toh(*(uint16_t *)frm); frm += 2;
2645 if (reassoc)
2646 frm += 6; /* ignore current AP info */
2647 ssid = rates = xrates = wpa = rsn = wme = ath = htcap = NULL;
2648 while (efrm - frm > 1) {
2649 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2, return);
2650 switch (*frm) {
2651 case IEEE80211_ELEMID_SSID:
2652 ssid = frm;
2653 break;
2654 case IEEE80211_ELEMID_RATES:
2655 rates = frm;
2656 break;
2657 case IEEE80211_ELEMID_XRATES:
2658 xrates = frm;
2659 break;
2660 /* XXX verify only one of RSN and WPA ie's? */
2661 case IEEE80211_ELEMID_RSN:
2662 rsn = frm;
2663 break;
2664 case IEEE80211_ELEMID_HTCAP:
2665 htcap = frm;
2666 break;
2667 case IEEE80211_ELEMID_VENDOR:
2668 if (iswpaoui(frm))
2669 wpa = frm;
2670 else if (iswmeinfo(frm))
2671 wme = frm;
2672 else if (isatherosoui(frm))
2673 ath = frm;
2674 else if (ic->ic_flags_ext & IEEE80211_FEXT_HTCOMPAT) {
2675 if (ishtcapoui(frm) && htcap == NULL)
2676 htcap = frm;
2677 }
2678 break;
2679 }
2680 frm += frm[1] + 2;
2681 }
2682 IEEE80211_VERIFY_ELEMENT(rates, IEEE80211_RATE_MAXSIZE);
2683 if (xrates != NULL)
2684 IEEE80211_VERIFY_ELEMENT(xrates,
2685 IEEE80211_RATE_MAXSIZE - rates[1]);
2686 IEEE80211_VERIFY_ELEMENT(ssid, IEEE80211_NWID_LEN);
2687 IEEE80211_VERIFY_SSID(ic->ic_bss, ssid);
2688 if (htcap != NULL) {
2689 IEEE80211_VERIFY_LENGTH(htcap[1],
2690 htcap[0] == IEEE80211_ELEMID_VENDOR ?
2691 4 + sizeof(struct ieee80211_ie_htcap)-2 :
2692 sizeof(struct ieee80211_ie_htcap)-2,
2693 return); /* XXX just NULL out? */
2694 }
2695
2696 if (ni == ic->ic_bss) {
2697 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ANY,
2698 "[%s] deny %s request, sta not authenticated\n",
2699 ether_sprintf(wh->i_addr2),
2700 reassoc ? "reassoc" : "assoc");
2701 ieee80211_send_error(ic, ni, wh->i_addr2,
2702 IEEE80211_FC0_SUBTYPE_DEAUTH,
2703 IEEE80211_REASON_ASSOC_NOT_AUTHED);
2704 ic->ic_stats.is_rx_assoc_notauth++;
2705 return;
2706 }
2707 /* assert right association security credentials */
2708 badwparsn = 0;
2709 switch (ic->ic_flags & IEEE80211_F_WPA) {
2710 case IEEE80211_F_WPA1:
2711 if (wpa == NULL)
2712 badwparsn = 1;
2713 break;
2714 case IEEE80211_F_WPA2:
2715 if (rsn == NULL)
2716 badwparsn = 1;
2717 break;
2718 case IEEE80211_F_WPA1|IEEE80211_F_WPA2:
2719 if (wpa == NULL && rsn == NULL)
2720 badwparsn = 1;
2721 break;
2722 }
2723 if (badwparsn) {
2724 IEEE80211_DPRINTF(ic,
2725 IEEE80211_MSG_ASSOC | IEEE80211_MSG_WPA,
2726 "[%s] no WPA/RSN IE in association request\n",
2727 ether_sprintf(wh->i_addr2));
2728 IEEE80211_SEND_MGMT(ic, ni,
2729 IEEE80211_FC0_SUBTYPE_DEAUTH,
2730 IEEE80211_REASON_IE_INVALID);
2731 ieee80211_node_leave(ic, ni);
2732 ic->ic_stats.is_rx_assoc_badwpaie++;
2733 return;
2734 }
2735 if (wpa != NULL || rsn != NULL) {
2736 /*
2737 * Parse WPA/RSN information element. Note that
2738 * we initialize the param block from the node
2739 * state so that information in the IE overrides
2740 * our defaults. The resulting parameters are
2741 * installed below after the association is assured.
2742 */
2743 rsnparms = ni->ni_rsn;
2744 if (wpa != NULL)
2745 reason = ieee80211_parse_wpa(ic, wpa, &rsnparms, wh);
2746 else
2747 reason = ieee80211_parse_rsn(ic, rsn, &rsnparms, wh);
2748 if (reason != 0) {
2749 IEEE80211_SEND_MGMT(ic, ni,
2750 IEEE80211_FC0_SUBTYPE_DEAUTH, reason);
2751 ieee80211_node_leave(ic, ni);
2752 /* XXX distinguish WPA/RSN? */
2753 ic->ic_stats.is_rx_assoc_badwpaie++;
2754 return;
2755 }
2756 IEEE80211_DPRINTF(ic,
2757 IEEE80211_MSG_ASSOC | IEEE80211_MSG_WPA,
2758 "[%s] %s ie: mc %u/%u uc %u/%u key %u caps 0x%x\n",
2759 ether_sprintf(wh->i_addr2),
2760 wpa != NULL ? "WPA" : "RSN",
2761 rsnparms.rsn_mcastcipher, rsnparms.rsn_mcastkeylen,
2762 rsnparms.rsn_ucastcipher, rsnparms.rsn_ucastkeylen,
2763 rsnparms.rsn_keymgmt, rsnparms.rsn_caps);
2764 }
2765 /* discard challenge after association */
2766 if (ni->ni_challenge != NULL) {
2767 FREE(ni->ni_challenge, M_80211_NODE);
2768 ni->ni_challenge = NULL;
2769 }
2770 /* NB: 802.11 spec says to ignore station's privacy bit */
2771 if ((capinfo & IEEE80211_CAPINFO_ESS) == 0) {
2772 capinfomismatch(ni, wh, reassoc, resp,
2773 "capability", capinfo);
2774 return;
2775 }
2776 /*
2777 * Disallow re-associate w/ invalid slot time setting.
2778 */
2779 if (ni->ni_associd != 0 &&
2780 IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan) &&
2781 ((ni->ni_capinfo ^ capinfo) & IEEE80211_CAPINFO_SHORT_SLOTTIME)) {
2782 capinfomismatch(ni, wh, reassoc, resp,
2783 "slot time", capinfo);
2784 return;
2785 }
2786 rate = ieee80211_setup_rates(ni, rates, xrates,
2787 IEEE80211_F_DOSORT | IEEE80211_F_DOFRATE |
2788 IEEE80211_F_DONEGO | IEEE80211_F_DODEL);
2789 if (rate & IEEE80211_RATE_BASIC) {
2790 ratesetmismatch(ni, wh, reassoc, resp, "basic", rate);
2791 return;
2792 }
2793 /*
2794 * If constrained to 11g-only stations reject an
2795 * 11b-only station. We cheat a bit here by looking
2796 * at the max negotiated xmit rate and assuming anyone
2797 * with a best rate <24Mb/s is an 11b station.
2798 */
2799 if ((ic->ic_flags & IEEE80211_F_PUREG) && rate < 48) {
2800 ratesetmismatch(ni, wh, reassoc, resp, "11g", rate);
2801 return;
2802 }
2803 /* XXX enforce PUREN */
2804 /* 802.11n-specific rateset handling */
2805 if (IEEE80211_IS_CHAN_HT(ic->ic_curchan) && htcap != NULL) {
2806 rate = ieee80211_setup_htrates(ni, htcap,
2807 IEEE80211_F_DOFRATE | IEEE80211_F_DONEGO |
2808 IEEE80211_F_DOBRS);
2809 if (rate & IEEE80211_RATE_BASIC) {
2810 /* XXX 11n-specific stat */
2811 ratesetmismatch(ni, wh, reassoc, resp,
2812 "HT", rate);
2813 return;
2814 }
2815 ieee80211_ht_node_init(ni, htcap);
2816 } else if (ni->ni_flags & IEEE80211_NODE_HT)
2817 ieee80211_ht_node_cleanup(ni);
2818 /*
2819 * Allow AMPDU operation only with unencrypted traffic
2820 * or AES-CCM; the 11n spec only specifies these ciphers
2821 * so permitting any others is undefined and can lead
2822 * to interoperability problems.
2823 *
2824 * NB: We check for AES by looking at the GTK cipher
2825 * since the WPA/11i specs say the PTK cipher has
2826 * to be "as good or better".
2827 */
2828 if ((ni->ni_flags & IEEE80211_NODE_HT) &&
2829 (((ic->ic_flags & IEEE80211_F_WPA) &&
2830 rsnparms.rsn_mcastcipher != IEEE80211_CIPHER_AES_CCM) ||
2831 (ic->ic_flags & (IEEE80211_F_WPA|IEEE80211_F_PRIVACY)) == IEEE80211_F_PRIVACY)) {
2832 IEEE80211_NOTE(ic,
2833 IEEE80211_MSG_ASSOC | IEEE80211_MSG_11N, ni,
2834 "disallow HT use because WEP or TKIP requested, "
2835 "capinfo 0x%x mcastcipher %d", capinfo,
2836 rsnparms.rsn_mcastcipher);
2837 ieee80211_ht_node_cleanup(ni);
2838 ic->ic_stats.is_ht_assoc_downgrade++;
2839 }
2840 /*
2841 * If constrained to 11n-only stations reject legacy stations.
2842 */
2843 if ((ic->ic_flags_ext & IEEE80211_FEXT_PUREN) &&
2844 (ni->ni_flags & IEEE80211_NODE_HT) == 0) {
2845 htcapmismatch(ni, wh, reassoc, resp);
2846 ic->ic_stats.is_ht_assoc_nohtcap++;
2847 return;
2848 }
2849 ni->ni_rssi = rssi;
2850 ni->ni_noise = noise;
2851 ni->ni_rstamp = rstamp;
2852 ni->ni_intval = lintval;
2853 ni->ni_capinfo = capinfo;
2854 ni->ni_chan = ic->ic_bsschan;
2855 ni->ni_fhdwell = ic->ic_bss->ni_fhdwell;
2856 ni->ni_fhindex = ic->ic_bss->ni_fhindex;
2857 if (wpa != NULL) {
2858 /*
2859 * Record WPA parameters for station, mark
2860 * node as using WPA and record information element
2861 * for applications that require it.
2862 */
2863 ni->ni_rsn = rsnparms;
2864 ieee80211_saveie(&ni->ni_wpa_ie, wpa);
2865 } else if (ni->ni_wpa_ie != NULL) {
2866 /*
2867 * Flush any state from a previous association.
2868 */
2869 FREE(ni->ni_wpa_ie, M_80211_NODE);
2870 ni->ni_wpa_ie = NULL;
2871 }
2872 if (rsn != NULL) {
2873 /*
2874 * Record RSN parameters for station, mark
2875 * node as using WPA and record information element
2876 * for applications that require it.
2877 */
2878 ni->ni_rsn = rsnparms;
2879 ieee80211_saveie(&ni->ni_rsn_ie, rsn);
2880 } else if (ni->ni_rsn_ie != NULL) {
2881 /*
2882 * Flush any state from a previous association.
2883 */
2884 FREE(ni->ni_rsn_ie, M_80211_NODE);
2885 ni->ni_rsn_ie = NULL;
2886 }
2887 if (wme != NULL) {
2888 /*
2889 * Record WME parameters for station, mark node
2890 * as capable of QoS and record information
2891 * element for applications that require it.
2892 */
2893 ieee80211_saveie(&ni->ni_wme_ie, wme);
2894 ni->ni_flags |= IEEE80211_NODE_QOS;
2895 } else if (ni->ni_wme_ie != NULL) {
2896 /*
2897 * Flush any state from a previous association.
2898 */
2899 FREE(ni->ni_wme_ie, M_80211_NODE);
2900 ni->ni_wme_ie = NULL;
2901 ni->ni_flags &= ~IEEE80211_NODE_QOS;
2902 }
2903 if (ath != NULL) {
2904 /*
2905 * Record ATH parameters for station, mark
2906 * node with appropriate capabilities, and
2907 * record the information element for
2908 * applications that require it.
2909 */
2910 ieee80211_saveath(ni, ath);
2911 } else if (ni->ni_ath_ie != NULL) {
2912 /*
2913 * Flush any state from a previous association.
2914 */
2915 FREE(ni->ni_ath_ie, M_80211_NODE);
2916 ni->ni_ath_ie = NULL;
2917 ni->ni_ath_flags = 0;
2918 }
2919 ieee80211_node_join(ic, ni, resp);
2920 ieee80211_deliver_l2uf(ni);
2921 break;
2922 }
2923
2924 case IEEE80211_FC0_SUBTYPE_ASSOC_RESP:
2925 case IEEE80211_FC0_SUBTYPE_REASSOC_RESP: {
2926 uint16_t capinfo, associd;
2927 uint16_t status;
2928
2929 if (ic->ic_opmode != IEEE80211_M_STA ||
2930 ic->ic_state != IEEE80211_S_ASSOC) {
2931 ic->ic_stats.is_rx_mgtdiscard++;
2932 return;
2933 }
2934
2935 /*
2936 * asresp frame format
2937 * [2] capability information
2938 * [2] status
2939 * [2] association ID
2940 * [tlv] supported rates
2941 * [tlv] extended supported rates
2942 * [tlv] WME
2943 * [tlv] HT capabilities
2944 * [tlv] HT info
2945 */
2946 IEEE80211_VERIFY_LENGTH(efrm - frm, 6, return);
2947 ni = ic->ic_bss;
2948 capinfo = le16toh(*(uint16_t *)frm);
2949 frm += 2;
2950 status = le16toh(*(uint16_t *)frm);
2951 frm += 2;
2952 if (status != 0) {
2953 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
2954 "[%s] %sassoc failed (reason %d)\n",
2955 ether_sprintf(wh->i_addr2),
2956 ISREASSOC(subtype) ? "re" : "", status);
2957 if (ni != ic->ic_bss) /* XXX never true? */
2958 ni->ni_fails++;
2959 ic->ic_stats.is_rx_auth_fail++; /* XXX */
2960 return;
2961 }
2962 associd = le16toh(*(uint16_t *)frm);
2963 frm += 2;
2964
2965 rates = xrates = wme = htcap = htinfo = NULL;
2966 while (efrm - frm > 1) {
2967 IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1] + 2, return);
2968 switch (*frm) {
2969 case IEEE80211_ELEMID_RATES:
2970 rates = frm;
2971 break;
2972 case IEEE80211_ELEMID_XRATES:
2973 xrates = frm;
2974 break;
2975 case IEEE80211_ELEMID_HTCAP:
2976 htcap = frm;
2977 break;
2978 case IEEE80211_ELEMID_HTINFO:
2979 htinfo = frm;
2980 break;
2981 case IEEE80211_ELEMID_VENDOR:
2982 if (iswmeoui(frm))
2983 wme = frm;
2984 else if (ic->ic_flags_ext & IEEE80211_FEXT_HTCOMPAT) {
2985 /*
2986 * Accept pre-draft HT ie's if the
2987 * standard ones have not been seen.
2988 */
2989 if (ishtcapoui(frm)) {
2990 if (htcap == NULL)
2991 htcap = frm;
2992 } else if (ishtinfooui(frm)) {
2993 if (htinfo == NULL)
2994 htcap = frm;
2995 }
2996 }
2997 /* XXX Atheros OUI support */
2998 break;
2999 }
3000 frm += frm[1] + 2;
3001 }
3002
3003 IEEE80211_VERIFY_ELEMENT(rates, IEEE80211_RATE_MAXSIZE);
3004 if (xrates != NULL)
3005 IEEE80211_VERIFY_ELEMENT(xrates,
3006 IEEE80211_RATE_MAXSIZE - rates[1]);
3007 rate = ieee80211_setup_rates(ni, rates, xrates,
3008 IEEE80211_F_JOIN |
3009 IEEE80211_F_DOSORT | IEEE80211_F_DOFRATE |
3010 IEEE80211_F_DONEGO | IEEE80211_F_DODEL);
3011 if (rate & IEEE80211_RATE_BASIC) {
3012 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
3013 "[%s] %sassoc failed (rate set mismatch)\n",
3014 ether_sprintf(wh->i_addr2),
3015 ISREASSOC(subtype) ? "re" : "");
3016 if (ni != ic->ic_bss) /* XXX never true? */
3017 ni->ni_fails++;
3018 ic->ic_stats.is_rx_assoc_norate++;
3019 ieee80211_new_state(ic, IEEE80211_S_SCAN,
3020 IEEE80211_SCAN_FAIL_STATUS);
3021 return;
3022 }
3023
3024 ni->ni_capinfo = capinfo;
3025 ni->ni_associd = associd;
3026 if (wme != NULL &&
3027 ieee80211_parse_wmeparams(ic, wme, wh) >= 0) {
3028 ni->ni_flags |= IEEE80211_NODE_QOS;
3029 ieee80211_wme_updateparams(ic);
3030 } else
3031 ni->ni_flags &= ~IEEE80211_NODE_QOS;
3032 /*
3033 * Setup HT state according to the negotiation.
3034 */
3035 if ((ic->ic_htcaps & IEEE80211_HTC_HT) &&
3036 htcap != NULL && htinfo != NULL) {
3037 ieee80211_ht_node_init(ni, htcap);
3038 ieee80211_parse_htinfo(ni, htinfo);
3039 ieee80211_setup_htrates(ni,
3040 htcap, IEEE80211_F_JOIN | IEEE80211_F_DOBRS);
3041 ieee80211_setup_basic_htrates(ni, htinfo);
3042 if (ni->ni_chan != ic->ic_bsschan) {
3043 /*
3044 * Channel has been adjusted based on
3045 * negotiated HT parameters; force the
3046 * channel state to follow.
3047 */
3048 ieee80211_setbsschan(ic, ni->ni_chan);
3049 }
3050 }
3051 /*
3052 * Configure state now that we are associated.
3053 *
3054 * XXX may need different/additional driver callbacks?
3055 */
3056 if (IEEE80211_IS_CHAN_A(ic->ic_curchan) ||
3057 (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE)) {
3058 ic->ic_flags |= IEEE80211_F_SHPREAMBLE;
3059 ic->ic_flags &= ~IEEE80211_F_USEBARKER;
3060 } else {
3061 ic->ic_flags &= ~IEEE80211_F_SHPREAMBLE;
3062 ic->ic_flags |= IEEE80211_F_USEBARKER;
3063 }
3064 ieee80211_set_shortslottime(ic,
3065 IEEE80211_IS_CHAN_A(ic->ic_curchan) ||
3066 (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME));
3067 /*
3068 * Honor ERP protection.
3069 *
3070 * NB: ni_erp should zero for non-11g operation.
3071 */
3072 if (IEEE80211_IS_CHAN_ANYG(ic->ic_curchan) &&
3073 (ni->ni_erp & IEEE80211_ERP_USE_PROTECTION))
3074 ic->ic_flags |= IEEE80211_F_USEPROT;
3075 else
3076 ic->ic_flags &= ~IEEE80211_F_USEPROT;
3077 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
3078 "[%s] %sassoc success: %s preamble, %s slot time%s%s%s%s\n",
3079 ether_sprintf(wh->i_addr2),
3080 ISREASSOC(subtype) ? "re" : "",
3081 ic->ic_flags&IEEE80211_F_SHPREAMBLE ? "short" : "long",
3082 ic->ic_flags&IEEE80211_F_SHSLOT ? "short" : "long",
3083 ic->ic_flags&IEEE80211_F_USEPROT ? ", protection" : "",
3084 ni->ni_flags & IEEE80211_NODE_QOS ? ", QoS" : "",
3085 ni->ni_flags & IEEE80211_NODE_HT ?
3086 (ni->ni_chw == 20 ? ", HT20" : ", HT40") : "",
3087 ni->ni_flags & IEEE80211_NODE_AMPDU ? " (+AMPDU)" : "",
3088 IEEE80211_ATH_CAP(ic, ni, IEEE80211_NODE_FF) ?
3089 ", fast-frames" : "",
3090 IEEE80211_ATH_CAP(ic, ni, IEEE80211_NODE_TURBOP) ?
3091 ", turbo" : ""
3092 );
3093 ieee80211_new_state(ic, IEEE80211_S_RUN, subtype);
3094 break;
3095 }
3096
3097 case IEEE80211_FC0_SUBTYPE_DEAUTH: {
3098 uint16_t reason;
3099
3100 if (ic->ic_state == IEEE80211_S_SCAN) {
3101 ic->ic_stats.is_rx_mgtdiscard++;
3102 return;
3103 }
3104 /*
3105 * deauth frame format
3106 * [2] reason
3107 */
3108 IEEE80211_VERIFY_LENGTH(efrm - frm, 2, return);
3109 reason = le16toh(*(uint16_t *)frm);
3110 ic->ic_stats.is_rx_deauth++;
3111 IEEE80211_NODE_STAT(ni, rx_deauth);
3112
3113 if (!IEEE80211_ADDR_EQ(wh->i_addr1, ic->ic_myaddr)) {
3114 /* NB: can happen when in promiscuous mode */
3115 ic->ic_stats.is_rx_mgtdiscard++;
3116 break;
3117 }
3118 IEEE80211_DPRINTF(ic, IEEE80211_MSG_AUTH,
3119 "[%s] recv deauthenticate (reason %d)\n",
3120 ether_sprintf(ni->ni_macaddr), reason);
3121 switch (ic->ic_opmode) {
3122 case IEEE80211_M_STA:
3123 ieee80211_new_state(ic, IEEE80211_S_AUTH,
3124 (reason << 8) | IEEE80211_FC0_SUBTYPE_DEAUTH);
3125 break;
3126 case IEEE80211_M_HOSTAP:
3127 if (ni != ic->ic_bss)
3128 ieee80211_node_leave(ic, ni);
3129 break;
3130 default:
3131 ic->ic_stats.is_rx_mgtdiscard++;
3132 break;
3133 }
3134 break;
3135 }
3136
3137 case IEEE80211_FC0_SUBTYPE_DISASSOC: {
3138 uint16_t reason;
3139
3140 if (ic->ic_state != IEEE80211_S_RUN &&
3141 ic->ic_state != IEEE80211_S_ASSOC &&
3142 ic->ic_state != IEEE80211_S_AUTH) {
3143 ic->ic_stats.is_rx_mgtdiscard++;
3144 return;
3145 }
3146 /*
3147 * disassoc frame format
3148 * [2] reason
3149 */
3150 IEEE80211_VERIFY_LENGTH(efrm - frm, 2, return);
3151 reason = le16toh(*(uint16_t *)frm);
3152 ic->ic_stats.is_rx_disassoc++;
3153 IEEE80211_NODE_STAT(ni, rx_disassoc);
3154
3155 if (!IEEE80211_ADDR_EQ(wh->i_addr1, ic->ic_myaddr)) {
3156 /* NB: can happen when in promiscuous mode */
3157 ic->ic_stats.is_rx_mgtdiscard++;
3158 break;
3159 }
3160 IEEE80211_DPRINTF(ic, IEEE80211_MSG_ASSOC,
3161 "[%s] recv disassociate (reason %d)\n",
3162 ether_sprintf(ni->ni_macaddr), reason);
3163 switch (ic->ic_opmode) {
3164 case IEEE80211_M_STA:
3165 ieee80211_new_state(ic, IEEE80211_S_ASSOC, 0);
3166 break;
3167 case IEEE80211_M_HOSTAP:
3168 if (ni != ic->ic_bss)
3169 ieee80211_node_leave(ic, ni);
3170 break;
3171 default:
3172 ic->ic_stats.is_rx_mgtdiscard++;
3173 break;
3174 }
3175 break;
3176 }
3177
3178 case IEEE80211_FC0_SUBTYPE_ACTION: {
3179 const struct ieee80211_action *ia;
3180
3181 if (ic->ic_state != IEEE80211_S_RUN &&
3182 ic->ic_state != IEEE80211_S_ASSOC &&
3183 ic->ic_state != IEEE80211_S_AUTH) {
3184 ic->ic_stats.is_rx_mgtdiscard++;
3185 return;
3186 }
3187 /*
3188 * action frame format:
3189 * [1] category
3190 * [1] action
3191 * [tlv] parameters
3192 */
3193 IEEE80211_VERIFY_LENGTH(efrm - frm,
3194 sizeof(struct ieee80211_action), return);
3195 ia = (const struct ieee80211_action *) frm;
3196
3197 ic->ic_stats.is_rx_action++;
3198 IEEE80211_NODE_STAT(ni, rx_action);
3199
3200 /* verify frame payloads but defer processing */
3201 /* XXX maybe push this to method */
3202 switch (ia->ia_category) {
3203 case IEEE80211_ACTION_CAT_BA:
3204 switch (ia->ia_action) {
3205 case IEEE80211_ACTION_BA_ADDBA_REQUEST:
3206 IEEE80211_VERIFY_LENGTH(efrm - frm,
3207 sizeof(struct ieee80211_action_ba_addbarequest),
3208 return);
3209 break;
3210 case IEEE80211_ACTION_BA_ADDBA_RESPONSE:
3211 IEEE80211_VERIFY_LENGTH(efrm - frm,
3212 sizeof(struct ieee80211_action_ba_addbaresponse),
3213 return);
3214 break;
3215 case IEEE80211_ACTION_BA_DELBA:
3216 IEEE80211_VERIFY_LENGTH(efrm - frm,
3217 sizeof(struct ieee80211_action_ba_delba),
3218 return);
3219 break;
3220 }
3221 break;
3222 case IEEE80211_ACTION_CAT_HT:
3223 switch (ia->ia_action) {
3224 case IEEE80211_ACTION_HT_TXCHWIDTH:
3225 IEEE80211_VERIFY_LENGTH(efrm - frm,
3226 sizeof(struct ieee80211_action_ht_txchwidth),
3227 return);
3228 break;
3229 }
3230 break;
3231 }
3232 ic->ic_recv_action(ni, frm, efrm);
3233 break;
3234 }
3235
3236 default:
3237 IEEE80211_DISCARD(ic, IEEE80211_MSG_ANY,
3238 wh, "mgt", "subtype 0x%x not handled", subtype);
3239 ic->ic_stats.is_rx_badsubtype++;
3240 break;
3241 }
3242#undef ISREASSOC
3243#undef ISPROBE
3244}
3245#undef IEEE80211_VERIFY_LENGTH
3246#undef IEEE80211_VERIFY_ELEMENT
3247
3248/*
3249 * Process a received ps-poll frame.
3250 */
3251static void
3252ieee80211_recv_pspoll(struct ieee80211com *ic,
3253 struct ieee80211_node *ni, struct mbuf *m0)
3254{
3255 struct ieee80211_frame_min *wh;
3256 struct mbuf *m;
3257 uint16_t aid;
3258 int qlen;
3259
3260 wh = mtod(m0, struct ieee80211_frame_min *);
3261 if (ni->ni_associd == 0) {
3262 IEEE80211_DISCARD(ic, IEEE80211_MSG_POWER | IEEE80211_MSG_DEBUG,
3263 (struct ieee80211_frame *) wh, "ps-poll",
3264 "%s", "unassociated station");
3265 ic->ic_stats.is_ps_unassoc++;
3266 IEEE80211_SEND_MGMT(ic, ni, IEEE80211_FC0_SUBTYPE_DEAUTH,
3267 IEEE80211_REASON_NOT_ASSOCED);
3268 return;
3269 }
3270
3271 aid = le16toh(*(uint16_t *)wh->i_dur);
3272 if (aid != ni->ni_associd) {
3273 IEEE80211_DISCARD(ic, IEEE80211_MSG_POWER | IEEE80211_MSG_DEBUG,
3274 (struct ieee80211_frame *) wh, "ps-poll",
3275 "aid mismatch: sta aid 0x%x poll aid 0x%x",
3276 ni->ni_associd, aid);
3277 ic->ic_stats.is_ps_badaid++;
3278 IEEE80211_SEND_MGMT(ic, ni, IEEE80211_FC0_SUBTYPE_DEAUTH,
3279 IEEE80211_REASON_NOT_ASSOCED);
3280 return;
3281 }
3282
3283 /* Okay, take the first queued packet and put it out... */
3284 IEEE80211_NODE_SAVEQ_DEQUEUE(ni, m, qlen);
3285 if (m == NULL) {
3286 IEEE80211_DPRINTF(ic, IEEE80211_MSG_POWER,
3287 "[%s] recv ps-poll, but queue empty\n",
3288 ether_sprintf(wh->i_addr2));
3289 ieee80211_send_nulldata(ieee80211_ref_node(ni));
3290 ic->ic_stats.is_ps_qempty++; /* XXX node stat */
3291 if (ic->ic_set_tim != NULL)
3292 ic->ic_set_tim(ni, 0); /* just in case */
3293 return;
3294 }
3295 /*
3296 * If there are more packets, set the more packets bit
3297 * in the packet dispatched to the station; otherwise
3298 * turn off the TIM bit.
3299 */
3300 if (qlen != 0) {
3301 IEEE80211_DPRINTF(ic, IEEE80211_MSG_POWER,
3302 "[%s] recv ps-poll, send packet, %u still queued\n",
3303 ether_sprintf(ni->ni_macaddr), qlen);
3304 m->m_flags |= M_MORE_DATA;
3305 } else {
3306 IEEE80211_DPRINTF(ic, IEEE80211_MSG_POWER,
3307 "[%s] recv ps-poll, send packet, queue empty\n",
3308 ether_sprintf(ni->ni_macaddr));
3309 if (ic->ic_set_tim != NULL)
3310 ic->ic_set_tim(ni, 0);
3311 }
3312 m->m_flags |= M_PWR_SAV; /* bypass PS handling */
3313 IF_ENQUEUE(&ic->ic_ifp->if_snd, m);
3314}
3315
3316#ifdef IEEE80211_DEBUG
3317/*
3318 * Debugging support.
3319 */
3320
3321/*
3322 * Return the bssid of a frame.
3323 */
3324static const uint8_t *
3325ieee80211_getbssid(struct ieee80211com *ic, const struct ieee80211_frame *wh)
3326{
3327 if (ic->ic_opmode == IEEE80211_M_STA)
3328 return wh->i_addr2;
3329 if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) != IEEE80211_FC1_DIR_NODS)
3330 return wh->i_addr1;
3331 if ((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) == IEEE80211_FC0_SUBTYPE_PS_POLL)
3332 return wh->i_addr1;
3333 return wh->i_addr3;
3334}
3335
3336void
3337ieee80211_note(struct ieee80211com *ic, const char *fmt, ...)
3338{
3339 char buf[128]; /* XXX */
3340 va_list ap;
3341
3342 va_start(ap, fmt);
3343 vsnprintf(buf, sizeof(buf), fmt, ap);
3344 va_end(ap);
3345
3346 if_printf(ic->ic_ifp, "%s", buf); /* NB: no \n */
3347}
3348
3349void
3350ieee80211_note_frame(struct ieee80211com *ic,
3351 const struct ieee80211_frame *wh,
3352 const char *fmt, ...)
3353{
3354 char buf[128]; /* XXX */
3355 va_list ap;
3356
3357 va_start(ap, fmt);
3358 vsnprintf(buf, sizeof(buf), fmt, ap);
3359 va_end(ap);
3360 if_printf(ic->ic_ifp, "[%s] %s\n",
3361 ether_sprintf(ieee80211_getbssid(ic, wh)), buf);
3362}
3363
3364void
3365ieee80211_note_mac(struct ieee80211com *ic,
3366 const uint8_t mac[IEEE80211_ADDR_LEN],
3367 const char *fmt, ...)
3368{
3369 char buf[128]; /* XXX */
3370 va_list ap;
3371
3372 va_start(ap, fmt);
3373 vsnprintf(buf, sizeof(buf), fmt, ap);
3374 va_end(ap);
3375 if_printf(ic->ic_ifp, "[%s] %s\n", ether_sprintf(mac), buf);
3376}
3377
3378void
3379ieee80211_discard_frame(struct ieee80211com *ic,
3380 const struct ieee80211_frame *wh,
3381 const char *type, const char *fmt, ...)
3382{
3383 va_list ap;
3384
3385 printf("[%s:%s] discard ", ic->ic_ifp->if_xname,
3386 ether_sprintf(ieee80211_getbssid(ic, wh)));
3387 if (type != NULL)
3388 printf("%s frame, ", type);
3389 else
3390 printf("frame, ");
3391 va_start(ap, fmt);
3392 vprintf(fmt, ap);
3393 va_end(ap);
3394 printf("\n");
3395}
3396
3397void
3398ieee80211_discard_ie(struct ieee80211com *ic,
3399 const struct ieee80211_frame *wh,
3400 const char *type, const char *fmt, ...)
3401{
3402 va_list ap;
3403
3404 printf("[%s:%s] discard ", ic->ic_ifp->if_xname,
3405 ether_sprintf(ieee80211_getbssid(ic, wh)));
3406 if (type != NULL)
3407 printf("%s information element, ", type);
3408 else
3409 printf("information element, ");
3410 va_start(ap, fmt);
3411 vprintf(fmt, ap);
3412 va_end(ap);
3413 printf("\n");
3414}
3415
3416void
3417ieee80211_discard_mac(struct ieee80211com *ic,
3418 const uint8_t mac[IEEE80211_ADDR_LEN],
3419 const char *type, const char *fmt, ...)
3420{
3421 va_list ap;
3422
3423 printf("[%s:%s] discard ", ic->ic_ifp->if_xname, ether_sprintf(mac));
3424 if (type != NULL)
3425 printf("%s frame, ", type);
3426 else
3427 printf("frame, ");
3428 va_start(ap, fmt);
3429 vprintf(fmt, ap);
3430 va_end(ap);
3431 printf("\n");
3432}
3433#endif /* IEEE80211_DEBUG */
|