1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53#include <linux/module.h>
54#include <linux/kernel.h>
55#include <linux/sched.h>
56#include <linux/types.h>
57#include <linux/skbuff.h>
58#include <linux/slab.h>
59#include <linux/proc_fs.h>
60#include <linux/interrupt.h>
61#include <linux/netdevice.h>
62#include <linux/kmod.h>
63#include <linux/if_arp.h>
64#include <linux/wireless.h>
65#include <linux/sockios.h>
66#include <linux/etherdevice.h>
67#include <linux/if_ether.h>
68#include <linux/byteorder/generic.h>
69#include <linux/bitops.h>
70#include <linux/uaccess.h>
71#include <asm/byteorder.h>
72
73#ifdef SIOCETHTOOL
74#include <linux/ethtool.h>
75#endif
76
77#include <net/iw_handler.h>
78#include <net/net_namespace.h>
79#include <net/cfg80211.h>
80
81#include "p80211types.h"
82#include "p80211hdr.h"
83#include "p80211conv.h"
84#include "p80211mgmt.h"
85#include "p80211msg.h"
86#include "p80211netdev.h"
87#include "p80211ioctl.h"
88#include "p80211req.h"
89#include "p80211metastruct.h"
90#include "p80211metadef.h"
91
92#include "cfg80211.c"
93
94
95static int p80211knetdev_init(struct net_device *netdev);
96static int p80211knetdev_open(struct net_device *netdev);
97static int p80211knetdev_stop(struct net_device *netdev);
98static netdev_tx_t p80211knetdev_hard_start_xmit(struct sk_buff *skb,
99 struct net_device *netdev);
100static void p80211knetdev_set_multicast_list(struct net_device *dev);
101static int p80211knetdev_siocdevprivate(struct net_device *dev, struct ifreq *ifr,
102 void __user *data, int cmd);
103static int p80211knetdev_set_mac_address(struct net_device *dev, void *addr);
104static void p80211knetdev_tx_timeout(struct net_device *netdev, unsigned int txqueue);
105static int p80211_rx_typedrop(struct wlandevice *wlandev, u16 fc);
106
107int wlan_watchdog = 5000;
108module_param(wlan_watchdog, int, 0644);
109MODULE_PARM_DESC(wlan_watchdog, "transmit timeout in milliseconds");
110
111int wlan_wext_write = 1;
112module_param(wlan_wext_write, int, 0644);
113MODULE_PARM_DESC(wlan_wext_write, "enable write wireless extensions");
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128static int p80211knetdev_init(struct net_device *netdev)
129{
130
131
132
133
134 return 0;
135}
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152static int p80211knetdev_open(struct net_device *netdev)
153{
154 int result = 0;
155 struct wlandevice *wlandev = netdev->ml_priv;
156
157
158 if (wlandev->msdstate != WLAN_MSD_RUNNING)
159 return -ENODEV;
160
161
162 if (wlandev->open) {
163 result = wlandev->open(wlandev);
164 if (result == 0) {
165 netif_start_queue(wlandev->netdev);
166 wlandev->state = WLAN_DEVICE_OPEN;
167 }
168 } else {
169 result = -EAGAIN;
170 }
171
172 return result;
173}
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188static int p80211knetdev_stop(struct net_device *netdev)
189{
190 int result = 0;
191 struct wlandevice *wlandev = netdev->ml_priv;
192
193 if (wlandev->close)
194 result = wlandev->close(wlandev);
195
196 netif_stop_queue(wlandev->netdev);
197 wlandev->state = WLAN_DEVICE_CLOSED;
198
199 return result;
200}
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216void p80211netdev_rx(struct wlandevice *wlandev, struct sk_buff *skb)
217{
218
219 skb_queue_tail(&wlandev->nsd_rxq, skb);
220 tasklet_schedule(&wlandev->rx_bh);
221}
222
223#define CONV_TO_ETHER_SKIPPED 0x01
224#define CONV_TO_ETHER_FAILED 0x02
225
226
227
228
229
230
231
232
233
234
235static int p80211_convert_to_ether(struct wlandevice *wlandev,
236 struct sk_buff *skb)
237{
238 struct p80211_hdr *hdr;
239
240 hdr = (struct p80211_hdr *)skb->data;
241 if (p80211_rx_typedrop(wlandev, le16_to_cpu(hdr->frame_control)))
242 return CONV_TO_ETHER_SKIPPED;
243
244
245
246
247 if (wlandev->netdev->flags & IFF_ALLMULTI) {
248 if (!ether_addr_equal_unaligned(wlandev->netdev->dev_addr,
249 hdr->address1)) {
250 if (!is_multicast_ether_addr(hdr->address1))
251 return CONV_TO_ETHER_SKIPPED;
252 }
253 }
254
255 if (skb_p80211_to_ether(wlandev, wlandev->ethconv, skb) == 0) {
256 wlandev->netdev->stats.rx_packets++;
257 wlandev->netdev->stats.rx_bytes += skb->len;
258 netif_rx_ni(skb);
259 return 0;
260 }
261
262 netdev_dbg(wlandev->netdev, "%s failed.\n", __func__);
263 return CONV_TO_ETHER_FAILED;
264}
265
266
267
268
269
270
271static void p80211netdev_rx_bh(struct tasklet_struct *t)
272{
273 struct wlandevice *wlandev = from_tasklet(wlandev, t, rx_bh);
274 struct sk_buff *skb = NULL;
275 struct net_device *dev = wlandev->netdev;
276
277
278 while ((skb = skb_dequeue(&wlandev->nsd_rxq))) {
279 if (wlandev->state == WLAN_DEVICE_OPEN) {
280 if (dev->type != ARPHRD_ETHER) {
281
282
283
284
285 skb->dev = dev;
286 skb_reset_mac_header(skb);
287 skb->ip_summed = CHECKSUM_NONE;
288 skb->pkt_type = PACKET_OTHERHOST;
289 skb->protocol = htons(ETH_P_80211_RAW);
290
291 dev->stats.rx_packets++;
292 dev->stats.rx_bytes += skb->len;
293 netif_rx_ni(skb);
294 continue;
295 } else {
296 if (!p80211_convert_to_ether(wlandev, skb))
297 continue;
298 }
299 }
300 dev_kfree_skb(skb);
301 }
302}
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324static netdev_tx_t p80211knetdev_hard_start_xmit(struct sk_buff *skb,
325 struct net_device *netdev)
326{
327 int result = 0;
328 int txresult;
329 struct wlandevice *wlandev = netdev->ml_priv;
330 struct p80211_hdr p80211_hdr;
331 struct p80211_metawep p80211_wep;
332
333 p80211_wep.data = NULL;
334
335 if (!skb)
336 return NETDEV_TX_OK;
337
338 if (wlandev->state != WLAN_DEVICE_OPEN) {
339 result = 1;
340 goto failed;
341 }
342
343 memset(&p80211_hdr, 0, sizeof(p80211_hdr));
344 memset(&p80211_wep, 0, sizeof(p80211_wep));
345
346 if (netif_queue_stopped(netdev)) {
347 netdev_dbg(netdev, "called when queue stopped.\n");
348 result = 1;
349 goto failed;
350 }
351
352 netif_stop_queue(netdev);
353
354
355 switch (wlandev->macmode) {
356 case WLAN_MACMODE_IBSS_STA:
357 case WLAN_MACMODE_ESS_STA:
358 case WLAN_MACMODE_ESS_AP:
359 break;
360 default:
361
362
363
364
365 if (be16_to_cpu(skb->protocol) != ETH_P_80211_RAW) {
366 netif_start_queue(wlandev->netdev);
367 netdev_notice(netdev, "Tx attempt prior to association, frame dropped.\n");
368 netdev->stats.tx_dropped++;
369 result = 0;
370 goto failed;
371 }
372 break;
373 }
374
375
376 if (be16_to_cpu(skb->protocol) == ETH_P_80211_RAW) {
377 if (!capable(CAP_NET_ADMIN)) {
378 result = 1;
379 goto failed;
380 }
381
382 memcpy(&p80211_hdr, skb->data, sizeof(p80211_hdr));
383 skb_pull(skb, sizeof(p80211_hdr));
384 } else {
385 if (skb_ether_to_p80211
386 (wlandev, wlandev->ethconv, skb, &p80211_hdr,
387 &p80211_wep) != 0) {
388
389 netdev_dbg(netdev, "ether_to_80211(%d) failed.\n",
390 wlandev->ethconv);
391 result = 1;
392 goto failed;
393 }
394 }
395 if (!wlandev->txframe) {
396 result = 1;
397 goto failed;
398 }
399
400 netif_trans_update(netdev);
401
402 netdev->stats.tx_packets++;
403
404 netdev->stats.tx_bytes += skb->len;
405
406 txresult = wlandev->txframe(wlandev, skb, &p80211_hdr, &p80211_wep);
407
408 if (txresult == 0) {
409
410
411 netif_wake_queue(wlandev->netdev);
412 result = NETDEV_TX_OK;
413 } else if (txresult == 1) {
414
415 netdev_dbg(netdev, "txframe success, no more bufs\n");
416
417
418 result = NETDEV_TX_OK;
419 } else if (txresult == 2) {
420
421 netdev_dbg(netdev, "txframe returned alloc_fail\n");
422 result = NETDEV_TX_BUSY;
423 } else {
424
425 netdev_dbg(netdev, "txframe returned full or busy\n");
426 result = NETDEV_TX_BUSY;
427 }
428
429failed:
430
431 if ((p80211_wep.data) && (p80211_wep.data != skb->data))
432 kfree_sensitive(p80211_wep.data);
433
434
435 if (!result)
436 dev_kfree_skb(skb);
437
438 return result;
439}
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454static void p80211knetdev_set_multicast_list(struct net_device *dev)
455{
456 struct wlandevice *wlandev = dev->ml_priv;
457
458
459
460 if (wlandev->set_multicast_list)
461 wlandev->set_multicast_list(wlandev, dev);
462}
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492static int p80211knetdev_siocdevprivate(struct net_device *dev,
493 struct ifreq *ifr,
494 void __user *data, int cmd)
495{
496 int result = 0;
497 struct p80211ioctl_req *req = (struct p80211ioctl_req *)ifr;
498 struct wlandevice *wlandev = dev->ml_priv;
499 u8 *msgbuf;
500
501 netdev_dbg(dev, "rx'd ioctl, cmd=%d, len=%d\n", cmd, req->len);
502
503 if (in_compat_syscall())
504 return -EOPNOTSUPP;
505
506
507 if (req->magic != P80211_IOCTL_MAGIC) {
508 result = -EINVAL;
509 goto bail;
510 }
511
512 if (cmd == P80211_IFTEST) {
513 result = 0;
514 goto bail;
515 } else if (cmd != P80211_IFREQ) {
516 result = -EINVAL;
517 goto bail;
518 }
519
520 msgbuf = memdup_user(data, req->len);
521 if (IS_ERR(msgbuf)) {
522 result = PTR_ERR(msgbuf);
523 goto bail;
524 }
525
526 result = p80211req_dorequest(wlandev, msgbuf);
527
528 if (result == 0) {
529 if (copy_to_user(data, msgbuf, req->len))
530 result = -EFAULT;
531 }
532 kfree(msgbuf);
533
534bail:
535
536 return result;
537}
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565static int p80211knetdev_set_mac_address(struct net_device *dev, void *addr)
566{
567 struct sockaddr *new_addr = addr;
568 struct p80211msg_dot11req_mibset dot11req;
569 struct p80211item_unk392 *mibattr;
570 struct p80211item_pstr6 *macaddr;
571 struct p80211item_uint32 *resultcode;
572 int result;
573
574
575 if (netif_running(dev))
576 return -EBUSY;
577
578
579 mibattr = &dot11req.mibattribute;
580 macaddr = (struct p80211item_pstr6 *)&mibattr->data;
581 resultcode = &dot11req.resultcode;
582
583
584 memset(&dot11req, 0, sizeof(dot11req));
585 dot11req.msgcode = DIDMSG_DOT11REQ_MIBSET;
586 dot11req.msglen = sizeof(dot11req);
587 memcpy(dot11req.devname,
588 ((struct wlandevice *)dev->ml_priv)->name,
589 WLAN_DEVNAMELEN_MAX - 1);
590
591
592 mibattr->did = DIDMSG_DOT11REQ_MIBSET_MIBATTRIBUTE;
593 mibattr->status = P80211ENUM_msgitem_status_data_ok;
594 mibattr->len = sizeof(mibattr->data);
595
596 macaddr->did = DIDMIB_DOT11MAC_OPERATIONTABLE_MACADDRESS;
597 macaddr->status = P80211ENUM_msgitem_status_data_ok;
598 macaddr->len = sizeof(macaddr->data);
599 macaddr->data.len = ETH_ALEN;
600 memcpy(&macaddr->data.data, new_addr->sa_data, ETH_ALEN);
601
602
603 resultcode->did = DIDMSG_DOT11REQ_MIBSET_RESULTCODE;
604 resultcode->status = P80211ENUM_msgitem_status_no_value;
605 resultcode->len = sizeof(resultcode->data);
606 resultcode->data = 0;
607
608
609 result = p80211req_dorequest(dev->ml_priv, (u8 *)&dot11req);
610
611
612
613
614 if (result != 0 || resultcode->data != P80211ENUM_resultcode_success) {
615 netdev_err(dev, "Low-level driver failed dot11req_mibset(dot11MACAddress).\n");
616 result = -EADDRNOTAVAIL;
617 } else {
618
619 memcpy(dev->dev_addr, new_addr->sa_data, dev->addr_len);
620 }
621
622 return result;
623}
624
625static const struct net_device_ops p80211_netdev_ops = {
626 .ndo_init = p80211knetdev_init,
627 .ndo_open = p80211knetdev_open,
628 .ndo_stop = p80211knetdev_stop,
629 .ndo_start_xmit = p80211knetdev_hard_start_xmit,
630 .ndo_set_rx_mode = p80211knetdev_set_multicast_list,
631 .ndo_siocdevprivate = p80211knetdev_siocdevprivate,
632 .ndo_set_mac_address = p80211knetdev_set_mac_address,
633 .ndo_tx_timeout = p80211knetdev_tx_timeout,
634 .ndo_validate_addr = eth_validate_addr,
635};
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661int wlan_setup(struct wlandevice *wlandev, struct device *physdev)
662{
663 int result = 0;
664 struct net_device *netdev;
665 struct wiphy *wiphy;
666 struct wireless_dev *wdev;
667
668
669 wlandev->state = WLAN_DEVICE_CLOSED;
670 wlandev->ethconv = WLAN_ETHCONV_8021h;
671 wlandev->macmode = WLAN_MACMODE_NONE;
672
673
674 skb_queue_head_init(&wlandev->nsd_rxq);
675 tasklet_setup(&wlandev->rx_bh, p80211netdev_rx_bh);
676
677
678 wiphy = wlan_create_wiphy(physdev, wlandev);
679 if (!wiphy) {
680 dev_err(physdev, "Failed to alloc wiphy.\n");
681 return 1;
682 }
683
684
685 netdev = alloc_netdev(sizeof(struct wireless_dev), "wlan%d",
686 NET_NAME_UNKNOWN, ether_setup);
687 if (!netdev) {
688 dev_err(physdev, "Failed to alloc netdev.\n");
689 wlan_free_wiphy(wiphy);
690 result = 1;
691 } else {
692 wlandev->netdev = netdev;
693 netdev->ml_priv = wlandev;
694 netdev->netdev_ops = &p80211_netdev_ops;
695 wdev = netdev_priv(netdev);
696 wdev->wiphy = wiphy;
697 wdev->iftype = NL80211_IFTYPE_STATION;
698 netdev->ieee80211_ptr = wdev;
699 netdev->min_mtu = 68;
700
701
702
703 netdev->max_mtu = (2312 - 20 - 8);
704
705 netif_stop_queue(netdev);
706 netif_carrier_off(netdev);
707 }
708
709 return result;
710}
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732void wlan_unsetup(struct wlandevice *wlandev)
733{
734 struct wireless_dev *wdev;
735
736 tasklet_kill(&wlandev->rx_bh);
737
738 if (wlandev->netdev) {
739 wdev = netdev_priv(wlandev->netdev);
740 if (wdev->wiphy)
741 wlan_free_wiphy(wdev->wiphy);
742 free_netdev(wlandev->netdev);
743 wlandev->netdev = NULL;
744 }
745}
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767int register_wlandev(struct wlandevice *wlandev)
768{
769 return register_netdev(wlandev->netdev);
770}
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790int unregister_wlandev(struct wlandevice *wlandev)
791{
792 struct sk_buff *skb;
793
794 unregister_netdev(wlandev->netdev);
795
796
797 while ((skb = skb_dequeue(&wlandev->nsd_rxq)))
798 dev_kfree_skb(skb);
799
800 return 0;
801}
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834void p80211netdev_hwremoved(struct wlandevice *wlandev)
835{
836 wlandev->hwremoved = 1;
837 if (wlandev->state == WLAN_DEVICE_OPEN)
838 netif_stop_queue(wlandev->netdev);
839
840 netif_device_detach(wlandev->netdev);
841}
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865static int p80211_rx_typedrop(struct wlandevice *wlandev, u16 fc)
866{
867 u16 ftype;
868 u16 fstype;
869 int drop = 0;
870
871 ftype = WLAN_GET_FC_FTYPE(fc);
872 fstype = WLAN_GET_FC_FSTYPE(fc);
873 switch (ftype) {
874 case WLAN_FTYPE_MGMT:
875 if ((wlandev->netdev->flags & IFF_PROMISC) ||
876 (wlandev->netdev->flags & IFF_ALLMULTI)) {
877 drop = 1;
878 break;
879 }
880 netdev_dbg(wlandev->netdev, "rx'd mgmt:\n");
881 wlandev->rx.mgmt++;
882 switch (fstype) {
883 case WLAN_FSTYPE_ASSOCREQ:
884
885 wlandev->rx.assocreq++;
886 break;
887 case WLAN_FSTYPE_ASSOCRESP:
888
889 wlandev->rx.assocresp++;
890 break;
891 case WLAN_FSTYPE_REASSOCREQ:
892
893 wlandev->rx.reassocreq++;
894 break;
895 case WLAN_FSTYPE_REASSOCRESP:
896
897 wlandev->rx.reassocresp++;
898 break;
899 case WLAN_FSTYPE_PROBEREQ:
900
901 wlandev->rx.probereq++;
902 break;
903 case WLAN_FSTYPE_PROBERESP:
904
905 wlandev->rx.proberesp++;
906 break;
907 case WLAN_FSTYPE_BEACON:
908
909 wlandev->rx.beacon++;
910 break;
911 case WLAN_FSTYPE_ATIM:
912
913 wlandev->rx.atim++;
914 break;
915 case WLAN_FSTYPE_DISASSOC:
916
917 wlandev->rx.disassoc++;
918 break;
919 case WLAN_FSTYPE_AUTHEN:
920
921 wlandev->rx.authen++;
922 break;
923 case WLAN_FSTYPE_DEAUTHEN:
924
925 wlandev->rx.deauthen++;
926 break;
927 default:
928
929 wlandev->rx.mgmt_unknown++;
930 break;
931 }
932
933 drop = 2;
934 break;
935
936 case WLAN_FTYPE_CTL:
937 if ((wlandev->netdev->flags & IFF_PROMISC) ||
938 (wlandev->netdev->flags & IFF_ALLMULTI)) {
939 drop = 1;
940 break;
941 }
942 netdev_dbg(wlandev->netdev, "rx'd ctl:\n");
943 wlandev->rx.ctl++;
944 switch (fstype) {
945 case WLAN_FSTYPE_PSPOLL:
946
947 wlandev->rx.pspoll++;
948 break;
949 case WLAN_FSTYPE_RTS:
950
951 wlandev->rx.rts++;
952 break;
953 case WLAN_FSTYPE_CTS:
954
955 wlandev->rx.cts++;
956 break;
957 case WLAN_FSTYPE_ACK:
958
959 wlandev->rx.ack++;
960 break;
961 case WLAN_FSTYPE_CFEND:
962
963 wlandev->rx.cfend++;
964 break;
965 case WLAN_FSTYPE_CFENDCFACK:
966
967 wlandev->rx.cfendcfack++;
968 break;
969 default:
970
971 wlandev->rx.ctl_unknown++;
972 break;
973 }
974
975 drop = 2;
976 break;
977
978 case WLAN_FTYPE_DATA:
979 wlandev->rx.data++;
980 switch (fstype) {
981 case WLAN_FSTYPE_DATAONLY:
982 wlandev->rx.dataonly++;
983 break;
984 case WLAN_FSTYPE_DATA_CFACK:
985 wlandev->rx.data_cfack++;
986 break;
987 case WLAN_FSTYPE_DATA_CFPOLL:
988 wlandev->rx.data_cfpoll++;
989 break;
990 case WLAN_FSTYPE_DATA_CFACK_CFPOLL:
991 wlandev->rx.data__cfack_cfpoll++;
992 break;
993 case WLAN_FSTYPE_NULL:
994 netdev_dbg(wlandev->netdev, "rx'd data:null\n");
995 wlandev->rx.null++;
996 break;
997 case WLAN_FSTYPE_CFACK:
998 netdev_dbg(wlandev->netdev, "rx'd data:cfack\n");
999 wlandev->rx.cfack++;
1000 break;
1001 case WLAN_FSTYPE_CFPOLL:
1002 netdev_dbg(wlandev->netdev, "rx'd data:cfpoll\n");
1003 wlandev->rx.cfpoll++;
1004 break;
1005 case WLAN_FSTYPE_CFACK_CFPOLL:
1006 netdev_dbg(wlandev->netdev, "rx'd data:cfack_cfpoll\n");
1007 wlandev->rx.cfack_cfpoll++;
1008 break;
1009 default:
1010
1011 wlandev->rx.data_unknown++;
1012 break;
1013 }
1014
1015 break;
1016 }
1017 return drop;
1018}
1019
1020static void p80211knetdev_tx_timeout(struct net_device *netdev, unsigned int txqueue)
1021{
1022 struct wlandevice *wlandev = netdev->ml_priv;
1023
1024 if (wlandev->tx_timeout) {
1025 wlandev->tx_timeout(wlandev);
1026 } else {
1027 netdev_warn(netdev, "Implement tx_timeout for %s\n",
1028 wlandev->nsdname);
1029 netif_wake_queue(wlandev->netdev);
1030 }
1031}
1032