| /* |
| * L2 Filter handling functions |
| * |
| * Copyright (C) 2021, Broadcom. |
| * |
| * Unless you and Broadcom execute a separate written software license |
| * agreement governing use of this software, this software is licensed to you |
| * under the terms of the GNU General Public License version 2 (the "GPL"), |
| * available at http://www.broadcom.com/licenses/GPLv2.php, with the |
| * following added to such license: |
| * |
| * As a special exception, the copyright holders of this software give you |
| * permission to link this software with independent modules, and to copy and |
| * distribute the resulting executable under terms of your choice, provided that |
| * you also meet, for each linked independent module, the terms and conditions of |
| * the license of that module. An independent module is a module which is not |
| * derived from this software. The special exception does not apply to any |
| * modifications of the software. |
| * |
| * |
| * <<Broadcom-WL-IPTag/Dual:>> |
| * |
| */ |
| #include <bcmutils.h> |
| #include <bcmendian.h> |
| #include <bcmdefs.h> |
| #include <bcmdevs.h> |
| #include <ethernet.h> |
| #include <bcmip.h> |
| #include <bcmipv6.h> |
| #include <bcmudp.h> |
| #include <bcmarp.h> |
| #include <bcmicmp.h> |
| #include <bcmproto.h> |
| #include <bcmdhcp.h> |
| #include <802.11.h> |
| #include <bcm_l2_filter.h> |
| |
| #ifdef BCMDBG_ERR |
| #define L2_FILTER_ERROR(args) printf args |
| #else |
| #define L2_FILTER_ERROR(args) |
| #endif /* BCMDBG_ERR */ |
| |
| #ifdef BCMDBG_MSG |
| #define L2_FILTER_MSG(args) printf args |
| #else |
| #define L2_FILTER_MSG(args) |
| #endif /* BCMDBG_msg */ |
| |
| struct arp_table { |
| parp_entry_t *parp_table[BCM_PARP_TABLE_SIZE]; /* proxyarp entries in cache table */ |
| parp_entry_t *parp_candidate_list; /* proxyarp entries in candidate list */ |
| uint8 parp_smac[ETHER_ADDR_LEN]; /* L2 SMAC from DHCP Req */ |
| uint8 parp_cmac[ETHER_ADDR_LEN]; /* Bootp Client MAC from DHCP Req */ |
| }; |
| #ifdef DHD_DUMP_ARPTABLE |
| void bcm_l2_parp_dump_table(arp_table_t* arp_tbl); |
| |
| void |
| bcm_l2_parp_dump_table(arp_table_t* arp_tbl) |
| { |
| parp_entry_t *entry; |
| uint16 idx, ip_len; |
| arp_table_t *ptable; |
| ip_len = IPV4_ADDR_LEN; |
| ptable = arp_tbl; |
| for (idx = 0; idx < BCM_PARP_TABLE_SIZE; idx++) { |
| entry = ptable->parp_table[idx]; |
| while (entry) { |
| printf("Cached entries..\n"); |
| printf("%d: %d.%d.%d.%d", idx, entry->ip.data[0], entry->ip.data[1], |
| entry->ip.data[2], entry->ip.data[3]); |
| printf("%02x:%02x:%02x:%02x:%02x:%02x", entry->ea.octet[0], |
| entry->ea.octet[1], entry->ea.octet[2], entry->ea.octet[3], |
| entry->ea.octet[4], entry->ea.octet[5]); |
| printf("\n"); |
| entry = entry->next; |
| } |
| } |
| entry = ptable->parp_candidate_list; |
| while (entry) { |
| printf("Candidate entries..\n"); |
| printf("%d.%d.%d.%d", entry->ip.data[0], entry->ip.data[1], |
| entry->ip.data[2], entry->ip.data[3]); |
| printf("%02x:%02x:%02x:%02x:%02x:%02x", entry->ea.octet[0], |
| entry->ea.octet[1], entry->ea.octet[2], entry->ea.octet[3], |
| entry->ea.octet[4], entry->ea.octet[5]); |
| |
| printf("\n"); |
| entry = entry->next; |
| } |
| } |
| #endif /* DHD_DUMP_ARPTABLE */ |
| |
| arp_table_t* init_l2_filter_arp_table(osl_t* osh) |
| { |
| return ((arp_table_t*)MALLOCZ(osh, sizeof(arp_table_t))); |
| } |
| |
| void deinit_l2_filter_arp_table(osl_t* osh, arp_table_t* ptable) |
| { |
| MFREE(osh, ptable, sizeof(arp_table_t)); |
| } |
| /* returns 0 if gratuitous ARP or unsolicited neighbour advertisement */ |
| int |
| bcm_l2_filter_gratuitous_arp(osl_t *osh, void *pktbuf) |
| { |
| uint8 *frame = PKTDATA(osh, pktbuf); |
| uint16 ethertype; |
| int send_ip_offset, target_ip_offset; |
| int iplen; |
| int minlen; |
| uint8 *data; |
| int datalen; |
| bool snap; |
| |
| if (get_pkt_ether_type(osh, pktbuf, &data, &datalen, ðertype, &snap) != BCME_OK) |
| return BCME_ERROR; |
| |
| if (!ETHER_ISBCAST(frame + ETHER_DEST_OFFSET) && |
| bcmp(ðer_ipv6_mcast, frame + ETHER_DEST_OFFSET, sizeof(ether_ipv6_mcast))) { |
| return BCME_ERROR; |
| } |
| |
| if (ethertype == ETHER_TYPE_ARP) { |
| L2_FILTER_MSG(("bcm_l2_filter_gratuitous_arp: ARP RX data : %p: datalen : %d\n", |
| data, datalen)); |
| send_ip_offset = ARP_SRC_IP_OFFSET; |
| target_ip_offset = ARP_TGT_IP_OFFSET; |
| iplen = IPV4_ADDR_LEN; |
| minlen = ARP_DATA_LEN; |
| } else if (ethertype == ETHER_TYPE_IPV6) { |
| send_ip_offset = NEIGHBOR_ADVERTISE_SRC_IPV6_OFFSET; |
| target_ip_offset = NEIGHBOR_ADVERTISE_TGT_IPV6_OFFSET; |
| iplen = IPV6_ADDR_LEN; |
| minlen = target_ip_offset + iplen; |
| |
| /* check for neighbour advertisement */ |
| if (datalen >= minlen && (data[IPV6_NEXT_HDR_OFFSET] != IP_PROT_ICMP6 || |
| data[NEIGHBOR_ADVERTISE_TYPE_OFFSET] != NEIGHBOR_ADVERTISE_TYPE)) |
| return BCME_ERROR; |
| |
| /* Dont drop Unsolicitated NA fm AP with allnode mcast dest addr (HS2-4.5.E) */ |
| if (datalen >= minlen && |
| (data[IPV6_NEXT_HDR_OFFSET] == IP_PROT_ICMP6) && |
| (data[NEIGHBOR_ADVERTISE_TYPE_OFFSET] == NEIGHBOR_ADVERTISE_TYPE) && |
| (data[NEIGHBOR_ADVERTISE_OPTION_OFFSET] == OPT_TYPE_TGT_LINK_ADDR)) { |
| L2_FILTER_MSG(("Unsolicitated Neighbour Advertisement from AP " |
| "with allnode mcast dest addr tx'ed (%d)\n", datalen)); |
| return -1; |
| } |
| |
| } else { |
| return BCME_ERROR; |
| } |
| |
| if (datalen < minlen) { |
| L2_FILTER_MSG(("BCM: dhd_gratuitous_arp: truncated packet (%d)\n", datalen)); |
| return BCME_ERROR; |
| } |
| |
| if (bcmp(data + send_ip_offset, data + target_ip_offset, iplen) == 0) { |
| L2_FILTER_MSG((" returning BCME_OK in bcm_l2_filter_gratuitous_arp\n")); |
| return BCME_OK; |
| } |
| |
| return BCME_ERROR; |
| } |
| int |
| get_pkt_ether_type(osl_t *osh, void *pktbuf, |
| uint8 **data_ptr, int *len_ptr, uint16 *et_ptr, bool *snap_ptr) |
| { |
| uint8 *frame = PKTDATA(osh, pktbuf); |
| int length = PKTLEN(osh, pktbuf); |
| uint8 *pt; /* Pointer to type field */ |
| uint16 ethertype; |
| bool snap = FALSE; |
| /* Process Ethernet II or SNAP-encapsulated 802.3 frames */ |
| if (length < ETHER_HDR_LEN) { |
| L2_FILTER_MSG(("BCM: get_pkt_ether_type: short eth frame (%d)\n", |
| length)); |
| return BCME_ERROR; |
| } else if (ntoh16_ua(frame + ETHER_TYPE_OFFSET) >= ETHER_TYPE_MIN) { |
| /* Frame is Ethernet II */ |
| pt = frame + ETHER_TYPE_OFFSET; |
| } else if (length >= ETHER_HDR_LEN + SNAP_HDR_LEN + ETHER_TYPE_LEN && |
| !bcmp(llc_snap_hdr, frame + ETHER_HDR_LEN, SNAP_HDR_LEN)) { |
| pt = frame + ETHER_HDR_LEN + SNAP_HDR_LEN; |
| snap = TRUE; |
| } else { |
| L2_FILTER_MSG((" get_pkt_ether_type: non-SNAP 802.3 frame\n")); |
| return BCME_ERROR; |
| } |
| |
| ethertype = ntoh16_ua(pt); |
| |
| /* Skip VLAN tag, if any */ |
| if (ethertype == ETHER_TYPE_8021Q) { |
| pt += VLAN_TAG_LEN; |
| |
| if ((pt + ETHER_TYPE_LEN) > (frame + length)) { |
| L2_FILTER_MSG(("BCM: get_pkt_ether_type: short VLAN frame (%d)\n", |
| length)); |
| return BCME_ERROR; |
| } |
| ethertype = ntoh16_ua(pt); |
| } |
| *data_ptr = pt + ETHER_TYPE_LEN; |
| *len_ptr = length - (int32)(pt + ETHER_TYPE_LEN - frame); |
| *et_ptr = ethertype; |
| *snap_ptr = snap; |
| return BCME_OK; |
| } |
| |
| int |
| get_pkt_ip_type(osl_t *osh, void *pktbuf, |
| uint8 **data_ptr, int *len_ptr, uint8 *prot_ptr) |
| { |
| struct ipv4_hdr *iph; /* IP frame pointer */ |
| int iplen; /* IP frame length */ |
| uint16 ethertype, iphdrlen, ippktlen; |
| uint16 iph_frag; |
| uint8 prot; |
| bool snap; |
| |
| if (get_pkt_ether_type(osh, pktbuf, (uint8 **)&iph, |
| &iplen, ðertype, &snap) != 0) |
| return BCME_ERROR; |
| |
| if (ethertype != ETHER_TYPE_IP) { |
| return BCME_ERROR; |
| } |
| |
| /* We support IPv4 only */ |
| if (iplen < IPV4_OPTIONS_OFFSET || (IP_VER(iph) != IP_VER_4)) { |
| return BCME_ERROR; |
| } |
| |
| /* Header length sanity */ |
| iphdrlen = IPV4_HLEN(iph); |
| |
| /* |
| * Packet length sanity; sometimes we receive eth-frame size bigger |
| * than the IP content, which results in a bad tcp chksum |
| */ |
| ippktlen = ntoh16(iph->tot_len); |
| if (ippktlen < iplen) { |
| L2_FILTER_MSG(("get_pkt_ip_type: extra frame length ignored\n")); |
| iplen = ippktlen; |
| } else if (ippktlen > iplen) { |
| L2_FILTER_MSG(("get_pkt_ip_type: truncated IP packet (%d)\n", |
| ippktlen - iplen)); |
| return BCME_ERROR; |
| } |
| |
| if (iphdrlen < IPV4_OPTIONS_OFFSET || iphdrlen > iplen) { |
| L2_FILTER_ERROR((" get_pkt_ip_type: IP-header-len (%d) out of range (%d-%d)\n", |
| iphdrlen, IPV4_OPTIONS_OFFSET, iplen)); |
| return BCME_ERROR; |
| } |
| |
| /* |
| * We don't handle fragmented IP packets. A first frag is indicated by the MF |
| * (more frag) bit and a subsequent frag is indicated by a non-zero frag offset. |
| */ |
| iph_frag = ntoh16(iph->frag); |
| |
| if ((iph_frag & IPV4_FRAG_MORE) || (iph_frag & IPV4_FRAG_OFFSET_MASK) != 0) { |
| L2_FILTER_ERROR(("get_pkt_ip_type: IP fragment not handled\n")); |
| return BCME_ERROR; |
| } |
| prot = IPV4_PROT(iph); |
| *data_ptr = (((uint8 *)iph) + iphdrlen); |
| *len_ptr = iplen - iphdrlen; |
| *prot_ptr = prot; |
| return BCME_OK; |
| } |
| |
| /* Check if packet type is ICMP ECHO */ |
| int bcm_l2_filter_block_ping(osl_t *osh, void *pktbuf) |
| { |
| struct bcmicmp_hdr *icmph; |
| int udpl; |
| uint8 prot; |
| |
| if (get_pkt_ip_type(osh, pktbuf, (uint8 **)&icmph, &udpl, &prot) != 0) |
| return BCME_ERROR; |
| if (prot == IP_PROT_ICMP) { |
| if (icmph->type == ICMP_TYPE_ECHO_REQUEST) |
| return BCME_OK; |
| } |
| return BCME_ERROR; |
| } |
| |
| int bcm_l2_filter_get_mac_addr_dhcp_pkt(osl_t *osh, void *pktbuf, |
| int ifidx, uint8** mac_addr) |
| { |
| uint8 *eh = PKTDATA(osh, pktbuf); |
| uint8 *udph; |
| uint8 *dhcp; |
| int udpl; |
| int dhcpl; |
| uint16 port; |
| uint8 prot; |
| |
| if (!ETHER_ISMULTI(eh + ETHER_DEST_OFFSET)) |
| return BCME_ERROR; |
| if (get_pkt_ip_type(osh, pktbuf, &udph, &udpl, &prot) != 0) |
| return BCME_ERROR; |
| if (prot != IP_PROT_UDP) |
| return BCME_ERROR; |
| /* check frame length, at least UDP_HDR_LEN */ |
| if (udpl < UDP_HDR_LEN) { |
| L2_FILTER_MSG(("BCM: bcm_l2_filter_get_mac_addr_dhcp_pkt: short UDP frame," |
| " ignored\n")); |
| return BCME_ERROR; |
| } |
| port = ntoh16_ua(udph + UDP_DEST_PORT_OFFSET); |
| /* only process DHCP packets from server to client */ |
| if (port != DHCP_PORT_CLIENT) |
| return BCME_ERROR; |
| |
| dhcp = udph + UDP_HDR_LEN; |
| dhcpl = udpl - UDP_HDR_LEN; |
| |
| if (dhcpl < DHCP_CHADDR_OFFSET + ETHER_ADDR_LEN) { |
| L2_FILTER_MSG(("BCM: bcm_l2_filter_get_mac_addr_dhcp_pkt: short DHCP frame," |
| " ignored\n")); |
| return BCME_ERROR; |
| } |
| /* only process DHCP reply(offer/ack) packets */ |
| if (*(dhcp + DHCP_TYPE_OFFSET) != DHCP_TYPE_REPLY) |
| return BCME_ERROR; |
| /* chaddr = dhcp + DHCP_CHADDR_OFFSET; */ |
| *mac_addr = dhcp + DHCP_CHADDR_OFFSET; |
| return BCME_OK; |
| } |
| /* modify the mac address for IP, in arp table */ |
| int |
| bcm_l2_filter_parp_modifyentry(arp_table_t* arp_tbl, struct ether_addr *ea, |
| uint8 *ip, uint8 ip_ver, bool cached, unsigned int entry_tickcnt) |
| { |
| parp_entry_t *entry; |
| uint8 idx, ip_len; |
| arp_table_t *ptable; |
| |
| if (ip_ver == IP_VER_4 && !IPV4_ADDR_NULL(ip) && !IPV4_ADDR_BCAST(ip)) { |
| idx = BCM_PARP_TABLE_INDEX(ip[IPV4_ADDR_LEN - 1]); |
| ip_len = IPV4_ADDR_LEN; |
| } |
| else if (ip_ver == IP_VER_6 && !IPV6_ADDR_NULL(ip)) { |
| idx = BCM_PARP_TABLE_INDEX(ip[IPV6_ADDR_LEN - 1]); |
| ip_len = IPV6_ADDR_LEN; |
| } |
| else { |
| return BCME_ERROR; |
| } |
| |
| ptable = arp_tbl; |
| if (cached) { |
| entry = ptable->parp_table[idx]; |
| } else { |
| entry = ptable->parp_candidate_list; |
| } |
| while (entry) { |
| if (bcmp(entry->ip.data, ip, ip_len) == 0) { |
| /* entry matches, overwrite mac content and return */ |
| bcopy((void *)ea, (void *)&entry->ea, ETHER_ADDR_LEN); |
| entry->used = entry_tickcnt; |
| #ifdef DHD_DUMP_ARPTABLE |
| bcm_l2_parp_dump_table(arp_tbl); |
| #endif |
| return BCME_OK; |
| } |
| entry = entry->next; |
| } |
| #ifdef DHD_DUMP_ARPTABLE |
| bcm_l2_parp_dump_table(arp_tbl); |
| #endif |
| return BCME_ERROR; |
| } |
| |
| /* Add the IP entry in ARP table based on Cached argument, if cached argument is |
| * non zero positive value: it adds to parp_table, else adds to |
| * parp_candidate_list |
| */ |
| int |
| bcm_l2_filter_parp_addentry(osl_t *osh, arp_table_t* arp_tbl, struct ether_addr *ea, |
| uint8 *ip, uint8 ip_ver, bool cached, unsigned int entry_tickcnt) |
| { |
| parp_entry_t *entry; |
| uint8 idx, ip_len; |
| arp_table_t *ptable; |
| |
| if (ip_ver == IP_VER_4 && !IPV4_ADDR_NULL(ip) && !IPV4_ADDR_BCAST(ip)) { |
| idx = BCM_PARP_TABLE_INDEX(ip[IPV4_ADDR_LEN - 1]); |
| ip_len = IPV4_ADDR_LEN; |
| } |
| else if (ip_ver == IP_VER_6 && !IPV6_ADDR_NULL(ip)) { |
| idx = BCM_PARP_TABLE_INDEX(ip[IPV6_ADDR_LEN - 1]); |
| ip_len = IPV6_ADDR_LEN; |
| } |
| else { |
| return BCME_ERROR; |
| } |
| |
| if ((entry = MALLOCZ(osh, sizeof(parp_entry_t) + ip_len)) == NULL) { |
| L2_FILTER_MSG(("Allocating new parp_entry for IPv%d failed!!\n", ip_ver)); |
| return BCME_NOMEM; |
| } |
| |
| bcopy((void *)ea, (void *)&entry->ea, ETHER_ADDR_LEN); |
| entry->used = entry_tickcnt; |
| entry->ip.id = ip_ver; |
| entry->ip.len = ip_len; |
| bcopy(ip, entry->ip.data, ip_len); |
| ptable = arp_tbl; |
| if (cached) { |
| entry->next = ptable->parp_table[idx]; |
| ptable->parp_table[idx] = entry; |
| } else { |
| entry->next = ptable->parp_candidate_list; |
| ptable->parp_candidate_list = entry; |
| } |
| #ifdef DHD_DUMP_ARPTABLE |
| bcm_l2_parp_dump_table(arp_tbl); |
| #endif |
| return BCME_OK; |
| } |
| |
| /* Delete the IP entry in ARP table based on Cached argument, if cached argument is |
| * non zero positive value: it delete from parp_table, else delete from |
| * parp_candidate_list |
| */ |
| int |
| bcm_l2_filter_parp_delentry(osl_t* osh, arp_table_t *arp_tbl, struct ether_addr *ea, |
| uint8 *ip, uint8 ip_ver, bool cached) |
| { |
| parp_entry_t *entry, *prev = NULL; |
| uint8 idx, ip_len; |
| arp_table_t *ptable; |
| |
| if (ip_ver == IP_VER_4) { |
| idx = BCM_PARP_TABLE_INDEX(ip[IPV4_ADDR_LEN - 1]); |
| ip_len = IPV4_ADDR_LEN; |
| } |
| else if (ip_ver == IP_VER_6) { |
| idx = BCM_PARP_TABLE_INDEX(ip[IPV6_ADDR_LEN - 1]); |
| ip_len = IPV6_ADDR_LEN; |
| } |
| else { |
| return BCME_ERROR; |
| } |
| ptable = arp_tbl; |
| if (cached) { |
| entry = ptable->parp_table[idx]; |
| } else { |
| entry = ptable->parp_candidate_list; |
| } |
| while (entry) { |
| if (entry->ip.id == ip_ver && |
| bcmp(entry->ip.data, ip, ip_len) == 0 && |
| bcmp(&entry->ea, ea, ETHER_ADDR_LEN) == 0) { |
| if (prev == NULL) { |
| if (cached) { |
| ptable->parp_table[idx] = entry->next; |
| } else { |
| ptable->parp_candidate_list = entry->next; |
| } |
| } else { |
| prev->next = entry->next; |
| } |
| break; |
| } |
| prev = entry; |
| entry = entry->next; |
| } |
| if (entry != NULL) |
| MFREE(osh, entry, sizeof(parp_entry_t) + ip_len); |
| #ifdef DHD_DUMP_ARPTABLE |
| bcm_l2_parp_dump_table(arp_tbl); |
| #endif |
| return BCME_OK; |
| } |
| |
| /* search the IP entry in ARP table based on Cached argument, if cached argument is |
| * non zero positive value: it searches from parp_table, else search from |
| * parp_candidate_list |
| */ |
| parp_entry_t * |
| bcm_l2_filter_parp_findentry(arp_table_t* arp_tbl, uint8 *ip, uint8 ip_ver, bool cached, |
| unsigned int entry_tickcnt) |
| { |
| parp_entry_t *entry; |
| uint8 idx, ip_len; |
| arp_table_t *ptable; |
| |
| if (ip_ver == IP_VER_4) { |
| idx = BCM_PARP_TABLE_INDEX(ip[IPV4_ADDR_LEN - 1]); |
| ip_len = IPV4_ADDR_LEN; |
| } else if (ip_ver == IP_VER_6) { |
| idx = BCM_PARP_TABLE_INDEX(ip[IPV6_ADDR_LEN - 1]); |
| ip_len = IPV6_ADDR_LEN; |
| } else { |
| return NULL; |
| } |
| ptable = arp_tbl; |
| if (cached) { |
| entry = ptable->parp_table[idx]; |
| } else { |
| entry = ptable->parp_candidate_list; |
| } |
| while (entry) { |
| if (entry->ip.id == ip_ver && bcmp(entry->ip.data, ip, ip_len) == 0) { |
| /* time stamp of adding the station entry to arp table for ifp */ |
| entry->used = entry_tickcnt; |
| break; |
| } |
| entry = entry->next; |
| } |
| return entry; |
| } |
| |
| /* update arp table entries for every proxy arp enable interface */ |
| void |
| bcm_l2_filter_arp_table_update(osl_t *osh, arp_table_t* arp_tbl, bool all, uint8 *del_ea, |
| bool periodic, unsigned int tickcnt) |
| { |
| parp_entry_t *prev, *entry, *delentry; |
| uint8 idx, ip_ver; |
| struct ether_addr ea; |
| uint8 ip[IPV6_ADDR_LEN]; |
| arp_table_t *ptable; |
| |
| ptable = arp_tbl; |
| for (idx = 0; idx < BCM_PARP_TABLE_SIZE; idx++) { |
| entry = ptable->parp_table[idx]; |
| while (entry) { |
| /* check if the entry need to be removed */ |
| if (all || (periodic && BCM_PARP_IS_TIMEOUT(tickcnt, entry)) || |
| (del_ea != NULL && !bcmp(del_ea, &entry->ea, ETHER_ADDR_LEN))) { |
| /* copy frame here */ |
| ip_ver = entry->ip.id; |
| bcopy(entry->ip.data, ip, entry->ip.len); |
| bcopy(&entry->ea, &ea, ETHER_ADDR_LEN); |
| entry = entry->next; |
| bcm_l2_filter_parp_delentry(osh, ptable, &ea, ip, ip_ver, TRUE); |
| } |
| else { |
| entry = entry->next; |
| } |
| } |
| } |
| |
| /* remove candidate or promote to real entry */ |
| prev = delentry = NULL; |
| entry = ptable->parp_candidate_list; |
| while (entry) { |
| /* remove candidate */ |
| if (all || (periodic && BCM_PARP_ANNOUNCE_WAIT_REACH(tickcnt, entry)) || |
| (del_ea != NULL && !bcmp(del_ea, (uint8 *)&entry->ea, ETHER_ADDR_LEN))) { |
| bool promote = (periodic && BCM_PARP_ANNOUNCE_WAIT_REACH(tickcnt, entry)) ? |
| TRUE: FALSE; |
| parp_entry_t *node = NULL; |
| |
| ip_ver = entry->ip.id; |
| |
| if (prev == NULL) |
| ptable->parp_candidate_list = entry->next; |
| else |
| prev->next = entry->next; |
| |
| node = bcm_l2_filter_parp_findentry(ptable, |
| entry->ip.data, IP_VER_6, TRUE, tickcnt); |
| if (promote && node == NULL) { |
| bcm_l2_filter_parp_addentry(osh, ptable, &entry->ea, |
| entry->ip.data, entry->ip.id, TRUE, tickcnt); |
| } |
| MFREE(osh, entry, sizeof(parp_entry_t) + entry->ip.len); |
| if (prev == NULL) { |
| entry = ptable->parp_candidate_list; |
| } else { |
| entry = prev->next; |
| } |
| } |
| else { |
| prev = entry; |
| entry = entry->next; |
| } |
| } |
| } |
| /* create 42 byte ARP packet for ARP response, aligned the Buffer */ |
| void * |
| bcm_l2_filter_proxyarp_alloc_reply(osl_t* osh, uint16 pktlen, struct ether_addr *src_ea, |
| struct ether_addr *dst_ea, uint16 ea_type, bool snap, void **p) |
| { |
| void *pkt; |
| uint8 *frame; |
| |
| /* adjust pktlen since skb->data is aligned to 2 */ |
| pktlen += ALIGN_ADJ_BUFLEN; |
| |
| if ((pkt = PKTGET(osh, pktlen, FALSE)) == NULL) { |
| L2_FILTER_ERROR(("bcm_l2_filter_proxyarp_alloc_reply: PKTGET failed\n")); |
| return NULL; |
| } |
| /* adjust for pkt->data aligned */ |
| PKTPULL(osh, pkt, ALIGN_ADJ_BUFLEN); |
| frame = PKTDATA(osh, pkt); |
| |
| /* Create 14-byte eth header, plus snap header if applicable */ |
| bcopy(src_ea, frame + ETHER_SRC_OFFSET, ETHER_ADDR_LEN); |
| bcopy(dst_ea, frame + ETHER_DEST_OFFSET, ETHER_ADDR_LEN); |
| if (snap) { |
| hton16_ua_store(pktlen, frame + ETHER_TYPE_OFFSET); |
| bcopy(llc_snap_hdr, frame + ETHER_HDR_LEN, SNAP_HDR_LEN); |
| hton16_ua_store(ea_type, frame + ETHER_HDR_LEN + SNAP_HDR_LEN); |
| } else |
| hton16_ua_store(ea_type, frame + ETHER_TYPE_OFFSET); |
| |
| *p = (void *)(frame + ETHER_HDR_LEN + (snap ? SNAP_HDR_LEN + ETHER_TYPE_LEN : 0)); |
| return pkt; |
| } |
| /* copy the smac entry from parp_table */ |
| void bcm_l2_filter_parp_get_smac(arp_table_t* ptable, void* smac) |
| { |
| bcopy(ptable->parp_smac, smac, ETHER_ADDR_LEN); |
| } |
| /* copy the cmac entry from parp_table */ |
| void bcm_l2_filter_parp_get_cmac(arp_table_t* ptable, void* cmac) |
| { |
| bcopy(ptable->parp_cmac, cmac, ETHER_ADDR_LEN); |
| } |
| /* copy the smac entry to smac entry in parp_table */ |
| void bcm_l2_filter_parp_set_smac(arp_table_t* ptable, void* smac) |
| { |
| bcopy(smac, ptable->parp_smac, ETHER_ADDR_LEN); |
| } |
| /* copy the cmac entry to cmac entry in parp_table */ |
| void bcm_l2_filter_parp_set_cmac(arp_table_t* ptable, void* cmac) |
| { |
| bcopy(cmac, ptable->parp_cmac, ETHER_ADDR_LEN); |
| } |
| |
| uint16 |
| calc_checksum(uint8 *src_ipa, uint8 *dst_ipa, uint32 ul_len, uint8 prot, uint8 *ul_data) |
| { |
| uint16 *startpos; |
| uint32 sum = 0; |
| int i; |
| uint16 answer = 0; |
| |
| if (src_ipa) { |
| uint8 ph[8] = {0, }; |
| for (i = 0; i < (IPV6_ADDR_LEN / 2); i++) { |
| sum += *((uint16 *)src_ipa); |
| src_ipa += 2; |
| } |
| |
| for (i = 0; i < (IPV6_ADDR_LEN / 2); i++) { |
| sum += *((uint16 *)dst_ipa); |
| dst_ipa += 2; |
| } |
| |
| *((uint32 *)ph) = hton32(ul_len); |
| *((uint32 *)(ph+4)) = 0; |
| ph[7] = prot; |
| startpos = (uint16 *)ph; |
| for (i = 0; i < 4; i++) { |
| sum += *startpos++; |
| } |
| } |
| |
| startpos = (uint16 *)ul_data; |
| while (ul_len > 1) { |
| sum += *startpos++; |
| ul_len -= 2; |
| } |
| |
| if (ul_len == 1) { |
| *((uint8 *)(&answer)) = *((uint8 *)startpos); |
| sum += answer; |
| } |
| |
| sum = (sum >> 16) + (sum & 0xffff); |
| sum += (sum >> 16); |
| answer = ~sum; |
| |
| return answer; |
| } |
| /* |
| * The length of the option including |
| * the type and length fields in units of 8 octets |
| */ |
| bcm_tlv_t * |
| parse_nd_options(void *buf, int buflen, uint key) |
| { |
| bcm_tlv_t *elt; |
| int totlen; |
| |
| elt = (bcm_tlv_t*)buf; |
| totlen = buflen; |
| |
| /* find tagged parameter */ |
| while (totlen >= TLV_HDR_LEN) { |
| int len = elt->len * 8; |
| |
| /* validate remaining totlen */ |
| if ((elt->id == key) && |
| (totlen >= len)) |
| return (elt); |
| |
| elt = (bcm_tlv_t*)((uint8*)elt + len); |
| totlen -= len; |
| } |
| |
| return NULL; |
| } |
| |
| /* returns 0 if tdls set up request or tdls discovery request */ |
| int |
| bcm_l2_filter_block_tdls(osl_t *osh, void *pktbuf) |
| { |
| uint16 ethertype; |
| uint8 *data; |
| int datalen; |
| bool snap; |
| uint8 action_field; |
| |
| if (get_pkt_ether_type(osh, pktbuf, &data, &datalen, ðertype, &snap) != BCME_OK) |
| return BCME_ERROR; |
| |
| if (ethertype != ETHER_TYPE_89_0D) |
| return BCME_ERROR; |
| |
| /* validate payload type */ |
| if (datalen < TDLS_PAYLOAD_TYPE_LEN + 2) { |
| L2_FILTER_ERROR(("bcm_l2_filter_block_tdls: wrong length for 89-0d eth frame %d\n", |
| datalen)); |
| return BCME_ERROR; |
| } |
| |
| /* validate payload type */ |
| if (*data != TDLS_PAYLOAD_TYPE) { |
| L2_FILTER_ERROR(("bcm_l2_filter_block_tdls: wrong payload type for 89-0d" |
| " eth frame %d\n", |
| *data)); |
| return BCME_ERROR; |
| } |
| data += TDLS_PAYLOAD_TYPE_LEN; |
| |
| /* validate TDLS action category */ |
| if (*data != TDLS_ACTION_CATEGORY_CODE) { |
| L2_FILTER_ERROR(("bcm_l2_filter_block_tdls: wrong TDLS Category %d\n", *data)); |
| return BCME_ERROR; |
| } |
| data++; |
| |
| action_field = *data; |
| |
| if ((action_field == TDLS_SETUP_REQ) || (action_field == TDLS_DISCOVERY_REQ)) |
| return BCME_OK; |
| |
| return BCME_ERROR; |
| } |