1 /* 2 * Original code based Host AP (software wireless LAN access point) driver 3 * for Intersil Prism2/2.5/3 - hostap.o module, common routines 4 * 5 * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen 6 * <jkmaline@cc.hut.fi> 7 * Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi> 8 * Copyright (c) 2004, Intel Corporation 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. See README and COPYING for 13 * more details. 14 ****************************************************************************** 15 16 Few modifications for Realtek's Wi-Fi drivers by 17 Andrea Merello <andrea.merello@gmail.com> 18 19 A special thanks goes to Realtek for their support ! 20 21 ******************************************************************************/ 22 23 24 #include <linux/compiler.h> 25 #include <linux/errno.h> 26 #include <linux/if_arp.h> 27 #include <linux/in6.h> 28 #include <linux/in.h> 29 #include <linux/ip.h> 30 #include <linux/kernel.h> 31 #include <linux/module.h> 32 #include <linux/netdevice.h> 33 #include <linux/pci.h> 34 #include <linux/proc_fs.h> 35 #include <linux/skbuff.h> 36 #include <linux/slab.h> 37 #include <linux/tcp.h> 38 #include <linux/types.h> 39 #include <linux/wireless.h> 40 #include <linux/etherdevice.h> 41 #include <linux/uaccess.h> 42 #include <linux/ctype.h> 43 44 #include "rtllib.h" 45 #include "dot11d.h" 46 47 static void rtllib_rx_mgt(struct rtllib_device *ieee, struct sk_buff *skb, 48 struct rtllib_rx_stats *stats); 49 50 static inline void rtllib_monitor_rx(struct rtllib_device *ieee, 51 struct sk_buff *skb, 52 struct rtllib_rx_stats *rx_status, 53 size_t hdr_length) 54 { 55 skb->dev = ieee->dev; 56 skb_reset_mac_header(skb); 57 skb_pull(skb, hdr_length); 58 skb->pkt_type = PACKET_OTHERHOST; 59 skb->protocol = htons(ETH_P_80211_RAW); 60 memset(skb->cb, 0, sizeof(skb->cb)); 61 netif_rx(skb); 62 } 63 64 /* Called only as a tasklet (software IRQ) */ 65 static struct rtllib_frag_entry * 66 rtllib_frag_cache_find(struct rtllib_device *ieee, unsigned int seq, 67 unsigned int frag, u8 tid, u8 *src, u8 *dst) 68 { 69 struct rtllib_frag_entry *entry; 70 int i; 71 72 for (i = 0; i < RTLLIB_FRAG_CACHE_LEN; i++) { 73 entry = &ieee->frag_cache[tid][i]; 74 if (entry->skb != NULL && 75 time_after(jiffies, entry->first_frag_time + 2 * HZ)) { 76 netdev_dbg(ieee->dev, 77 "expiring fragment cache entry seq=%u last_frag=%u\n", 78 entry->seq, entry->last_frag); 79 dev_kfree_skb_any(entry->skb); 80 entry->skb = NULL; 81 } 82 83 if (entry->skb != NULL && entry->seq == seq && 84 (entry->last_frag + 1 == frag || frag == -1) && 85 memcmp(entry->src_addr, src, ETH_ALEN) == 0 && 86 memcmp(entry->dst_addr, dst, ETH_ALEN) == 0) 87 return entry; 88 } 89 90 return NULL; 91 } 92 93 /* Called only as a tasklet (software IRQ) */ 94 static struct sk_buff * 95 rtllib_frag_cache_get(struct rtllib_device *ieee, 96 struct rtllib_hdr_4addr *hdr) 97 { 98 struct sk_buff *skb = NULL; 99 u16 fc = le16_to_cpu(hdr->frame_ctl); 100 u16 sc = le16_to_cpu(hdr->seq_ctl); 101 unsigned int frag = WLAN_GET_SEQ_FRAG(sc); 102 unsigned int seq = WLAN_GET_SEQ_SEQ(sc); 103 struct rtllib_frag_entry *entry; 104 struct rtllib_hdr_3addrqos *hdr_3addrqos; 105 struct rtllib_hdr_4addrqos *hdr_4addrqos; 106 u8 tid; 107 108 if (((fc & RTLLIB_FCTL_DSTODS) == RTLLIB_FCTL_DSTODS) && 109 RTLLIB_QOS_HAS_SEQ(fc)) { 110 hdr_4addrqos = (struct rtllib_hdr_4addrqos *)hdr; 111 tid = le16_to_cpu(hdr_4addrqos->qos_ctl) & RTLLIB_QCTL_TID; 112 tid = UP2AC(tid); 113 tid++; 114 } else if (RTLLIB_QOS_HAS_SEQ(fc)) { 115 hdr_3addrqos = (struct rtllib_hdr_3addrqos *)hdr; 116 tid = le16_to_cpu(hdr_3addrqos->qos_ctl) & RTLLIB_QCTL_TID; 117 tid = UP2AC(tid); 118 tid++; 119 } else { 120 tid = 0; 121 } 122 123 if (frag == 0) { 124 /* Reserve enough space to fit maximum frame length */ 125 skb = dev_alloc_skb(ieee->dev->mtu + 126 sizeof(struct rtllib_hdr_4addr) + 127 8 /* LLC */ + 128 2 /* alignment */ + 129 8 /* WEP */ + 130 ETH_ALEN /* WDS */ + 131 /* QOS Control */ 132 (RTLLIB_QOS_HAS_SEQ(fc) ? 2 : 0)); 133 if (!skb) 134 return NULL; 135 136 entry = &ieee->frag_cache[tid][ieee->frag_next_idx[tid]]; 137 ieee->frag_next_idx[tid]++; 138 if (ieee->frag_next_idx[tid] >= RTLLIB_FRAG_CACHE_LEN) 139 ieee->frag_next_idx[tid] = 0; 140 141 if (entry->skb != NULL) 142 dev_kfree_skb_any(entry->skb); 143 144 entry->first_frag_time = jiffies; 145 entry->seq = seq; 146 entry->last_frag = frag; 147 entry->skb = skb; 148 ether_addr_copy(entry->src_addr, hdr->addr2); 149 ether_addr_copy(entry->dst_addr, hdr->addr1); 150 } else { 151 /* received a fragment of a frame for which the head fragment 152 * should have already been received 153 */ 154 entry = rtllib_frag_cache_find(ieee, seq, frag, tid, hdr->addr2, 155 hdr->addr1); 156 if (entry != NULL) { 157 entry->last_frag = frag; 158 skb = entry->skb; 159 } 160 } 161 162 return skb; 163 } 164 165 166 /* Called only as a tasklet (software IRQ) */ 167 static int rtllib_frag_cache_invalidate(struct rtllib_device *ieee, 168 struct rtllib_hdr_4addr *hdr) 169 { 170 u16 fc = le16_to_cpu(hdr->frame_ctl); 171 u16 sc = le16_to_cpu(hdr->seq_ctl); 172 unsigned int seq = WLAN_GET_SEQ_SEQ(sc); 173 struct rtllib_frag_entry *entry; 174 struct rtllib_hdr_3addrqos *hdr_3addrqos; 175 struct rtllib_hdr_4addrqos *hdr_4addrqos; 176 u8 tid; 177 178 if (((fc & RTLLIB_FCTL_DSTODS) == RTLLIB_FCTL_DSTODS) && 179 RTLLIB_QOS_HAS_SEQ(fc)) { 180 hdr_4addrqos = (struct rtllib_hdr_4addrqos *)hdr; 181 tid = le16_to_cpu(hdr_4addrqos->qos_ctl) & RTLLIB_QCTL_TID; 182 tid = UP2AC(tid); 183 tid++; 184 } else if (RTLLIB_QOS_HAS_SEQ(fc)) { 185 hdr_3addrqos = (struct rtllib_hdr_3addrqos *)hdr; 186 tid = le16_to_cpu(hdr_3addrqos->qos_ctl) & RTLLIB_QCTL_TID; 187 tid = UP2AC(tid); 188 tid++; 189 } else { 190 tid = 0; 191 } 192 193 entry = rtllib_frag_cache_find(ieee, seq, -1, tid, hdr->addr2, 194 hdr->addr1); 195 196 if (entry == NULL) { 197 netdev_dbg(ieee->dev, 198 "Couldn't invalidate fragment cache entry (seq=%u)\n", 199 seq); 200 return -1; 201 } 202 203 entry->skb = NULL; 204 return 0; 205 } 206 207 /* rtllib_rx_frame_mgtmt 208 * 209 * Responsible for handling management control frames 210 * 211 * Called by rtllib_rx 212 */ 213 static inline int 214 rtllib_rx_frame_mgmt(struct rtllib_device *ieee, struct sk_buff *skb, 215 struct rtllib_rx_stats *rx_stats, u16 type, 216 u16 stype) 217 { 218 /* On the struct stats definition there is written that 219 * this is not mandatory.... but seems that the probe 220 * response parser uses it 221 */ 222 struct rtllib_hdr_3addr *hdr = (struct rtllib_hdr_3addr *)skb->data; 223 224 rx_stats->len = skb->len; 225 rtllib_rx_mgt(ieee, skb, rx_stats); 226 if ((memcmp(hdr->addr1, ieee->dev->dev_addr, ETH_ALEN))) { 227 dev_kfree_skb_any(skb); 228 return 0; 229 } 230 rtllib_rx_frame_softmac(ieee, skb, rx_stats, type, stype); 231 232 dev_kfree_skb_any(skb); 233 234 return 0; 235 } 236 237 /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation 238 * Ethernet-II snap header (RFC1042 for most EtherTypes) 239 */ 240 static unsigned char rfc1042_header[] = { 241 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 242 }; 243 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */ 244 static unsigned char bridge_tunnel_header[] = { 245 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 246 }; 247 /* No encapsulation header if EtherType < 0x600 (=length) */ 248 249 /* Called by rtllib_rx_frame_decrypt */ 250 static int rtllib_is_eapol_frame(struct rtllib_device *ieee, 251 struct sk_buff *skb, size_t hdrlen) 252 { 253 struct net_device *dev = ieee->dev; 254 u16 fc, ethertype; 255 struct rtllib_hdr_4addr *hdr; 256 u8 *pos; 257 258 if (skb->len < 24) 259 return 0; 260 261 hdr = (struct rtllib_hdr_4addr *) skb->data; 262 fc = le16_to_cpu(hdr->frame_ctl); 263 264 /* check that the frame is unicast frame to us */ 265 if ((fc & (RTLLIB_FCTL_TODS | RTLLIB_FCTL_FROMDS)) == 266 RTLLIB_FCTL_TODS && 267 memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN) == 0 && 268 memcmp(hdr->addr3, dev->dev_addr, ETH_ALEN) == 0) { 269 /* ToDS frame with own addr BSSID and DA */ 270 } else if ((fc & (RTLLIB_FCTL_TODS | RTLLIB_FCTL_FROMDS)) == 271 RTLLIB_FCTL_FROMDS && 272 memcmp(hdr->addr1, dev->dev_addr, ETH_ALEN) == 0) { 273 /* FromDS frame with own addr as DA */ 274 } else 275 return 0; 276 277 if (skb->len < 24 + 8) 278 return 0; 279 280 /* check for port access entity Ethernet type */ 281 pos = skb->data + hdrlen; 282 ethertype = (pos[6] << 8) | pos[7]; 283 if (ethertype == ETH_P_PAE) 284 return 1; 285 286 return 0; 287 } 288 289 /* Called only as a tasklet (software IRQ), by rtllib_rx */ 290 static inline int 291 rtllib_rx_frame_decrypt(struct rtllib_device *ieee, struct sk_buff *skb, 292 struct lib80211_crypt_data *crypt) 293 { 294 struct rtllib_hdr_4addr *hdr; 295 int res, hdrlen; 296 297 if (crypt == NULL || crypt->ops->decrypt_mpdu == NULL) 298 return 0; 299 300 if (ieee->hwsec_active) { 301 struct cb_desc *tcb_desc = (struct cb_desc *) 302 (skb->cb + MAX_DEV_ADDR_SIZE); 303 304 tcb_desc->bHwSec = 1; 305 306 if (ieee->need_sw_enc) 307 tcb_desc->bHwSec = 0; 308 } 309 310 hdr = (struct rtllib_hdr_4addr *) skb->data; 311 hdrlen = rtllib_get_hdrlen(le16_to_cpu(hdr->frame_ctl)); 312 313 atomic_inc(&crypt->refcnt); 314 res = crypt->ops->decrypt_mpdu(skb, hdrlen, crypt->priv); 315 atomic_dec(&crypt->refcnt); 316 if (res < 0) { 317 netdev_dbg(ieee->dev, "decryption failed (SA= %pM) res=%d\n", 318 hdr->addr2, res); 319 if (res == -2) 320 netdev_dbg(ieee->dev, 321 "Decryption failed ICV mismatch (key %d)\n", 322 skb->data[hdrlen + 3] >> 6); 323 return -1; 324 } 325 326 return res; 327 } 328 329 330 /* Called only as a tasklet (software IRQ), by rtllib_rx */ 331 static inline int 332 rtllib_rx_frame_decrypt_msdu(struct rtllib_device *ieee, struct sk_buff *skb, 333 int keyidx, struct lib80211_crypt_data *crypt) 334 { 335 struct rtllib_hdr_4addr *hdr; 336 int res, hdrlen; 337 338 if (crypt == NULL || crypt->ops->decrypt_msdu == NULL) 339 return 0; 340 if (ieee->hwsec_active) { 341 struct cb_desc *tcb_desc = (struct cb_desc *) 342 (skb->cb + MAX_DEV_ADDR_SIZE); 343 344 tcb_desc->bHwSec = 1; 345 346 if (ieee->need_sw_enc) 347 tcb_desc->bHwSec = 0; 348 } 349 350 hdr = (struct rtllib_hdr_4addr *) skb->data; 351 hdrlen = rtllib_get_hdrlen(le16_to_cpu(hdr->frame_ctl)); 352 353 atomic_inc(&crypt->refcnt); 354 res = crypt->ops->decrypt_msdu(skb, keyidx, hdrlen, crypt->priv); 355 atomic_dec(&crypt->refcnt); 356 if (res < 0) { 357 netdev_dbg(ieee->dev, 358 "MSDU decryption/MIC verification failed (SA= %pM keyidx=%d)\n", 359 hdr->addr2, keyidx); 360 return -1; 361 } 362 363 return 0; 364 } 365 366 367 /* this function is stolen from ipw2200 driver*/ 368 #define IEEE_PACKET_RETRY_TIME (5*HZ) 369 static int is_duplicate_packet(struct rtllib_device *ieee, 370 struct rtllib_hdr_4addr *header) 371 { 372 u16 fc = le16_to_cpu(header->frame_ctl); 373 u16 sc = le16_to_cpu(header->seq_ctl); 374 u16 seq = WLAN_GET_SEQ_SEQ(sc); 375 u16 frag = WLAN_GET_SEQ_FRAG(sc); 376 u16 *last_seq, *last_frag; 377 unsigned long *last_time; 378 struct rtllib_hdr_3addrqos *hdr_3addrqos; 379 struct rtllib_hdr_4addrqos *hdr_4addrqos; 380 u8 tid; 381 382 if (((fc & RTLLIB_FCTL_DSTODS) == RTLLIB_FCTL_DSTODS) && 383 RTLLIB_QOS_HAS_SEQ(fc)) { 384 hdr_4addrqos = (struct rtllib_hdr_4addrqos *)header; 385 tid = le16_to_cpu(hdr_4addrqos->qos_ctl) & RTLLIB_QCTL_TID; 386 tid = UP2AC(tid); 387 tid++; 388 } else if (RTLLIB_QOS_HAS_SEQ(fc)) { 389 hdr_3addrqos = (struct rtllib_hdr_3addrqos *)header; 390 tid = le16_to_cpu(hdr_3addrqos->qos_ctl) & RTLLIB_QCTL_TID; 391 tid = UP2AC(tid); 392 tid++; 393 } else { 394 tid = 0; 395 } 396 397 switch (ieee->iw_mode) { 398 case IW_MODE_ADHOC: 399 { 400 struct list_head *p; 401 struct ieee_ibss_seq *entry = NULL; 402 u8 *mac = header->addr2; 403 int index = mac[5] % IEEE_IBSS_MAC_HASH_SIZE; 404 405 list_for_each(p, &ieee->ibss_mac_hash[index]) { 406 entry = list_entry(p, struct ieee_ibss_seq, list); 407 if (!memcmp(entry->mac, mac, ETH_ALEN)) 408 break; 409 } 410 if (p == &ieee->ibss_mac_hash[index]) { 411 entry = kmalloc(sizeof(struct ieee_ibss_seq), 412 GFP_ATOMIC); 413 if (!entry) 414 return 0; 415 416 ether_addr_copy(entry->mac, mac); 417 entry->seq_num[tid] = seq; 418 entry->frag_num[tid] = frag; 419 entry->packet_time[tid] = jiffies; 420 list_add(&entry->list, &ieee->ibss_mac_hash[index]); 421 return 0; 422 } 423 last_seq = &entry->seq_num[tid]; 424 last_frag = &entry->frag_num[tid]; 425 last_time = &entry->packet_time[tid]; 426 break; 427 } 428 429 case IW_MODE_INFRA: 430 last_seq = &ieee->last_rxseq_num[tid]; 431 last_frag = &ieee->last_rxfrag_num[tid]; 432 last_time = &ieee->last_packet_time[tid]; 433 break; 434 default: 435 return 0; 436 } 437 438 if ((*last_seq == seq) && 439 time_after(*last_time + IEEE_PACKET_RETRY_TIME, jiffies)) { 440 if (*last_frag == frag) 441 goto drop; 442 if (*last_frag + 1 != frag) 443 /* out-of-order fragment */ 444 goto drop; 445 } else 446 *last_seq = seq; 447 448 *last_frag = frag; 449 *last_time = jiffies; 450 return 0; 451 452 drop: 453 454 return 1; 455 } 456 457 static bool AddReorderEntry(struct rx_ts_record *pTS, 458 struct rx_reorder_entry *pReorderEntry) 459 { 460 struct list_head *pList = &pTS->RxPendingPktList; 461 462 while (pList->next != &pTS->RxPendingPktList) { 463 if (SN_LESS(pReorderEntry->SeqNum, ((struct rx_reorder_entry *) 464 list_entry(pList->next, struct rx_reorder_entry, 465 List))->SeqNum)) 466 pList = pList->next; 467 else if (SN_EQUAL(pReorderEntry->SeqNum, 468 ((struct rx_reorder_entry *)list_entry(pList->next, 469 struct rx_reorder_entry, List))->SeqNum)) 470 return false; 471 else 472 break; 473 } 474 pReorderEntry->List.next = pList->next; 475 pReorderEntry->List.next->prev = &pReorderEntry->List; 476 pReorderEntry->List.prev = pList; 477 pList->next = &pReorderEntry->List; 478 479 return true; 480 } 481 482 void rtllib_indicate_packets(struct rtllib_device *ieee, 483 struct rtllib_rxb **prxbIndicateArray, u8 index) 484 { 485 struct net_device_stats *stats = &ieee->stats; 486 u8 i = 0, j = 0; 487 u16 ethertype; 488 489 for (j = 0; j < index; j++) { 490 struct rtllib_rxb *prxb = prxbIndicateArray[j]; 491 492 for (i = 0; i < prxb->nr_subframes; i++) { 493 struct sk_buff *sub_skb = prxb->subframes[i]; 494 495 /* convert hdr + possible LLC headers into Ethernet header */ 496 ethertype = (sub_skb->data[6] << 8) | sub_skb->data[7]; 497 if (sub_skb->len >= 8 && 498 ((memcmp(sub_skb->data, rfc1042_header, 499 SNAP_SIZE) == 0 && 500 ethertype != ETH_P_AARP && 501 ethertype != ETH_P_IPX) || 502 memcmp(sub_skb->data, bridge_tunnel_header, 503 SNAP_SIZE) == 0)) { 504 /* remove RFC1042 or Bridge-Tunnel encapsulation 505 * and replace EtherType 506 */ 507 skb_pull(sub_skb, SNAP_SIZE); 508 memcpy(skb_push(sub_skb, ETH_ALEN), prxb->src, ETH_ALEN); 509 memcpy(skb_push(sub_skb, ETH_ALEN), prxb->dst, ETH_ALEN); 510 } else { 511 u16 len; 512 /* Leave Ethernet header part of hdr and full payload */ 513 len = sub_skb->len; 514 memcpy(skb_push(sub_skb, 2), &len, 2); 515 memcpy(skb_push(sub_skb, ETH_ALEN), prxb->src, ETH_ALEN); 516 memcpy(skb_push(sub_skb, ETH_ALEN), prxb->dst, ETH_ALEN); 517 } 518 519 /* Indicate the packets to upper layer */ 520 if (sub_skb) { 521 stats->rx_packets++; 522 stats->rx_bytes += sub_skb->len; 523 524 memset(sub_skb->cb, 0, sizeof(sub_skb->cb)); 525 sub_skb->protocol = eth_type_trans(sub_skb, 526 ieee->dev); 527 sub_skb->dev = ieee->dev; 528 sub_skb->dev->stats.rx_packets++; 529 sub_skb->dev->stats.rx_bytes += sub_skb->len; 530 /* 802.11 crc not sufficient */ 531 sub_skb->ip_summed = CHECKSUM_NONE; 532 ieee->last_rx_ps_time = jiffies; 533 netif_rx(sub_skb); 534 } 535 } 536 kfree(prxb); 537 prxb = NULL; 538 } 539 } 540 541 void rtllib_FlushRxTsPendingPkts(struct rtllib_device *ieee, 542 struct rx_ts_record *pTS) 543 { 544 struct rx_reorder_entry *pRxReorderEntry; 545 u8 RfdCnt = 0; 546 547 del_timer_sync(&pTS->RxPktPendingTimer); 548 while (!list_empty(&pTS->RxPendingPktList)) { 549 if (RfdCnt >= REORDER_WIN_SIZE) { 550 netdev_info(ieee->dev, 551 "-------------->%s() error! RfdCnt >= REORDER_WIN_SIZE\n", 552 __func__); 553 break; 554 } 555 556 pRxReorderEntry = (struct rx_reorder_entry *) 557 list_entry(pTS->RxPendingPktList.prev, 558 struct rx_reorder_entry, List); 559 netdev_dbg(ieee->dev, "%s(): Indicate SeqNum %d!\n", __func__, 560 pRxReorderEntry->SeqNum); 561 list_del_init(&pRxReorderEntry->List); 562 563 ieee->RfdArray[RfdCnt] = pRxReorderEntry->prxb; 564 565 RfdCnt = RfdCnt + 1; 566 list_add_tail(&pRxReorderEntry->List, 567 &ieee->RxReorder_Unused_List); 568 } 569 rtllib_indicate_packets(ieee, ieee->RfdArray, RfdCnt); 570 571 pTS->RxIndicateSeq = 0xffff; 572 } 573 574 static void RxReorderIndicatePacket(struct rtllib_device *ieee, 575 struct rtllib_rxb *prxb, 576 struct rx_ts_record *pTS, u16 SeqNum) 577 { 578 struct rt_hi_throughput *pHTInfo = ieee->pHTInfo; 579 struct rx_reorder_entry *pReorderEntry = NULL; 580 u8 WinSize = pHTInfo->RxReorderWinSize; 581 u16 WinEnd = 0; 582 u8 index = 0; 583 bool bMatchWinStart = false, bPktInBuf = false; 584 unsigned long flags; 585 586 netdev_dbg(ieee->dev, 587 "%s(): Seq is %d, pTS->RxIndicateSeq is %d, WinSize is %d\n", 588 __func__, SeqNum, pTS->RxIndicateSeq, WinSize); 589 590 spin_lock_irqsave(&(ieee->reorder_spinlock), flags); 591 592 WinEnd = (pTS->RxIndicateSeq + WinSize - 1) % 4096; 593 /* Rx Reorder initialize condition.*/ 594 if (pTS->RxIndicateSeq == 0xffff) 595 pTS->RxIndicateSeq = SeqNum; 596 597 /* Drop out the packet which SeqNum is smaller than WinStart */ 598 if (SN_LESS(SeqNum, pTS->RxIndicateSeq)) { 599 netdev_dbg(ieee->dev, 600 "Packet Drop! IndicateSeq: %d, NewSeq: %d\n", 601 pTS->RxIndicateSeq, SeqNum); 602 pHTInfo->RxReorderDropCounter++; 603 { 604 int i; 605 606 for (i = 0; i < prxb->nr_subframes; i++) 607 dev_kfree_skb(prxb->subframes[i]); 608 kfree(prxb); 609 prxb = NULL; 610 } 611 spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags); 612 return; 613 } 614 615 /* Sliding window manipulation. Conditions includes: 616 * 1. Incoming SeqNum is equal to WinStart =>Window shift 1 617 * 2. Incoming SeqNum is larger than the WinEnd => Window shift N 618 */ 619 if (SN_EQUAL(SeqNum, pTS->RxIndicateSeq)) { 620 pTS->RxIndicateSeq = (pTS->RxIndicateSeq + 1) % 4096; 621 bMatchWinStart = true; 622 } else if (SN_LESS(WinEnd, SeqNum)) { 623 if (SeqNum >= (WinSize - 1)) 624 pTS->RxIndicateSeq = SeqNum + 1 - WinSize; 625 else 626 pTS->RxIndicateSeq = 4095 - 627 (WinSize - (SeqNum + 1)) + 1; 628 netdev_dbg(ieee->dev, 629 "Window Shift! IndicateSeq: %d, NewSeq: %d\n", 630 pTS->RxIndicateSeq, SeqNum); 631 } 632 633 /* Indication process. 634 * After Packet dropping and Sliding Window shifting as above, we can 635 * now just indicate the packets with the SeqNum smaller than latest 636 * WinStart and struct buffer other packets. 637 * 638 * For Rx Reorder condition: 639 * 1. All packets with SeqNum smaller than WinStart => Indicate 640 * 2. All packets with SeqNum larger than or equal to 641 * WinStart => Buffer it. 642 */ 643 if (bMatchWinStart) { 644 /* Current packet is going to be indicated.*/ 645 netdev_dbg(ieee->dev, 646 "Packets indication! IndicateSeq: %d, NewSeq: %d\n", 647 pTS->RxIndicateSeq, SeqNum); 648 ieee->prxbIndicateArray[0] = prxb; 649 index = 1; 650 } else { 651 /* Current packet is going to be inserted into pending list.*/ 652 if (!list_empty(&ieee->RxReorder_Unused_List)) { 653 pReorderEntry = (struct rx_reorder_entry *) 654 list_entry(ieee->RxReorder_Unused_List.next, 655 struct rx_reorder_entry, List); 656 list_del_init(&pReorderEntry->List); 657 658 /* Make a reorder entry and insert 659 * into a the packet list. 660 */ 661 pReorderEntry->SeqNum = SeqNum; 662 pReorderEntry->prxb = prxb; 663 664 if (!AddReorderEntry(pTS, pReorderEntry)) { 665 int i; 666 667 netdev_dbg(ieee->dev, 668 "%s(): Duplicate packet is dropped. IndicateSeq: %d, NewSeq: %d\n", 669 __func__, pTS->RxIndicateSeq, 670 SeqNum); 671 list_add_tail(&pReorderEntry->List, 672 &ieee->RxReorder_Unused_List); 673 674 for (i = 0; i < prxb->nr_subframes; i++) 675 dev_kfree_skb(prxb->subframes[i]); 676 kfree(prxb); 677 prxb = NULL; 678 } else { 679 netdev_dbg(ieee->dev, 680 "Pkt insert into struct buffer. IndicateSeq: %d, NewSeq: %d\n", 681 pTS->RxIndicateSeq, SeqNum); 682 } 683 } else { 684 /* Packets are dropped if there are not enough reorder 685 * entries. This part should be modified!! We can just 686 * indicate all the packets in struct buffer and get 687 * reorder entries. 688 */ 689 netdev_err(ieee->dev, 690 "%s(): There is no reorder entry! Packet is dropped!\n", 691 __func__); 692 { 693 int i; 694 695 for (i = 0; i < prxb->nr_subframes; i++) 696 dev_kfree_skb(prxb->subframes[i]); 697 kfree(prxb); 698 prxb = NULL; 699 } 700 } 701 } 702 703 /* Check if there is any packet need indicate.*/ 704 while (!list_empty(&pTS->RxPendingPktList)) { 705 netdev_dbg(ieee->dev, "%s(): start RREORDER indicate\n", 706 __func__); 707 708 pReorderEntry = (struct rx_reorder_entry *) 709 list_entry(pTS->RxPendingPktList.prev, 710 struct rx_reorder_entry, 711 List); 712 if (SN_LESS(pReorderEntry->SeqNum, pTS->RxIndicateSeq) || 713 SN_EQUAL(pReorderEntry->SeqNum, pTS->RxIndicateSeq)) { 714 /* This protect struct buffer from overflow. */ 715 if (index >= REORDER_WIN_SIZE) { 716 netdev_err(ieee->dev, 717 "%s(): Buffer overflow!\n", 718 __func__); 719 bPktInBuf = true; 720 break; 721 } 722 723 list_del_init(&pReorderEntry->List); 724 725 if (SN_EQUAL(pReorderEntry->SeqNum, pTS->RxIndicateSeq)) 726 pTS->RxIndicateSeq = (pTS->RxIndicateSeq + 1) % 727 4096; 728 729 ieee->prxbIndicateArray[index] = pReorderEntry->prxb; 730 netdev_dbg(ieee->dev, "%s(): Indicate SeqNum %d!\n", 731 __func__, pReorderEntry->SeqNum); 732 index++; 733 734 list_add_tail(&pReorderEntry->List, 735 &ieee->RxReorder_Unused_List); 736 } else { 737 bPktInBuf = true; 738 break; 739 } 740 } 741 742 /* Handling pending timer. Set this timer to prevent from long time 743 * Rx buffering. 744 */ 745 if (index > 0) { 746 if (timer_pending(&pTS->RxPktPendingTimer)) 747 del_timer_sync(&pTS->RxPktPendingTimer); 748 pTS->RxTimeoutIndicateSeq = 0xffff; 749 750 if (index > REORDER_WIN_SIZE) { 751 netdev_err(ieee->dev, 752 "%s(): Rx Reorder struct buffer full!\n", 753 __func__); 754 spin_unlock_irqrestore(&(ieee->reorder_spinlock), 755 flags); 756 return; 757 } 758 rtllib_indicate_packets(ieee, ieee->prxbIndicateArray, index); 759 bPktInBuf = false; 760 } 761 762 if (bPktInBuf && pTS->RxTimeoutIndicateSeq == 0xffff) { 763 netdev_dbg(ieee->dev, "%s(): SET rx timeout timer\n", __func__); 764 pTS->RxTimeoutIndicateSeq = pTS->RxIndicateSeq; 765 mod_timer(&pTS->RxPktPendingTimer, jiffies + 766 msecs_to_jiffies(pHTInfo->RxReorderPendingTime)); 767 } 768 spin_unlock_irqrestore(&(ieee->reorder_spinlock), flags); 769 } 770 771 static u8 parse_subframe(struct rtllib_device *ieee, struct sk_buff *skb, 772 struct rtllib_rx_stats *rx_stats, 773 struct rtllib_rxb *rxb, u8 *src, u8 *dst) 774 { 775 struct rtllib_hdr_3addr *hdr = (struct rtllib_hdr_3addr *)skb->data; 776 u16 fc = le16_to_cpu(hdr->frame_ctl); 777 778 u16 LLCOffset = sizeof(struct rtllib_hdr_3addr); 779 u16 ChkLength; 780 bool bIsAggregateFrame = false; 781 u16 nSubframe_Length; 782 u8 nPadding_Length = 0; 783 u16 SeqNum = 0; 784 struct sk_buff *sub_skb; 785 u8 *data_ptr; 786 /* just for debug purpose */ 787 SeqNum = WLAN_GET_SEQ_SEQ(le16_to_cpu(hdr->seq_ctl)); 788 if ((RTLLIB_QOS_HAS_SEQ(fc)) && 789 (((union frameqos *)(skb->data + RTLLIB_3ADDR_LEN))->field.reserved)) 790 bIsAggregateFrame = true; 791 792 if (RTLLIB_QOS_HAS_SEQ(fc)) 793 LLCOffset += 2; 794 if (rx_stats->bContainHTC) 795 LLCOffset += sHTCLng; 796 797 ChkLength = LLCOffset; 798 799 if (skb->len <= ChkLength) 800 return 0; 801 802 skb_pull(skb, LLCOffset); 803 ieee->bIsAggregateFrame = bIsAggregateFrame; 804 if (!bIsAggregateFrame) { 805 rxb->nr_subframes = 1; 806 807 /* altered by clark 3/30/2010 808 * The struct buffer size of the skb indicated to upper layer 809 * must be less than 5000, or the defraged IP datagram 810 * in the IP layer will exceed "ipfrag_high_tresh" and be 811 * discarded. so there must not use the function 812 * "skb_copy" and "skb_clone" for "skb". 813 */ 814 815 /* Allocate new skb for releasing to upper layer */ 816 sub_skb = dev_alloc_skb(RTLLIB_SKBBUFFER_SIZE); 817 if (!sub_skb) 818 return 0; 819 skb_reserve(sub_skb, 12); 820 data_ptr = (u8 *)skb_put(sub_skb, skb->len); 821 memcpy(data_ptr, skb->data, skb->len); 822 sub_skb->dev = ieee->dev; 823 824 rxb->subframes[0] = sub_skb; 825 826 memcpy(rxb->src, src, ETH_ALEN); 827 memcpy(rxb->dst, dst, ETH_ALEN); 828 rxb->subframes[0]->dev = ieee->dev; 829 return 1; 830 } 831 832 rxb->nr_subframes = 0; 833 memcpy(rxb->src, src, ETH_ALEN); 834 memcpy(rxb->dst, dst, ETH_ALEN); 835 while (skb->len > ETHERNET_HEADER_SIZE) { 836 /* Offset 12 denote 2 mac address */ 837 nSubframe_Length = *((u16 *)(skb->data + 12)); 838 nSubframe_Length = (nSubframe_Length >> 8) + 839 (nSubframe_Length << 8); 840 841 if (skb->len < (ETHERNET_HEADER_SIZE + nSubframe_Length)) { 842 netdev_info(ieee->dev, 843 "%s: A-MSDU parse error!! pRfd->nTotalSubframe : %d\n", 844 __func__, rxb->nr_subframes); 845 netdev_info(ieee->dev, 846 "%s: A-MSDU parse error!! Subframe Length: %d\n", 847 __func__, nSubframe_Length); 848 netdev_info(ieee->dev, 849 "nRemain_Length is %d and nSubframe_Length is : %d\n", 850 skb->len, nSubframe_Length); 851 netdev_info(ieee->dev, 852 "The Packet SeqNum is %d\n", 853 SeqNum); 854 return 0; 855 } 856 857 /* move the data point to data content */ 858 skb_pull(skb, ETHERNET_HEADER_SIZE); 859 860 /* altered by clark 3/30/2010 861 * The struct buffer size of the skb indicated to upper layer 862 * must be less than 5000, or the defraged IP datagram 863 * in the IP layer will exceed "ipfrag_high_tresh" and be 864 * discarded. so there must not use the function 865 * "skb_copy" and "skb_clone" for "skb". 866 */ 867 868 /* Allocate new skb for releasing to upper layer */ 869 sub_skb = dev_alloc_skb(nSubframe_Length + 12); 870 if (!sub_skb) 871 return 0; 872 skb_reserve(sub_skb, 12); 873 data_ptr = (u8 *)skb_put(sub_skb, nSubframe_Length); 874 memcpy(data_ptr, skb->data, nSubframe_Length); 875 876 sub_skb->dev = ieee->dev; 877 rxb->subframes[rxb->nr_subframes++] = sub_skb; 878 if (rxb->nr_subframes >= MAX_SUBFRAME_COUNT) { 879 netdev_dbg(ieee->dev, 880 "ParseSubframe(): Too many Subframes! Packets dropped!\n"); 881 break; 882 } 883 skb_pull(skb, nSubframe_Length); 884 885 if (skb->len != 0) { 886 nPadding_Length = 4 - ((nSubframe_Length + 887 ETHERNET_HEADER_SIZE) % 4); 888 if (nPadding_Length == 4) 889 nPadding_Length = 0; 890 891 if (skb->len < nPadding_Length) 892 return 0; 893 894 skb_pull(skb, nPadding_Length); 895 } 896 } 897 898 return rxb->nr_subframes; 899 } 900 901 902 static size_t rtllib_rx_get_hdrlen(struct rtllib_device *ieee, 903 struct sk_buff *skb, 904 struct rtllib_rx_stats *rx_stats) 905 { 906 struct rtllib_hdr_4addr *hdr = (struct rtllib_hdr_4addr *)skb->data; 907 u16 fc = le16_to_cpu(hdr->frame_ctl); 908 size_t hdrlen; 909 910 hdrlen = rtllib_get_hdrlen(fc); 911 if (HTCCheck(ieee, skb->data)) { 912 if (net_ratelimit()) 913 netdev_info(ieee->dev, "%s: find HTCControl!\n", 914 __func__); 915 hdrlen += 4; 916 rx_stats->bContainHTC = true; 917 } 918 919 if (RTLLIB_QOS_HAS_SEQ(fc)) 920 rx_stats->bIsQosData = true; 921 922 return hdrlen; 923 } 924 925 static int rtllib_rx_check_duplicate(struct rtllib_device *ieee, 926 struct sk_buff *skb, u8 multicast) 927 { 928 struct rtllib_hdr_4addr *hdr = (struct rtllib_hdr_4addr *)skb->data; 929 u16 fc, sc; 930 u8 frag, type, stype; 931 932 fc = le16_to_cpu(hdr->frame_ctl); 933 type = WLAN_FC_GET_TYPE(fc); 934 stype = WLAN_FC_GET_STYPE(fc); 935 sc = le16_to_cpu(hdr->seq_ctl); 936 frag = WLAN_GET_SEQ_FRAG(sc); 937 938 if ((ieee->pHTInfo->bCurRxReorderEnable == false) || 939 !ieee->current_network.qos_data.active || 940 !IsDataFrame(skb->data) || 941 IsLegacyDataFrame(skb->data)) { 942 if (!((type == RTLLIB_FTYPE_MGMT) && 943 (stype == RTLLIB_STYPE_BEACON))) { 944 if (is_duplicate_packet(ieee, hdr)) 945 return -1; 946 } 947 } else { 948 struct rx_ts_record *pRxTS = NULL; 949 950 if (GetTs(ieee, (struct ts_common_info **) &pRxTS, hdr->addr2, 951 (u8)Frame_QoSTID((u8 *)(skb->data)), RX_DIR, true)) { 952 if ((fc & (1<<11)) && (frag == pRxTS->RxLastFragNum) && 953 (WLAN_GET_SEQ_SEQ(sc) == pRxTS->RxLastSeqNum)) 954 return -1; 955 pRxTS->RxLastFragNum = frag; 956 pRxTS->RxLastSeqNum = WLAN_GET_SEQ_SEQ(sc); 957 } else { 958 netdev_warn(ieee->dev, "%s(): No TS! Skip the check!\n", 959 __func__); 960 return -1; 961 } 962 } 963 964 return 0; 965 } 966 967 static void rtllib_rx_extract_addr(struct rtllib_device *ieee, 968 struct rtllib_hdr_4addr *hdr, u8 *dst, 969 u8 *src, u8 *bssid) 970 { 971 u16 fc = le16_to_cpu(hdr->frame_ctl); 972 973 switch (fc & (RTLLIB_FCTL_FROMDS | RTLLIB_FCTL_TODS)) { 974 case RTLLIB_FCTL_FROMDS: 975 ether_addr_copy(dst, hdr->addr1); 976 ether_addr_copy(src, hdr->addr3); 977 ether_addr_copy(bssid, hdr->addr2); 978 break; 979 case RTLLIB_FCTL_TODS: 980 ether_addr_copy(dst, hdr->addr3); 981 ether_addr_copy(src, hdr->addr2); 982 ether_addr_copy(bssid, hdr->addr1); 983 break; 984 case RTLLIB_FCTL_FROMDS | RTLLIB_FCTL_TODS: 985 ether_addr_copy(dst, hdr->addr3); 986 ether_addr_copy(src, hdr->addr4); 987 ether_addr_copy(bssid, ieee->current_network.bssid); 988 break; 989 default: 990 ether_addr_copy(dst, hdr->addr1); 991 ether_addr_copy(src, hdr->addr2); 992 ether_addr_copy(bssid, hdr->addr3); 993 break; 994 } 995 } 996 997 static int rtllib_rx_data_filter(struct rtllib_device *ieee, u16 fc, 998 u8 *dst, u8 *src, u8 *bssid, u8 *addr2) 999 { 1000 u8 type, stype; 1001 1002 type = WLAN_FC_GET_TYPE(fc); 1003 stype = WLAN_FC_GET_STYPE(fc); 1004 1005 /* Filter frames from different BSS */ 1006 if (((fc & RTLLIB_FCTL_DSTODS) != RTLLIB_FCTL_DSTODS) && 1007 !ether_addr_equal(ieee->current_network.bssid, bssid) && 1008 !is_zero_ether_addr(ieee->current_network.bssid)) { 1009 return -1; 1010 } 1011 1012 /* Filter packets sent by an STA that will be forwarded by AP */ 1013 if (ieee->IntelPromiscuousModeInfo.bPromiscuousOn && 1014 ieee->IntelPromiscuousModeInfo.bFilterSourceStationFrame) { 1015 if ((fc & RTLLIB_FCTL_TODS) && !(fc & RTLLIB_FCTL_FROMDS) && 1016 !ether_addr_equal(dst, ieee->current_network.bssid) && 1017 ether_addr_equal(bssid, ieee->current_network.bssid)) { 1018 return -1; 1019 } 1020 } 1021 1022 /* Nullfunc frames may have PS-bit set, so they must be passed to 1023 * hostap_handle_sta_rx() before being dropped here. 1024 */ 1025 if (!ieee->IntelPromiscuousModeInfo.bPromiscuousOn) { 1026 if (stype != RTLLIB_STYPE_DATA && 1027 stype != RTLLIB_STYPE_DATA_CFACK && 1028 stype != RTLLIB_STYPE_DATA_CFPOLL && 1029 stype != RTLLIB_STYPE_DATA_CFACKPOLL && 1030 stype != RTLLIB_STYPE_QOS_DATA) { 1031 if (stype != RTLLIB_STYPE_NULLFUNC) 1032 netdev_dbg(ieee->dev, 1033 "RX: dropped data frame with no data (type=0x%02x, subtype=0x%02x)\n", 1034 type, stype); 1035 return -1; 1036 } 1037 } 1038 1039 if (ieee->iw_mode != IW_MODE_MESH) { 1040 /* packets from our adapter are dropped (echo) */ 1041 if (!memcmp(src, ieee->dev->dev_addr, ETH_ALEN)) 1042 return -1; 1043 1044 /* {broad,multi}cast packets to our BSS go through */ 1045 if (is_multicast_ether_addr(dst)) { 1046 if (memcmp(bssid, ieee->current_network.bssid, 1047 ETH_ALEN)) 1048 return -1; 1049 } 1050 } 1051 return 0; 1052 } 1053 1054 static int rtllib_rx_get_crypt(struct rtllib_device *ieee, struct sk_buff *skb, 1055 struct lib80211_crypt_data **crypt, size_t hdrlen) 1056 { 1057 struct rtllib_hdr_4addr *hdr = (struct rtllib_hdr_4addr *)skb->data; 1058 u16 fc = le16_to_cpu(hdr->frame_ctl); 1059 int idx = 0; 1060 1061 if (ieee->host_decrypt) { 1062 if (skb->len >= hdrlen + 3) 1063 idx = skb->data[hdrlen + 3] >> 6; 1064 1065 *crypt = ieee->crypt_info.crypt[idx]; 1066 /* allow NULL decrypt to indicate an station specific override 1067 * for default encryption 1068 */ 1069 if (*crypt && ((*crypt)->ops == NULL || 1070 (*crypt)->ops->decrypt_mpdu == NULL)) 1071 *crypt = NULL; 1072 1073 if (!*crypt && (fc & RTLLIB_FCTL_WEP)) { 1074 /* This seems to be triggered by some (multicast?) 1075 * frames from other than current BSS, so just drop the 1076 * frames silently instead of filling system log with 1077 * these reports. 1078 */ 1079 netdev_dbg(ieee->dev, 1080 "Decryption failed (not set) (SA= %pM)\n", 1081 hdr->addr2); 1082 return -1; 1083 } 1084 } 1085 1086 return 0; 1087 } 1088 1089 static int rtllib_rx_decrypt(struct rtllib_device *ieee, struct sk_buff *skb, 1090 struct rtllib_rx_stats *rx_stats, 1091 struct lib80211_crypt_data *crypt, size_t hdrlen) 1092 { 1093 struct rtllib_hdr_4addr *hdr; 1094 int keyidx = 0; 1095 u16 fc, sc; 1096 u8 frag; 1097 1098 hdr = (struct rtllib_hdr_4addr *)skb->data; 1099 fc = le16_to_cpu(hdr->frame_ctl); 1100 sc = le16_to_cpu(hdr->seq_ctl); 1101 frag = WLAN_GET_SEQ_FRAG(sc); 1102 1103 if ((!rx_stats->Decrypted)) 1104 ieee->need_sw_enc = 1; 1105 else 1106 ieee->need_sw_enc = 0; 1107 1108 keyidx = rtllib_rx_frame_decrypt(ieee, skb, crypt); 1109 if (ieee->host_decrypt && (fc & RTLLIB_FCTL_WEP) && (keyidx < 0)) { 1110 netdev_info(ieee->dev, "%s: decrypt frame error\n", __func__); 1111 return -1; 1112 } 1113 1114 hdr = (struct rtllib_hdr_4addr *) skb->data; 1115 if ((frag != 0 || (fc & RTLLIB_FCTL_MOREFRAGS))) { 1116 int flen; 1117 struct sk_buff *frag_skb = rtllib_frag_cache_get(ieee, hdr); 1118 1119 netdev_dbg(ieee->dev, "Rx Fragment received (%u)\n", frag); 1120 1121 if (!frag_skb) { 1122 netdev_dbg(ieee->dev, 1123 "Rx cannot get skb from fragment cache (morefrag=%d seq=%u frag=%u)\n", 1124 (fc & RTLLIB_FCTL_MOREFRAGS) != 0, 1125 WLAN_GET_SEQ_SEQ(sc), frag); 1126 return -1; 1127 } 1128 flen = skb->len; 1129 if (frag != 0) 1130 flen -= hdrlen; 1131 1132 if (frag_skb->tail + flen > frag_skb->end) { 1133 netdev_warn(ieee->dev, 1134 "%s: host decrypted and reassembled frame did not fit skb\n", 1135 __func__); 1136 rtllib_frag_cache_invalidate(ieee, hdr); 1137 return -1; 1138 } 1139 1140 if (frag == 0) { 1141 /* copy first fragment (including full headers) into 1142 * beginning of the fragment cache skb 1143 */ 1144 memcpy(skb_put(frag_skb, flen), skb->data, flen); 1145 } else { 1146 /* append frame payload to the end of the fragment 1147 * cache skb 1148 */ 1149 memcpy(skb_put(frag_skb, flen), skb->data + hdrlen, 1150 flen); 1151 } 1152 dev_kfree_skb_any(skb); 1153 skb = NULL; 1154 1155 if (fc & RTLLIB_FCTL_MOREFRAGS) { 1156 /* more fragments expected - leave the skb in fragment 1157 * cache for now; it will be delivered to upper layers 1158 * after all fragments have been received 1159 */ 1160 return -2; 1161 } 1162 1163 /* this was the last fragment and the frame will be 1164 * delivered, so remove skb from fragment cache 1165 */ 1166 skb = frag_skb; 1167 hdr = (struct rtllib_hdr_4addr *) skb->data; 1168 rtllib_frag_cache_invalidate(ieee, hdr); 1169 } 1170 1171 /* skb: hdr + (possible reassembled) full MSDU payload; possibly still 1172 * encrypted/authenticated 1173 */ 1174 if (ieee->host_decrypt && (fc & RTLLIB_FCTL_WEP) && 1175 rtllib_rx_frame_decrypt_msdu(ieee, skb, keyidx, crypt)) { 1176 netdev_info(ieee->dev, "%s: ==>decrypt msdu error\n", __func__); 1177 return -1; 1178 } 1179 1180 hdr = (struct rtllib_hdr_4addr *) skb->data; 1181 if (crypt && !(fc & RTLLIB_FCTL_WEP) && !ieee->open_wep) { 1182 if (/*ieee->ieee802_1x &&*/ 1183 rtllib_is_eapol_frame(ieee, skb, hdrlen)) { 1184 1185 /* pass unencrypted EAPOL frames even if encryption is 1186 * configured 1187 */ 1188 struct eapol *eap = (struct eapol *)(skb->data + 1189 24); 1190 netdev_dbg(ieee->dev, 1191 "RX: IEEE 802.1X EAPOL frame: %s\n", 1192 eap_get_type(eap->type)); 1193 } else { 1194 netdev_dbg(ieee->dev, 1195 "encryption configured, but RX frame not encrypted (SA= %pM)\n", 1196 hdr->addr2); 1197 return -1; 1198 } 1199 } 1200 1201 if (crypt && !(fc & RTLLIB_FCTL_WEP) && 1202 rtllib_is_eapol_frame(ieee, skb, hdrlen)) { 1203 struct eapol *eap = (struct eapol *)(skb->data + 24); 1204 1205 netdev_dbg(ieee->dev, "RX: IEEE 802.1X EAPOL frame: %s\n", 1206 eap_get_type(eap->type)); 1207 } 1208 1209 if (crypt && !(fc & RTLLIB_FCTL_WEP) && !ieee->open_wep && 1210 !rtllib_is_eapol_frame(ieee, skb, hdrlen)) { 1211 netdev_dbg(ieee->dev, 1212 "dropped unencrypted RX data frame from %pM (drop_unencrypted=1)\n", 1213 hdr->addr2); 1214 return -1; 1215 } 1216 1217 if (rtllib_is_eapol_frame(ieee, skb, hdrlen)) 1218 netdev_warn(ieee->dev, "RX: IEEE802.1X EAPOL frame!\n"); 1219 1220 return 0; 1221 } 1222 1223 static void rtllib_rx_check_leave_lps(struct rtllib_device *ieee, u8 unicast, 1224 u8 nr_subframes) 1225 { 1226 if (unicast) { 1227 1228 if (ieee->state == RTLLIB_LINKED) { 1229 if (((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod + 1230 ieee->LinkDetectInfo.NumTxOkInPeriod) > 8) || 1231 (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2)) { 1232 if (ieee->LeisurePSLeave) 1233 ieee->LeisurePSLeave(ieee->dev); 1234 } 1235 } 1236 } 1237 ieee->last_rx_ps_time = jiffies; 1238 } 1239 1240 static void rtllib_rx_indicate_pkt_legacy(struct rtllib_device *ieee, 1241 struct rtllib_rx_stats *rx_stats, 1242 struct rtllib_rxb *rxb, 1243 u8 *dst, 1244 u8 *src) 1245 { 1246 struct net_device *dev = ieee->dev; 1247 u16 ethertype; 1248 int i = 0; 1249 1250 if (rxb == NULL) { 1251 netdev_info(dev, "%s: rxb is NULL!!\n", __func__); 1252 return; 1253 } 1254 1255 for (i = 0; i < rxb->nr_subframes; i++) { 1256 struct sk_buff *sub_skb = rxb->subframes[i]; 1257 1258 if (sub_skb) { 1259 /* convert hdr + possible LLC headers 1260 * into Ethernet header 1261 */ 1262 ethertype = (sub_skb->data[6] << 8) | sub_skb->data[7]; 1263 if (sub_skb->len >= 8 && 1264 ((memcmp(sub_skb->data, rfc1042_header, SNAP_SIZE) == 0 && 1265 ethertype != ETH_P_AARP && ethertype != ETH_P_IPX) || 1266 memcmp(sub_skb->data, bridge_tunnel_header, SNAP_SIZE) == 0)) { 1267 /* remove RFC1042 or Bridge-Tunnel encapsulation 1268 * and replace EtherType 1269 */ 1270 skb_pull(sub_skb, SNAP_SIZE); 1271 ether_addr_copy(skb_push(sub_skb, ETH_ALEN), 1272 src); 1273 ether_addr_copy(skb_push(sub_skb, ETH_ALEN), 1274 dst); 1275 } else { 1276 u16 len; 1277 /* Leave Ethernet header part of hdr 1278 * and full payload 1279 */ 1280 len = sub_skb->len; 1281 memcpy(skb_push(sub_skb, 2), &len, 2); 1282 ether_addr_copy(skb_push(sub_skb, ETH_ALEN), 1283 src); 1284 ether_addr_copy(skb_push(sub_skb, ETH_ALEN), 1285 dst); 1286 } 1287 1288 ieee->stats.rx_packets++; 1289 ieee->stats.rx_bytes += sub_skb->len; 1290 1291 if (is_multicast_ether_addr(dst)) 1292 ieee->stats.multicast++; 1293 1294 /* Indicate the packets to upper layer */ 1295 memset(sub_skb->cb, 0, sizeof(sub_skb->cb)); 1296 sub_skb->protocol = eth_type_trans(sub_skb, dev); 1297 sub_skb->dev = dev; 1298 sub_skb->dev->stats.rx_packets++; 1299 sub_skb->dev->stats.rx_bytes += sub_skb->len; 1300 /* 802.11 crc not sufficient */ 1301 sub_skb->ip_summed = CHECKSUM_NONE; 1302 netif_rx(sub_skb); 1303 } 1304 } 1305 kfree(rxb); 1306 } 1307 1308 static int rtllib_rx_InfraAdhoc(struct rtllib_device *ieee, struct sk_buff *skb, 1309 struct rtllib_rx_stats *rx_stats) 1310 { 1311 struct net_device *dev = ieee->dev; 1312 struct rtllib_hdr_4addr *hdr = (struct rtllib_hdr_4addr *)skb->data; 1313 struct lib80211_crypt_data *crypt = NULL; 1314 struct rtllib_rxb *rxb = NULL; 1315 struct rx_ts_record *pTS = NULL; 1316 u16 fc, sc, SeqNum = 0; 1317 u8 type, stype, multicast = 0, unicast = 0, nr_subframes = 0, TID = 0; 1318 u8 *payload; 1319 u8 dst[ETH_ALEN]; 1320 u8 src[ETH_ALEN]; 1321 u8 bssid[ETH_ALEN] = {0}; 1322 1323 size_t hdrlen = 0; 1324 bool bToOtherSTA = false; 1325 int ret = 0, i = 0; 1326 1327 hdr = (struct rtllib_hdr_4addr *)skb->data; 1328 fc = le16_to_cpu(hdr->frame_ctl); 1329 type = WLAN_FC_GET_TYPE(fc); 1330 stype = WLAN_FC_GET_STYPE(fc); 1331 sc = le16_to_cpu(hdr->seq_ctl); 1332 1333 /*Filter pkt not to me*/ 1334 multicast = is_multicast_ether_addr(hdr->addr1); 1335 unicast = !multicast; 1336 if (unicast && !ether_addr_equal(dev->dev_addr, hdr->addr1)) { 1337 if (ieee->bNetPromiscuousMode) 1338 bToOtherSTA = true; 1339 else 1340 goto rx_dropped; 1341 } 1342 1343 /*Filter pkt has too small length */ 1344 hdrlen = rtllib_rx_get_hdrlen(ieee, skb, rx_stats); 1345 if (skb->len < hdrlen) { 1346 netdev_info(dev, 1347 "%s():ERR!!! skb->len is smaller than hdrlen\n", 1348 __func__); 1349 goto rx_dropped; 1350 } 1351 1352 /* Filter Duplicate pkt */ 1353 ret = rtllib_rx_check_duplicate(ieee, skb, multicast); 1354 if (ret < 0) 1355 goto rx_dropped; 1356 1357 /* Filter CTRL Frame */ 1358 if (type == RTLLIB_FTYPE_CTL) 1359 goto rx_dropped; 1360 1361 /* Filter MGNT Frame */ 1362 if (type == RTLLIB_FTYPE_MGMT) { 1363 if (bToOtherSTA) 1364 goto rx_dropped; 1365 if (rtllib_rx_frame_mgmt(ieee, skb, rx_stats, type, stype)) 1366 goto rx_dropped; 1367 else 1368 goto rx_exit; 1369 } 1370 1371 /* Filter WAPI DATA Frame */ 1372 1373 /* Update statstics for AP roaming */ 1374 if (!bToOtherSTA) { 1375 ieee->LinkDetectInfo.NumRecvDataInPeriod++; 1376 ieee->LinkDetectInfo.NumRxOkInPeriod++; 1377 } 1378 1379 /* Data frame - extract src/dst addresses */ 1380 rtllib_rx_extract_addr(ieee, hdr, dst, src, bssid); 1381 1382 /* Filter Data frames */ 1383 ret = rtllib_rx_data_filter(ieee, fc, dst, src, bssid, hdr->addr2); 1384 if (ret < 0) 1385 goto rx_dropped; 1386 1387 if (skb->len == hdrlen) 1388 goto rx_dropped; 1389 1390 /* Send pspoll based on moredata */ 1391 if ((ieee->iw_mode == IW_MODE_INFRA) && 1392 (ieee->sta_sleep == LPS_IS_SLEEP) && 1393 (ieee->polling) && (!bToOtherSTA)) { 1394 if (WLAN_FC_MORE_DATA(fc)) { 1395 /* more data bit is set, let's request a new frame 1396 * from the AP 1397 */ 1398 rtllib_sta_ps_send_pspoll_frame(ieee); 1399 } else { 1400 ieee->polling = false; 1401 } 1402 } 1403 1404 /* Get crypt if encrypted */ 1405 ret = rtllib_rx_get_crypt(ieee, skb, &crypt, hdrlen); 1406 if (ret == -1) 1407 goto rx_dropped; 1408 1409 /* Decrypt data frame (including reassemble) */ 1410 ret = rtllib_rx_decrypt(ieee, skb, rx_stats, crypt, hdrlen); 1411 if (ret == -1) 1412 goto rx_dropped; 1413 else if (ret == -2) 1414 goto rx_exit; 1415 1416 /* Get TS for Rx Reorder */ 1417 hdr = (struct rtllib_hdr_4addr *) skb->data; 1418 if (ieee->current_network.qos_data.active && IsQoSDataFrame(skb->data) 1419 && !is_multicast_ether_addr(hdr->addr1) 1420 && (!bToOtherSTA)) { 1421 TID = Frame_QoSTID(skb->data); 1422 SeqNum = WLAN_GET_SEQ_SEQ(sc); 1423 GetTs(ieee, (struct ts_common_info **) &pTS, hdr->addr2, TID, 1424 RX_DIR, true); 1425 if (TID != 0 && TID != 3) 1426 ieee->bis_any_nonbepkts = true; 1427 } 1428 1429 /* Parse rx data frame (For AMSDU) */ 1430 /* skb: hdr + (possible reassembled) full plaintext payload */ 1431 payload = skb->data + hdrlen; 1432 rxb = kmalloc(sizeof(struct rtllib_rxb), GFP_ATOMIC); 1433 if (!rxb) 1434 goto rx_dropped; 1435 1436 /* to parse amsdu packets */ 1437 /* qos data packets & reserved bit is 1 */ 1438 if (parse_subframe(ieee, skb, rx_stats, rxb, src, dst) == 0) { 1439 /* only to free rxb, and not submit the packets 1440 * to upper layer 1441 */ 1442 for (i = 0; i < rxb->nr_subframes; i++) 1443 dev_kfree_skb(rxb->subframes[i]); 1444 kfree(rxb); 1445 rxb = NULL; 1446 goto rx_dropped; 1447 } 1448 1449 /* Update WAPI PN */ 1450 1451 /* Check if leave LPS */ 1452 if (!bToOtherSTA) { 1453 if (ieee->bIsAggregateFrame) 1454 nr_subframes = rxb->nr_subframes; 1455 else 1456 nr_subframes = 1; 1457 if (unicast) 1458 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod += nr_subframes; 1459 rtllib_rx_check_leave_lps(ieee, unicast, nr_subframes); 1460 } 1461 1462 /* Indicate packets to upper layer or Rx Reorder */ 1463 if (ieee->pHTInfo->bCurRxReorderEnable == false || pTS == NULL || 1464 bToOtherSTA) 1465 rtllib_rx_indicate_pkt_legacy(ieee, rx_stats, rxb, dst, src); 1466 else 1467 RxReorderIndicatePacket(ieee, rxb, pTS, SeqNum); 1468 1469 dev_kfree_skb(skb); 1470 1471 rx_exit: 1472 return 1; 1473 1474 rx_dropped: 1475 ieee->stats.rx_dropped++; 1476 1477 /* Returning 0 indicates to caller that we have not handled the SKB-- 1478 * so it is still allocated and can be used again by underlying 1479 * hardware as a DMA target 1480 */ 1481 return 0; 1482 } 1483 1484 static int rtllib_rx_Master(struct rtllib_device *ieee, struct sk_buff *skb, 1485 struct rtllib_rx_stats *rx_stats) 1486 { 1487 return 0; 1488 } 1489 1490 static int rtllib_rx_Monitor(struct rtllib_device *ieee, struct sk_buff *skb, 1491 struct rtllib_rx_stats *rx_stats) 1492 { 1493 struct rtllib_hdr_4addr *hdr = (struct rtllib_hdr_4addr *)skb->data; 1494 u16 fc = le16_to_cpu(hdr->frame_ctl); 1495 size_t hdrlen = rtllib_get_hdrlen(fc); 1496 1497 if (skb->len < hdrlen) { 1498 netdev_info(ieee->dev, 1499 "%s():ERR!!! skb->len is smaller than hdrlen\n", 1500 __func__); 1501 return 0; 1502 } 1503 1504 if (HTCCheck(ieee, skb->data)) { 1505 if (net_ratelimit()) 1506 netdev_info(ieee->dev, "%s: Find HTCControl!\n", 1507 __func__); 1508 hdrlen += 4; 1509 } 1510 1511 rtllib_monitor_rx(ieee, skb, rx_stats, hdrlen); 1512 ieee->stats.rx_packets++; 1513 ieee->stats.rx_bytes += skb->len; 1514 1515 return 1; 1516 } 1517 1518 static int rtllib_rx_Mesh(struct rtllib_device *ieee, struct sk_buff *skb, 1519 struct rtllib_rx_stats *rx_stats) 1520 { 1521 return 0; 1522 } 1523 1524 /* All received frames are sent to this function. @skb contains the frame in 1525 * IEEE 802.11 format, i.e., in the format it was sent over air. 1526 * This function is called only as a tasklet (software IRQ). 1527 */ 1528 int rtllib_rx(struct rtllib_device *ieee, struct sk_buff *skb, 1529 struct rtllib_rx_stats *rx_stats) 1530 { 1531 int ret = 0; 1532 1533 if (!ieee || !skb || !rx_stats) { 1534 pr_info("%s: Input parameters NULL!\n", __func__); 1535 goto rx_dropped; 1536 } 1537 if (skb->len < 10) { 1538 netdev_info(ieee->dev, "%s: SKB length < 10\n", __func__); 1539 goto rx_dropped; 1540 } 1541 1542 switch (ieee->iw_mode) { 1543 case IW_MODE_ADHOC: 1544 case IW_MODE_INFRA: 1545 ret = rtllib_rx_InfraAdhoc(ieee, skb, rx_stats); 1546 break; 1547 case IW_MODE_MASTER: 1548 case IW_MODE_REPEAT: 1549 ret = rtllib_rx_Master(ieee, skb, rx_stats); 1550 break; 1551 case IW_MODE_MONITOR: 1552 ret = rtllib_rx_Monitor(ieee, skb, rx_stats); 1553 break; 1554 case IW_MODE_MESH: 1555 ret = rtllib_rx_Mesh(ieee, skb, rx_stats); 1556 break; 1557 default: 1558 netdev_info(ieee->dev, "%s: ERR iw mode!!!\n", __func__); 1559 break; 1560 } 1561 1562 return ret; 1563 1564 rx_dropped: 1565 if (ieee) 1566 ieee->stats.rx_dropped++; 1567 return 0; 1568 } 1569 EXPORT_SYMBOL(rtllib_rx); 1570 1571 static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 }; 1572 1573 /* Make ther structure we read from the beacon packet has the right values */ 1574 static int rtllib_verify_qos_info(struct rtllib_qos_information_element 1575 *info_element, int sub_type) 1576 { 1577 1578 if (info_element->qui_subtype != sub_type) 1579 return -1; 1580 if (memcmp(info_element->qui, qos_oui, QOS_OUI_LEN)) 1581 return -1; 1582 if (info_element->qui_type != QOS_OUI_TYPE) 1583 return -1; 1584 if (info_element->version != QOS_VERSION_1) 1585 return -1; 1586 1587 return 0; 1588 } 1589 1590 1591 /* Parse a QoS parameter element */ 1592 static int rtllib_read_qos_param_element(struct rtllib_qos_parameter_info 1593 *element_param, 1594 struct rtllib_info_element 1595 *info_element) 1596 { 1597 int ret = 0; 1598 u16 size = sizeof(struct rtllib_qos_parameter_info) - 2; 1599 1600 if ((info_element == NULL) || (element_param == NULL)) 1601 return -1; 1602 1603 if (info_element->id == QOS_ELEMENT_ID && info_element->len == size) { 1604 memcpy(element_param->info_element.qui, info_element->data, 1605 info_element->len); 1606 element_param->info_element.elementID = info_element->id; 1607 element_param->info_element.length = info_element->len; 1608 } else 1609 ret = -1; 1610 if (ret == 0) 1611 ret = rtllib_verify_qos_info(&element_param->info_element, 1612 QOS_OUI_PARAM_SUB_TYPE); 1613 return ret; 1614 } 1615 1616 /* Parse a QoS information element */ 1617 static int rtllib_read_qos_info_element(struct rtllib_qos_information_element 1618 *element_info, 1619 struct rtllib_info_element 1620 *info_element) 1621 { 1622 int ret = 0; 1623 u16 size = sizeof(struct rtllib_qos_information_element) - 2; 1624 1625 if (element_info == NULL) 1626 return -1; 1627 if (info_element == NULL) 1628 return -1; 1629 1630 if ((info_element->id == QOS_ELEMENT_ID) && 1631 (info_element->len == size)) { 1632 memcpy(element_info->qui, info_element->data, 1633 info_element->len); 1634 element_info->elementID = info_element->id; 1635 element_info->length = info_element->len; 1636 } else 1637 ret = -1; 1638 1639 if (ret == 0) 1640 ret = rtllib_verify_qos_info(element_info, 1641 QOS_OUI_INFO_SUB_TYPE); 1642 return ret; 1643 } 1644 1645 1646 /* Write QoS parameters from the ac parameters. */ 1647 static int rtllib_qos_convert_ac_to_parameters(struct rtllib_qos_parameter_info *param_elm, 1648 struct rtllib_qos_data *qos_data) 1649 { 1650 struct rtllib_qos_ac_parameter *ac_params; 1651 struct rtllib_qos_parameters *qos_param = &(qos_data->parameters); 1652 int i; 1653 u8 aci; 1654 u8 acm; 1655 1656 qos_data->wmm_acm = 0; 1657 for (i = 0; i < QOS_QUEUE_NUM; i++) { 1658 ac_params = &(param_elm->ac_params_record[i]); 1659 1660 aci = (ac_params->aci_aifsn & 0x60) >> 5; 1661 acm = (ac_params->aci_aifsn & 0x10) >> 4; 1662 1663 if (aci >= QOS_QUEUE_NUM) 1664 continue; 1665 switch (aci) { 1666 case 1: 1667 /* BIT(0) | BIT(3) */ 1668 if (acm) 1669 qos_data->wmm_acm |= (0x01<<0)|(0x01<<3); 1670 break; 1671 case 2: 1672 /* BIT(4) | BIT(5) */ 1673 if (acm) 1674 qos_data->wmm_acm |= (0x01<<4)|(0x01<<5); 1675 break; 1676 case 3: 1677 /* BIT(6) | BIT(7) */ 1678 if (acm) 1679 qos_data->wmm_acm |= (0x01<<6)|(0x01<<7); 1680 break; 1681 case 0: 1682 default: 1683 /* BIT(1) | BIT(2) */ 1684 if (acm) 1685 qos_data->wmm_acm |= (0x01<<1)|(0x01<<2); 1686 break; 1687 } 1688 1689 qos_param->aifs[aci] = (ac_params->aci_aifsn) & 0x0f; 1690 1691 /* WMM spec P.11: The minimum value for AIFSN shall be 2 */ 1692 qos_param->aifs[aci] = max_t(u8, qos_param->aifs[aci], 2); 1693 1694 qos_param->cw_min[aci] = cpu_to_le16(ac_params->ecw_min_max & 1695 0x0F); 1696 1697 qos_param->cw_max[aci] = cpu_to_le16((ac_params->ecw_min_max & 1698 0xF0) >> 4); 1699 1700 qos_param->flag[aci] = 1701 (ac_params->aci_aifsn & 0x10) ? 0x01 : 0x00; 1702 qos_param->tx_op_limit[aci] = ac_params->tx_op_limit; 1703 } 1704 return 0; 1705 } 1706 1707 /* we have a generic data element which it may contain QoS information or 1708 * parameters element. check the information element length to decide 1709 * which type to read 1710 */ 1711 static int rtllib_parse_qos_info_param_IE(struct rtllib_device *ieee, 1712 struct rtllib_info_element 1713 *info_element, 1714 struct rtllib_network *network) 1715 { 1716 int rc = 0; 1717 struct rtllib_qos_information_element qos_info_element; 1718 1719 rc = rtllib_read_qos_info_element(&qos_info_element, info_element); 1720 1721 if (rc == 0) { 1722 network->qos_data.param_count = qos_info_element.ac_info & 0x0F; 1723 network->flags |= NETWORK_HAS_QOS_INFORMATION; 1724 } else { 1725 struct rtllib_qos_parameter_info param_element; 1726 1727 rc = rtllib_read_qos_param_element(¶m_element, 1728 info_element); 1729 if (rc == 0) { 1730 rtllib_qos_convert_ac_to_parameters(¶m_element, 1731 &(network->qos_data)); 1732 network->flags |= NETWORK_HAS_QOS_PARAMETERS; 1733 network->qos_data.param_count = 1734 param_element.info_element.ac_info & 0x0F; 1735 } 1736 } 1737 1738 if (rc == 0) { 1739 netdev_dbg(ieee->dev, "QoS is supported\n"); 1740 network->qos_data.supported = 1; 1741 } 1742 return rc; 1743 } 1744 1745 static const char *get_info_element_string(u16 id) 1746 { 1747 switch (id) { 1748 case MFIE_TYPE_SSID: 1749 return "SSID"; 1750 case MFIE_TYPE_RATES: 1751 return "RATES"; 1752 case MFIE_TYPE_FH_SET: 1753 return "FH_SET"; 1754 case MFIE_TYPE_DS_SET: 1755 return "DS_SET"; 1756 case MFIE_TYPE_CF_SET: 1757 return "CF_SET"; 1758 case MFIE_TYPE_TIM: 1759 return "TIM"; 1760 case MFIE_TYPE_IBSS_SET: 1761 return "IBSS_SET"; 1762 case MFIE_TYPE_COUNTRY: 1763 return "COUNTRY"; 1764 case MFIE_TYPE_HOP_PARAMS: 1765 return "HOP_PARAMS"; 1766 case MFIE_TYPE_HOP_TABLE: 1767 return "HOP_TABLE"; 1768 case MFIE_TYPE_REQUEST: 1769 return "REQUEST"; 1770 case MFIE_TYPE_CHALLENGE: 1771 return "CHALLENGE"; 1772 case MFIE_TYPE_POWER_CONSTRAINT: 1773 return "POWER_CONSTRAINT"; 1774 case MFIE_TYPE_POWER_CAPABILITY: 1775 return "POWER_CAPABILITY"; 1776 case MFIE_TYPE_TPC_REQUEST: 1777 return "TPC_REQUEST"; 1778 case MFIE_TYPE_TPC_REPORT: 1779 return "TPC_REPORT"; 1780 case MFIE_TYPE_SUPP_CHANNELS: 1781 return "SUPP_CHANNELS"; 1782 case MFIE_TYPE_CSA: 1783 return "CSA"; 1784 case MFIE_TYPE_MEASURE_REQUEST: 1785 return "MEASURE_REQUEST"; 1786 case MFIE_TYPE_MEASURE_REPORT: 1787 return "MEASURE_REPORT"; 1788 case MFIE_TYPE_QUIET: 1789 return "QUIET"; 1790 case MFIE_TYPE_IBSS_DFS: 1791 return "IBSS_DFS"; 1792 case MFIE_TYPE_RSN: 1793 return "RSN"; 1794 case MFIE_TYPE_RATES_EX: 1795 return "RATES_EX"; 1796 case MFIE_TYPE_GENERIC: 1797 return "GENERIC"; 1798 case MFIE_TYPE_QOS_PARAMETER: 1799 return "QOS_PARAMETER"; 1800 default: 1801 return "UNKNOWN"; 1802 } 1803 } 1804 1805 static inline void rtllib_extract_country_ie( 1806 struct rtllib_device *ieee, 1807 struct rtllib_info_element *info_element, 1808 struct rtllib_network *network, 1809 u8 *addr2) 1810 { 1811 if (IS_DOT11D_ENABLE(ieee)) { 1812 if (info_element->len != 0) { 1813 memcpy(network->CountryIeBuf, info_element->data, 1814 info_element->len); 1815 network->CountryIeLen = info_element->len; 1816 1817 if (!IS_COUNTRY_IE_VALID(ieee)) { 1818 if (rtllib_act_scanning(ieee, false) && 1819 ieee->FirstIe_InScan) 1820 netdev_info(ieee->dev, 1821 "Received beacon ContryIE, SSID: <%s>\n", 1822 network->ssid); 1823 Dot11d_UpdateCountryIe(ieee, addr2, 1824 info_element->len, 1825 info_element->data); 1826 } 1827 } 1828 1829 if (IS_EQUAL_CIE_SRC(ieee, addr2)) 1830 UPDATE_CIE_WATCHDOG(ieee); 1831 } 1832 } 1833 1834 static void rtllib_parse_mife_generic(struct rtllib_device *ieee, 1835 struct rtllib_info_element *info_element, 1836 struct rtllib_network *network, 1837 u16 *tmp_htcap_len, 1838 u16 *tmp_htinfo_len) 1839 { 1840 u16 ht_realtek_agg_len = 0; 1841 u8 ht_realtek_agg_buf[MAX_IE_LEN]; 1842 1843 if (!rtllib_parse_qos_info_param_IE(ieee, info_element, network)) 1844 return; 1845 if (info_element->len >= 4 && 1846 info_element->data[0] == 0x00 && 1847 info_element->data[1] == 0x50 && 1848 info_element->data[2] == 0xf2 && 1849 info_element->data[3] == 0x01) { 1850 network->wpa_ie_len = min(info_element->len + 2, 1851 MAX_WPA_IE_LEN); 1852 memcpy(network->wpa_ie, info_element, network->wpa_ie_len); 1853 return; 1854 } 1855 if (info_element->len == 7 && 1856 info_element->data[0] == 0x00 && 1857 info_element->data[1] == 0xe0 && 1858 info_element->data[2] == 0x4c && 1859 info_element->data[3] == 0x01 && 1860 info_element->data[4] == 0x02) 1861 network->Turbo_Enable = 1; 1862 1863 if (*tmp_htcap_len == 0) { 1864 if (info_element->len >= 4 && 1865 info_element->data[0] == 0x00 && 1866 info_element->data[1] == 0x90 && 1867 info_element->data[2] == 0x4c && 1868 info_element->data[3] == 0x033) { 1869 *tmp_htcap_len = min_t(u8, info_element->len, 1870 MAX_IE_LEN); 1871 if (*tmp_htcap_len != 0) { 1872 network->bssht.bdHTSpecVer = HT_SPEC_VER_EWC; 1873 network->bssht.bdHTCapLen = min_t(u16, *tmp_htcap_len, sizeof(network->bssht.bdHTCapBuf)); 1874 memcpy(network->bssht.bdHTCapBuf, 1875 info_element->data, 1876 network->bssht.bdHTCapLen); 1877 } 1878 } 1879 if (*tmp_htcap_len != 0) { 1880 network->bssht.bdSupportHT = true; 1881 network->bssht.bdHT1R = ((((struct ht_capab_ele *)(network->bssht.bdHTCapBuf))->MCS[1]) == 0); 1882 } else { 1883 network->bssht.bdSupportHT = false; 1884 network->bssht.bdHT1R = false; 1885 } 1886 } 1887 1888 1889 if (*tmp_htinfo_len == 0) { 1890 if (info_element->len >= 4 && 1891 info_element->data[0] == 0x00 && 1892 info_element->data[1] == 0x90 && 1893 info_element->data[2] == 0x4c && 1894 info_element->data[3] == 0x034) { 1895 *tmp_htinfo_len = min_t(u8, info_element->len, 1896 MAX_IE_LEN); 1897 if (*tmp_htinfo_len != 0) { 1898 network->bssht.bdHTSpecVer = HT_SPEC_VER_EWC; 1899 network->bssht.bdHTInfoLen = min_t(u16, *tmp_htinfo_len, sizeof(network->bssht.bdHTInfoBuf)); 1900 memcpy(network->bssht.bdHTInfoBuf, 1901 info_element->data, 1902 network->bssht.bdHTInfoLen); 1903 } 1904 } 1905 } 1906 1907 if (network->bssht.bdSupportHT) { 1908 if (info_element->len >= 4 && 1909 info_element->data[0] == 0x00 && 1910 info_element->data[1] == 0xe0 && 1911 info_element->data[2] == 0x4c && 1912 info_element->data[3] == 0x02) { 1913 ht_realtek_agg_len = min_t(u8, info_element->len, 1914 MAX_IE_LEN); 1915 memcpy(ht_realtek_agg_buf, info_element->data, 1916 info_element->len); 1917 } 1918 if (ht_realtek_agg_len >= 5) { 1919 network->realtek_cap_exit = true; 1920 network->bssht.bdRT2RTAggregation = true; 1921 1922 if ((ht_realtek_agg_buf[4] == 1) && 1923 (ht_realtek_agg_buf[5] & 0x02)) 1924 network->bssht.bdRT2RTLongSlotTime = true; 1925 1926 if ((ht_realtek_agg_buf[4] == 1) && 1927 (ht_realtek_agg_buf[5] & RT_HT_CAP_USE_92SE)) 1928 network->bssht.RT2RT_HT_Mode |= RT_HT_CAP_USE_92SE; 1929 } 1930 } 1931 if (ht_realtek_agg_len >= 5) { 1932 if ((ht_realtek_agg_buf[5] & RT_HT_CAP_USE_SOFTAP)) 1933 network->bssht.RT2RT_HT_Mode |= RT_HT_CAP_USE_SOFTAP; 1934 } 1935 1936 if ((info_element->len >= 3 && 1937 info_element->data[0] == 0x00 && 1938 info_element->data[1] == 0x05 && 1939 info_element->data[2] == 0xb5) || 1940 (info_element->len >= 3 && 1941 info_element->data[0] == 0x00 && 1942 info_element->data[1] == 0x0a && 1943 info_element->data[2] == 0xf7) || 1944 (info_element->len >= 3 && 1945 info_element->data[0] == 0x00 && 1946 info_element->data[1] == 0x10 && 1947 info_element->data[2] == 0x18)) { 1948 network->broadcom_cap_exist = true; 1949 } 1950 if (info_element->len >= 3 && 1951 info_element->data[0] == 0x00 && 1952 info_element->data[1] == 0x0c && 1953 info_element->data[2] == 0x43) 1954 network->ralink_cap_exist = true; 1955 if ((info_element->len >= 3 && 1956 info_element->data[0] == 0x00 && 1957 info_element->data[1] == 0x03 && 1958 info_element->data[2] == 0x7f) || 1959 (info_element->len >= 3 && 1960 info_element->data[0] == 0x00 && 1961 info_element->data[1] == 0x13 && 1962 info_element->data[2] == 0x74)) 1963 network->atheros_cap_exist = true; 1964 1965 if ((info_element->len >= 3 && 1966 info_element->data[0] == 0x00 && 1967 info_element->data[1] == 0x50 && 1968 info_element->data[2] == 0x43)) 1969 network->marvell_cap_exist = true; 1970 if (info_element->len >= 3 && 1971 info_element->data[0] == 0x00 && 1972 info_element->data[1] == 0x40 && 1973 info_element->data[2] == 0x96) 1974 network->cisco_cap_exist = true; 1975 1976 1977 if (info_element->len >= 3 && 1978 info_element->data[0] == 0x00 && 1979 info_element->data[1] == 0x0a && 1980 info_element->data[2] == 0xf5) 1981 network->airgo_cap_exist = true; 1982 1983 if (info_element->len > 4 && 1984 info_element->data[0] == 0x00 && 1985 info_element->data[1] == 0x40 && 1986 info_element->data[2] == 0x96 && 1987 info_element->data[3] == 0x01) { 1988 if (info_element->len == 6) { 1989 memcpy(network->CcxRmState, &info_element[4], 2); 1990 if (network->CcxRmState[0] != 0) 1991 network->bCcxRmEnable = true; 1992 else 1993 network->bCcxRmEnable = false; 1994 network->MBssidMask = network->CcxRmState[1] & 0x07; 1995 if (network->MBssidMask != 0) { 1996 network->bMBssidValid = true; 1997 network->MBssidMask = 0xff << 1998 (network->MBssidMask); 1999 ether_addr_copy(network->MBssid, 2000 network->bssid); 2001 network->MBssid[5] &= network->MBssidMask; 2002 } else { 2003 network->bMBssidValid = false; 2004 } 2005 } else { 2006 network->bCcxRmEnable = false; 2007 } 2008 } 2009 if (info_element->len > 4 && 2010 info_element->data[0] == 0x00 && 2011 info_element->data[1] == 0x40 && 2012 info_element->data[2] == 0x96 && 2013 info_element->data[3] == 0x03) { 2014 if (info_element->len == 5) { 2015 network->bWithCcxVerNum = true; 2016 network->BssCcxVerNumber = info_element->data[4]; 2017 } else { 2018 network->bWithCcxVerNum = false; 2019 network->BssCcxVerNumber = 0; 2020 } 2021 } 2022 if (info_element->len > 4 && 2023 info_element->data[0] == 0x00 && 2024 info_element->data[1] == 0x50 && 2025 info_element->data[2] == 0xf2 && 2026 info_element->data[3] == 0x04) { 2027 netdev_dbg(ieee->dev, "MFIE_TYPE_WZC: %d bytes\n", 2028 info_element->len); 2029 network->wzc_ie_len = min(info_element->len+2, MAX_WZC_IE_LEN); 2030 memcpy(network->wzc_ie, info_element, network->wzc_ie_len); 2031 } 2032 } 2033 2034 static void rtllib_parse_mfie_ht_cap(struct rtllib_info_element *info_element, 2035 struct rtllib_network *network, 2036 u16 *tmp_htcap_len) 2037 { 2038 struct bss_ht *ht = &network->bssht; 2039 2040 *tmp_htcap_len = min_t(u8, info_element->len, MAX_IE_LEN); 2041 if (*tmp_htcap_len != 0) { 2042 ht->bdHTSpecVer = HT_SPEC_VER_EWC; 2043 ht->bdHTCapLen = min_t(u16, *tmp_htcap_len, 2044 sizeof(ht->bdHTCapBuf)); 2045 memcpy(ht->bdHTCapBuf, info_element->data, ht->bdHTCapLen); 2046 2047 ht->bdSupportHT = true; 2048 ht->bdHT1R = ((((struct ht_capab_ele *) 2049 ht->bdHTCapBuf))->MCS[1]) == 0; 2050 2051 ht->bdBandWidth = (enum ht_channel_width) 2052 (((struct ht_capab_ele *) 2053 (ht->bdHTCapBuf))->ChlWidth); 2054 } else { 2055 ht->bdSupportHT = false; 2056 ht->bdHT1R = false; 2057 ht->bdBandWidth = HT_CHANNEL_WIDTH_20; 2058 } 2059 } 2060 2061 int rtllib_parse_info_param(struct rtllib_device *ieee, 2062 struct rtllib_info_element *info_element, 2063 u16 length, 2064 struct rtllib_network *network, 2065 struct rtllib_rx_stats *stats) 2066 { 2067 u8 i; 2068 short offset; 2069 u16 tmp_htcap_len = 0; 2070 u16 tmp_htinfo_len = 0; 2071 char rates_str[64]; 2072 char *p; 2073 2074 while (length >= sizeof(*info_element)) { 2075 if (sizeof(*info_element) + info_element->len > length) { 2076 netdev_dbg(ieee->dev, 2077 "Info elem: parse failed: info_element->len + 2 > left : info_element->len+2=%zd left=%d, id=%d.\n", 2078 info_element->len + sizeof(*info_element), 2079 length, info_element->id); 2080 /* We stop processing but don't return an error here 2081 * because some misbehaviour APs break this rule. ie. 2082 * Orinoco AP1000. 2083 */ 2084 break; 2085 } 2086 2087 switch (info_element->id) { 2088 case MFIE_TYPE_SSID: 2089 if (rtllib_is_empty_essid(info_element->data, 2090 info_element->len)) { 2091 network->flags |= NETWORK_EMPTY_ESSID; 2092 break; 2093 } 2094 2095 network->ssid_len = min(info_element->len, 2096 (u8) IW_ESSID_MAX_SIZE); 2097 memcpy(network->ssid, info_element->data, 2098 network->ssid_len); 2099 if (network->ssid_len < IW_ESSID_MAX_SIZE) 2100 memset(network->ssid + network->ssid_len, 0, 2101 IW_ESSID_MAX_SIZE - network->ssid_len); 2102 2103 netdev_dbg(ieee->dev, "MFIE_TYPE_SSID: '%s' len=%d.\n", 2104 network->ssid, network->ssid_len); 2105 break; 2106 2107 case MFIE_TYPE_RATES: 2108 p = rates_str; 2109 network->rates_len = min(info_element->len, 2110 MAX_RATES_LENGTH); 2111 for (i = 0; i < network->rates_len; i++) { 2112 network->rates[i] = info_element->data[i]; 2113 p += snprintf(p, sizeof(rates_str) - 2114 (p - rates_str), "%02X ", 2115 network->rates[i]); 2116 if (rtllib_is_ofdm_rate 2117 (info_element->data[i])) { 2118 network->flags |= NETWORK_HAS_OFDM; 2119 if (info_element->data[i] & 2120 RTLLIB_BASIC_RATE_MASK) 2121 network->flags &= 2122 ~NETWORK_HAS_CCK; 2123 } 2124 2125 if (rtllib_is_cck_rate 2126 (info_element->data[i])) { 2127 network->flags |= NETWORK_HAS_CCK; 2128 } 2129 } 2130 2131 netdev_dbg(ieee->dev, "MFIE_TYPE_RATES: '%s' (%d)\n", 2132 rates_str, network->rates_len); 2133 break; 2134 2135 case MFIE_TYPE_RATES_EX: 2136 p = rates_str; 2137 network->rates_ex_len = min(info_element->len, 2138 MAX_RATES_EX_LENGTH); 2139 for (i = 0; i < network->rates_ex_len; i++) { 2140 network->rates_ex[i] = info_element->data[i]; 2141 p += snprintf(p, sizeof(rates_str) - 2142 (p - rates_str), "%02X ", 2143 network->rates_ex[i]); 2144 if (rtllib_is_ofdm_rate 2145 (info_element->data[i])) { 2146 network->flags |= NETWORK_HAS_OFDM; 2147 if (info_element->data[i] & 2148 RTLLIB_BASIC_RATE_MASK) 2149 network->flags &= 2150 ~NETWORK_HAS_CCK; 2151 } 2152 } 2153 2154 netdev_dbg(ieee->dev, "MFIE_TYPE_RATES_EX: '%s' (%d)\n", 2155 rates_str, network->rates_ex_len); 2156 break; 2157 2158 case MFIE_TYPE_DS_SET: 2159 netdev_dbg(ieee->dev, "MFIE_TYPE_DS_SET: %d\n", 2160 info_element->data[0]); 2161 network->channel = info_element->data[0]; 2162 break; 2163 2164 case MFIE_TYPE_FH_SET: 2165 netdev_dbg(ieee->dev, "MFIE_TYPE_FH_SET: ignored\n"); 2166 break; 2167 2168 case MFIE_TYPE_CF_SET: 2169 netdev_dbg(ieee->dev, "MFIE_TYPE_CF_SET: ignored\n"); 2170 break; 2171 2172 case MFIE_TYPE_TIM: 2173 if (info_element->len < 4) 2174 break; 2175 2176 network->tim.tim_count = info_element->data[0]; 2177 network->tim.tim_period = info_element->data[1]; 2178 2179 network->dtim_period = info_element->data[1]; 2180 if (ieee->state != RTLLIB_LINKED) 2181 break; 2182 network->last_dtim_sta_time = jiffies; 2183 2184 network->dtim_data = RTLLIB_DTIM_VALID; 2185 2186 2187 if (info_element->data[2] & 1) 2188 network->dtim_data |= RTLLIB_DTIM_MBCAST; 2189 2190 offset = (info_element->data[2] >> 1)*2; 2191 2192 2193 if (ieee->assoc_id < 8*offset || 2194 ieee->assoc_id > 8*(offset + info_element->len - 3)) 2195 break; 2196 2197 offset = (ieee->assoc_id / 8) - offset; 2198 if (info_element->data[3 + offset] & 2199 (1 << (ieee->assoc_id % 8))) 2200 network->dtim_data |= RTLLIB_DTIM_UCAST; 2201 2202 network->listen_interval = network->dtim_period; 2203 break; 2204 2205 case MFIE_TYPE_ERP: 2206 network->erp_value = info_element->data[0]; 2207 network->flags |= NETWORK_HAS_ERP_VALUE; 2208 netdev_dbg(ieee->dev, "MFIE_TYPE_ERP_SET: %d\n", 2209 network->erp_value); 2210 break; 2211 case MFIE_TYPE_IBSS_SET: 2212 network->atim_window = info_element->data[0]; 2213 netdev_dbg(ieee->dev, "MFIE_TYPE_IBSS_SET: %d\n", 2214 network->atim_window); 2215 break; 2216 2217 case MFIE_TYPE_CHALLENGE: 2218 netdev_dbg(ieee->dev, "MFIE_TYPE_CHALLENGE: ignored\n"); 2219 break; 2220 2221 case MFIE_TYPE_GENERIC: 2222 netdev_dbg(ieee->dev, "MFIE_TYPE_GENERIC: %d bytes\n", 2223 info_element->len); 2224 2225 rtllib_parse_mife_generic(ieee, info_element, network, 2226 &tmp_htcap_len, 2227 &tmp_htinfo_len); 2228 break; 2229 2230 case MFIE_TYPE_RSN: 2231 netdev_dbg(ieee->dev, "MFIE_TYPE_RSN: %d bytes\n", 2232 info_element->len); 2233 network->rsn_ie_len = min(info_element->len + 2, 2234 MAX_WPA_IE_LEN); 2235 memcpy(network->rsn_ie, info_element, 2236 network->rsn_ie_len); 2237 break; 2238 2239 case MFIE_TYPE_HT_CAP: 2240 netdev_dbg(ieee->dev, "MFIE_TYPE_HT_CAP: %d bytes\n", 2241 info_element->len); 2242 2243 rtllib_parse_mfie_ht_cap(info_element, network, 2244 &tmp_htcap_len); 2245 break; 2246 2247 2248 case MFIE_TYPE_HT_INFO: 2249 netdev_dbg(ieee->dev, "MFIE_TYPE_HT_INFO: %d bytes\n", 2250 info_element->len); 2251 tmp_htinfo_len = min_t(u8, info_element->len, 2252 MAX_IE_LEN); 2253 if (tmp_htinfo_len) { 2254 network->bssht.bdHTSpecVer = HT_SPEC_VER_IEEE; 2255 network->bssht.bdHTInfoLen = tmp_htinfo_len > 2256 sizeof(network->bssht.bdHTInfoBuf) ? 2257 sizeof(network->bssht.bdHTInfoBuf) : 2258 tmp_htinfo_len; 2259 memcpy(network->bssht.bdHTInfoBuf, 2260 info_element->data, 2261 network->bssht.bdHTInfoLen); 2262 } 2263 break; 2264 2265 case MFIE_TYPE_AIRONET: 2266 netdev_dbg(ieee->dev, "MFIE_TYPE_AIRONET: %d bytes\n", 2267 info_element->len); 2268 if (info_element->len > IE_CISCO_FLAG_POSITION) { 2269 network->bWithAironetIE = true; 2270 2271 if ((info_element->data[IE_CISCO_FLAG_POSITION] 2272 & SUPPORT_CKIP_MIC) || 2273 (info_element->data[IE_CISCO_FLAG_POSITION] 2274 & SUPPORT_CKIP_PK)) 2275 network->bCkipSupported = true; 2276 else 2277 network->bCkipSupported = false; 2278 } else { 2279 network->bWithAironetIE = false; 2280 network->bCkipSupported = false; 2281 } 2282 break; 2283 case MFIE_TYPE_QOS_PARAMETER: 2284 netdev_err(ieee->dev, 2285 "QoS Error need to parse QOS_PARAMETER IE\n"); 2286 break; 2287 2288 case MFIE_TYPE_COUNTRY: 2289 netdev_dbg(ieee->dev, "MFIE_TYPE_COUNTRY: %d bytes\n", 2290 info_element->len); 2291 rtllib_extract_country_ie(ieee, info_element, network, 2292 network->bssid); 2293 break; 2294 /* TODO */ 2295 default: 2296 netdev_dbg(ieee->dev, 2297 "Unsupported info element: %s (%d)\n", 2298 get_info_element_string(info_element->id), 2299 info_element->id); 2300 break; 2301 } 2302 2303 length -= sizeof(*info_element) + info_element->len; 2304 info_element = 2305 (struct rtllib_info_element *)&info_element-> 2306 data[info_element->len]; 2307 } 2308 2309 if (!network->atheros_cap_exist && !network->broadcom_cap_exist && 2310 !network->cisco_cap_exist && !network->ralink_cap_exist && 2311 !network->bssht.bdRT2RTAggregation) 2312 network->unknown_cap_exist = true; 2313 else 2314 network->unknown_cap_exist = false; 2315 return 0; 2316 } 2317 2318 static long rtllib_translate_todbm(u8 signal_strength_index) 2319 { 2320 long signal_power; 2321 2322 signal_power = (long)((signal_strength_index + 1) >> 1); 2323 signal_power -= 95; 2324 2325 return signal_power; 2326 } 2327 2328 static inline int rtllib_network_init( 2329 struct rtllib_device *ieee, 2330 struct rtllib_probe_response *beacon, 2331 struct rtllib_network *network, 2332 struct rtllib_rx_stats *stats) 2333 { 2334 memset(&network->qos_data, 0, sizeof(struct rtllib_qos_data)); 2335 2336 /* Pull out fixed field data */ 2337 ether_addr_copy(network->bssid, beacon->header.addr3); 2338 network->capability = le16_to_cpu(beacon->capability); 2339 network->last_scanned = jiffies; 2340 network->time_stamp[0] = beacon->time_stamp[0]; 2341 network->time_stamp[1] = beacon->time_stamp[1]; 2342 network->beacon_interval = le16_to_cpu(beacon->beacon_interval); 2343 /* Where to pull this? beacon->listen_interval;*/ 2344 network->listen_interval = 0x0A; 2345 network->rates_len = network->rates_ex_len = 0; 2346 network->ssid_len = 0; 2347 network->hidden_ssid_len = 0; 2348 memset(network->hidden_ssid, 0, sizeof(network->hidden_ssid)); 2349 network->flags = 0; 2350 network->atim_window = 0; 2351 network->erp_value = (network->capability & WLAN_CAPABILITY_IBSS) ? 2352 0x3 : 0x0; 2353 network->berp_info_valid = false; 2354 network->broadcom_cap_exist = false; 2355 network->ralink_cap_exist = false; 2356 network->atheros_cap_exist = false; 2357 network->cisco_cap_exist = false; 2358 network->unknown_cap_exist = false; 2359 network->realtek_cap_exit = false; 2360 network->marvell_cap_exist = false; 2361 network->airgo_cap_exist = false; 2362 network->Turbo_Enable = 0; 2363 network->SignalStrength = stats->SignalStrength; 2364 network->RSSI = stats->SignalStrength; 2365 network->CountryIeLen = 0; 2366 memset(network->CountryIeBuf, 0, MAX_IE_LEN); 2367 HTInitializeBssDesc(&network->bssht); 2368 if (stats->freq == RTLLIB_52GHZ_BAND) { 2369 /* for A band (No DS info) */ 2370 network->channel = stats->received_channel; 2371 } else 2372 network->flags |= NETWORK_HAS_CCK; 2373 2374 network->wpa_ie_len = 0; 2375 network->rsn_ie_len = 0; 2376 network->wzc_ie_len = 0; 2377 2378 if (rtllib_parse_info_param(ieee, 2379 beacon->info_element, 2380 (stats->len - sizeof(*beacon)), 2381 network, 2382 stats)) 2383 return 1; 2384 2385 network->mode = 0; 2386 if (stats->freq == RTLLIB_52GHZ_BAND) 2387 network->mode = IEEE_A; 2388 else { 2389 if (network->flags & NETWORK_HAS_OFDM) 2390 network->mode |= IEEE_G; 2391 if (network->flags & NETWORK_HAS_CCK) 2392 network->mode |= IEEE_B; 2393 } 2394 2395 if (network->mode == 0) { 2396 netdev_dbg(ieee->dev, "Filtered out '%s (%pM)' network.\n", 2397 escape_essid(network->ssid, network->ssid_len), 2398 network->bssid); 2399 return 1; 2400 } 2401 2402 if (network->bssht.bdSupportHT) { 2403 if (network->mode == IEEE_A) 2404 network->mode = IEEE_N_5G; 2405 else if (network->mode & (IEEE_G | IEEE_B)) 2406 network->mode = IEEE_N_24G; 2407 } 2408 if (rtllib_is_empty_essid(network->ssid, network->ssid_len)) 2409 network->flags |= NETWORK_EMPTY_ESSID; 2410 stats->signal = 30 + (stats->SignalStrength * 70) / 100; 2411 stats->noise = rtllib_translate_todbm((u8)(100-stats->signal)) - 25; 2412 2413 memcpy(&network->stats, stats, sizeof(network->stats)); 2414 2415 return 0; 2416 } 2417 2418 static inline int is_same_network(struct rtllib_network *src, 2419 struct rtllib_network *dst, u8 ssidbroad) 2420 { 2421 /* A network is only a duplicate if the channel, BSSID, ESSID 2422 * and the capability field (in particular IBSS and BSS) all match. 2423 * We treat all <hidden> with the same BSSID and channel 2424 * as one network 2425 */ 2426 return (((src->ssid_len == dst->ssid_len) || (!ssidbroad)) && 2427 (src->channel == dst->channel) && 2428 !memcmp(src->bssid, dst->bssid, ETH_ALEN) && 2429 (!memcmp(src->ssid, dst->ssid, src->ssid_len) || 2430 (!ssidbroad)) && 2431 ((src->capability & WLAN_CAPABILITY_IBSS) == 2432 (dst->capability & WLAN_CAPABILITY_IBSS)) && 2433 ((src->capability & WLAN_CAPABILITY_ESS) == 2434 (dst->capability & WLAN_CAPABILITY_ESS))); 2435 } 2436 2437 2438 static inline void update_network(struct rtllib_device *ieee, 2439 struct rtllib_network *dst, 2440 struct rtllib_network *src) 2441 { 2442 int qos_active; 2443 u8 old_param; 2444 2445 memcpy(&dst->stats, &src->stats, sizeof(struct rtllib_rx_stats)); 2446 dst->capability = src->capability; 2447 memcpy(dst->rates, src->rates, src->rates_len); 2448 dst->rates_len = src->rates_len; 2449 memcpy(dst->rates_ex, src->rates_ex, src->rates_ex_len); 2450 dst->rates_ex_len = src->rates_ex_len; 2451 if (src->ssid_len > 0) { 2452 if (dst->ssid_len == 0) { 2453 memset(dst->hidden_ssid, 0, sizeof(dst->hidden_ssid)); 2454 dst->hidden_ssid_len = src->ssid_len; 2455 memcpy(dst->hidden_ssid, src->ssid, src->ssid_len); 2456 } else { 2457 memset(dst->ssid, 0, dst->ssid_len); 2458 dst->ssid_len = src->ssid_len; 2459 memcpy(dst->ssid, src->ssid, src->ssid_len); 2460 } 2461 } 2462 dst->mode = src->mode; 2463 dst->flags = src->flags; 2464 dst->time_stamp[0] = src->time_stamp[0]; 2465 dst->time_stamp[1] = src->time_stamp[1]; 2466 if (src->flags & NETWORK_HAS_ERP_VALUE) { 2467 dst->erp_value = src->erp_value; 2468 dst->berp_info_valid = src->berp_info_valid = true; 2469 } 2470 dst->beacon_interval = src->beacon_interval; 2471 dst->listen_interval = src->listen_interval; 2472 dst->atim_window = src->atim_window; 2473 dst->dtim_period = src->dtim_period; 2474 dst->dtim_data = src->dtim_data; 2475 dst->last_dtim_sta_time = src->last_dtim_sta_time; 2476 memcpy(&dst->tim, &src->tim, sizeof(struct rtllib_tim_parameters)); 2477 2478 dst->bssht.bdSupportHT = src->bssht.bdSupportHT; 2479 dst->bssht.bdRT2RTAggregation = src->bssht.bdRT2RTAggregation; 2480 dst->bssht.bdHTCapLen = src->bssht.bdHTCapLen; 2481 memcpy(dst->bssht.bdHTCapBuf, src->bssht.bdHTCapBuf, 2482 src->bssht.bdHTCapLen); 2483 dst->bssht.bdHTInfoLen = src->bssht.bdHTInfoLen; 2484 memcpy(dst->bssht.bdHTInfoBuf, src->bssht.bdHTInfoBuf, 2485 src->bssht.bdHTInfoLen); 2486 dst->bssht.bdHTSpecVer = src->bssht.bdHTSpecVer; 2487 dst->bssht.bdRT2RTLongSlotTime = src->bssht.bdRT2RTLongSlotTime; 2488 dst->broadcom_cap_exist = src->broadcom_cap_exist; 2489 dst->ralink_cap_exist = src->ralink_cap_exist; 2490 dst->atheros_cap_exist = src->atheros_cap_exist; 2491 dst->realtek_cap_exit = src->realtek_cap_exit; 2492 dst->marvell_cap_exist = src->marvell_cap_exist; 2493 dst->cisco_cap_exist = src->cisco_cap_exist; 2494 dst->airgo_cap_exist = src->airgo_cap_exist; 2495 dst->unknown_cap_exist = src->unknown_cap_exist; 2496 memcpy(dst->wpa_ie, src->wpa_ie, src->wpa_ie_len); 2497 dst->wpa_ie_len = src->wpa_ie_len; 2498 memcpy(dst->rsn_ie, src->rsn_ie, src->rsn_ie_len); 2499 dst->rsn_ie_len = src->rsn_ie_len; 2500 memcpy(dst->wzc_ie, src->wzc_ie, src->wzc_ie_len); 2501 dst->wzc_ie_len = src->wzc_ie_len; 2502 2503 dst->last_scanned = jiffies; 2504 /* qos related parameters */ 2505 qos_active = dst->qos_data.active; 2506 old_param = dst->qos_data.param_count; 2507 dst->qos_data.supported = src->qos_data.supported; 2508 if (dst->flags & NETWORK_HAS_QOS_PARAMETERS) 2509 memcpy(&dst->qos_data, &src->qos_data, 2510 sizeof(struct rtllib_qos_data)); 2511 if (dst->qos_data.supported == 1) { 2512 if (dst->ssid_len) 2513 netdev_dbg(ieee->dev, 2514 "QoS the network %s is QoS supported\n", 2515 dst->ssid); 2516 else 2517 netdev_dbg(ieee->dev, 2518 "QoS the network is QoS supported\n"); 2519 } 2520 dst->qos_data.active = qos_active; 2521 dst->qos_data.old_param_count = old_param; 2522 2523 dst->wmm_info = src->wmm_info; 2524 if (src->wmm_param[0].ac_aci_acm_aifsn || 2525 src->wmm_param[1].ac_aci_acm_aifsn || 2526 src->wmm_param[2].ac_aci_acm_aifsn || 2527 src->wmm_param[3].ac_aci_acm_aifsn) 2528 memcpy(dst->wmm_param, src->wmm_param, WME_AC_PRAM_LEN); 2529 2530 dst->SignalStrength = src->SignalStrength; 2531 dst->RSSI = src->RSSI; 2532 dst->Turbo_Enable = src->Turbo_Enable; 2533 2534 dst->CountryIeLen = src->CountryIeLen; 2535 memcpy(dst->CountryIeBuf, src->CountryIeBuf, src->CountryIeLen); 2536 2537 dst->bWithAironetIE = src->bWithAironetIE; 2538 dst->bCkipSupported = src->bCkipSupported; 2539 memcpy(dst->CcxRmState, src->CcxRmState, 2); 2540 dst->bCcxRmEnable = src->bCcxRmEnable; 2541 dst->MBssidMask = src->MBssidMask; 2542 dst->bMBssidValid = src->bMBssidValid; 2543 memcpy(dst->MBssid, src->MBssid, 6); 2544 dst->bWithCcxVerNum = src->bWithCcxVerNum; 2545 dst->BssCcxVerNumber = src->BssCcxVerNumber; 2546 } 2547 2548 static inline int is_beacon(u16 fc) 2549 { 2550 return (WLAN_FC_GET_STYPE(fc) == RTLLIB_STYPE_BEACON); 2551 } 2552 2553 static int IsPassiveChannel(struct rtllib_device *rtllib, u8 channel) 2554 { 2555 if (channel > MAX_CHANNEL_NUMBER) { 2556 netdev_info(rtllib->dev, "%s(): Invalid Channel\n", __func__); 2557 return 0; 2558 } 2559 2560 if (rtllib->active_channel_map[channel] == 2) 2561 return 1; 2562 2563 return 0; 2564 } 2565 2566 int rtllib_legal_channel(struct rtllib_device *rtllib, u8 channel) 2567 { 2568 if (channel > MAX_CHANNEL_NUMBER) { 2569 netdev_info(rtllib->dev, "%s(): Invalid Channel\n", __func__); 2570 return 0; 2571 } 2572 if (rtllib->active_channel_map[channel] > 0) 2573 return 1; 2574 2575 return 0; 2576 } 2577 EXPORT_SYMBOL(rtllib_legal_channel); 2578 2579 static inline void rtllib_process_probe_response( 2580 struct rtllib_device *ieee, 2581 struct rtllib_probe_response *beacon, 2582 struct rtllib_rx_stats *stats) 2583 { 2584 struct rtllib_network *target; 2585 struct rtllib_network *oldest = NULL; 2586 struct rtllib_info_element *info_element = &beacon->info_element[0]; 2587 unsigned long flags; 2588 short renew; 2589 struct rtllib_network *network = kzalloc(sizeof(struct rtllib_network), 2590 GFP_ATOMIC); 2591 u16 frame_ctl = le16_to_cpu(beacon->header.frame_ctl); 2592 2593 if (!network) 2594 return; 2595 2596 netdev_dbg(ieee->dev, 2597 "'%s' ( %pM ): %c%c%c%c %c%c%c%c-%c%c%c%c %c%c%c%c\n", 2598 escape_essid(info_element->data, info_element->len), 2599 beacon->header.addr3, 2600 (le16_to_cpu(beacon->capability) & (1<<0xf)) ? '1' : '0', 2601 (le16_to_cpu(beacon->capability) & (1<<0xe)) ? '1' : '0', 2602 (le16_to_cpu(beacon->capability) & (1<<0xd)) ? '1' : '0', 2603 (le16_to_cpu(beacon->capability) & (1<<0xc)) ? '1' : '0', 2604 (le16_to_cpu(beacon->capability) & (1<<0xb)) ? '1' : '0', 2605 (le16_to_cpu(beacon->capability) & (1<<0xa)) ? '1' : '0', 2606 (le16_to_cpu(beacon->capability) & (1<<0x9)) ? '1' : '0', 2607 (le16_to_cpu(beacon->capability) & (1<<0x8)) ? '1' : '0', 2608 (le16_to_cpu(beacon->capability) & (1<<0x7)) ? '1' : '0', 2609 (le16_to_cpu(beacon->capability) & (1<<0x6)) ? '1' : '0', 2610 (le16_to_cpu(beacon->capability) & (1<<0x5)) ? '1' : '0', 2611 (le16_to_cpu(beacon->capability) & (1<<0x4)) ? '1' : '0', 2612 (le16_to_cpu(beacon->capability) & (1<<0x3)) ? '1' : '0', 2613 (le16_to_cpu(beacon->capability) & (1<<0x2)) ? '1' : '0', 2614 (le16_to_cpu(beacon->capability) & (1<<0x1)) ? '1' : '0', 2615 (le16_to_cpu(beacon->capability) & (1<<0x0)) ? '1' : '0'); 2616 2617 if (rtllib_network_init(ieee, beacon, network, stats)) { 2618 netdev_dbg(ieee->dev, "Dropped '%s' ( %pM) via %s.\n", 2619 escape_essid(info_element->data, info_element->len), 2620 beacon->header.addr3, 2621 is_beacon(frame_ctl) ? "BEACON" : "PROBE RESPONSE"); 2622 goto free_network; 2623 } 2624 2625 2626 if (!rtllib_legal_channel(ieee, network->channel)) 2627 goto free_network; 2628 2629 if (WLAN_FC_GET_STYPE(frame_ctl) == RTLLIB_STYPE_PROBE_RESP) { 2630 if (IsPassiveChannel(ieee, network->channel)) { 2631 netdev_info(ieee->dev, 2632 "GetScanInfo(): For Global Domain, filter probe response at channel(%d).\n", 2633 network->channel); 2634 goto free_network; 2635 } 2636 } 2637 2638 /* The network parsed correctly -- so now we scan our known networks 2639 * to see if we can find it in our list. 2640 * 2641 * NOTE: This search is definitely not optimized. Once its doing 2642 * the "right thing" we'll optimize it for efficiency if 2643 * necessary 2644 */ 2645 2646 /* Search for this entry in the list and update it if it is 2647 * already there. 2648 */ 2649 2650 spin_lock_irqsave(&ieee->lock, flags); 2651 if (is_same_network(&ieee->current_network, network, 2652 (network->ssid_len ? 1 : 0))) { 2653 update_network(ieee, &ieee->current_network, network); 2654 if ((ieee->current_network.mode == IEEE_N_24G || 2655 ieee->current_network.mode == IEEE_G) 2656 && ieee->current_network.berp_info_valid) { 2657 if (ieee->current_network.erp_value & ERP_UseProtection) 2658 ieee->current_network.buseprotection = true; 2659 else 2660 ieee->current_network.buseprotection = false; 2661 } 2662 if (is_beacon(frame_ctl)) { 2663 if (ieee->state >= RTLLIB_LINKED) 2664 ieee->LinkDetectInfo.NumRecvBcnInPeriod++; 2665 } 2666 } 2667 list_for_each_entry(target, &ieee->network_list, list) { 2668 if (is_same_network(target, network, 2669 (target->ssid_len ? 1 : 0))) 2670 break; 2671 if ((oldest == NULL) || 2672 (target->last_scanned < oldest->last_scanned)) 2673 oldest = target; 2674 } 2675 2676 /* If we didn't find a match, then get a new network slot to initialize 2677 * with this beacon's information 2678 */ 2679 if (&target->list == &ieee->network_list) { 2680 if (list_empty(&ieee->network_free_list)) { 2681 /* If there are no more slots, expire the oldest */ 2682 list_del(&oldest->list); 2683 target = oldest; 2684 netdev_dbg(ieee->dev, 2685 "Expired '%s' ( %pM) from network list.\n", 2686 escape_essid(target->ssid, target->ssid_len), 2687 target->bssid); 2688 } else { 2689 /* Otherwise just pull from the free list */ 2690 target = list_entry(ieee->network_free_list.next, 2691 struct rtllib_network, list); 2692 list_del(ieee->network_free_list.next); 2693 } 2694 2695 netdev_dbg(ieee->dev, "Adding '%s' ( %pM) via %s.\n", 2696 escape_essid(network->ssid, network->ssid_len), 2697 network->bssid, 2698 is_beacon(frame_ctl) ? "BEACON" : "PROBE RESPONSE"); 2699 2700 memcpy(target, network, sizeof(*target)); 2701 list_add_tail(&target->list, &ieee->network_list); 2702 if (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) 2703 rtllib_softmac_new_net(ieee, network); 2704 } else { 2705 netdev_dbg(ieee->dev, "Updating '%s' ( %pM) via %s.\n", 2706 escape_essid(target->ssid, target->ssid_len), 2707 target->bssid, 2708 is_beacon(frame_ctl) ? "BEACON" : "PROBE RESPONSE"); 2709 2710 /* we have an entry and we are going to update it. But this 2711 * entry may be already expired. In this case we do the same 2712 * as we found a new net and call the new_net handler 2713 */ 2714 renew = !time_after(target->last_scanned + ieee->scan_age, 2715 jiffies); 2716 if ((!target->ssid_len) && 2717 (((network->ssid_len > 0) && (target->hidden_ssid_len == 0)) 2718 || ((ieee->current_network.ssid_len == network->ssid_len) && 2719 (strncmp(ieee->current_network.ssid, network->ssid, 2720 network->ssid_len) == 0) && 2721 (ieee->state == RTLLIB_NOLINK)))) 2722 renew = 1; 2723 update_network(ieee, target, network); 2724 if (renew && (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE)) 2725 rtllib_softmac_new_net(ieee, network); 2726 } 2727 2728 spin_unlock_irqrestore(&ieee->lock, flags); 2729 if (is_beacon(frame_ctl) && 2730 is_same_network(&ieee->current_network, network, 2731 (network->ssid_len ? 1 : 0)) && 2732 (ieee->state == RTLLIB_LINKED)) { 2733 if (ieee->handle_beacon != NULL) 2734 ieee->handle_beacon(ieee->dev, beacon, 2735 &ieee->current_network); 2736 } 2737 free_network: 2738 kfree(network); 2739 } 2740 2741 static void rtllib_rx_mgt(struct rtllib_device *ieee, 2742 struct sk_buff *skb, 2743 struct rtllib_rx_stats *stats) 2744 { 2745 struct rtllib_hdr_4addr *header = (struct rtllib_hdr_4addr *)skb->data; 2746 2747 if ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) != 2748 RTLLIB_STYPE_PROBE_RESP) && 2749 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) != 2750 RTLLIB_STYPE_BEACON)) 2751 ieee->last_rx_ps_time = jiffies; 2752 2753 switch (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl))) { 2754 2755 case RTLLIB_STYPE_BEACON: 2756 netdev_dbg(ieee->dev, "received BEACON (%d)\n", 2757 WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl))); 2758 rtllib_process_probe_response( 2759 ieee, (struct rtllib_probe_response *)header, 2760 stats); 2761 2762 if (ieee->sta_sleep || (ieee->ps != RTLLIB_PS_DISABLED && 2763 ieee->iw_mode == IW_MODE_INFRA && 2764 ieee->state == RTLLIB_LINKED)) 2765 tasklet_schedule(&ieee->ps_task); 2766 2767 break; 2768 2769 case RTLLIB_STYPE_PROBE_RESP: 2770 netdev_dbg(ieee->dev, "received PROBE RESPONSE (%d)\n", 2771 WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl))); 2772 rtllib_process_probe_response(ieee, 2773 (struct rtllib_probe_response *)header, stats); 2774 break; 2775 case RTLLIB_STYPE_PROBE_REQ: 2776 netdev_dbg(ieee->dev, "received PROBE RESQUEST (%d)\n", 2777 WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl))); 2778 if ((ieee->softmac_features & IEEE_SOFTMAC_PROBERS) && 2779 ((ieee->iw_mode == IW_MODE_ADHOC || 2780 ieee->iw_mode == IW_MODE_MASTER) && 2781 ieee->state == RTLLIB_LINKED)) 2782 rtllib_rx_probe_rq(ieee, skb); 2783 break; 2784 } 2785 } 2786