tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[SK_BUFF]: Introduce skb_mac_header()

For the places where we need a pointer to the mac header, it is still legal to
touch skb->mac.raw directly if just adding to, subtracting from or setting it
to another layer header.

This one also converts some more cases to skb_reset_mac_header() that my
regex missed as it had no spaces before nor after '=', ugh.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Arnaldo Carvalho de Melo and committed by
David S. Miller 98e399f8 31713c33

+108 -88
+1 -1
arch/um/drivers/daemon_kern.c
··· 46 46 { 47 47 *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER); 48 48 if(*skb == NULL) return(-ENOMEM); 49 - return(net_recvfrom(fd, (*skb)->mac.raw, 49 + return(net_recvfrom(fd, skb_mac_header(*skb), 50 50 (*skb)->dev->mtu + ETH_HEADER_OTHER)); 51 51 } 52 52
+1 -1
arch/um/drivers/mcast_kern.c
··· 50 50 { 51 51 *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER); 52 52 if(*skb == NULL) return(-ENOMEM); 53 - return(net_recvfrom(fd, (*skb)->mac.raw, 53 + return(net_recvfrom(fd, skb_mac_header(*skb), 54 54 (*skb)->dev->mtu + ETH_HEADER_OTHER)); 55 55 } 56 56
+1 -1
arch/um/drivers/pcap_kern.c
··· 36 36 { 37 37 *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER); 38 38 if(*skb == NULL) return(-ENOMEM); 39 - return(pcap_user_read(fd, (*skb)->mac.raw, 39 + return(pcap_user_read(fd, skb_mac_header(*skb), 40 40 (*skb)->dev->mtu + ETH_HEADER_OTHER, 41 41 (struct pcap_data *) &lp->user)); 42 42 }
+1 -1
arch/um/drivers/slip_kern.c
··· 49 49 static int slip_read(int fd, struct sk_buff **skb, 50 50 struct uml_net_private *lp) 51 51 { 52 - return(slip_user_read(fd, (*skb)->mac.raw, (*skb)->dev->mtu, 52 + return(slip_user_read(fd, skb_mac_header(*skb), (*skb)->dev->mtu, 53 53 (struct slip_data *) &lp->user)); 54 54 } 55 55
+1 -1
arch/um/drivers/slirp_kern.c
··· 53 53 static int slirp_read(int fd, struct sk_buff **skb, 54 54 struct uml_net_private *lp) 55 55 { 56 - return(slirp_user_read(fd, (*skb)->mac.raw, (*skb)->dev->mtu, 56 + return(slirp_user_read(fd, skb_mac_header(*skb), (*skb)->dev->mtu, 57 57 (struct slirp_data *) &lp->user)); 58 58 } 59 59
+1 -1
arch/um/os-Linux/drivers/ethertap_kern.c
··· 43 43 44 44 *skb = ether_adjust_skb(*skb, ETH_HEADER_ETHERTAP); 45 45 if(*skb == NULL) return(-ENOMEM); 46 - len = net_recvfrom(fd, (*skb)->mac.raw, 46 + len = net_recvfrom(fd, skb_mac_header(*skb), 47 47 (*skb)->dev->mtu + 2 * ETH_HEADER_ETHERTAP); 48 48 if(len <= 0) return(len); 49 49 skb_pull(*skb, 2);
+1 -1
arch/um/os-Linux/drivers/tuntap_kern.c
··· 43 43 { 44 44 *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER); 45 45 if(*skb == NULL) return(-ENOMEM); 46 - return(net_read(fd, (*skb)->mac.raw, 46 + return(net_read(fd, skb_mac_header(*skb), 47 47 (*skb)->dev->mtu + ETH_HEADER_OTHER)); 48 48 } 49 49
+1 -1
drivers/block/aoe/aoe.h
··· 53 53 54 54 static inline struct aoe_hdr *aoe_hdr(const struct sk_buff *skb) 55 55 { 56 - return (struct aoe_hdr *)skb->mac.raw; 56 + return (struct aoe_hdr *)skb_mac_header(skb); 57 57 } 58 58 #endif 59 59
+1 -1
drivers/ieee1394/eth1394.h
··· 90 90 91 91 static inline struct eth1394hdr *eth1394_hdr(const struct sk_buff *skb) 92 92 { 93 - return (struct eth1394hdr *)skb->mac.raw; 93 + return (struct eth1394hdr *)skb_mac_header(skb); 94 94 } 95 95 #endif 96 96
+1 -1
drivers/media/dvb/dvb-core/dvb_net.c
··· 174 174 struct ethhdr *eth; 175 175 unsigned char *rawp; 176 176 177 - skb->mac.raw=skb->data; 177 + skb_reset_mac_header(skb); 178 178 skb_pull(skb,dev->hard_header_len); 179 179 eth = eth_hdr(skb); 180 180
+14 -12
drivers/message/fusion/mptlan.c
··· 714 714 LANSendRequest_t *pSendReq; 715 715 SGETransaction32_t *pTrans; 716 716 SGESimple64_t *pSimple; 717 + const unsigned char *mac; 717 718 dma_addr_t dma; 718 719 unsigned long flags; 719 720 int ctx; ··· 785 784 // IOC_AND_NETDEV_NAMES_s_s(dev), 786 785 // ctx, skb, skb->data)); 787 786 787 + mac = skb_mac_header(skb); 788 788 #ifdef QLOGIC_NAA_WORKAROUND 789 789 { 790 790 struct NAA_Hosed *nh; ··· 795 793 drops. */ 796 794 read_lock_irq(&bad_naa_lock); 797 795 for (nh = mpt_bad_naa; nh != NULL; nh=nh->next) { 798 - if ((nh->ieee[0] == skb->mac.raw[0]) && 799 - (nh->ieee[1] == skb->mac.raw[1]) && 800 - (nh->ieee[2] == skb->mac.raw[2]) && 801 - (nh->ieee[3] == skb->mac.raw[3]) && 802 - (nh->ieee[4] == skb->mac.raw[4]) && 803 - (nh->ieee[5] == skb->mac.raw[5])) { 796 + if ((nh->ieee[0] == mac[0]) && 797 + (nh->ieee[1] == mac[1]) && 798 + (nh->ieee[2] == mac[2]) && 799 + (nh->ieee[3] == mac[3]) && 800 + (nh->ieee[4] == mac[4]) && 801 + (nh->ieee[5] == mac[5])) { 804 802 cur_naa = nh->NAA; 805 803 dlprintk ((KERN_INFO "mptlan/sdu_send: using NAA value " 806 804 "= %04x.\n", cur_naa)); ··· 812 810 #endif 813 811 814 812 pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa << 16) | 815 - (skb->mac.raw[0] << 8) | 816 - (skb->mac.raw[1] << 0)); 817 - pTrans->TransactionDetails[1] = cpu_to_le32((skb->mac.raw[2] << 24) | 818 - (skb->mac.raw[3] << 16) | 819 - (skb->mac.raw[4] << 8) | 820 - (skb->mac.raw[5] << 0)); 813 + (mac[0] << 8) | 814 + (mac[1] << 0)); 815 + pTrans->TransactionDetails[1] = cpu_to_le32((mac[2] << 24) | 816 + (mac[3] << 16) | 817 + (mac[4] << 8) | 818 + (mac[5] << 0)); 821 819 822 820 pSimple = (SGESimple64_t *) &pTrans->TransactionDetails[2]; 823 821
+2 -2
drivers/net/arcnet/capmode.c
··· 123 123 skb_put(skb, length + ARC_HDR_SIZE + sizeof(int)); 124 124 skb->dev = dev; 125 125 skb_reset_mac_header(skb); 126 - pkt = (struct archdr *)skb->mac.raw; 126 + pkt = (struct archdr *)skb_mac_header(skb); 127 127 skb_pull(skb, ARC_HDR_SIZE); 128 128 129 129 /* up to sizeof(pkt->soft) has already been copied from the card */ ··· 269 269 ackskb->dev = dev; 270 270 271 271 skb_reset_mac_header(ackskb); 272 - ackpkt = (struct archdr *)ackskb->mac.raw; 272 + ackpkt = (struct archdr *)skb_mac_header(ackskb); 273 273 /* skb_pull(ackskb, ARC_HDR_SIZE); */ 274 274 275 275
+1 -1
drivers/net/plip.c
··· 546 546 struct ethhdr *eth; 547 547 unsigned char *rawp; 548 548 549 - skb->mac.raw=skb->data; 549 + skb_reset_mac_header(skb); 550 550 skb_pull(skb,dev->hard_header_len); 551 551 eth = eth_hdr(skb); 552 552
+1 -1
drivers/net/slip.c
··· 363 363 } 364 364 skb->dev = sl->dev; 365 365 memcpy(skb_put(skb,count), sl->rbuff, count); 366 - skb->mac.raw=skb->data; 366 + skb_reset_mac_header(skb); 367 367 skb->protocol=htons(ETH_P_IP); 368 368 netif_rx(skb); 369 369 sl->dev->last_rx = jiffies;
+1 -1
drivers/net/wan/hostess_sv11.c
··· 59 59 /* Drop the CRC - it's not a good idea to try and negotiate it ;) */ 60 60 skb_trim(skb, skb->len-2); 61 61 skb->protocol=__constant_htons(ETH_P_WAN_PPP); 62 - skb->mac.raw=skb->data; 62 + skb_reset_mac_header(skb); 63 63 skb->dev=c->netdevice; 64 64 /* 65 65 * Send it to the PPP layer. We don't have time to process
+1 -1
drivers/net/wan/sealevel.c
··· 61 61 /* Drop the CRC - it's not a good idea to try and negotiate it ;) */ 62 62 skb_trim(skb, skb->len-2); 63 63 skb->protocol=htons(ETH_P_WAN_PPP); 64 - skb->mac.raw=skb->data; 64 + skb_reset_mac_header(skb); 65 65 skb->dev=c->netdevice; 66 66 /* 67 67 * Send it to the PPP layer. We don't have time to process
+1 -1
drivers/net/wan/syncppp.c
··· 227 227 unsigned long flags; 228 228 229 229 skb->dev=dev; 230 - skb->mac.raw=skb->data; 230 + skb_reset_mac_header(skb); 231 231 232 232 if (dev->flags & IFF_RUNNING) 233 233 {
+1 -1
drivers/net/wireless/airo.c
··· 2444 2444 2445 2445 static int wll_header_parse(struct sk_buff *skb, unsigned char *haddr) 2446 2446 { 2447 - memcpy(haddr, skb->mac.raw + 10, ETH_ALEN); 2447 + memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); 2448 2448 return ETH_ALEN; 2449 2449 } 2450 2450
+7 -7
drivers/net/wireless/hostap/hostap_main.c
··· 590 590 591 591 int hostap_80211_header_parse(struct sk_buff *skb, unsigned char *haddr) 592 592 { 593 - memcpy(haddr, skb->mac.raw + 10, ETH_ALEN); /* addr2 */ 593 + memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */ 594 594 return ETH_ALEN; 595 595 } 596 596 597 597 598 598 int hostap_80211_prism_header_parse(struct sk_buff *skb, unsigned char *haddr) 599 599 { 600 - if (*(u32 *)skb->mac.raw == LWNG_CAP_DID_BASE) { 601 - memcpy(haddr, skb->mac.raw + 602 - sizeof(struct linux_wlan_ng_prism_hdr) + 10, 600 + const unsigned char *mac = skb_mac_header(skb); 601 + 602 + if (*(u32 *)mac == LWNG_CAP_DID_BASE) { 603 + memcpy(haddr, mac + sizeof(struct linux_wlan_ng_prism_hdr) + 10, 603 604 ETH_ALEN); /* addr2 */ 604 - } else { /* (*(u32 *)skb->mac.raw == htonl(LWNG_CAPHDR_VERSION)) */ 605 - memcpy(haddr, skb->mac.raw + 606 - sizeof(struct linux_wlan_ng_cap_hdr) + 10, 605 + } else { /* (*(u32 *)mac == htonl(LWNG_CAPHDR_VERSION)) */ 606 + memcpy(haddr, mac + sizeof(struct linux_wlan_ng_cap_hdr) + 10, 607 607 ETH_ALEN); /* addr2 */ 608 608 } 609 609 return ETH_ALEN;
+1 -1
drivers/net/wireless/orinoco.c
··· 689 689 /* Note : gcc will optimise the whole section away if 690 690 * WIRELESS_SPY is not defined... - Jean II */ 691 691 if (SPY_NUMBER(priv)) { 692 - orinoco_spy_gather(dev, skb->mac.raw + ETH_ALEN, 692 + orinoco_spy_gather(dev, skb_mac_header(skb) + ETH_ALEN, 693 693 desc->signal, desc->silence); 694 694 } 695 695 }
+3 -2
drivers/net/wireless/wavelan.c
··· 2517 2517 skb->protocol = eth_type_trans(skb, dev); 2518 2518 2519 2519 #ifdef DEBUG_RX_INFO 2520 - wv_packet_info(skb->mac.raw, sksize, dev->name, "wv_packet_read"); 2520 + wv_packet_info(skb_mac_header(skb), sksize, dev->name, 2521 + "wv_packet_read"); 2521 2522 #endif /* DEBUG_RX_INFO */ 2522 2523 2523 2524 /* Statistics-gathering and associated stuff. ··· 2554 2553 2555 2554 /* Spying stuff */ 2556 2555 #ifdef IW_WIRELESS_SPY 2557 - wl_spy_gather(dev, skb->mac.raw + WAVELAN_ADDR_SIZE, 2556 + wl_spy_gather(dev, skb_mac_header(skb) + WAVELAN_ADDR_SIZE, 2558 2557 stats); 2559 2558 #endif /* IW_WIRELESS_SPY */ 2560 2559 #ifdef HISTOGRAM
+2 -2
drivers/net/wireless/wavelan_cs.c
··· 2889 2889 skb->protocol = eth_type_trans(skb, dev); 2890 2890 2891 2891 #ifdef DEBUG_RX_INFO 2892 - wv_packet_info(skb->mac.raw, sksize, dev->name, "wv_packet_read"); 2892 + wv_packet_info(skb_mac_header(skb), sksize, dev->name, "wv_packet_read"); 2893 2893 #endif /* DEBUG_RX_INFO */ 2894 2894 2895 2895 /* Statistics gathering & stuff associated. ··· 2923 2923 #endif /* WAVELAN_ROAMING */ 2924 2924 2925 2925 #ifdef WIRELESS_SPY 2926 - wl_spy_gather(dev, skb->mac.raw + WAVELAN_ADDR_SIZE, stats); 2926 + wl_spy_gather(dev, skb_mac_header(skb) + WAVELAN_ADDR_SIZE, stats); 2927 2927 #endif /* WIRELESS_SPY */ 2928 2928 #ifdef HISTOGRAM 2929 2929 wl_his_gather(dev, stats);
+1 -1
drivers/s390/net/claw.c
··· 3525 3525 memcpy(skb_put(skb,len_of_data), 3526 3526 privptr->p_mtc_envelope, 3527 3527 len_of_data); 3528 - skb->mac.raw=skb->data; 3529 3528 skb->dev=dev; 3529 + skb_reset_mac_header(skb); 3530 3530 skb->protocol=htons(ETH_P_IP); 3531 3531 skb->ip_summed=CHECKSUM_UNNECESSARY; 3532 3532 privptr->stats.rx_packets++;
+1 -1
include/linux/if_ether.h
··· 112 112 113 113 static inline struct ethhdr *eth_hdr(const struct sk_buff *skb) 114 114 { 115 - return (struct ethhdr *)skb->mac.raw; 115 + return (struct ethhdr *)skb_mac_header(skb); 116 116 } 117 117 118 118 #ifdef CONFIG_SYSCTL
+1 -1
include/linux/if_tr.h
··· 47 47 48 48 static inline struct trh_hdr *tr_hdr(const struct sk_buff *skb) 49 49 { 50 - return (struct trh_hdr *)skb->mac.raw; 50 + return (struct trh_hdr *)skb_mac_header(skb); 51 51 } 52 52 #ifdef CONFIG_SYSCTL 53 53 extern struct ctl_table tr_table[];
+1 -1
include/linux/if_vlan.h
··· 51 51 52 52 static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb) 53 53 { 54 - return (struct vlan_ethhdr *)skb->mac.raw; 54 + return (struct vlan_ethhdr *)skb_mac_header(skb); 55 55 } 56 56 57 57 struct vlan_hdr {
+1 -1
include/linux/netfilter_bridge/ebt_802_3.h
··· 54 54 55 55 static inline struct ebt_802_3_hdr *ebt_802_3_hdr(const struct sk_buff *skb) 56 56 { 57 - return (struct ebt_802_3_hdr *)skb->mac.raw; 57 + return (struct ebt_802_3_hdr *)skb_mac_header(skb); 58 58 } 59 59 #endif 60 60
+10
include/linux/skbuff.h
··· 960 960 skb->tail += len; 961 961 } 962 962 963 + static inline unsigned char *skb_mac_header(const struct sk_buff *skb) 964 + { 965 + return skb->mac.raw; 966 + } 967 + 968 + static inline int skb_mac_header_was_set(const struct sk_buff *skb) 969 + { 970 + return skb->mac.raw != NULL; 971 + } 972 + 963 973 static inline void skb_reset_mac_header(struct sk_buff *skb) 964 974 { 965 975 skb->mac.raw = skb->data;
+1 -1
net/802/hippi.c
··· 132 132 */ 133 133 skb->dev = dev; 134 134 skb_reset_mac_header(skb); 135 - hip = (struct hippi_hdr *)skb->mac.raw; 135 + hip = (struct hippi_hdr *)skb_mac_header(skb); 136 136 skb_pull(skb, HIPPI_HLEN); 137 137 138 138 /*
+3 -3
net/appletalk/ddp.c
··· 1484 1484 struct packet_type *pt, struct net_device *orig_dev) 1485 1485 { 1486 1486 /* Expand any short form frames */ 1487 - if (skb->mac.raw[2] == 1) { 1487 + if (skb_mac_header(skb)[2] == 1) { 1488 1488 struct ddpehdr *ddp; 1489 1489 /* Find our address */ 1490 1490 struct atalk_addr *ap = atalk_find_dev_addr(dev); ··· 1510 1510 * we write the network numbers ! 1511 1511 */ 1512 1512 1513 - ddp->deh_dnode = skb->mac.raw[0]; /* From physical header */ 1514 - ddp->deh_snode = skb->mac.raw[1]; /* From physical header */ 1513 + ddp->deh_dnode = skb_mac_header(skb)[0]; /* From physical header */ 1514 + ddp->deh_snode = skb_mac_header(skb)[1]; /* From physical header */ 1515 1515 1516 1516 ddp->deh_dnet = ap->s_net; /* Network number */ 1517 1517 ddp->deh_snet = ap->s_net;
+3 -2
net/ax25/af_ax25.c
··· 1645 1645 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name; 1646 1646 ax25_digi digi; 1647 1647 ax25_address src; 1648 + const unsigned char *mac = skb_mac_header(skb); 1648 1649 1649 - ax25_addr_parse(skb->mac.raw+1, skb->data-skb->mac.raw-1, &src, NULL, &digi, NULL, NULL); 1650 - 1650 + ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL, 1651 + &digi, NULL, NULL); 1651 1652 sax->sax25_family = AF_AX25; 1652 1653 /* We set this correctly, even though we may not let the 1653 1654 application know the digi calls further down (because it
+7 -4
net/bluetooth/bnep/core.c
··· 364 364 365 365 case BNEP_COMPRESSED_SRC_ONLY: 366 366 memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN); 367 - memcpy(__skb_put(nskb, ETH_ALEN), skb->mac.raw, ETH_ALEN); 367 + memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), ETH_ALEN); 368 368 put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2)); 369 369 break; 370 370 371 371 case BNEP_COMPRESSED_DST_ONLY: 372 - memcpy(__skb_put(nskb, ETH_ALEN), skb->mac.raw, ETH_ALEN); 373 - memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source, ETH_ALEN + 2); 372 + memcpy(__skb_put(nskb, ETH_ALEN), skb_mac_header(skb), 373 + ETH_ALEN); 374 + memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source, 375 + ETH_ALEN + 2); 374 376 break; 375 377 376 378 case BNEP_GENERAL: 377 - memcpy(__skb_put(nskb, ETH_ALEN * 2), skb->mac.raw, ETH_ALEN * 2); 379 + memcpy(__skb_put(nskb, ETH_ALEN * 2), skb_mac_header(skb), 380 + ETH_ALEN * 2); 378 381 put_unaligned(s->eh.h_proto, (__be16 *) __skb_put(nskb, 2)); 379 382 break; 380 383 }
+3 -2
net/bridge/br_netfilter.c
··· 753 753 #ifdef CONFIG_NETFILTER_DEBUG 754 754 /* Be very paranoid. This probably won't happen anymore, but let's 755 755 * keep the check just to be sure... */ 756 - if (skb->mac.raw < skb->head || skb->mac.raw + ETH_HLEN > skb->data) { 756 + if (skb_mac_header(skb) < skb->head || 757 + skb_mac_header(skb) + ETH_HLEN > skb->data) { 757 758 printk(KERN_CRIT "br_netfilter: Argh!! br_nf_post_routing: " 758 759 "bad mac.raw pointer.\n"); 759 760 goto print_error; ··· 809 808 if (realoutdev) 810 809 printk("[%s]", realoutdev->name); 811 810 } 812 - printk(" head:%p, raw:%p, data:%p\n", skb->head, skb->mac.raw, 811 + printk(" head:%p, raw:%p, data:%p\n", skb->head, skb_mac_header(skb), 813 812 skb->data); 814 813 dump_stack(); 815 814 return NF_ACCEPT;
+1 -1
net/core/dev.c
··· 1232 1232 } 1233 1233 rcu_read_unlock(); 1234 1234 1235 - __skb_push(skb, skb->data - skb->mac.raw); 1235 + __skb_push(skb, skb->data - skb_mac_header(skb)); 1236 1236 1237 1237 return segs; 1238 1238 }
+1 -1
net/core/filter.c
··· 44 44 if (k >= SKF_NET_OFF) 45 45 ptr = skb->nh.raw + k - SKF_NET_OFF; 46 46 else if (k >= SKF_LL_OFF) 47 - ptr = skb->mac.raw + k - SKF_LL_OFF; 47 + ptr = skb_mac_header(skb) + k - SKF_LL_OFF; 48 48 49 49 if (ptr >= skb->head && ptr < skb->tail) 50 50 return ptr;
+1 -1
net/core/skbuff.c
··· 1878 1878 struct sk_buff *segs = NULL; 1879 1879 struct sk_buff *tail = NULL; 1880 1880 unsigned int mss = skb_shinfo(skb)->gso_size; 1881 - unsigned int doffset = skb->data - skb->mac.raw; 1881 + unsigned int doffset = skb->data - skb_mac_header(skb); 1882 1882 unsigned int offset = doffset; 1883 1883 unsigned int headroom; 1884 1884 unsigned int len;
+2 -2
net/ipv4/netfilter/ipt_LOG.c
··· 399 399 /* MAC logging for input chain only. */ 400 400 printk("MAC="); 401 401 if (skb->dev && skb->dev->hard_header_len 402 - && skb->mac.raw != (void*)skb->nh.iph) { 402 + && skb->mac.raw != skb->nh.raw) { 403 403 int i; 404 - unsigned char *p = skb->mac.raw; 404 + const unsigned char *p = skb_mac_header(skb); 405 405 for (i = 0; i < skb->dev->hard_header_len; i++,p++) 406 406 printk("%02x%c", *p, 407 407 i==skb->dev->hard_header_len - 1
+2 -2
net/ipv4/netfilter/ipt_ULOG.c
··· 251 251 *(pm->prefix) = '\0'; 252 252 253 253 if (in && in->hard_header_len > 0 254 - && skb->mac.raw != (void *) skb->nh.iph 254 + && skb->mac.raw != skb->nh.raw 255 255 && in->hard_header_len <= ULOG_MAC_LEN) { 256 - memcpy(pm->mac, skb->mac.raw, in->hard_header_len); 256 + memcpy(pm->mac, skb_mac_header(skb), in->hard_header_len); 257 257 pm->mac_len = in->hard_header_len; 258 258 } else 259 259 pm->mac_len = 0;
+2 -2
net/ipv4/route.c
··· 1698 1698 printk(KERN_WARNING "martian source %u.%u.%u.%u from " 1699 1699 "%u.%u.%u.%u, on dev %s\n", 1700 1700 NIPQUAD(daddr), NIPQUAD(saddr), dev->name); 1701 - if (dev->hard_header_len && skb->mac.raw) { 1701 + if (dev->hard_header_len && skb_mac_header_was_set(skb)) { 1702 1702 int i; 1703 - unsigned char *p = skb->mac.raw; 1703 + const unsigned char *p = skb_mac_header(skb); 1704 1704 printk(KERN_WARNING "ll header: "); 1705 1705 for (i = 0; i < dev->hard_header_len; i++, p++) { 1706 1706 printk("%02x", *p);
+1 -1
net/ipv4/tcp_input.c
··· 3633 3633 if (!nskb) 3634 3634 return; 3635 3635 3636 - skb_set_mac_header(nskb, skb->mac.raw - skb->head); 3636 + skb_set_mac_header(nskb, skb_mac_header(skb) - skb->head); 3637 3637 nskb->nh.raw = nskb->data + (skb->nh.raw - skb->head); 3638 3638 nskb->h.raw = nskb->data + (skb->h.raw - skb->head); 3639 3639
+2 -2
net/ipv4/xfrm4_mode_tunnel.c
··· 126 126 skb->protocol = htons(ETH_P_IPV6); 127 127 } 128 128 #endif 129 - old_mac = skb->mac.raw; 129 + old_mac = skb_mac_header(skb); 130 130 skb_set_mac_header(skb, -skb->mac_len); 131 - memmove(skb->mac.raw, old_mac, skb->mac_len); 131 + memmove(skb_mac_header(skb), old_mac, skb->mac_len); 132 132 skb->nh.raw = skb->data; 133 133 err = 0; 134 134
+2 -1
net/ipv6/ndisc.c
··· 828 828 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) { 829 829 if (dad) { 830 830 if (dev->type == ARPHRD_IEEE802_TR) { 831 - unsigned char *sadr = skb->mac.raw; 831 + const unsigned char *sadr; 832 + sadr = skb_mac_header(skb); 832 833 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 && 833 834 sadr[9] == dev->dev_addr[1] && 834 835 sadr[10] == dev->dev_addr[2] &&
+3 -2
net/ipv6/netfilter/ip6t_LOG.c
··· 397 397 printk("MAC="); 398 398 if (skb->dev && (len = skb->dev->hard_header_len) && 399 399 skb->mac.raw != skb->nh.raw) { 400 - unsigned char *p = skb->mac.raw; 400 + const unsigned char *p = skb_mac_header(skb); 401 401 int i; 402 402 403 403 if (skb->dev->type == ARPHRD_SIT && ··· 412 412 printk(" "); 413 413 414 414 if (skb->dev->type == ARPHRD_SIT) { 415 - struct iphdr *iph = (struct iphdr *)skb->mac.raw; 415 + const struct iphdr *iph = 416 + (struct iphdr *)skb_mac_header(skb); 416 417 printk("TUNNEL=%u.%u.%u.%u->%u.%u.%u.%u ", 417 418 NIPQUAD(iph->saddr), 418 419 NIPQUAD(iph->daddr));
+2 -2
net/ipv6/netfilter/ip6t_eui64.c
··· 32 32 unsigned char eui64[8]; 33 33 int i = 0; 34 34 35 - if (!(skb->mac.raw >= skb->head && 36 - (skb->mac.raw + ETH_HLEN) <= skb->data) && 35 + if (!(skb_mac_header(skb) >= skb->head && 36 + (skb_mac_header(skb) + ETH_HLEN) <= skb->data) && 37 37 offset != 0) { 38 38 *hotdrop = 1; 39 39 return 0;
+2 -2
net/ipv6/xfrm6_mode_beet.c
··· 70 70 memmove(skb->data, skb->nh.raw, size); 71 71 skb->nh.raw = skb->data; 72 72 73 - old_mac = skb->mac.raw; 73 + old_mac = skb_mac_header(skb); 74 74 skb_set_mac_header(skb, -skb->mac_len); 75 - memmove(skb->mac.raw, old_mac, skb->mac_len); 75 + memmove(skb_mac_header(skb), old_mac, skb->mac_len); 76 76 77 77 ip6h = skb->nh.ipv6h; 78 78 ip6h->payload_len = htons(skb->len - size);
+2 -2
net/ipv6/xfrm6_mode_tunnel.c
··· 108 108 ip6ip_ecn_decapsulate(skb); 109 109 skb->protocol = htons(ETH_P_IP); 110 110 } 111 - old_mac = skb->mac.raw; 111 + old_mac = skb_mac_header(skb); 112 112 skb_set_mac_header(skb, -skb->mac_len); 113 - memmove(skb->mac.raw, old_mac, skb->mac_len); 113 + memmove(skb_mac_header(skb), old_mac, skb->mac_len); 114 114 skb->nh.raw = skb->data; 115 115 err = 0; 116 116
+2 -2
net/netfilter/xt_mac.c
··· 37 37 const struct xt_mac_info *info = matchinfo; 38 38 39 39 /* Is mac pointer valid? */ 40 - return (skb->mac.raw >= skb->head 41 - && (skb->mac.raw + ETH_HLEN) <= skb->data 40 + return (skb_mac_header(skb) >= skb->head && 41 + (skb_mac_header(skb) + ETH_HLEN) <= skb->data 42 42 /* If so, compare... */ 43 43 && ((!compare_ether_addr(eth_hdr(skb)->h_source, info->srcaddr)) 44 44 ^ info->invert));
+4 -4
net/packet/af_packet.c
··· 284 284 * Incoming packets have ll header pulled, 285 285 * push it back. 286 286 * 287 - * For outgoing ones skb->data == skb->mac.raw 287 + * For outgoing ones skb->data == skb_mac_header(skb) 288 288 * so that this procedure is noop. 289 289 */ 290 290 ··· 303 303 304 304 spkt = &PACKET_SKB_CB(skb)->sa.pkt; 305 305 306 - skb_push(skb, skb->data-skb->mac.raw); 306 + skb_push(skb, skb->data - skb_mac_header(skb)); 307 307 308 308 /* 309 309 * The SOCK_PACKET socket receives _all_ frames. ··· 488 488 never delivered to user. 489 489 */ 490 490 if (sk->sk_type != SOCK_DGRAM) 491 - skb_push(skb, skb->data - skb->mac.raw); 491 + skb_push(skb, skb->data - skb_mac_header(skb)); 492 492 else if (skb->pkt_type == PACKET_OUTGOING) { 493 493 /* Special case: outgoing packets have ll header at head */ 494 494 skb_pull(skb, skb->nh.raw - skb->data); ··· 592 592 593 593 if (dev->hard_header) { 594 594 if (sk->sk_type != SOCK_DGRAM) 595 - skb_push(skb, skb->data - skb->mac.raw); 595 + skb_push(skb, skb->data - skb_mac_header(skb)); 596 596 else if (skb->pkt_type == PACKET_OUTGOING) { 597 597 /* Special case: outgoing packets have ll header at head */ 598 598 skb_pull(skb, skb->nh.raw - skb->data);
+2 -2
net/tipc/eth_media.c
··· 99 99 100 100 if (likely(eb_ptr->bearer)) { 101 101 if (likely(!dev->promiscuity) || 102 - !memcmp(buf->mac.raw,dev->dev_addr,ETH_ALEN) || 103 - !memcmp(buf->mac.raw,dev->broadcast,ETH_ALEN)) { 102 + !memcmp(skb_mac_header(buf), dev->dev_addr, ETH_ALEN) || 103 + !memcmp(skb_mac_header(buf), dev->broadcast, ETH_ALEN)) { 104 104 size = msg_size((struct tipc_msg *)buf->data); 105 105 skb_trim(buf, size); 106 106 if (likely(buf->len == size)) {