![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to net80211.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / 80211|
Return to net80211.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / 80211 |
1.1 root 1: /*
2: * The iPXE 802.11 MAC layer.
3: *
4: * Copyright (c) 2009 Joshua Oreman <[email protected]>.
5: *
6: * This program is free software; you can redistribute it and/or
7: * modify it under the terms of the GNU General Public License as
8: * published by the Free Software Foundation; either version 2 of the
9: * License, or any later version.
10: *
11: * This program is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of
13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: * General Public License for more details.
15: *
16: * You should have received a copy of the GNU General Public License
17: * along with this program; if not, write to the Free Software
18: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19: */
20:
21: FILE_LICENCE ( GPL2_OR_LATER );
22:
23: #include <string.h>
24: #include <byteswap.h>
25: #include <stdlib.h>
26: #include <unistd.h>
27: #include <errno.h>
28: #include <ipxe/settings.h>
29: #include <ipxe/if_arp.h>
30: #include <ipxe/ethernet.h>
31: #include <ipxe/ieee80211.h>
32: #include <ipxe/netdevice.h>
33: #include <ipxe/net80211.h>
34: #include <ipxe/sec80211.h>
35: #include <ipxe/timer.h>
36: #include <ipxe/nap.h>
37: #include <ipxe/errortab.h>
38: #include <ipxe/net80211_err.h>
39:
40: /** @file
41: *
42: * 802.11 device management
43: */
44:
45: /** List of 802.11 devices */
46: static struct list_head net80211_devices = LIST_HEAD_INIT ( net80211_devices );
47:
48: /** Set of device operations that does nothing */
49: static struct net80211_device_operations net80211_null_ops;
50:
51: /** Information associated with a received management packet
52: *
53: * This is used to keep beacon signal strengths in a parallel queue to
54: * the beacons themselves.
55: */
56: struct net80211_rx_info {
57: int signal;
58: struct list_head list;
59: };
60:
61: /** Context for a probe operation */
62: struct net80211_probe_ctx {
63: /** 802.11 device to probe on */
64: struct net80211_device *dev;
65:
66: /** Value of keep_mgmt before probe was started */
67: int old_keep_mgmt;
68:
69: /** If scanning actively, pointer to probe packet to send */
70: struct io_buffer *probe;
71:
72: /** If non-"", the ESSID to limit ourselves to */
73: const char *essid;
74:
75: /** Time probe was started */
76: u32 ticks_start;
77:
78: /** Time last useful beacon was received */
79: u32 ticks_beacon;
80:
81: /** Time channel was last changed */
82: u32 ticks_channel;
83:
84: /** Time to stay on each channel */
85: u32 hop_time;
86:
87: /** Channels to hop by when changing channel */
88: int hop_step;
89:
90: /** List of best beacons for each network found so far */
91: struct list_head *beacons;
92: };
93:
94: /** Context for the association task */
95: struct net80211_assoc_ctx {
96: /** Next authentication method to try using */
97: int method;
98:
99: /** Time (in ticks) of the last sent association-related packet */
100: int last_packet;
101:
102: /** Number of times we have tried sending it */
103: int times_tried;
104: };
105:
106: /**
107: * Detect secure 802.11 network when security support is not available
108: *
109: * @return -ENOTSUP, always.
110: */
111: __weak int sec80211_detect ( struct io_buffer *iob __unused,
112: enum net80211_security_proto *secprot __unused,
113: enum net80211_crypto_alg *crypt __unused ) {
114: return -ENOTSUP;
115: }
116:
117: /**
118: * @defgroup net80211_netdev Network device interface functions
119: * @{
120: */
121: static int net80211_netdev_open ( struct net_device *netdev );
122: static void net80211_netdev_close ( struct net_device *netdev );
123: static int net80211_netdev_transmit ( struct net_device *netdev,
124: struct io_buffer *iobuf );
125: static void net80211_netdev_poll ( struct net_device *netdev );
126: static void net80211_netdev_irq ( struct net_device *netdev, int enable );
127: /** @} */
128:
129: /**
130: * @defgroup net80211_linklayer 802.11 link-layer protocol functions
131: * @{
132: */
133: static int net80211_ll_push ( struct net_device *netdev,
134: struct io_buffer *iobuf, const void *ll_dest,
135: const void *ll_source, uint16_t net_proto );
136: static int net80211_ll_pull ( struct net_device *netdev,
137: struct io_buffer *iobuf, const void **ll_dest,
138: const void **ll_source, uint16_t * net_proto );
139: /** @} */
140:
141: /**
142: * @defgroup net80211_help 802.11 helper functions
143: * @{
144: */
145: static void net80211_add_channels ( struct net80211_device *dev, int start,
146: int len, int txpower );
147: static void net80211_filter_hw_channels ( struct net80211_device *dev );
148: static void net80211_set_rtscts_rate ( struct net80211_device *dev );
149: static int net80211_process_capab ( struct net80211_device *dev,
150: u16 capab );
151: static int net80211_process_ie ( struct net80211_device *dev,
152: union ieee80211_ie *ie, void *ie_end );
153: static union ieee80211_ie *
154: net80211_marshal_request_info ( struct net80211_device *dev,
155: union ieee80211_ie *ie );
156: /** @} */
157:
158: /**
159: * @defgroup net80211_assoc_ll 802.11 association handling functions
160: * @{
161: */
162: static void net80211_step_associate ( struct process *proc );
163: static void net80211_handle_auth ( struct net80211_device *dev,
164: struct io_buffer *iob );
165: static void net80211_handle_assoc_reply ( struct net80211_device *dev,
166: struct io_buffer *iob );
167: static int net80211_send_disassoc ( struct net80211_device *dev, int reason,
168: int deauth );
169: static void net80211_handle_mgmt ( struct net80211_device *dev,
170: struct io_buffer *iob, int signal );
171: /** @} */
172:
173: /**
174: * @defgroup net80211_frag 802.11 fragment handling functions
175: * @{
176: */
177: static void net80211_free_frags ( struct net80211_device *dev, int fcid );
178: static struct io_buffer *net80211_accum_frags ( struct net80211_device *dev,
179: int fcid, int nfrags, int size );
180: static void net80211_rx_frag ( struct net80211_device *dev,
181: struct io_buffer *iob, int signal );
182: /** @} */
183:
184: /**
185: * @defgroup net80211_settings 802.11 settings handlers
186: * @{
187: */
188: static int net80211_check_settings_update ( void );
189:
190: /** 802.11 settings applicator
191: *
192: * When the SSID is changed, this will cause any open devices to
193: * re-associate; when the encryption key is changed, we similarly
194: * update their state.
195: */
196: struct settings_applicator net80211_applicator __settings_applicator = {
197: .apply = net80211_check_settings_update,
198: };
199:
200: /** The network name to associate with
201: *
202: * If this is blank, we scan for all networks and use the one with the
203: * greatest signal strength.
204: */
205: struct setting net80211_ssid_setting __setting ( SETTING_NETDEV_EXTRA ) = {
206: .name = "ssid",
207: .description = "Wireless SSID",
208: .type = &setting_type_string,
209: .tag = NET80211_SETTING_TAG_SSID,
210: };
211:
212: /** Whether to use active scanning
213: *
214: * In order to associate with a hidden SSID, it's necessary to use an
215: * active scan (send probe packets). If this setting is nonzero, an
216: * active scan on the 2.4GHz band will be used to associate.
217: */
218: struct setting net80211_active_setting __setting ( SETTING_NETDEV_EXTRA ) = {
219: .name = "active-scan",
220: .description = "Actively scan for wireless networks",
221: .type = &setting_type_int8,
222: .tag = NET80211_SETTING_TAG_ACTIVE_SCAN,
223: };
224:
225: /** The cryptographic key to use
226: *
227: * For hex WEP keys, as is common, this must be entered using the
228: * normal iPXE method for entering hex settings; an ASCII string of
229: * hex characters will not behave as expected.
230: */
231: struct setting net80211_key_setting __setting ( SETTING_NETDEV_EXTRA ) = {
232: .name = "key",
233: .description = "Wireless encryption key",
234: .type = &setting_type_string,
235: .tag = NET80211_SETTING_TAG_KEY,
236: };
237:
238: /** @} */
239:
240:
241: /* ---------- net_device wrapper ---------- */
242:
243: /**
244: * Open 802.11 device and start association
245: *
246: * @v netdev Wrapping network device
247: * @ret rc Return status code
248: *
249: * This sets up a default conservative set of channels for probing,
250: * and starts the auto-association task unless the @c
251: * NET80211_NO_ASSOC flag is set in the wrapped 802.11 device's @c
252: * state field.
253: */
254: static int net80211_netdev_open ( struct net_device *netdev )
255: {
256: struct net80211_device *dev = netdev->priv;
257: int rc = 0;
258:
259: if ( dev->op == &net80211_null_ops )
260: return -EFAULT;
261:
262: if ( dev->op->open )
263: rc = dev->op->open ( dev );
264:
265: if ( rc < 0 )
266: return rc;
267:
268: if ( ! ( dev->state & NET80211_NO_ASSOC ) )
269: net80211_autoassociate ( dev );
270:
271: return 0;
272: }
273:
274: /**
275: * Close 802.11 device
276: *
277: * @v netdev Wrapping network device.
278: *
279: * If the association task is running, this will stop it.
280: */
281: static void net80211_netdev_close ( struct net_device *netdev )
282: {
283: struct net80211_device *dev = netdev->priv;
284:
285: if ( dev->state & NET80211_WORKING )
286: process_del ( &dev->proc_assoc );
287:
288: /* Send disassociation frame to AP, to be polite */
289: if ( dev->state & NET80211_ASSOCIATED )
290: net80211_send_disassoc ( dev, IEEE80211_REASON_LEAVING, 0 );
291:
292: if ( dev->handshaker && dev->handshaker->stop &&
293: dev->handshaker->started )
294: dev->handshaker->stop ( dev );
295:
296: free ( dev->crypto );
297: free ( dev->handshaker );
298: dev->crypto = NULL;
299: dev->handshaker = NULL;
300:
301: netdev_link_down ( netdev );
302: dev->state = 0;
303:
304: if ( dev->op->close )
305: dev->op->close ( dev );
306: }
307:
308: /**
309: * Transmit packet on 802.11 device
310: *
311: * @v netdev Wrapping network device
312: * @v iobuf I/O buffer
313: * @ret rc Return status code
314: *
315: * If encryption is enabled for the currently associated network, the
316: * packet will be encrypted prior to transmission.
317: */
318: static int net80211_netdev_transmit ( struct net_device *netdev,
319: struct io_buffer *iobuf )
320: {
321: struct net80211_device *dev = netdev->priv;
322: struct ieee80211_frame *hdr = iobuf->data;
323: int rc = -ENOSYS;
324:
325: if ( dev->crypto && ! ( hdr->fc & IEEE80211_FC_PROTECTED ) &&
326: ( ( hdr->fc & IEEE80211_FC_TYPE ) == IEEE80211_TYPE_DATA ) ) {
327: struct io_buffer *niob = dev->crypto->encrypt ( dev->crypto,
328: iobuf );
329: if ( ! niob )
330: return -ENOMEM; /* only reason encryption could fail */
331:
332: /* Free the non-encrypted iob */
333: netdev_tx_complete ( netdev, iobuf );
334:
335: /* Transmit the encrypted iob; the Protected flag is
336: set, so we won't recurse into here again */
337: netdev_tx ( netdev, niob );
338:
339: /* Don't transmit the freed packet */
340: return 0;
341: }
342:
343: if ( dev->op->transmit )
344: rc = dev->op->transmit ( dev, iobuf );
345:
346: return rc;
347: }
348:
349: /**
350: * Poll 802.11 device for received packets and completed transmissions
351: *
352: * @v netdev Wrapping network device
353: */
354: static void net80211_netdev_poll ( struct net_device *netdev )
355: {
356: struct net80211_device *dev = netdev->priv;
357:
358: if ( dev->op->poll )
359: dev->op->poll ( dev );
360: }
361:
362: /**
363: * Enable or disable interrupts for 802.11 device
364: *
365: * @v netdev Wrapping network device
366: * @v enable Whether to enable interrupts
367: */
368: static void net80211_netdev_irq ( struct net_device *netdev, int enable )
369: {
370: struct net80211_device *dev = netdev->priv;
371:
372: if ( dev->op->irq )
373: dev->op->irq ( dev, enable );
374: }
375:
376: /** Network device operations for a wrapped 802.11 device */
377: static struct net_device_operations net80211_netdev_ops = {
378: .open = net80211_netdev_open,
379: .close = net80211_netdev_close,
380: .transmit = net80211_netdev_transmit,
381: .poll = net80211_netdev_poll,
382: .irq = net80211_netdev_irq,
383: };
384:
385:
386: /* ---------- 802.11 link-layer protocol ---------- */
387:
388: /** 802.11 broadcast MAC address */
389: static u8 net80211_ll_broadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
390:
391: /**
392: * Determine whether a transmission rate uses ERP/OFDM
393: *
394: * @v rate Rate in 100 kbps units
395: * @ret is_erp TRUE if the rate is an ERP/OFDM rate
396: *
397: * 802.11b supports rates of 1.0, 2.0, 5.5, and 11.0 Mbps; any other
398: * rate than these on the 2.4GHz spectrum is an ERP (802.11g) rate.
399: */
400: static inline int net80211_rate_is_erp ( u16 rate )
401: {
402: if ( rate == 10 || rate == 20 || rate == 55 || rate == 110 )
403: return 0;
404: return 1;
405: }
406:
407:
408: /**
409: * Calculate one frame's contribution to 802.11 duration field
410: *
411: * @v dev 802.11 device
412: * @v bytes Amount of data to calculate duration for
413: * @ret dur Duration field in microseconds
414: *
415: * To avoid multiple stations attempting to transmit at once, 802.11
416: * provides that every packet shall include a duration field
417: * specifying a length of time for which the wireless medium will be
418: * reserved after it is transmitted. The duration is measured in
419: * microseconds and is calculated with respect to the current
420: * physical-layer parameters of the 802.11 device.
421: *
422: * For an unfragmented data or management frame, or the last fragment
423: * of a fragmented frame, the duration captures only the 10 data bytes
424: * of one ACK; call once with bytes = 10.
425: *
426: * For a fragment of a data or management rame that will be followed
427: * by more fragments, the duration captures an ACK, the following
428: * fragment, and its ACK; add the results of three calls, two with
429: * bytes = 10 and one with bytes set to the next fragment's size.
430: *
431: * For an RTS control frame, the duration captures the responding CTS,
432: * the frame being sent, and its ACK; add the results of three calls,
433: * two with bytes = 10 and one with bytes set to the next frame's size
434: * (assuming unfragmented).
435: *
436: * For a CTS-to-self control frame, the duration captures the frame
437: * being protected and its ACK; add the results of two calls, one with
438: * bytes = 10 and one with bytes set to the next frame's size.
439: *
440: * No other frame types are currently supported by iPXE.
441: */
442: u16 net80211_duration ( struct net80211_device *dev, int bytes, u16 rate )
443: {
444: struct net80211_channel *chan = &dev->channels[dev->channel];
445: u32 kbps = rate * 100;
446:
447: if ( chan->band == NET80211_BAND_5GHZ || net80211_rate_is_erp ( rate ) ) {
448: /* OFDM encoding (802.11a/g) */
449: int bits_per_symbol = ( kbps * 4 ) / 1000; /* 4us/symbol */
450: int bits = 22 + ( bytes << 3 ); /* 22-bit PLCP */
451: int symbols = ( bits + bits_per_symbol - 1 ) / bits_per_symbol;
452:
453: return 16 + 20 + ( symbols * 4 ); /* 16us SIFS, 20us preamble */
454: } else {
455: /* CCK encoding (802.11b) */
456: int phy_time = 144 + 48; /* preamble + PLCP */
457: int bits = bytes << 3;
458: int data_time = ( bits * 1000 + kbps - 1 ) / kbps;
459:
460: if ( dev->phy_flags & NET80211_PHY_USE_SHORT_PREAMBLE )
461: phy_time >>= 1;
462:
463: return 10 + phy_time + data_time; /* 10us SIFS */
464: }
465: }
466:
467: /**
468: * Add 802.11 link-layer header
469: *
470: * @v netdev Wrapping network device
471: * @v iobuf I/O buffer
472: * @v ll_dest Link-layer destination address
473: * @v ll_source Link-layer source address
474: * @v net_proto Network-layer protocol, in network byte order
475: * @ret rc Return status code
476: *
477: * This adds both the 802.11 frame header and the 802.2 LLC/SNAP
478: * header used on data packets.
479: *
480: * We also check here for state of the link that would make it invalid
481: * to send a data packet; every data packet must pass through here,
482: * and no non-data packet (e.g. management frame) should.
483: */
484: static int net80211_ll_push ( struct net_device *netdev,
485: struct io_buffer *iobuf, const void *ll_dest,
486: const void *ll_source, uint16_t net_proto )
487: {
488: struct net80211_device *dev = netdev->priv;
489: struct ieee80211_frame *hdr = iob_push ( iobuf,
490: IEEE80211_LLC_HEADER_LEN +
491: IEEE80211_TYP_FRAME_HEADER_LEN );
492: struct ieee80211_llc_snap_header *lhdr =
493: ( void * ) hdr + IEEE80211_TYP_FRAME_HEADER_LEN;
494:
495: /* We can't send data packets if we're not associated. */
496: if ( ! ( dev->state & NET80211_ASSOCIATED ) ) {
497: if ( dev->assoc_rc )
498: return dev->assoc_rc;
499: return -ENETUNREACH;
500: }
501:
502: hdr->fc = IEEE80211_THIS_VERSION | IEEE80211_TYPE_DATA |
503: IEEE80211_STYPE_DATA | IEEE80211_FC_TODS;
504:
505: /* We don't send fragmented frames, so duration is the time
506: for an SIFS + 10-byte ACK. */
507: hdr->duration = net80211_duration ( dev, 10, dev->rates[dev->rate] );
508:
509: memcpy ( hdr->addr1, dev->bssid, ETH_ALEN );
510: memcpy ( hdr->addr2, ll_source, ETH_ALEN );
511: memcpy ( hdr->addr3, ll_dest, ETH_ALEN );
512:
513: hdr->seq = IEEE80211_MAKESEQ ( ++dev->last_tx_seqnr, 0 );
514:
515: lhdr->dsap = IEEE80211_LLC_DSAP;
516: lhdr->ssap = IEEE80211_LLC_SSAP;
517: lhdr->ctrl = IEEE80211_LLC_CTRL;
518: memset ( lhdr->oui, 0x00, 3 );
519: lhdr->ethertype = net_proto;
520:
521: return 0;
522: }
523:
524: /**
525: * Remove 802.11 link-layer header
526: *
527: * @v netdev Wrapping network device
528: * @v iobuf I/O buffer
529: * @ret ll_dest Link-layer destination address
530: * @ret ll_source Link-layer source
531: * @ret net_proto Network-layer protocol, in network byte order
532: * @ret rc Return status code
533: *
534: * This expects and removes both the 802.11 frame header and the 802.2
535: * LLC/SNAP header that are used on data packets.
536: */
537: static int net80211_ll_pull ( struct net_device *netdev __unused,
538: struct io_buffer *iobuf,
539: const void **ll_dest, const void **ll_source,
540: uint16_t * net_proto )
541: {
542: struct ieee80211_frame *hdr = iobuf->data;
543: struct ieee80211_llc_snap_header *lhdr =
544: ( void * ) hdr + IEEE80211_TYP_FRAME_HEADER_LEN;
545:
546: /* Bunch of sanity checks */
547: if ( iob_len ( iobuf ) < IEEE80211_TYP_FRAME_HEADER_LEN +
548: IEEE80211_LLC_HEADER_LEN ) {
549: DBGC ( netdev->priv, "802.11 %p packet too short (%zd bytes)\n",
550: netdev->priv, iob_len ( iobuf ) );
551: return -EINVAL_PKT_TOO_SHORT;
552: }
553:
554: if ( ( hdr->fc & IEEE80211_FC_VERSION ) != IEEE80211_THIS_VERSION ) {
555: DBGC ( netdev->priv, "802.11 %p packet invalid version %04x\n",
556: netdev->priv, hdr->fc & IEEE80211_FC_VERSION );
557: return -EINVAL_PKT_VERSION;
558: }
559:
560: if ( ( hdr->fc & IEEE80211_FC_TYPE ) != IEEE80211_TYPE_DATA ||
561: ( hdr->fc & IEEE80211_FC_SUBTYPE ) != IEEE80211_STYPE_DATA ) {
562: DBGC ( netdev->priv, "802.11 %p packet not data/data (fc=%04x)\n",
563: netdev->priv, hdr->fc );
564: return -EINVAL_PKT_NOT_DATA;
565: }
566:
567: if ( ( hdr->fc & ( IEEE80211_FC_TODS | IEEE80211_FC_FROMDS ) ) !=
568: IEEE80211_FC_FROMDS ) {
569: DBGC ( netdev->priv, "802.11 %p packet not from DS (fc=%04x)\n",
570: netdev->priv, hdr->fc );
571: return -EINVAL_PKT_NOT_FROMDS;
572: }
573:
574: if ( lhdr->dsap != IEEE80211_LLC_DSAP || lhdr->ssap != IEEE80211_LLC_SSAP ||
575: lhdr->ctrl != IEEE80211_LLC_CTRL || lhdr->oui[0] || lhdr->oui[1] ||
576: lhdr->oui[2] ) {
577: DBGC ( netdev->priv, "802.11 %p LLC header is not plain EtherType "
578: "encapsulator: %02x->%02x [%02x] %02x:%02x:%02x %04x\n",
579: netdev->priv, lhdr->dsap, lhdr->ssap, lhdr->ctrl,
580: lhdr->oui[0], lhdr->oui[1], lhdr->oui[2], lhdr->ethertype );
581: return -EINVAL_PKT_LLC_HEADER;
582: }
583:
584: iob_pull ( iobuf, sizeof ( *hdr ) + sizeof ( *lhdr ) );
585:
586: *ll_dest = hdr->addr1;
587: *ll_source = hdr->addr3;
588: *net_proto = lhdr->ethertype;
589: return 0;
590: }
591:
592: /** 802.11 link-layer protocol */
593: static struct ll_protocol net80211_ll_protocol __ll_protocol = {
594: .name = "802.11",
595: .push = net80211_ll_push,
596: .pull = net80211_ll_pull,
597: .init_addr = eth_init_addr,
598: .ntoa = eth_ntoa,
599: .mc_hash = eth_mc_hash,
600: .eth_addr = eth_eth_addr,
601: .ll_proto = htons ( ARPHRD_ETHER ), /* "encapsulated Ethernet" */
602: .hw_addr_len = ETH_ALEN,
603: .ll_addr_len = ETH_ALEN,
604: .ll_header_len = IEEE80211_TYP_FRAME_HEADER_LEN +
605: IEEE80211_LLC_HEADER_LEN,
606: };
607:
608:
609: /* ---------- 802.11 network management API ---------- */
610:
611: /**
612: * Get 802.11 device from wrapping network device
613: *
614: * @v netdev Wrapping network device
615: * @ret dev 802.11 device wrapped by network device, or NULL
616: *
617: * Returns NULL if the network device does not wrap an 802.11 device.
618: */
619: struct net80211_device * net80211_get ( struct net_device *netdev )
620: {
621: struct net80211_device *dev;
622:
623: list_for_each_entry ( dev, &net80211_devices, list ) {
624: if ( netdev->priv == dev )
625: return netdev->priv;
626: }
627:
628: return NULL;
629: }
630:
631: /**
632: * Set state of 802.11 device keeping management frames
633: *
634: * @v dev 802.11 device
635: * @v enable Whether to keep management frames
636: * @ret oldenab Whether management frames were enabled before this call
637: *
638: * If enable is TRUE, beacon, probe, and action frames will be kept
639: * and may be retrieved by calling net80211_mgmt_dequeue().
640: */
641: int net80211_keep_mgmt ( struct net80211_device *dev, int enable )
642: {
643: int oldenab = dev->keep_mgmt;
644:
645: dev->keep_mgmt = enable;
646: return oldenab;
647: }
648:
649: /**
650: * Get 802.11 management frame
651: *
652: * @v dev 802.11 device
653: * @ret signal Signal strength of returned management frame
654: * @ret iob I/O buffer, or NULL if no management frame is queued
655: *
656: * Frames will only be returned by this function if
657: * net80211_keep_mgmt() has been previously called with enable set to
658: * TRUE.
659: *
660: * The calling function takes ownership of the returned I/O buffer.
661: */
662: struct io_buffer * net80211_mgmt_dequeue ( struct net80211_device *dev,
663: int *signal )
664: {
665: struct io_buffer *iobuf;
666: struct net80211_rx_info *rxi;
667:
668: list_for_each_entry ( rxi, &dev->mgmt_info_queue, list ) {
669: list_del ( &rxi->list );
670: if ( signal )
671: *signal = rxi->signal;
672: free ( rxi );
673:
674: assert ( ! list_empty ( &dev->mgmt_queue ) );
675: iobuf = list_first_entry ( &dev->mgmt_queue, struct io_buffer,
676: list );
677: list_del ( &iobuf->list );
678: return iobuf;
679: }
680:
681: return NULL;
682: }
683:
684: /**
685: * Transmit 802.11 management frame
686: *
687: * @v dev 802.11 device
688: * @v fc Frame Control flags for management frame
689: * @v dest Destination access point
690: * @v iob I/O buffer
691: * @ret rc Return status code
692: *
693: * The @a fc argument must contain at least an IEEE 802.11 management
694: * subtype number (e.g. IEEE80211_STYPE_PROBE_REQ). If it contains
695: * IEEE80211_FC_PROTECTED, the frame will be encrypted prior to
696: * transmission.
697: *
698: * It is required that @a iob have at least 24 bytes of headroom
699: * reserved before its data start.
700: */
701: int net80211_tx_mgmt ( struct net80211_device *dev, u16 fc, u8 dest[6],
702: struct io_buffer *iob )
703: {
704: struct ieee80211_frame *hdr = iob_push ( iob,
705: IEEE80211_TYP_FRAME_HEADER_LEN );
706:
707: hdr->fc = IEEE80211_THIS_VERSION | IEEE80211_TYPE_MGMT |
708: ( fc & ~IEEE80211_FC_PROTECTED );
709: hdr->duration = net80211_duration ( dev, 10, dev->rates[dev->rate] );
710: hdr->seq = IEEE80211_MAKESEQ ( ++dev->last_tx_seqnr, 0 );
711:
712: memcpy ( hdr->addr1, dest, ETH_ALEN ); /* DA = RA */
713: memcpy ( hdr->addr2, dev->netdev->ll_addr, ETH_ALEN ); /* SA = TA */
714: memcpy ( hdr->addr3, dest, ETH_ALEN ); /* BSSID */
715:
716: if ( fc & IEEE80211_FC_PROTECTED ) {
717: if ( ! dev->crypto )
718: return -EINVAL_CRYPTO_REQUEST;
719:
720: struct io_buffer *eiob = dev->crypto->encrypt ( dev->crypto,
721: iob );
722: free_iob ( iob );
723: iob = eiob;
724: }
725:
726: return netdev_tx ( dev->netdev, iob );
727: }
728:
729:
730: /* ---------- Driver API ---------- */
731:
732: /**
733: * Allocate 802.11 device
734: *
735: * @v priv_size Size of driver-private allocation area
736: * @ret dev Newly allocated 802.11 device
737: *
738: * This function allocates a net_device with space in its private area
739: * for both the net80211_device it will wrap and the driver-private
740: * data space requested. It initializes the link-layer-specific parts
741: * of the net_device, and links the net80211_device to the net_device
742: * appropriately.
743: */
744: struct net80211_device * net80211_alloc ( size_t priv_size )
745: {
746: struct net80211_device *dev;
747: struct net_device *netdev =
748: alloc_netdev ( sizeof ( *dev ) + priv_size );
749:
750: if ( ! netdev )
751: return NULL;
752:
753: netdev->ll_protocol = &net80211_ll_protocol;
754: netdev->ll_broadcast = net80211_ll_broadcast;
755: netdev->max_pkt_len = IEEE80211_MAX_DATA_LEN;
756: netdev_init ( netdev, &net80211_netdev_ops );
757:
758: dev = netdev->priv;
759: dev->netdev = netdev;
760: dev->priv = ( u8 * ) dev + sizeof ( *dev );
761: dev->op = &net80211_null_ops;
762:
763: process_init_stopped ( &dev->proc_assoc, net80211_step_associate,
764: &netdev->refcnt );
765: INIT_LIST_HEAD ( &dev->mgmt_queue );
766: INIT_LIST_HEAD ( &dev->mgmt_info_queue );
767:
768: return dev;
769: }
770:
771: /**
772: * Register 802.11 device with network stack
773: *
774: * @v dev 802.11 device
775: * @v ops 802.11 device operations
776: * @v hw 802.11 hardware information
777: *
778: * This also registers the wrapping net_device with the higher network
779: * layers.
780: */
781: int net80211_register ( struct net80211_device *dev,
782: struct net80211_device_operations *ops,
783: struct net80211_hw_info *hw )
784: {
785: dev->op = ops;
786: dev->hw = malloc ( sizeof ( *hw ) );
787: if ( ! dev->hw )
788: return -ENOMEM;
789:
790: memcpy ( dev->hw, hw, sizeof ( *hw ) );
791: memcpy ( dev->netdev->hw_addr, hw->hwaddr, ETH_ALEN );
792:
793: /* Set some sensible channel defaults for driver's open() function */
794: memcpy ( dev->channels, dev->hw->channels,
795: NET80211_MAX_CHANNELS * sizeof ( dev->channels[0] ) );
796: dev->channel = 0;
797:
798: list_add_tail ( &dev->list, &net80211_devices );
799: return register_netdev ( dev->netdev );
800: }
801:
802: /**
803: * Unregister 802.11 device from network stack
804: *
805: * @v dev 802.11 device
806: *
807: * After this call, the device operations are cleared so that they
808: * will not be called.
809: */
810: void net80211_unregister ( struct net80211_device *dev )
811: {
812: unregister_netdev ( dev->netdev );
813: list_del ( &dev->list );
814: dev->op = &net80211_null_ops;
815: }
816:
817: /**
818: * Free 802.11 device
819: *
820: * @v dev 802.11 device
821: *
822: * The device should be unregistered before this function is called.
823: */
824: void net80211_free ( struct net80211_device *dev )
825: {
826: free ( dev->hw );
827: rc80211_free ( dev->rctl );
828: netdev_nullify ( dev->netdev );
829: netdev_put ( dev->netdev );
830: }
831:
832:
833: /* ---------- 802.11 network management workhorse code ---------- */
834:
835: /**
836: * Set state of 802.11 device
837: *
838: * @v dev 802.11 device
839: * @v clear Bitmask of flags to clear
840: * @v set Bitmask of flags to set
841: * @v status Status or reason code for most recent operation
842: *
843: * If @a status represents a reason code, it should be OR'ed with
844: * NET80211_IS_REASON.
845: *
846: * Clearing authentication also clears association; clearing
847: * association also clears security handshaking state. Clearing
848: * association removes the link-up flag from the wrapping net_device,
849: * but setting it does not automatically set the flag; that is left to
850: * the judgment of higher-level code.
851: */
852: static inline void net80211_set_state ( struct net80211_device *dev,
853: short clear, short set,
854: u16 status )
855: {
856: /* The conditions in this function are deliberately formulated
857: to be decidable at compile-time in most cases. Since clear
858: and set are generally passed as constants, the body of this
859: function can be reduced down to a few statements by the
860: compiler. */
861:
862: const int statmsk = NET80211_STATUS_MASK | NET80211_IS_REASON;
863:
864: if ( clear & NET80211_PROBED )
865: clear |= NET80211_AUTHENTICATED;
866:
867: if ( clear & NET80211_AUTHENTICATED )
868: clear |= NET80211_ASSOCIATED;
869:
870: if ( clear & NET80211_ASSOCIATED )
871: clear |= NET80211_CRYPTO_SYNCED;
872:
873: dev->state = ( dev->state & ~clear ) | set;
874: dev->state = ( dev->state & ~statmsk ) | ( status & statmsk );
875:
876: if ( clear & NET80211_ASSOCIATED )
877: netdev_link_down ( dev->netdev );
878:
879: if ( ( clear | set ) & NET80211_ASSOCIATED )
880: dev->op->config ( dev, NET80211_CFG_ASSOC );
881:
882: if ( status != 0 ) {
883: if ( status & NET80211_IS_REASON )
884: dev->assoc_rc = -E80211_REASON ( status );
885: else
886: dev->assoc_rc = -E80211_STATUS ( status );
887: netdev_link_err ( dev->netdev, dev->assoc_rc );
888: }
889: }
890:
891: /**
892: * Add channels to 802.11 device
893: *
894: * @v dev 802.11 device
895: * @v start First channel number to add
896: * @v len Number of channels to add
897: * @v txpower TX power (dBm) to allow on added channels
898: *
899: * To replace the current list of channels instead of adding to it,
900: * set the nr_channels field of the 802.11 device to 0 before calling
901: * this function.
902: */
903: static void net80211_add_channels ( struct net80211_device *dev, int start,
904: int len, int txpower )
905: {
906: int i, chan = start;
907:
908: for ( i = dev->nr_channels; len-- && i < NET80211_MAX_CHANNELS; i++ ) {
909: dev->channels[i].channel_nr = chan;
910: dev->channels[i].maxpower = txpower;
911: dev->channels[i].hw_value = 0;
912:
913: if ( chan >= 1 && chan <= 14 ) {
914: dev->channels[i].band = NET80211_BAND_2GHZ;
915: if ( chan == 14 )
916: dev->channels[i].center_freq = 2484;
917: else
918: dev->channels[i].center_freq = 2407 + 5 * chan;
919: chan++;
920: } else {
921: dev->channels[i].band = NET80211_BAND_5GHZ;
922: dev->channels[i].center_freq = 5000 + 5 * chan;
923: chan += 4;
924: }
925: }
926:
927: dev->nr_channels = i;
928: }
929:
930: /**
931: * Filter 802.11 device channels for hardware capabilities
932: *
933: * @v dev 802.11 device
934: *
935: * Hardware may support fewer channels than regulatory restrictions
936: * allow; this function filters out channels in dev->channels that are
937: * not supported by the hardware list in dev->hwinfo. It also copies
938: * over the net80211_channel::hw_value and limits maximum TX power
939: * appropriately.
940: *
941: * Channels are matched based on center frequency, ignoring band and
942: * channel number.
943: *
944: * If the driver specifies no supported channels, the effect will be
945: * as though all were supported.
946: */
947: static void net80211_filter_hw_channels ( struct net80211_device *dev )
948: {
949: int delta = 0, i = 0;
950: int old_freq = dev->channels[dev->channel].center_freq;
951: struct net80211_channel *chan, *hwchan;
952:
953: if ( ! dev->hw->nr_channels )
954: return;
955:
956: dev->channel = 0;
957: for ( chan = dev->channels; chan < dev->channels + dev->nr_channels;
958: chan++, i++ ) {
959: int ok = 0;
960: for ( hwchan = dev->hw->channels;
961: hwchan < dev->hw->channels + dev->hw->nr_channels;
962: hwchan++ ) {
963: if ( hwchan->center_freq == chan->center_freq ) {
964: ok = 1;
965: break;
966: }
967: }
968:
969: if ( ! ok )
970: delta++;
971: else {
972: chan->hw_value = hwchan->hw_value;
973: if ( hwchan->maxpower != 0 &&
974: chan->maxpower > hwchan->maxpower )
975: chan->maxpower = hwchan->maxpower;
976: if ( old_freq == chan->center_freq )
977: dev->channel = i - delta;
978: if ( delta )
979: chan[-delta] = *chan;
980: }
981: }
982:
983: dev->nr_channels -= delta;
984:
985: if ( dev->channels[dev->channel].center_freq != old_freq )
986: dev->op->config ( dev, NET80211_CFG_CHANNEL );
987: }
988:
989: /**
990: * Update 802.11 device state to reflect received capabilities field
991: *
992: * @v dev 802.11 device
993: * @v capab Capabilities field in beacon, probe, or association frame
994: * @ret rc Return status code
995: */
996: static int net80211_process_capab ( struct net80211_device *dev,
997: u16 capab )
998: {
999: u16 old_phy = dev->phy_flags;
1000:
1001: if ( ( capab & ( IEEE80211_CAPAB_MANAGED | IEEE80211_CAPAB_ADHOC ) ) !=
1002: IEEE80211_CAPAB_MANAGED ) {
1003: DBGC ( dev, "802.11 %p cannot handle IBSS network\n", dev );
1004: return -ENOSYS;
1005: }
1006:
1007: dev->phy_flags &= ~( NET80211_PHY_USE_SHORT_PREAMBLE |
1008: NET80211_PHY_USE_SHORT_SLOT );
1009:
1010: if ( capab & IEEE80211_CAPAB_SHORT_PMBL )
1011: dev->phy_flags |= NET80211_PHY_USE_SHORT_PREAMBLE;
1012:
1013: if ( capab & IEEE80211_CAPAB_SHORT_SLOT )
1014: dev->phy_flags |= NET80211_PHY_USE_SHORT_SLOT;
1015:
1016: if ( old_phy != dev->phy_flags )
1017: dev->op->config ( dev, NET80211_CFG_PHY_PARAMS );
1018:
1019: return 0;
1020: }
1021:
1022: /**
1023: * Update 802.11 device state to reflect received information elements
1024: *
1025: * @v dev 802.11 device
1026: * @v ie Pointer to first information element
1027: * @v ie_end Pointer to tail of packet I/O buffer
1028: * @ret rc Return status code
1029: */
1030: static int net80211_process_ie ( struct net80211_device *dev,
1031: union ieee80211_ie *ie, void *ie_end )
1032: {
1033: u16 old_rate = dev->rates[dev->rate];
1034: u16 old_phy = dev->phy_flags;
1035: int have_rates = 0, i;
1036: int ds_channel = 0;
1037: int changed = 0;
1038: int band = dev->channels[dev->channel].band;
1039:
1040: if ( ! ieee80211_ie_bound ( ie, ie_end ) )
1041: return 0;
1042:
1043: for ( ; ie; ie = ieee80211_next_ie ( ie, ie_end ) ) {
1044: switch ( ie->id ) {
1045: case IEEE80211_IE_SSID:
1046: if ( ie->len <= 32 ) {
1047: memcpy ( dev->essid, ie->ssid, ie->len );
1048: dev->essid[ie->len] = 0;
1049: }
1050: break;
1051:
1052: case IEEE80211_IE_RATES:
1053: case IEEE80211_IE_EXT_RATES:
1054: if ( ! have_rates ) {
1055: dev->nr_rates = 0;
1056: dev->basic_rates = 0;
1057: have_rates = 1;
1058: }
1059: for ( i = 0; i < ie->len &&
1060: dev->nr_rates < NET80211_MAX_RATES; i++ ) {
1061: u8 rid = ie->rates[i];
1062: u16 rate = ( rid & 0x7f ) * 5;
1063:
1064: if ( rid & 0x80 )
1065: dev->basic_rates |=
1066: ( 1 << dev->nr_rates );
1067:
1068: dev->rates[dev->nr_rates++] = rate;
1069: }
1070:
1071: break;
1072:
1073: case IEEE80211_IE_DS_PARAM:
1074: if ( dev->channel < dev->nr_channels && ds_channel ==
1075: dev->channels[dev->channel].channel_nr )
1076: break;
1077: ds_channel = ie->ds_param.current_channel;
1078: net80211_change_channel ( dev, ds_channel );
1079: break;
1080:
1081: case IEEE80211_IE_COUNTRY:
1082: dev->nr_channels = 0;
1083:
1084: DBGC ( dev, "802.11 %p setting country regulations "
1085: "for %c%c\n", dev, ie->country.name[0],
1086: ie->country.name[1] );
1087: for ( i = 0; i < ( ie->len - 3 ) / 3; i++ ) {
1088: union ieee80211_ie_country_triplet *t =
1089: &ie->country.triplet[i];
1090: if ( t->first > 200 ) {
1091: DBGC ( dev, "802.11 %p ignoring regulatory "
1092: "extension information\n", dev );
1093: } else {
1094: net80211_add_channels ( dev,
1095: t->band.first_channel,
1096: t->band.nr_channels,
1097: t->band.max_txpower );
1098: }
1099: }
1100: net80211_filter_hw_channels ( dev );
1101: break;
1102:
1103: case IEEE80211_IE_ERP_INFO:
1104: dev->phy_flags &= ~( NET80211_PHY_USE_PROTECTION |
1105: NET80211_PHY_USE_SHORT_PREAMBLE );
1106: if ( ie->erp_info & IEEE80211_ERP_USE_PROTECTION )
1107: dev->phy_flags |= NET80211_PHY_USE_PROTECTION;
1108: if ( ! ( ie->erp_info & IEEE80211_ERP_BARKER_LONG ) )
1109: dev->phy_flags |= NET80211_PHY_USE_SHORT_PREAMBLE;
1110: break;
1111: }
1112: }
1113:
1114: if ( have_rates ) {
1115: /* Allow only those rates that are also supported by
1116: the hardware. */
1117: int delta = 0, j;
1118:
1119: dev->rate = 0;
1120: for ( i = 0; i < dev->nr_rates; i++ ) {
1121: int ok = 0;
1122: for ( j = 0; j < dev->hw->nr_rates[band]; j++ ) {
1123: if ( dev->hw->rates[band][j] == dev->rates[i] ){
1124: ok = 1;
1125: break;
1126: }
1127: }
1128:
1129: if ( ! ok )
1130: delta++;
1131: else {
1132: dev->rates[i - delta] = dev->rates[i];
1133: if ( old_rate == dev->rates[i] )
1134: dev->rate = i - delta;
1135: }
1136: }
1137:
1138: dev->nr_rates -= delta;
1139:
1140: /* Sort available rates - sorted subclumps tend to already
1141: exist, so insertion sort works well. */
1142: for ( i = 1; i < dev->nr_rates; i++ ) {
1143: u16 rate = dev->rates[i];
1144: u32 tmp, br, mask;
1145:
1146: for ( j = i - 1; j >= 0 && dev->rates[j] >= rate; j-- )
1147: dev->rates[j + 1] = dev->rates[j];
1148: dev->rates[j + 1] = rate;
1149:
1150: /* Adjust basic_rates to match by rotating the
1151: bits from bit j+1 to bit i left one position. */
1152: mask = ( ( 1 << i ) - 1 ) & ~( ( 1 << ( j + 1 ) ) - 1 );
1153: br = dev->basic_rates;
1154: tmp = br & ( 1 << i );
1155: br = ( br & ~( mask | tmp ) ) | ( ( br & mask ) << 1 );
1156: br |= ( tmp >> ( i - j - 1 ) );
1157: dev->basic_rates = br;
1158: }
1159:
1160: net80211_set_rtscts_rate ( dev );
1161:
1162: if ( dev->rates[dev->rate] != old_rate )
1163: changed |= NET80211_CFG_RATE;
1164: }
1165:
1166: if ( dev->hw->flags & NET80211_HW_NO_SHORT_PREAMBLE )
1167: dev->phy_flags &= ~NET80211_PHY_USE_SHORT_PREAMBLE;
1168: if ( dev->hw->flags & NET80211_HW_NO_SHORT_SLOT )
1169: dev->phy_flags &= ~NET80211_PHY_USE_SHORT_SLOT;
1170:
1171: if ( old_phy != dev->phy_flags )
1172: changed |= NET80211_CFG_PHY_PARAMS;
1173:
1174: if ( changed )
1175: dev->op->config ( dev, changed );
1176:
1177: return 0;
1178: }
1179:
1180: /**
1181: * Create information elements for outgoing probe or association packet
1182: *
1183: * @v dev 802.11 device
1184: * @v ie Pointer to start of information element area
1185: * @ret next_ie Pointer to first byte after added information elements
1186: */
1187: static union ieee80211_ie *
1188: net80211_marshal_request_info ( struct net80211_device *dev,
1189: union ieee80211_ie *ie )
1190: {
1191: int i;
1192:
1193: ie->id = IEEE80211_IE_SSID;
1194: ie->len = strlen ( dev->essid );
1195: memcpy ( ie->ssid, dev->essid, ie->len );
1196:
1197: ie = ieee80211_next_ie ( ie, NULL );
1198:
1199: ie->id = IEEE80211_IE_RATES;
1200: ie->len = dev->nr_rates;
1201: if ( ie->len > 8 )
1202: ie->len = 8;
1203:
1204: for ( i = 0; i < ie->len; i++ ) {
1205: ie->rates[i] = dev->rates[i] / 5;
1206: if ( dev->basic_rates & ( 1 << i ) )
1207: ie->rates[i] |= 0x80;
1208: }
1209:
1210: ie = ieee80211_next_ie ( ie, NULL );
1211:
1212: if ( dev->rsn_ie && dev->rsn_ie->id == IEEE80211_IE_RSN ) {
1213: memcpy ( ie, dev->rsn_ie, dev->rsn_ie->len + 2 );
1214: ie = ieee80211_next_ie ( ie, NULL );
1215: }
1216:
1217: if ( dev->nr_rates > 8 ) {
1218: /* 802.11 requires we use an Extended Basic Rates IE
1219: for the rates beyond the eighth. */
1220:
1221: ie->id = IEEE80211_IE_EXT_RATES;
1222: ie->len = dev->nr_rates - 8;
1223:
1224: for ( ; i < dev->nr_rates; i++ ) {
1225: ie->rates[i - 8] = dev->rates[i] / 5;
1226: if ( dev->basic_rates & ( 1 << i ) )
1227: ie->rates[i - 8] |= 0x80;
1228: }
1229:
1230: ie = ieee80211_next_ie ( ie, NULL );
1231: }
1232:
1233: if ( dev->rsn_ie && dev->rsn_ie->id == IEEE80211_IE_VENDOR ) {
1234: memcpy ( ie, dev->rsn_ie, dev->rsn_ie->len + 2 );
1235: ie = ieee80211_next_ie ( ie, NULL );
1236: }
1237:
1238: return ie;
1239: }
1240:
1241: /** Seconds to wait after finding a network, to possibly find better APs for it
1242: *
1243: * This is used when a specific SSID to scan for is specified.
1244: */
1245: #define NET80211_PROBE_GATHER 1
1246:
1247: /** Seconds to wait after finding a network, to possibly find other networks
1248: *
1249: * This is used when an empty SSID is specified, to scan for all
1250: * networks.
1251: */
1252: #define NET80211_PROBE_GATHER_ALL 2
1253:
1254: /** Seconds to allow a probe to take if no network has been found */
1255: #define NET80211_PROBE_TIMEOUT 6
1256:
1257: /**
1258: * Begin probe of 802.11 networks
1259: *
1260: * @v dev 802.11 device
1261: * @v essid SSID to probe for, or "" to accept any (may not be NULL)
1262: * @v active Whether to use active scanning
1263: * @ret ctx Probe context
1264: *
1265: * Active scanning may only be used on channels 1-11 in the 2.4GHz
1266: * band, due to iPXE's lack of a complete regulatory database. If
1267: * active scanning is used, probe packets will be sent on each
1268: * channel; this can allow association with hidden-SSID networks if
1269: * the SSID is properly specified.
1270: *
1271: * A @c NULL return indicates an out-of-memory condition.
1272: *
1273: * The returned context must be periodically passed to
1274: * net80211_probe_step() until that function returns zero.
1275: */
1276: struct net80211_probe_ctx * net80211_probe_start ( struct net80211_device *dev,
1277: const char *essid,
1278: int active )
1279: {
1280: struct net80211_probe_ctx *ctx = zalloc ( sizeof ( *ctx ) );
1281:
1282: if ( ! ctx )
1283: return NULL;
1284:
1285: assert ( netdev_is_open ( dev->netdev ) );
1286:
1287: ctx->dev = dev;
1288: ctx->old_keep_mgmt = net80211_keep_mgmt ( dev, 1 );
1289: ctx->essid = essid;
1290: if ( dev->essid != ctx->essid )
1291: strcpy ( dev->essid, ctx->essid );
1292:
1293: if ( active ) {
1294: struct ieee80211_probe_req *probe_req;
1295: union ieee80211_ie *ie;
1296:
1297: ctx->probe = alloc_iob ( 128 );
1298: iob_reserve ( ctx->probe, IEEE80211_TYP_FRAME_HEADER_LEN );
1299: probe_req = ctx->probe->data;
1300:
1301: ie = net80211_marshal_request_info ( dev,
1302: probe_req->info_element );
1303:
1304: iob_put ( ctx->probe, ( void * ) ie - ctx->probe->data );
1305: }
1306:
1307: ctx->ticks_start = currticks();
1308: ctx->ticks_beacon = 0;
1309: ctx->ticks_channel = currticks();
1310: ctx->hop_time = ticks_per_sec() / ( active ? 2 : 6 );
1311:
1312: /*
1313: * Channels on 2.4GHz overlap, and the most commonly used
1314: * are 1, 6, and 11. We'll get a result faster if we check
1315: * every 5 channels, but in order to hit all of them the
1316: * number of channels must be relatively prime to 5. If it's
1317: * not, tweak the hop.
1318: */
1319: ctx->hop_step = 5;
1320: while ( dev->nr_channels % ctx->hop_step == 0 && ctx->hop_step > 1 )
1321: ctx->hop_step--;
1322:
1323: ctx->beacons = malloc ( sizeof ( *ctx->beacons ) );
1324: INIT_LIST_HEAD ( ctx->beacons );
1325:
1326: dev->channel = 0;
1327: dev->op->config ( dev, NET80211_CFG_CHANNEL );
1328:
1329: return ctx;
1330: }
1331:
1332: /**
1333: * Continue probe of 802.11 networks
1334: *
1335: * @v ctx Probe context returned by net80211_probe_start()
1336: * @ret rc Probe status
1337: *
1338: * The return code will be 0 if the probe is still going on (and this
1339: * function should be called again), a positive number if the probe
1340: * completed successfully, or a negative error code if the probe
1341: * failed for that reason.
1342: *
1343: * Whether the probe succeeded or failed, you must call
1344: * net80211_probe_finish_all() or net80211_probe_finish_best()
1345: * (depending on whether you want information on all networks or just
1346: * the best-signal one) in order to release the probe context. A
1347: * failed probe may still have acquired some valid data.
1348: */
1349: int net80211_probe_step ( struct net80211_probe_ctx *ctx )
1350: {
1351: struct net80211_device *dev = ctx->dev;
1352: u32 start_timeout = NET80211_PROBE_TIMEOUT * ticks_per_sec();
1353: u32 gather_timeout = ticks_per_sec();
1354: u32 now = currticks();
1355: struct io_buffer *iob;
1356: int signal;
1357: int rc;
1358: char ssid[IEEE80211_MAX_SSID_LEN + 1];
1359:
1360: gather_timeout *= ( ctx->essid[0] ? NET80211_PROBE_GATHER :
1361: NET80211_PROBE_GATHER_ALL );
1362:
1363: /* Time out if necessary */
1364: if ( now >= ctx->ticks_start + start_timeout )
1365: return list_empty ( ctx->beacons ) ? -ETIMEDOUT : +1;
1366:
1367: if ( ctx->ticks_beacon > 0 && now >= ctx->ticks_start + gather_timeout )
1368: return +1;
1369:
1370: /* Change channels if necessary */
1371: if ( now >= ctx->ticks_channel + ctx->hop_time ) {
1372: dev->channel = ( dev->channel + ctx->hop_step )
1373: % dev->nr_channels;
1374: dev->op->config ( dev, NET80211_CFG_CHANNEL );
1375: udelay ( dev->hw->channel_change_time );
1376:
1377: ctx->ticks_channel = now;
1378:
1379: if ( ctx->probe ) {
1380: struct io_buffer *siob = ctx->probe; /* to send */
1381:
1382: /* make a copy for future use */
1383: iob = alloc_iob ( siob->tail - siob->head );
1384: iob_reserve ( iob, iob_headroom ( siob ) );
1385: memcpy ( iob_put ( iob, iob_len ( siob ) ),
1386: siob->data, iob_len ( siob ) );
1387:
1388: ctx->probe = iob;
1389: rc = net80211_tx_mgmt ( dev, IEEE80211_STYPE_PROBE_REQ,
1390: net80211_ll_broadcast,
1391: iob_disown ( siob ) );
1392: if ( rc ) {
1393: DBGC ( dev, "802.11 %p send probe failed: "
1394: "%s\n", dev, strerror ( rc ) );
1395: return rc;
1396: }
1397: }
1398: }
1399:
1400: /* Check for new management packets */
1401: while ( ( iob = net80211_mgmt_dequeue ( dev, &signal ) ) != NULL ) {
1402: struct ieee80211_frame *hdr;
1403: struct ieee80211_beacon *beacon;
1404: union ieee80211_ie *ie;
1405: struct net80211_wlan *wlan;
1406: u16 type;
1407:
1408: hdr = iob->data;
1409: type = hdr->fc & IEEE80211_FC_SUBTYPE;
1410: beacon = ( struct ieee80211_beacon * ) hdr->data;
1411:
1412: if ( type != IEEE80211_STYPE_BEACON &&
1413: type != IEEE80211_STYPE_PROBE_RESP ) {
1414: DBGC2 ( dev, "802.11 %p probe: non-beacon\n", dev );
1415: goto drop;
1416: }
1417:
1418: if ( ( void * ) beacon->info_element >= iob->tail ) {
1419: DBGC ( dev, "802.11 %p probe: beacon with no IEs\n",
1420: dev );
1421: goto drop;
1422: }
1423:
1424: ie = beacon->info_element;
1425:
1426: if ( ! ieee80211_ie_bound ( ie, iob->tail ) )
1427: ie = NULL;
1428:
1429: while ( ie && ie->id != IEEE80211_IE_SSID )
1430: ie = ieee80211_next_ie ( ie, iob->tail );
1431:
1432: if ( ! ie ) {
1433: DBGC ( dev, "802.11 %p probe: beacon with no SSID\n",
1434: dev );
1435: goto drop;
1436: }
1437:
1438: memcpy ( ssid, ie->ssid, ie->len );
1439: ssid[ie->len] = 0;
1440:
1441: if ( ctx->essid[0] && strcmp ( ctx->essid, ssid ) != 0 ) {
1442: DBGC2 ( dev, "802.11 %p probe: beacon with wrong SSID "
1443: "(%s)\n", dev, ssid );
1444: goto drop;
1445: }
1446:
1447: /* See if we've got an entry for this network */
1448: list_for_each_entry ( wlan, ctx->beacons, list ) {
1449: if ( strcmp ( wlan->essid, ssid ) != 0 )
1450: continue;
1451:
1452: if ( signal < wlan->signal ) {
1453: DBGC2 ( dev, "802.11 %p probe: beacon for %s "
1454: "(%s) with weaker signal %d\n", dev,
1455: ssid, eth_ntoa ( hdr->addr3 ), signal );
1456: goto drop;
1457: }
1458:
1459: goto fill;
1460: }
1461:
1462: /* No entry yet - make one */
1463: wlan = zalloc ( sizeof ( *wlan ) );
1464: strcpy ( wlan->essid, ssid );
1465: list_add_tail ( &wlan->list, ctx->beacons );
1466:
1467: /* Whether we're using an old entry or a new one, fill
1468: it with new data. */
1469: fill:
1470: memcpy ( wlan->bssid, hdr->addr3, ETH_ALEN );
1471: wlan->signal = signal;
1472: wlan->channel = dev->channels[dev->channel].channel_nr;
1473:
1474: /* Copy this I/O buffer into a new wlan->beacon; the
1475: * iob we've got probably came from the device driver
1476: * and may have the full 2.4k allocation, which we
1477: * don't want to keep around wasting memory.
1478: */
1479: free_iob ( wlan->beacon );
1480: wlan->beacon = alloc_iob ( iob_len ( iob ) );
1481: memcpy ( iob_put ( wlan->beacon, iob_len ( iob ) ),
1482: iob->data, iob_len ( iob ) );
1483:
1484: if ( ( rc = sec80211_detect ( wlan->beacon, &wlan->handshaking,
1485: &wlan->crypto ) ) == -ENOTSUP ) {
1486: struct ieee80211_beacon *beacon =
1487: ( struct ieee80211_beacon * ) hdr->data;
1488:
1489: if ( beacon->capability & IEEE80211_CAPAB_PRIVACY ) {
1490: DBG ( "802.11 %p probe: secured network %s but "
1491: "encryption support not compiled in\n",
1492: dev, wlan->essid );
1493: wlan->handshaking = NET80211_SECPROT_UNKNOWN;
1494: wlan->crypto = NET80211_CRYPT_UNKNOWN;
1495: } else {
1496: wlan->handshaking = NET80211_SECPROT_NONE;
1497: wlan->crypto = NET80211_CRYPT_NONE;
1498: }
1499: } else if ( rc != 0 ) {
1500: DBGC ( dev, "802.11 %p probe warning: network "
1501: "%s with unidentifiable security "
1502: "settings: %s\n", dev, wlan->essid,
1503: strerror ( rc ) );
1504: }
1505:
1506: ctx->ticks_beacon = now;
1507:
1508: DBGC2 ( dev, "802.11 %p probe: good beacon for %s (%s)\n",
1509: dev, wlan->essid, eth_ntoa ( wlan->bssid ) );
1510:
1511: drop:
1512: free_iob ( iob );
1513: }
1514:
1515: return 0;
1516: }
1517:
1518:
1519: /**
1520: * Finish probe of 802.11 networks, returning best-signal network found
1521: *
1522: * @v ctx Probe context
1523: * @ret wlan Best-signal network found, or @c NULL if none were found
1524: *
1525: * If net80211_probe_start() was called with a particular SSID
1526: * parameter as filter, only a network with that SSID (matching
1527: * case-sensitively) can be returned from this function.
1528: */
1529: struct net80211_wlan *
1530: net80211_probe_finish_best ( struct net80211_probe_ctx *ctx )
1531: {
1532: struct net80211_wlan *best = NULL, *wlan;
1533:
1534: if ( ! ctx )
1535: return NULL;
1536:
1537: list_for_each_entry ( wlan, ctx->beacons, list ) {
1538: if ( ! best || best->signal < wlan->signal )
1539: best = wlan;
1540: }
1541:
1542: if ( best )
1543: list_del ( &best->list );
1544: else
1545: DBGC ( ctx->dev, "802.11 %p probe: found nothing for '%s'\n",
1546: ctx->dev, ctx->essid );
1547:
1548: net80211_free_wlanlist ( ctx->beacons );
1549:
1550: net80211_keep_mgmt ( ctx->dev, ctx->old_keep_mgmt );
1551:
1552: if ( ctx->probe )
1553: free_iob ( ctx->probe );
1554:
1555: free ( ctx );
1556:
1557: return best;
1558: }
1559:
1560:
1561: /**
1562: * Finish probe of 802.11 networks, returning all networks found
1563: *
1564: * @v ctx Probe context
1565: * @ret list List of net80211_wlan detailing networks found
1566: *
1567: * If net80211_probe_start() was called with a particular SSID
1568: * parameter as filter, this will always return either an empty or a
1569: * one-element list.
1570: */
1571: struct list_head *net80211_probe_finish_all ( struct net80211_probe_ctx *ctx )
1572: {
1573: struct list_head *beacons = ctx->beacons;
1574:
1575: if ( ! ctx )
1576: return NULL;
1577:
1578: net80211_keep_mgmt ( ctx->dev, ctx->old_keep_mgmt );
1579:
1580: if ( ctx->probe )
1581: free_iob ( ctx->probe );
1582:
1583: free ( ctx );
1584:
1585: return beacons;
1586: }
1587:
1588:
1589: /**
1590: * Free WLAN structure
1591: *
1592: * @v wlan WLAN structure to free
1593: */
1594: void net80211_free_wlan ( struct net80211_wlan *wlan )
1595: {
1596: if ( wlan ) {
1597: free_iob ( wlan->beacon );
1598: free ( wlan );
1599: }
1600: }
1601:
1602:
1603: /**
1604: * Free list of WLAN structures
1605: *
1606: * @v list List of WLAN structures to free
1607: */
1608: void net80211_free_wlanlist ( struct list_head *list )
1609: {
1610: struct net80211_wlan *wlan, *tmp;
1611:
1612: if ( ! list )
1613: return;
1614:
1615: list_for_each_entry_safe ( wlan, tmp, list, list ) {
1616: list_del ( &wlan->list );
1617: net80211_free_wlan ( wlan );
1618: }
1619:
1620: free ( list );
1621: }
1622:
1623:
1624: /** Number of ticks to wait for replies to association management frames */
1625: #define ASSOC_TIMEOUT TICKS_PER_SEC
1626:
1627: /** Number of times to try sending a particular association management frame */
1628: #define ASSOC_RETRIES 2
1629:
1630: /**
1631: * Step 802.11 association process
1632: *
1633: * @v proc Association process
1634: */
1635: static void net80211_step_associate ( struct process *proc )
1636: {
1637: struct net80211_device *dev =
1638: container_of ( proc, struct net80211_device, proc_assoc );
1639: int rc = 0;
1640: int status = dev->state & NET80211_STATUS_MASK;
1641:
1642: /*
1643: * We use a sort of state machine implemented using bits in
1644: * the dev->state variable. At each call, we take the
1645: * logically first step that has not yet succeeded; either it
1646: * has not been tried yet, it's being retried, or it failed.
1647: * If it failed, we return an error indication; otherwise we
1648: * perform the step. If it succeeds, RX handling code will set
1649: * the appropriate status bit for us.
1650: *
1651: * Probe works a bit differently, since we have to step it
1652: * on every call instead of waiting for a packet to arrive
1653: * that will set the completion bit for us.
1654: */
1655:
1656: /* If we're waiting for a reply, check for timeout condition */
1657: if ( dev->state & NET80211_WAITING ) {
1658: /* Sanity check */
1659: if ( ! dev->associating )
1660: return;
1661:
1662: if ( currticks() - dev->ctx.assoc->last_packet > ASSOC_TIMEOUT ) {
1663: /* Timed out - fail if too many retries, or retry */
1664: dev->ctx.assoc->times_tried++;
1665: if ( ++dev->ctx.assoc->times_tried > ASSOC_RETRIES ) {
1666: rc = -ETIMEDOUT;
1667: goto fail;
1668: }
1669: } else {
1670: /* Didn't time out - let it keep going */
1671: return;
1672: }
1673: } else {
1674: if ( dev->state & NET80211_PROBED )
1675: dev->ctx.assoc->times_tried = 0;
1676: }
1677:
1678: if ( ! ( dev->state & NET80211_PROBED ) ) {
1679: /* state: probe */
1680:
1681: if ( ! dev->ctx.probe ) {
1682: /* start probe */
1683: int active = fetch_intz_setting ( NULL,
1684: &net80211_active_setting );
1685: int band = dev->hw->bands;
1686:
1687: if ( active )
1688: band &= ~NET80211_BAND_BIT_5GHZ;
1689:
1690: rc = net80211_prepare_probe ( dev, band, active );
1691: if ( rc )
1692: goto fail;
1693:
1694: dev->ctx.probe = net80211_probe_start ( dev, dev->essid,
1695: active );
1696: if ( ! dev->ctx.probe ) {
1697: dev->assoc_rc = -ENOMEM;
1698: goto fail;
1699: }
1700: }
1701:
1702: rc = net80211_probe_step ( dev->ctx.probe );
1703: if ( ! rc ) {
1704: return; /* still going */
1705: }
1706:
1707: dev->associating = net80211_probe_finish_best ( dev->ctx.probe );
1708: dev->ctx.probe = NULL;
1709: if ( ! dev->associating ) {
1710: if ( rc > 0 ) /* "successful" probe found nothing */
1711: rc = -ETIMEDOUT;
1712: goto fail;
1713: }
1714:
1715: /* If we probed using a broadcast SSID, record that
1716: fact for the settings applicator before we clobber
1717: it with the specific SSID we've chosen. */
1718: if ( ! dev->essid[0] )
1719: dev->state |= NET80211_AUTO_SSID;
1720:
1721: DBGC ( dev, "802.11 %p found network %s (%s)\n", dev,
1722: dev->associating->essid,
1723: eth_ntoa ( dev->associating->bssid ) );
1724:
1725: dev->ctx.assoc = zalloc ( sizeof ( *dev->ctx.assoc ) );
1726: if ( ! dev->ctx.assoc ) {
1727: rc = -ENOMEM;
1728: goto fail;
1729: }
1730:
1731: dev->state |= NET80211_PROBED;
1732: dev->ctx.assoc->method = IEEE80211_AUTH_OPEN_SYSTEM;
1733:
1734: return;
1735: }
1736:
1737: /* Record time of sending the packet we're about to send, for timeout */
1738: dev->ctx.assoc->last_packet = currticks();
1739:
1740: if ( ! ( dev->state & NET80211_AUTHENTICATED ) ) {
1741: /* state: prepare and authenticate */
1742:
1743: if ( status != IEEE80211_STATUS_SUCCESS ) {
1744: /* we tried authenticating already, but failed */
1745: int method = dev->ctx.assoc->method;
1746:
1747: if ( method == IEEE80211_AUTH_OPEN_SYSTEM &&
1748: ( status == IEEE80211_STATUS_AUTH_CHALL_INVALID ||
1749: status == IEEE80211_STATUS_AUTH_ALGO_UNSUPP ) ) {
1750: /* Maybe this network uses Shared Key? */
1751: dev->ctx.assoc->method =
1752: IEEE80211_AUTH_SHARED_KEY;
1753: } else {
1754: goto fail;
1755: }
1756: }
1757:
1758: DBGC ( dev, "802.11 %p authenticating with method %d\n", dev,
1759: dev->ctx.assoc->method );
1760:
1761: rc = net80211_prepare_assoc ( dev, dev->associating );
1762: if ( rc )
1763: goto fail;
1764:
1765: rc = net80211_send_auth ( dev, dev->associating,
1766: dev->ctx.assoc->method );
1767: if ( rc )
1768: goto fail;
1769:
1770: return;
1771: }
1772:
1773: if ( ! ( dev->state & NET80211_ASSOCIATED ) ) {
1774: /* state: associate */
1775:
1776: if ( status != IEEE80211_STATUS_SUCCESS )
1777: goto fail;
1778:
1779: DBGC ( dev, "802.11 %p associating\n", dev );
1780:
1781: if ( dev->handshaker && dev->handshaker->start &&
1782: ! dev->handshaker->started ) {
1783: rc = dev->handshaker->start ( dev );
1784: if ( rc < 0 )
1785: goto fail;
1786: dev->handshaker->started = 1;
1787: }
1788:
1789: rc = net80211_send_assoc ( dev, dev->associating );
1790: if ( rc )
1791: goto fail;
1792:
1793: return;
1794: }
1795:
1796: if ( ! ( dev->state & NET80211_CRYPTO_SYNCED ) ) {
1797: /* state: crypto sync */
1798: DBGC ( dev, "802.11 %p security handshaking\n", dev );
1799:
1800: if ( ! dev->handshaker || ! dev->handshaker->step ) {
1801: dev->state |= NET80211_CRYPTO_SYNCED;
1802: return;
1803: }
1804:
1805: rc = dev->handshaker->step ( dev );
1806:
1807: if ( rc < 0 ) {
1808: /* Only record the returned error if we're
1809: still marked as associated, because an
1810: asynchronous error will have already been
1811: reported to net80211_deauthenticate() and
1812: assoc_rc thereby set. */
1813: if ( dev->state & NET80211_ASSOCIATED )
1814: dev->assoc_rc = rc;
1815: rc = 0;
1816: goto fail;
1817: }
1818:
1819: if ( rc > 0 ) {
1820: dev->assoc_rc = 0;
1821: dev->state |= NET80211_CRYPTO_SYNCED;
1822: }
1823: return;
1824: }
1825:
1826: /* state: done! */
1827: netdev_link_up ( dev->netdev );
1828: dev->assoc_rc = 0;
1829: dev->state &= ~NET80211_WORKING;
1830:
1831: free ( dev->ctx.assoc );
1832: dev->ctx.assoc = NULL;
1833:
1834: net80211_free_wlan ( dev->associating );
1835: dev->associating = NULL;
1836:
1837: dev->rctl = rc80211_init ( dev );
1838:
1839: process_del ( proc );
1840:
1841: DBGC ( dev, "802.11 %p associated with %s (%s)\n", dev,
1842: dev->essid, eth_ntoa ( dev->bssid ) );
1843:
1844: return;
1845:
1846: fail:
1847: dev->state &= ~( NET80211_WORKING | NET80211_WAITING );
1848: if ( rc )
1849: dev->assoc_rc = rc;
1850:
1851: netdev_link_err ( dev->netdev, dev->assoc_rc );
1852:
1853: /* We never reach here from the middle of a probe, so we don't
1854: need to worry about freeing dev->ctx.probe. */
1855:
1856: if ( dev->state & NET80211_PROBED ) {
1857: free ( dev->ctx.assoc );
1858: dev->ctx.assoc = NULL;
1859: }
1860:
1861: net80211_free_wlan ( dev->associating );
1862: dev->associating = NULL;
1863:
1864: process_del ( proc );
1865:
1866: DBGC ( dev, "802.11 %p association failed (state=%04x): "
1867: "%s\n", dev, dev->state, strerror ( dev->assoc_rc ) );
1868:
1869: /* Try it again: */
1870: net80211_autoassociate ( dev );
1871: }
1872:
1873: /**
1874: * Check for 802.11 SSID or key updates
1875: *
1876: * This acts as a settings applicator; if the user changes netX/ssid,
1877: * and netX is currently open, the association task will be invoked
1878: * again. If the user changes the encryption key, the current security
1879: * handshaker will be asked to update its state to match; if that is
1880: * impossible without reassociation, we reassociate.
1881: */
1882: static int net80211_check_settings_update ( void )
1883: {
1884: struct net80211_device *dev;
1885: char ssid[IEEE80211_MAX_SSID_LEN + 1];
1886: int key_reassoc;
1887:
1888: list_for_each_entry ( dev, &net80211_devices, list ) {
1889: if ( ! netdev_is_open ( dev->netdev ) )
1890: continue;
1891:
1892: key_reassoc = 0;
1893: if ( dev->handshaker && dev->handshaker->change_key &&
1894: dev->handshaker->change_key ( dev ) < 0 )
1895: key_reassoc = 1;
1896:
1897: fetch_string_setting ( netdev_settings ( dev->netdev ),
1898: &net80211_ssid_setting, ssid,
1899: IEEE80211_MAX_SSID_LEN + 1 );
1900:
1901: if ( key_reassoc ||
1902: ( ! ( ! ssid[0] && ( dev->state & NET80211_AUTO_SSID ) ) &&
1903: strcmp ( ssid, dev->essid ) != 0 ) ) {
1904: DBGC ( dev, "802.11 %p updating association: "
1905: "%s -> %s\n", dev, dev->essid, ssid );
1906: net80211_autoassociate ( dev );
1907: }
1908: }
1909:
1910: return 0;
1911: }
1912:
1913: /**
1914: * Start 802.11 association process
1915: *
1916: * @v dev 802.11 device
1917: *
1918: * If the association process is running, it will be restarted.
1919: */
1920: void net80211_autoassociate ( struct net80211_device *dev )
1921: {
1922: if ( ! ( dev->state & NET80211_WORKING ) ) {
1923: DBGC2 ( dev, "802.11 %p spawning association process\n", dev );
1924: process_add ( &dev->proc_assoc );
1925: } else {
1926: DBGC2 ( dev, "802.11 %p restarting association\n", dev );
1927: }
1928:
1929: /* Clean up everything an earlier association process might
1930: have been in the middle of using */
1931: if ( dev->associating )
1932: net80211_free_wlan ( dev->associating );
1933:
1934: if ( ! ( dev->state & NET80211_PROBED ) )
1935: net80211_free_wlan (
1936: net80211_probe_finish_best ( dev->ctx.probe ) );
1937: else
1938: free ( dev->ctx.assoc );
1939:
1940: /* Reset to a clean state */
1941: fetch_string_setting ( netdev_settings ( dev->netdev ),
1942: &net80211_ssid_setting, dev->essid,
1943: IEEE80211_MAX_SSID_LEN + 1 );
1944: dev->ctx.probe = NULL;
1945: dev->associating = NULL;
1946: dev->assoc_rc = 0;
1947: net80211_set_state ( dev, NET80211_PROBED, NET80211_WORKING, 0 );
1948: }
1949:
1950: /**
1951: * Pick TX rate for RTS/CTS packets based on data rate
1952: *
1953: * @v dev 802.11 device
1954: *
1955: * The RTS/CTS rate is the fastest TX rate marked as "basic" that is
1956: * not faster than the data rate.
1957: */
1958: static void net80211_set_rtscts_rate ( struct net80211_device *dev )
1959: {
1960: u16 datarate = dev->rates[dev->rate];
1961: u16 rtsrate = 0;
1962: int rts_idx = -1;
1963: int i;
1964:
1965: for ( i = 0; i < dev->nr_rates; i++ ) {
1966: u16 rate = dev->rates[i];
1967:
1968: if ( ! ( dev->basic_rates & ( 1 << i ) ) || rate > datarate )
1969: continue;
1970:
1971: if ( rate > rtsrate ) {
1972: rtsrate = rate;
1973: rts_idx = i;
1974: }
1975: }
1976:
1977: /* If this is in initialization, we might not have any basic
1978: rates; just use the first data rate in that case. */
1979: if ( rts_idx < 0 )
1980: rts_idx = 0;
1981:
1982: dev->rtscts_rate = rts_idx;
1983: }
1984:
1985: /**
1986: * Set data transmission rate for 802.11 device
1987: *
1988: * @v dev 802.11 device
1989: * @v rate Rate to set, as index into @c dev->rates array
1990: */
1991: void net80211_set_rate_idx ( struct net80211_device *dev, int rate )
1992: {
1993: assert ( netdev_is_open ( dev->netdev ) );
1994:
1995: if ( rate >= 0 && rate < dev->nr_rates && rate != dev->rate ) {
1996: DBGC2 ( dev, "802.11 %p changing rate from %d->%d Mbps\n",
1997: dev, dev->rates[dev->rate] / 10,
1998: dev->rates[rate] / 10 );
1999:
2000: dev->rate = rate;
2001: net80211_set_rtscts_rate ( dev );
2002: dev->op->config ( dev, NET80211_CFG_RATE );
2003: }
2004: }
2005:
2006: /**
2007: * Configure 802.11 device to transmit on a certain channel
2008: *
2009: * @v dev 802.11 device
2010: * @v channel Channel number (1-11 for 2.4GHz) to transmit on
2011: */
2012: int net80211_change_channel ( struct net80211_device *dev, int channel )
2013: {
2014: int i, oldchan = dev->channel;
2015:
2016: assert ( netdev_is_open ( dev->netdev ) );
2017:
2018: for ( i = 0; i < dev->nr_channels; i++ ) {
2019: if ( dev->channels[i].channel_nr == channel ) {
2020: dev->channel = i;
2021: break;
2022: }
2023: }
2024:
2025: if ( i == dev->nr_channels )
2026: return -ENOENT;
2027:
2028: if ( i != oldchan )
2029: return dev->op->config ( dev, NET80211_CFG_CHANNEL );
2030:
2031: return 0;
2032: }
2033:
2034: /**
2035: * Prepare 802.11 device channel and rate set for scanning
2036: *
2037: * @v dev 802.11 device
2038: * @v band RF band(s) on which to prepare for scanning
2039: * @v active Whether the scanning will be active
2040: * @ret rc Return status code
2041: */
2042: int net80211_prepare_probe ( struct net80211_device *dev, int band,
2043: int active )
2044: {
2045: assert ( netdev_is_open ( dev->netdev ) );
2046:
2047: if ( active && ( band & NET80211_BAND_BIT_5GHZ ) ) {
2048: DBGC ( dev, "802.11 %p cannot perform active scanning on "
2049: "5GHz band\n", dev );
2050: return -EINVAL_ACTIVE_SCAN;
2051: }
2052:
2053: if ( band == 0 ) {
2054: /* This can happen for a 5GHz-only card with 5GHz
2055: scanning masked out by an active request. */
2056: DBGC ( dev, "802.11 %p asked to prepare for scanning nothing\n",
2057: dev );
2058: return -EINVAL_ACTIVE_SCAN;
2059: }
2060:
2061: dev->nr_channels = 0;
2062:
2063: if ( active )
2064: net80211_add_channels ( dev, 1, 11, NET80211_REG_TXPOWER );
2065: else {
2066: if ( band & NET80211_BAND_BIT_2GHZ )
2067: net80211_add_channels ( dev, 1, 14,
2068: NET80211_REG_TXPOWER );
2069: if ( band & NET80211_BAND_BIT_5GHZ )
2070: net80211_add_channels ( dev, 36, 8,
2071: NET80211_REG_TXPOWER );
2072: }
2073:
2074: net80211_filter_hw_channels ( dev );
2075:
2076: /* Use channel 1 for now */
2077: dev->channel = 0;
2078: dev->op->config ( dev, NET80211_CFG_CHANNEL );
2079:
2080: /* Always do active probes at lowest (presumably first) speed */
2081: dev->rate = 0;
2082: dev->nr_rates = 1;
2083: dev->rates[0] = dev->hw->rates[dev->channels[0].band][0];
2084: dev->op->config ( dev, NET80211_CFG_RATE );
2085:
2086: return 0;
2087: }
2088:
2089: /**
2090: * Prepare 802.11 device channel and rate set for communication
2091: *
2092: * @v dev 802.11 device
2093: * @v wlan WLAN to prepare for communication with
2094: * @ret rc Return status code
2095: */
2096: int net80211_prepare_assoc ( struct net80211_device *dev,
2097: struct net80211_wlan *wlan )
2098: {
2099: struct ieee80211_frame *hdr = wlan->beacon->data;
2100: struct ieee80211_beacon *beacon =
2101: ( struct ieee80211_beacon * ) hdr->data;
2102: struct net80211_handshaker *handshaker;
2103: int rc;
2104:
2105: assert ( netdev_is_open ( dev->netdev ) );
2106:
2107: net80211_set_state ( dev, NET80211_ASSOCIATED, 0, 0 );
2108: memcpy ( dev->bssid, wlan->bssid, ETH_ALEN );
2109: strcpy ( dev->essid, wlan->essid );
2110:
2111: free ( dev->rsn_ie );
2112: dev->rsn_ie = NULL;
2113:
2114: dev->last_beacon_timestamp = beacon->timestamp;
2115: dev->tx_beacon_interval = 1024 * beacon->beacon_interval;
2116:
2117: /* Barring an IE that tells us the channel outright, assume
2118: the channel we heard this AP best on is the channel it's
2119: communicating on. */
2120: net80211_change_channel ( dev, wlan->channel );
2121:
2122: rc = net80211_process_capab ( dev, beacon->capability );
2123: if ( rc )
2124: return rc;
2125:
2126: rc = net80211_process_ie ( dev, beacon->info_element,
2127: wlan->beacon->tail );
2128: if ( rc )
2129: return rc;
2130:
2131: /* Associate at the lowest rate so we know it'll get through */
2132: dev->rate = 0;
2133: dev->op->config ( dev, NET80211_CFG_RATE );
2134:
2135: /* Free old handshaker and crypto, if they exist */
2136: if ( dev->handshaker && dev->handshaker->stop &&
2137: dev->handshaker->started )
2138: dev->handshaker->stop ( dev );
2139: free ( dev->handshaker );
2140: dev->handshaker = NULL;
2141: free ( dev->crypto );
2142: free ( dev->gcrypto );
2143: dev->crypto = dev->gcrypto = NULL;
2144:
2145: /* Find new security handshaker to use */
2146: for_each_table_entry ( handshaker, NET80211_HANDSHAKERS ) {
2147: if ( handshaker->protocol == wlan->handshaking ) {
2148: dev->handshaker = zalloc ( sizeof ( *handshaker ) +
2149: handshaker->priv_len );
2150: if ( ! dev->handshaker )
2151: return -ENOMEM;
2152:
2153: memcpy ( dev->handshaker, handshaker,
2154: sizeof ( *handshaker ) );
2155: dev->handshaker->priv = ( ( void * ) dev->handshaker +
2156: sizeof ( *handshaker ) );
2157: break;
2158: }
2159: }
2160:
2161: if ( ( wlan->handshaking != NET80211_SECPROT_NONE ) &&
2162: ! dev->handshaker ) {
2163: DBGC ( dev, "802.11 %p no support for handshaking scheme %d\n",
2164: dev, wlan->handshaking );
2165: return -( ENOTSUP | ( wlan->handshaking << 8 ) );
2166: }
2167:
2168: /* Initialize security handshaker */
2169: if ( dev->handshaker ) {
2170: rc = dev->handshaker->init ( dev );
2171: if ( rc < 0 )
2172: return rc;
2173: }
2174:
2175: return 0;
2176: }
2177:
2178: /**
2179: * Send 802.11 initial authentication frame
2180: *
2181: * @v dev 802.11 device
2182: * @v wlan WLAN to authenticate with
2183: * @v method Authentication method
2184: * @ret rc Return status code
2185: *
2186: * @a method may be 0 for Open System authentication or 1 for Shared
2187: * Key authentication. Open System provides no security in association
2188: * whatsoever, relying on encryption for confidentiality, but Shared
2189: * Key actively introduces security problems and is very rarely used.
2190: */
2191: int net80211_send_auth ( struct net80211_device *dev,
2192: struct net80211_wlan *wlan, int method )
2193: {
2194: struct io_buffer *iob = alloc_iob ( 64 );
2195: struct ieee80211_auth *auth;
2196:
2197: net80211_set_state ( dev, 0, NET80211_WAITING, 0 );
2198: iob_reserve ( iob, IEEE80211_TYP_FRAME_HEADER_LEN );
2199: auth = iob_put ( iob, sizeof ( *auth ) );
2200: auth->algorithm = method;
2201: auth->tx_seq = 1;
2202: auth->status = 0;
2203:
2204: return net80211_tx_mgmt ( dev, IEEE80211_STYPE_AUTH, wlan->bssid, iob );
2205: }
2206:
2207: /**
2208: * Handle receipt of 802.11 authentication frame
2209: *
2210: * @v dev 802.11 device
2211: * @v iob I/O buffer
2212: *
2213: * If the authentication method being used is Shared Key, and the
2214: * frame that was received included challenge text, the frame is
2215: * encrypted using the cryptosystem currently in effect and sent back
2216: * to the AP to complete the authentication.
2217: */
2218: static void net80211_handle_auth ( struct net80211_device *dev,
2219: struct io_buffer *iob )
2220: {
2221: struct ieee80211_frame *hdr = iob->data;
2222: struct ieee80211_auth *auth =
2223: ( struct ieee80211_auth * ) hdr->data;
2224:
2225: if ( auth->tx_seq & 1 ) {
2226: DBGC ( dev, "802.11 %p authentication received improperly "
2227: "directed frame (seq. %d)\n", dev, auth->tx_seq );
2228: net80211_set_state ( dev, NET80211_WAITING, 0,
2229: IEEE80211_STATUS_FAILURE );
2230: return;
2231: }
2232:
2233: if ( auth->status != IEEE80211_STATUS_SUCCESS ) {
2234: DBGC ( dev, "802.11 %p authentication failed: status %d\n",
2235: dev, auth->status );
2236: net80211_set_state ( dev, NET80211_WAITING, 0,
2237: auth->status );
2238: return;
2239: }
2240:
2241: if ( auth->algorithm == IEEE80211_AUTH_SHARED_KEY && ! dev->crypto ) {
2242: DBGC ( dev, "802.11 %p can't perform shared-key authentication "
2243: "without a cryptosystem\n", dev );
2244: net80211_set_state ( dev, NET80211_WAITING, 0,
2245: IEEE80211_STATUS_FAILURE );
2246: return;
2247: }
2248:
2249: if ( auth->algorithm == IEEE80211_AUTH_SHARED_KEY &&
2250: auth->tx_seq == 2 ) {
2251: /* Since the iob we got is going to be freed as soon
2252: as we return, we can do some in-place
2253: modification. */
2254: auth->tx_seq = 3;
2255: auth->status = 0;
2256:
2257: memcpy ( hdr->addr2, hdr->addr1, ETH_ALEN );
2258: memcpy ( hdr->addr1, hdr->addr3, ETH_ALEN );
2259:
2260: netdev_tx ( dev->netdev,
2261: dev->crypto->encrypt ( dev->crypto, iob ) );
2262: return;
2263: }
2264:
2265: net80211_set_state ( dev, NET80211_WAITING, NET80211_AUTHENTICATED,
2266: IEEE80211_STATUS_SUCCESS );
2267:
2268: return;
2269: }
2270:
2271: /**
2272: * Send 802.11 association frame
2273: *
2274: * @v dev 802.11 device
2275: * @v wlan WLAN to associate with
2276: * @ret rc Return status code
2277: */
2278: int net80211_send_assoc ( struct net80211_device *dev,
2279: struct net80211_wlan *wlan )
2280: {
2281: struct io_buffer *iob = alloc_iob ( 128 );
2282: struct ieee80211_assoc_req *assoc;
2283: union ieee80211_ie *ie;
2284:
2285: net80211_set_state ( dev, 0, NET80211_WAITING, 0 );
2286:
2287: iob_reserve ( iob, IEEE80211_TYP_FRAME_HEADER_LEN );
2288: assoc = iob->data;
2289:
2290: assoc->capability = IEEE80211_CAPAB_MANAGED;
2291: if ( ! ( dev->hw->flags & NET80211_HW_NO_SHORT_PREAMBLE ) )
2292: assoc->capability |= IEEE80211_CAPAB_SHORT_PMBL;
2293: if ( ! ( dev->hw->flags & NET80211_HW_NO_SHORT_SLOT ) )
2294: assoc->capability |= IEEE80211_CAPAB_SHORT_SLOT;
2295: if ( wlan->crypto )
2296: assoc->capability |= IEEE80211_CAPAB_PRIVACY;
2297:
2298: assoc->listen_interval = 1;
2299:
2300: ie = net80211_marshal_request_info ( dev, assoc->info_element );
2301:
2302: DBGP ( "802.11 %p about to send association request:\n", dev );
2303: DBGP_HD ( iob->data, ( void * ) ie - iob->data );
2304:
2305: iob_put ( iob, ( void * ) ie - iob->data );
2306:
2307: return net80211_tx_mgmt ( dev, IEEE80211_STYPE_ASSOC_REQ,
2308: wlan->bssid, iob );
2309: }
2310:
2311: /**
2312: * Handle receipt of 802.11 association reply frame
2313: *
2314: * @v dev 802.11 device
2315: * @v iob I/O buffer
2316: */
2317: static void net80211_handle_assoc_reply ( struct net80211_device *dev,
2318: struct io_buffer *iob )
2319: {
2320: struct ieee80211_frame *hdr = iob->data;
2321: struct ieee80211_assoc_resp *assoc =
2322: ( struct ieee80211_assoc_resp * ) hdr->data;
2323:
2324: net80211_process_capab ( dev, assoc->capability );
2325: net80211_process_ie ( dev, assoc->info_element, iob->tail );
2326:
2327: if ( assoc->status != IEEE80211_STATUS_SUCCESS ) {
2328: DBGC ( dev, "802.11 %p association failed: status %d\n",
2329: dev, assoc->status );
2330: net80211_set_state ( dev, NET80211_WAITING, 0,
2331: assoc->status );
2332: return;
2333: }
2334:
2335: /* ESSID was filled before the association request was sent */
2336: memcpy ( dev->bssid, hdr->addr3, ETH_ALEN );
2337: dev->aid = assoc->aid;
2338:
2339: net80211_set_state ( dev, NET80211_WAITING, NET80211_ASSOCIATED,
2340: IEEE80211_STATUS_SUCCESS );
2341: }
2342:
2343:
2344: /**
2345: * Send 802.11 disassociation frame
2346: *
2347: * @v dev 802.11 device
2348: * @v reason Reason for disassociation
2349: * @v deauth If TRUE, send deauthentication instead of disassociation
2350: * @ret rc Return status code
2351: */
2352: static int net80211_send_disassoc ( struct net80211_device *dev, int reason,
2353: int deauth )
2354: {
2355: struct io_buffer *iob = alloc_iob ( 64 );
2356: struct ieee80211_disassoc *disassoc;
2357:
2358: if ( ! ( dev->state & NET80211_ASSOCIATED ) )
2359: return -EINVAL;
2360:
2361: net80211_set_state ( dev, NET80211_ASSOCIATED, 0, 0 );
2362: iob_reserve ( iob, IEEE80211_TYP_FRAME_HEADER_LEN );
2363: disassoc = iob_put ( iob, sizeof ( *disassoc ) );
2364: disassoc->reason = reason;
2365:
2366: return net80211_tx_mgmt ( dev, deauth ? IEEE80211_STYPE_DEAUTH :
2367: IEEE80211_STYPE_DISASSOC, dev->bssid, iob );
2368: }
2369:
2370:
2371: /**
2372: * Deauthenticate from current network and try again
2373: *
2374: * @v dev 802.11 device
2375: * @v rc Return status code indicating reason
2376: *
2377: * The deauthentication will be sent using an 802.11 "unspecified
2378: * reason", as is common, but @a rc will be set as a link-up
2379: * error to aid the user in debugging.
2380: */
2381: void net80211_deauthenticate ( struct net80211_device *dev, int rc )
2382: {
2383: net80211_send_disassoc ( dev, IEEE80211_REASON_UNSPECIFIED, 1 );
2384: dev->assoc_rc = rc;
2385: netdev_link_err ( dev->netdev, rc );
2386:
2387: net80211_autoassociate ( dev );
2388: }
2389:
2390:
2391: /** Smoothing factor (1-7) for link quality calculation */
2392: #define LQ_SMOOTH 7
2393:
2394: /**
2395: * Update link quality information based on received beacon
2396: *
2397: * @v dev 802.11 device
2398: * @v iob I/O buffer containing beacon
2399: * @ret rc Return status code
2400: */
2401: static void net80211_update_link_quality ( struct net80211_device *dev,
2402: struct io_buffer *iob )
2403: {
2404: struct ieee80211_frame *hdr = iob->data;
2405: struct ieee80211_beacon *beacon;
2406: u32 dt, rxi;
2407:
2408: if ( ! ( dev->state & NET80211_ASSOCIATED ) )
2409: return;
2410:
2411: beacon = ( struct ieee80211_beacon * ) hdr->data;
2412: dt = ( u32 ) ( beacon->timestamp - dev->last_beacon_timestamp );
2413: rxi = dev->rx_beacon_interval;
2414:
2415: rxi = ( LQ_SMOOTH * rxi ) + ( ( 8 - LQ_SMOOTH ) * dt );
2416: dev->rx_beacon_interval = rxi >> 3;
2417:
2418: dev->last_beacon_timestamp = beacon->timestamp;
2419: }
2420:
2421:
2422: /**
2423: * Handle receipt of 802.11 management frame
2424: *
2425: * @v dev 802.11 device
2426: * @v iob I/O buffer
2427: * @v signal Signal strength of received frame
2428: */
2429: static void net80211_handle_mgmt ( struct net80211_device *dev,
2430: struct io_buffer *iob, int signal )
2431: {
2432: struct ieee80211_frame *hdr = iob->data;
2433: struct ieee80211_disassoc *disassoc;
2434: u16 stype = hdr->fc & IEEE80211_FC_SUBTYPE;
2435: int keep = 0;
2436: int is_deauth = ( stype == IEEE80211_STYPE_DEAUTH );
2437:
2438: if ( ( hdr->fc & IEEE80211_FC_TYPE ) != IEEE80211_TYPE_MGMT ) {
2439: free_iob ( iob );
2440: return; /* only handle management frames */
2441: }
2442:
2443: switch ( stype ) {
2444: /* We reconnect on deauthentication and disassociation. */
2445: case IEEE80211_STYPE_DEAUTH:
2446: case IEEE80211_STYPE_DISASSOC:
2447: disassoc = ( struct ieee80211_disassoc * ) hdr->data;
2448: net80211_set_state ( dev, is_deauth ? NET80211_AUTHENTICATED :
2449: NET80211_ASSOCIATED, 0,
2450: NET80211_IS_REASON | disassoc->reason );
2451: DBGC ( dev, "802.11 %p %s: reason %d\n",
2452: dev, is_deauth ? "deauthenticated" : "disassociated",
2453: disassoc->reason );
2454:
2455: /* Try to reassociate, in case it's transient. */
2456: net80211_autoassociate ( dev );
2457:
2458: break;
2459:
2460: /* We handle authentication and association. */
2461: case IEEE80211_STYPE_AUTH:
2462: if ( ! ( dev->state & NET80211_AUTHENTICATED ) )
2463: net80211_handle_auth ( dev, iob );
2464: break;
2465:
2466: case IEEE80211_STYPE_ASSOC_RESP:
2467: case IEEE80211_STYPE_REASSOC_RESP:
2468: if ( ! ( dev->state & NET80211_ASSOCIATED ) )
2469: net80211_handle_assoc_reply ( dev, iob );
2470: break;
2471:
2472: /* We pass probes and beacons onto network scanning
2473: code. Pass actions for future extensibility. */
2474: case IEEE80211_STYPE_BEACON:
2475: net80211_update_link_quality ( dev, iob );
2476: /* fall through */
2477: case IEEE80211_STYPE_PROBE_RESP:
2478: case IEEE80211_STYPE_ACTION:
2479: if ( dev->keep_mgmt ) {
2480: struct net80211_rx_info *rxinf;
2481: rxinf = zalloc ( sizeof ( *rxinf ) );
2482: if ( ! rxinf ) {
2483: DBGC ( dev, "802.11 %p out of memory\n", dev );
2484: break;
2485: }
2486: rxinf->signal = signal;
2487: list_add_tail ( &iob->list, &dev->mgmt_queue );
2488: list_add_tail ( &rxinf->list, &dev->mgmt_info_queue );
2489: keep = 1;
2490: }
2491: break;
2492:
2493: case IEEE80211_STYPE_PROBE_REQ:
2494: /* Some nodes send these broadcast. Ignore them. */
2495: break;
2496:
2497: case IEEE80211_STYPE_ASSOC_REQ:
2498: case IEEE80211_STYPE_REASSOC_REQ:
2499: /* We should never receive these, only send them. */
2500: DBGC ( dev, "802.11 %p received strange management request "
2501: "(%04x)\n", dev, stype );
2502: break;
2503:
2504: default:
2505: DBGC ( dev, "802.11 %p received unimplemented management "
2506: "packet (%04x)\n", dev, stype );
2507: break;
2508: }
2509:
2510: if ( ! keep )
2511: free_iob ( iob );
2512: }
2513:
2514: /* ---------- Packet handling functions ---------- */
2515:
2516: /**
2517: * Free buffers used by 802.11 fragment cache entry
2518: *
2519: * @v dev 802.11 device
2520: * @v fcid Fragment cache entry index
2521: *
2522: * After this function, the referenced entry will be marked unused.
2523: */
2524: static void net80211_free_frags ( struct net80211_device *dev, int fcid )
2525: {
2526: int j;
2527: struct net80211_frag_cache *frag = &dev->frags[fcid];
2528:
2529: for ( j = 0; j < 16; j++ ) {
2530: if ( frag->iob[j] ) {
2531: free_iob ( frag->iob[j] );
2532: frag->iob[j] = NULL;
2533: }
2534: }
2535:
2536: frag->seqnr = 0;
2537: frag->start_ticks = 0;
2538: frag->in_use = 0;
2539: }
2540:
2541: /**
2542: * Accumulate 802.11 fragments into one I/O buffer
2543: *
2544: * @v dev 802.11 device
2545: * @v fcid Fragment cache entry index
2546: * @v nfrags Number of fragments received
2547: * @v size Sum of sizes of all fragments, including headers
2548: * @ret iob I/O buffer containing reassembled packet
2549: *
2550: * This function does not free the fragment buffers.
2551: */
2552: static struct io_buffer *net80211_accum_frags ( struct net80211_device *dev,
2553: int fcid, int nfrags, int size )
2554: {
2555: struct net80211_frag_cache *frag = &dev->frags[fcid];
2556: int hdrsize = IEEE80211_TYP_FRAME_HEADER_LEN;
2557: int nsize = size - hdrsize * ( nfrags - 1 );
2558: int i;
2559:
2560: struct io_buffer *niob = alloc_iob ( nsize );
2561: struct ieee80211_frame *hdr;
2562:
2563: /* Add the header from the first one... */
2564: memcpy ( iob_put ( niob, hdrsize ), frag->iob[0]->data, hdrsize );
2565:
2566: /* ... and all the data from all of them. */
2567: for ( i = 0; i < nfrags; i++ ) {
2568: int len = iob_len ( frag->iob[i] ) - hdrsize;
2569: memcpy ( iob_put ( niob, len ),
2570: frag->iob[i]->data + hdrsize, len );
2571: }
2572:
2573: /* Turn off the fragment bit. */
2574: hdr = niob->data;
2575: hdr->fc &= ~IEEE80211_FC_MORE_FRAG;
2576:
2577: return niob;
2578: }
2579:
2580: /**
2581: * Handle receipt of 802.11 fragment
2582: *
2583: * @v dev 802.11 device
2584: * @v iob I/O buffer containing fragment
2585: * @v signal Signal strength with which fragment was received
2586: */
2587: static void net80211_rx_frag ( struct net80211_device *dev,
2588: struct io_buffer *iob, int signal )
2589: {
2590: struct ieee80211_frame *hdr = iob->data;
2591: int fragnr = IEEE80211_FRAG ( hdr->seq );
2592:
2593: if ( fragnr == 0 && ( hdr->fc & IEEE80211_FC_MORE_FRAG ) ) {
2594: /* start a frag cache entry */
2595: int i, newest = -1;
2596: u32 curr_ticks = currticks(), newest_ticks = 0;
2597: u32 timeout = ticks_per_sec() * NET80211_FRAG_TIMEOUT;
2598:
2599: for ( i = 0; i < NET80211_NR_CONCURRENT_FRAGS; i++ ) {
2600: if ( dev->frags[i].in_use == 0 )
2601: break;
2602:
2603: if ( dev->frags[i].start_ticks + timeout >=
2604: curr_ticks ) {
2605: net80211_free_frags ( dev, i );
2606: break;
2607: }
2608:
2609: if ( dev->frags[i].start_ticks > newest_ticks ) {
2610: newest = i;
2611: newest_ticks = dev->frags[i].start_ticks;
2612: }
2613: }
2614:
2615: /* If we're being sent more concurrent fragmented
2616: packets than we can handle, drop the newest so the
2617: older ones have time to complete. */
2618: if ( i == NET80211_NR_CONCURRENT_FRAGS ) {
2619: i = newest;
2620: net80211_free_frags ( dev, i );
2621: }
2622:
2623: dev->frags[i].in_use = 1;
2624: dev->frags[i].seqnr = IEEE80211_SEQNR ( hdr->seq );
2625: dev->frags[i].start_ticks = currticks();
2626: dev->frags[i].iob[0] = iob;
2627: return;
2628: } else {
2629: int i;
2630: for ( i = 0; i < NET80211_NR_CONCURRENT_FRAGS; i++ ) {
2631: if ( dev->frags[i].in_use && dev->frags[i].seqnr ==
2632: IEEE80211_SEQNR ( hdr->seq ) )
2633: break;
2634: }
2635: if ( i == NET80211_NR_CONCURRENT_FRAGS ) {
2636: /* Drop non-first not-in-cache fragments */
2637: DBGC ( dev, "802.11 %p dropped fragment fc=%04x "
2638: "seq=%04x\n", dev, hdr->fc, hdr->seq );
2639: free_iob ( iob );
2640: return;
2641: }
2642:
2643: dev->frags[i].iob[fragnr] = iob;
2644:
2645: if ( ! ( hdr->fc & IEEE80211_FC_MORE_FRAG ) ) {
2646: int j, size = 0;
2647: for ( j = 0; j < fragnr; j++ ) {
2648: size += iob_len ( dev->frags[i].iob[j] );
2649: if ( dev->frags[i].iob[j] == NULL )
2650: break;
2651: }
2652: if ( j == fragnr ) {
2653: /* We've got everything */
2654: struct io_buffer *niob =
2655: net80211_accum_frags ( dev, i, fragnr,
2656: size );
2657: net80211_free_frags ( dev, i );
2658: net80211_rx ( dev, niob, signal, 0 );
2659: } else {
2660: DBGC ( dev, "802.11 %p dropping fragmented "
2661: "packet due to out-of-order arrival, "
2662: "fc=%04x seq=%04x\n", dev, hdr->fc,
2663: hdr->seq );
2664: net80211_free_frags ( dev, i );
2665: }
2666: }
2667: }
2668: }
2669:
2670: /**
2671: * Handle receipt of 802.11 frame
2672: *
2673: * @v dev 802.11 device
2674: * @v iob I/O buffer
2675: * @v signal Received signal strength
2676: * @v rate Bitrate at which frame was received, in 100 kbps units
2677: *
2678: * If the rate or signal is unknown, 0 should be passed.
2679: */
2680: void net80211_rx ( struct net80211_device *dev, struct io_buffer *iob,
2681: int signal, u16 rate )
2682: {
2683: struct ieee80211_frame *hdr = iob->data;
2684: u16 type = hdr->fc & IEEE80211_FC_TYPE;
2685: if ( ( hdr->fc & IEEE80211_FC_VERSION ) != IEEE80211_THIS_VERSION )
2686: goto drop; /* drop invalid-version packets */
2687:
2688: if ( type == IEEE80211_TYPE_CTRL )
2689: goto drop; /* we don't handle control packets,
2690: the hardware does */
2691:
2692: if ( dev->last_rx_seq == hdr->seq )
2693: goto drop; /* avoid duplicate packet */
2694: dev->last_rx_seq = hdr->seq;
2695:
2696: if ( dev->hw->flags & NET80211_HW_RX_HAS_FCS ) {
2697: /* discard the FCS */
2698: iob_unput ( iob, 4 );
2699: }
2700:
2701: /* Only decrypt packets from our BSSID, to avoid spurious errors */
2702: if ( ( hdr->fc & IEEE80211_FC_PROTECTED ) &&
2703: ! memcmp ( hdr->addr2, dev->bssid, ETH_ALEN ) ) {
2704: /* Decrypt packet; record and drop if it fails */
2705: struct io_buffer *niob;
2706: struct net80211_crypto *crypto = dev->crypto;
2707:
2708: if ( ! dev->crypto ) {
2709: DBGC ( dev, "802.11 %p cannot decrypt packet "
2710: "without a cryptosystem\n", dev );
2711: goto drop_crypt;
2712: }
2713:
2714: if ( ( hdr->addr1[0] & 1 ) && dev->gcrypto ) {
2715: /* Use group decryption if needed */
2716: crypto = dev->gcrypto;
2717: }
2718:
2719: niob = crypto->decrypt ( crypto, iob );
2720: if ( ! niob ) {
2721: DBGC ( dev, "802.11 %p decryption error\n", dev );
2722: goto drop_crypt;
2723: }
2724: free_iob ( iob );
2725: iob = niob;
2726: hdr = iob->data;
2727: }
2728:
2729: dev->last_signal = signal;
2730:
2731: /* Fragments go into the frag cache or get dropped. */
2732: if ( IEEE80211_FRAG ( hdr->seq ) != 0
2733: || ( hdr->fc & IEEE80211_FC_MORE_FRAG ) ) {
2734: net80211_rx_frag ( dev, iob, signal );
2735: return;
2736: }
2737:
2738: /* Management frames get handled, enqueued, or dropped. */
2739: if ( type == IEEE80211_TYPE_MGMT ) {
2740: net80211_handle_mgmt ( dev, iob, signal );
2741: return;
2742: }
2743:
2744: /* Data frames get dropped or sent to the net_device. */
2745: if ( ( hdr->fc & IEEE80211_FC_SUBTYPE ) != IEEE80211_STYPE_DATA )
2746: goto drop; /* drop QoS, CFP, or null data packets */
2747:
2748: /* Update rate-control algorithm */
2749: if ( dev->rctl )
2750: rc80211_update_rx ( dev, hdr->fc & IEEE80211_FC_RETRY, rate );
2751:
2752: /* Pass packet onward */
2753: if ( dev->state & NET80211_ASSOCIATED ) {
2754: netdev_rx ( dev->netdev, iob );
2755: return;
2756: }
2757:
2758: /* No association? Drop it. */
2759: goto drop;
2760:
2761: drop_crypt:
2762: netdev_rx_err ( dev->netdev, NULL, EINVAL_CRYPTO_REQUEST );
2763: drop:
2764: DBGC2 ( dev, "802.11 %p dropped packet fc=%04x seq=%04x\n", dev,
2765: hdr->fc, hdr->seq );
2766: free_iob ( iob );
2767: return;
2768: }
2769:
2770: /** Indicate an error in receiving a packet
2771: *
2772: * @v dev 802.11 device
2773: * @v iob I/O buffer with received packet, or NULL
2774: * @v rc Error code
2775: *
2776: * This logs the error with the wrapping net_device, and frees iob if
2777: * it is passed.
2778: */
2779: void net80211_rx_err ( struct net80211_device *dev,
2780: struct io_buffer *iob, int rc )
2781: {
2782: netdev_rx_err ( dev->netdev, iob, rc );
2783: }
2784:
2785: /** Indicate the completed transmission of a packet
2786: *
2787: * @v dev 802.11 device
2788: * @v iob I/O buffer of transmitted packet
2789: * @v retries Number of times this packet was retransmitted
2790: * @v rc Error code, or 0 for success
2791: *
2792: * This logs an error with the wrapping net_device if one occurred,
2793: * and removes and frees the I/O buffer from its TX queue. The
2794: * provided retry information is used to tune our transmission rate.
2795: *
2796: * If the packet did not need to be retransmitted because it was
2797: * properly ACKed the first time, @a retries should be 0.
2798: */
2799: void net80211_tx_complete ( struct net80211_device *dev,
2800: struct io_buffer *iob, int retries, int rc )
2801: {
2802: /* Update rate-control algorithm */
2803: if ( dev->rctl )
2804: rc80211_update_tx ( dev, retries, rc );
2805:
2806: /* Pass completion onward */
2807: netdev_tx_complete_err ( dev->netdev, iob, rc );
2808: }
2809:
2810: /** Common 802.11 errors */
2811: struct errortab common_wireless_errors[] __errortab = {
2812: __einfo_errortab ( EINFO_EINVAL_CRYPTO_REQUEST ),
2813: __einfo_errortab ( EINFO_ECONNRESET_UNSPECIFIED ),
2814: __einfo_errortab ( EINFO_ECONNRESET_INACTIVITY ),
2815: __einfo_errortab ( EINFO_ECONNRESET_4WAY_TIMEOUT ),
2816: __einfo_errortab ( EINFO_ECONNRESET_8021X_FAILURE ),
2817: __einfo_errortab ( EINFO_ECONNREFUSED_FAILURE ),
2818: __einfo_errortab ( EINFO_ECONNREFUSED_ASSOC_DENIED ),
2819: __einfo_errortab ( EINFO_ECONNREFUSED_AUTH_ALGO_UNSUPP ),
2820: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.