2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* VLAN An implementation of 802.1Q VLAN tagging.
|
|
|
|
*
|
|
|
|
* Authors: Ben Greear <greearb@candelatech.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#ifndef _LINUX_IF_VLAN_H_
|
|
|
|
#define _LINUX_IF_VLAN_H_
|
|
|
|
|
|
|
|
#include <linux/netdevice.h>
|
2006-07-14 23:34:22 +00:00
|
|
|
#include <linux/etherdevice.h>
|
2010-10-20 13:56:05 +00:00
|
|
|
#include <linux/rtnetlink.h>
|
2011-11-24 01:12:59 +00:00
|
|
|
#include <linux/bug.h>
|
2012-10-13 09:46:48 +00:00
|
|
|
#include <uapi/linux/if_vlan.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-03-18 17:37:56 +00:00
|
|
|
#define VLAN_HLEN 4 /* The additional bytes required by VLAN
|
|
|
|
* (in addition to the Ethernet header)
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
#define VLAN_ETH_HLEN 18 /* Total octets in header. */
|
|
|
|
#define VLAN_ETH_ZLEN 64 /* Min. octets in frame sans FCS */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* According to 802.3ac, the packet can be 4 bytes longer. --Klika Jan
|
|
|
|
*/
|
|
|
|
#define VLAN_ETH_DATA_LEN 1500 /* Max. octets in payload */
|
|
|
|
#define VLAN_ETH_FRAME_LEN 1518 /* Max. octets in frame sans FCS */
|
|
|
|
|
2008-01-21 08:18:53 +00:00
|
|
|
/*
|
|
|
|
* struct vlan_hdr - vlan header
|
|
|
|
* @h_vlan_TCI: priority and VLAN ID
|
|
|
|
* @h_vlan_encapsulated_proto: packet type ID or len
|
|
|
|
*/
|
|
|
|
struct vlan_hdr {
|
|
|
|
__be16 h_vlan_TCI;
|
|
|
|
__be16 h_vlan_encapsulated_proto;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct vlan_ethhdr - vlan ethernet header (ethhdr + vlan_hdr)
|
|
|
|
* @h_dest: destination ethernet address
|
|
|
|
* @h_source: source ethernet address
|
|
|
|
* @h_vlan_proto: ethernet protocol (always 0x8100)
|
|
|
|
* @h_vlan_TCI: priority and VLAN ID
|
|
|
|
* @h_vlan_encapsulated_proto: packet type ID or len
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
struct vlan_ethhdr {
|
2008-01-21 08:18:53 +00:00
|
|
|
unsigned char h_dest[ETH_ALEN];
|
|
|
|
unsigned char h_source[ETH_ALEN];
|
|
|
|
__be16 h_vlan_proto;
|
|
|
|
__be16 h_vlan_TCI;
|
|
|
|
__be16 h_vlan_encapsulated_proto;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
|
|
|
|
static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb)
|
|
|
|
{
|
2007-03-19 22:33:04 +00:00
|
|
|
return (struct vlan_ethhdr *)skb_mac_header(skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-10-27 01:40:35 +00:00
|
|
|
#define VLAN_PRIO_MASK 0xe000 /* Priority Code Point */
|
|
|
|
#define VLAN_PRIO_SHIFT 13
|
|
|
|
#define VLAN_CFI_MASK 0x1000 /* Canonical Format Indicator */
|
|
|
|
#define VLAN_TAG_PRESENT VLAN_CFI_MASK
|
|
|
|
#define VLAN_VID_MASK 0x0fff /* VLAN Identifier */
|
2010-10-20 13:56:02 +00:00
|
|
|
#define VLAN_N_VID 4096
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* found in socket.c */
|
2007-09-17 18:56:21 +00:00
|
|
|
extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-05-24 08:31:08 +00:00
|
|
|
static inline int is_vlan_dev(struct net_device *dev)
|
|
|
|
{
|
|
|
|
return dev->priv_flags & IFF_802_1Q_VLAN;
|
|
|
|
}
|
|
|
|
|
2009-10-27 01:40:35 +00:00
|
|
|
#define vlan_tx_tag_present(__skb) ((__skb)->vlan_tci & VLAN_TAG_PRESENT)
|
vlan: don't deliver frames for unknown vlans to protocols
6a32e4f9dd9219261f8856f817e6655114cfec2f made the vlan code skip marking
vlan-tagged frames for not locally configured vlans as PACKET_OTHERHOST if
there was an rx_handler, as the rx_handler could cause the frame to be received
on a different (virtual) vlan-capable interface where that vlan might be
configured.
As rx_handlers do not necessarily return RX_HANDLER_ANOTHER, this could cause
frames for unknown vlans to be delivered to the protocol stack as if they had
been received untagged.
For example, if an ipv6 router advertisement that's tagged for a locally not
configured vlan is received on an interface with macvlan interfaces attached,
macvlan's rx_handler returns RX_HANDLER_PASS after delivering the frame to the
macvlan interfaces, which caused it to be passed to the protocol stack, leading
to ipv6 addresses for the announced prefix being configured even though those
are completely unusable on the underlying interface.
The fix moves marking as PACKET_OTHERHOST after the rx_handler so the
rx_handler, if there is one, sees the frame unchanged, but afterwards,
before the frame is delivered to the protocol stack, it gets marked whether
there is an rx_handler or not.
Signed-off-by: Florian Zumbiehl <florz@florz.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-10-07 15:51:58 +00:00
|
|
|
#define vlan_tx_nonzero_tag_present(__skb) \
|
|
|
|
(vlan_tx_tag_present(__skb) && ((__skb)->vlan_tci & VLAN_VID_MASK))
|
2009-10-27 01:40:35 +00:00
|
|
|
#define vlan_tx_tag_get(__skb) ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-08 10:23:36 +00:00
|
|
|
#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
|
2010-10-20 13:56:05 +00:00
|
|
|
|
2011-07-20 04:54:05 +00:00
|
|
|
extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev,
|
2013-04-19 02:04:29 +00:00
|
|
|
__be16 vlan_proto, u16 vlan_id);
|
2008-07-08 10:23:57 +00:00
|
|
|
extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
|
|
|
|
extern u16 vlan_dev_vlan_id(const struct net_device *dev);
|
|
|
|
|
vlan: don't deliver frames for unknown vlans to protocols
6a32e4f9dd9219261f8856f817e6655114cfec2f made the vlan code skip marking
vlan-tagged frames for not locally configured vlans as PACKET_OTHERHOST if
there was an rx_handler, as the rx_handler could cause the frame to be received
on a different (virtual) vlan-capable interface where that vlan might be
configured.
As rx_handlers do not necessarily return RX_HANDLER_ANOTHER, this could cause
frames for unknown vlans to be delivered to the protocol stack as if they had
been received untagged.
For example, if an ipv6 router advertisement that's tagged for a locally not
configured vlan is received on an interface with macvlan interfaces attached,
macvlan's rx_handler returns RX_HANDLER_PASS after delivering the frame to the
macvlan interfaces, which caused it to be passed to the protocol stack, leading
to ipv6 addresses for the announced prefix being configured even though those
are completely unusable on the underlying interface.
The fix moves marking as PACKET_OTHERHOST after the rx_handler so the
rx_handler, if there is one, sees the frame unchanged, but afterwards,
before the frame is delivered to the protocol stack, it gets marked whether
there is an rx_handler or not.
Signed-off-by: Florian Zumbiehl <florz@florz.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-10-07 15:51:58 +00:00
|
|
|
extern bool vlan_do_receive(struct sk_buff **skb);
|
2011-04-07 19:48:33 +00:00
|
|
|
extern struct sk_buff *vlan_untag(struct sk_buff *skb);
|
2008-11-04 22:49:57 +00:00
|
|
|
|
2013-04-19 02:04:28 +00:00
|
|
|
extern int vlan_vid_add(struct net_device *dev, __be16 proto, u16 vid);
|
|
|
|
extern void vlan_vid_del(struct net_device *dev, __be16 proto, u16 vid);
|
2011-12-08 04:11:17 +00:00
|
|
|
|
2011-12-08 04:11:19 +00:00
|
|
|
extern int vlan_vids_add_by_dev(struct net_device *dev,
|
|
|
|
const struct net_device *by_dev);
|
|
|
|
extern void vlan_vids_del_by_dev(struct net_device *dev,
|
|
|
|
const struct net_device *by_dev);
|
2012-08-23 03:26:52 +00:00
|
|
|
|
|
|
|
extern bool vlan_uses_dev(const struct net_device *dev);
|
2008-07-08 10:23:36 +00:00
|
|
|
#else
|
2011-07-20 04:54:05 +00:00
|
|
|
static inline struct net_device *
|
|
|
|
__vlan_find_dev_deep(struct net_device *real_dev, u16 vlan_id)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-07-08 10:23:57 +00:00
|
|
|
static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u16 vlan_dev_vlan_id(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
vlan: don't deliver frames for unknown vlans to protocols
6a32e4f9dd9219261f8856f817e6655114cfec2f made the vlan code skip marking
vlan-tagged frames for not locally configured vlans as PACKET_OTHERHOST if
there was an rx_handler, as the rx_handler could cause the frame to be received
on a different (virtual) vlan-capable interface where that vlan might be
configured.
As rx_handlers do not necessarily return RX_HANDLER_ANOTHER, this could cause
frames for unknown vlans to be delivered to the protocol stack as if they had
been received untagged.
For example, if an ipv6 router advertisement that's tagged for a locally not
configured vlan is received on an interface with macvlan interfaces attached,
macvlan's rx_handler returns RX_HANDLER_PASS after delivering the frame to the
macvlan interfaces, which caused it to be passed to the protocol stack, leading
to ipv6 addresses for the announced prefix being configured even though those
are completely unusable on the underlying interface.
The fix moves marking as PACKET_OTHERHOST after the rx_handler so the
rx_handler, if there is one, sees the frame unchanged, but afterwards,
before the frame is delivered to the protocol stack, it gets marked whether
there is an rx_handler or not.
Signed-off-by: Florian Zumbiehl <florz@florz.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-10-07 15:51:58 +00:00
|
|
|
static inline bool vlan_do_receive(struct sk_buff **skb)
|
2008-11-04 22:49:57 +00:00
|
|
|
{
|
2010-10-20 13:56:06 +00:00
|
|
|
return false;
|
2008-11-04 22:49:57 +00:00
|
|
|
}
|
2009-01-06 18:50:09 +00:00
|
|
|
|
2011-04-13 02:27:51 +00:00
|
|
|
static inline struct sk_buff *vlan_untag(struct sk_buff *skb)
|
2011-04-07 19:48:33 +00:00
|
|
|
{
|
|
|
|
return skb;
|
|
|
|
}
|
2011-12-08 04:11:17 +00:00
|
|
|
|
|
|
|
static inline int vlan_vid_add(struct net_device *dev, unsigned short vid)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void vlan_vid_del(struct net_device *dev, unsigned short vid)
|
|
|
|
{
|
|
|
|
}
|
2011-12-08 04:11:19 +00:00
|
|
|
|
|
|
|
static inline int vlan_vids_add_by_dev(struct net_device *dev,
|
|
|
|
const struct net_device *by_dev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void vlan_vids_del_by_dev(struct net_device *dev,
|
|
|
|
const struct net_device *by_dev)
|
|
|
|
{
|
|
|
|
}
|
2012-08-23 03:26:52 +00:00
|
|
|
|
|
|
|
static inline bool vlan_uses_dev(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2008-07-08 10:23:36 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-04-19 02:04:30 +00:00
|
|
|
static inline bool vlan_hw_offload_capable(netdev_features_t features,
|
|
|
|
__be16 proto)
|
|
|
|
{
|
|
|
|
if (proto == htons(ETH_P_8021Q) && features & NETIF_F_HW_VLAN_CTAG_TX)
|
|
|
|
return true;
|
net: vlan: add 802.1ad support
Add support for 802.1ad VLAN devices. This mainly consists of checking for
ETH_P_8021AD in addition to ETH_P_8021Q in a couple of places and check
offloading capabilities based on the used protocol.
Configuration is done using "ip link":
# ip link add link eth0 eth0.1000 \
type vlan proto 802.1ad id 1000
# ip link add link eth0.1000 eth0.1000.1000 \
type vlan proto 802.1q id 1000
52:54:00:12:34:56 > 92:b1:54:28:e4:8c, ethertype 802.1Q (0x8100), length 106: vlan 1000, p 0, ethertype 802.1Q, vlan 1000, p 0, ethertype IPv4, (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto ICMP (1), length 84)
20.1.0.2 > 20.1.0.1: ICMP echo request, id 3003, seq 8, length 64
92:b1:54:28:e4:8c > 52:54:00:12:34:56, ethertype 802.1Q-QinQ (0x88a8), length 106: vlan 1000, p 0, ethertype 802.1Q, vlan 1000, p 0, ethertype IPv4, (tos 0x0, ttl 64, id 47944, offset 0, flags [none], proto ICMP (1), length 84)
20.1.0.1 > 20.1.0.2: ICMP echo reply, id 3003, seq 8, length 64
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-04-19 02:04:31 +00:00
|
|
|
if (proto == htons(ETH_P_8021AD) && features & NETIF_F_HW_VLAN_STAG_TX)
|
|
|
|
return true;
|
2013-04-19 02:04:30 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2011-06-10 06:56:58 +00:00
|
|
|
* vlan_insert_tag - regular VLAN tag inserting
|
2005-04-16 22:20:36 +00:00
|
|
|
* @skb: skbuff to tag
|
2013-04-19 02:04:30 +00:00
|
|
|
* @vlan_proto: VLAN encapsulation protocol
|
2008-07-08 10:24:44 +00:00
|
|
|
* @vlan_tci: VLAN TCI to insert
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Inserts the VLAN tag into @skb as part of the payload
|
|
|
|
* Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
|
2008-07-08 10:24:44 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Following the skb_unshare() example, in case of error, the calling function
|
|
|
|
* doesn't have to worry about freeing the original skb.
|
2011-06-10 06:56:58 +00:00
|
|
|
*
|
|
|
|
* Does not change skb->protocol so this function can be used during receive.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2013-04-19 02:04:30 +00:00
|
|
|
static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
|
|
|
|
__be16 vlan_proto, u16 vlan_tci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct vlan_ethhdr *veth;
|
|
|
|
|
2008-07-08 22:36:57 +00:00
|
|
|
if (skb_cow_head(skb, VLAN_HLEN) < 0) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
|
|
|
|
|
|
|
|
/* Move the mac addresses to the beginning of the new header. */
|
2012-03-18 17:37:56 +00:00
|
|
|
memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN);
|
2009-02-19 07:31:11 +00:00
|
|
|
skb->mac_header -= VLAN_HLEN;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* first, the ethernet type */
|
2013-04-19 02:04:30 +00:00
|
|
|
veth->h_vlan_proto = vlan_proto;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-08 10:24:44 +00:00
|
|
|
/* now, the TCI */
|
|
|
|
veth->h_vlan_TCI = htons(vlan_tci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-06-10 06:56:58 +00:00
|
|
|
return skb;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-06-10 06:56:58 +00:00
|
|
|
/**
|
|
|
|
* __vlan_put_tag - regular VLAN tag inserting
|
|
|
|
* @skb: skbuff to tag
|
|
|
|
* @vlan_tci: VLAN TCI to insert
|
|
|
|
*
|
|
|
|
* Inserts the VLAN tag into @skb as part of the payload
|
|
|
|
* Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
|
|
|
|
*
|
|
|
|
* Following the skb_unshare() example, in case of error, the calling function
|
|
|
|
* doesn't have to worry about freeing the original skb.
|
|
|
|
*/
|
2013-04-19 02:04:30 +00:00
|
|
|
static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb,
|
|
|
|
__be16 vlan_proto, u16 vlan_tci)
|
2011-06-10 06:56:58 +00:00
|
|
|
{
|
2013-04-19 02:04:30 +00:00
|
|
|
skb = vlan_insert_tag(skb, vlan_proto, vlan_tci);
|
2011-06-10 06:56:58 +00:00
|
|
|
if (skb)
|
2013-04-19 02:04:30 +00:00
|
|
|
skb->protocol = vlan_proto;
|
2005-04-16 22:20:36 +00:00
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
|
|
|
|
* @skb: skbuff to tag
|
2013-04-19 02:04:30 +00:00
|
|
|
* @vlan_proto: VLAN encapsulation protocol
|
2008-07-08 10:24:44 +00:00
|
|
|
* @vlan_tci: VLAN TCI to insert
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-07-15 05:49:06 +00:00
|
|
|
* Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-07-08 10:24:44 +00:00
|
|
|
static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb,
|
2013-04-19 02:04:30 +00:00
|
|
|
__be16 vlan_proto,
|
2008-07-08 10:24:44 +00:00
|
|
|
u16 vlan_tci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-04-19 02:04:30 +00:00
|
|
|
skb->vlan_proto = vlan_proto;
|
2009-10-27 01:40:35 +00:00
|
|
|
skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci;
|
2005-04-16 22:20:36 +00:00
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define HAVE_VLAN_PUT_TAG
|
|
|
|
|
|
|
|
/**
|
|
|
|
* vlan_put_tag - inserts VLAN tag according to device features
|
|
|
|
* @skb: skbuff to tag
|
2008-07-08 10:24:44 +00:00
|
|
|
* @vlan_tci: VLAN TCI to insert
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Assumes skb->dev is the target that will xmit this frame.
|
|
|
|
* Returns a VLAN tagged skb.
|
|
|
|
*/
|
2013-04-19 02:04:30 +00:00
|
|
|
static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb,
|
|
|
|
__be16 vlan_proto, u16 vlan_tci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-04-19 02:04:30 +00:00
|
|
|
if (vlan_hw_offload_capable(skb->dev->features, vlan_proto)) {
|
|
|
|
return __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2013-04-19 02:04:30 +00:00
|
|
|
return __vlan_put_tag(skb, vlan_proto, vlan_tci);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __vlan_get_tag - get the VLAN ID that is part of the payload
|
|
|
|
* @skb: skbuff to query
|
2008-07-08 10:24:44 +00:00
|
|
|
* @vlan_tci: buffer to store vlaue
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Returns error if the skb is not of VLAN type
|
|
|
|
*/
|
2008-07-08 10:24:44 +00:00
|
|
|
static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
|
|
|
|
|
net: vlan: add 802.1ad support
Add support for 802.1ad VLAN devices. This mainly consists of checking for
ETH_P_8021AD in addition to ETH_P_8021Q in a couple of places and check
offloading capabilities based on the used protocol.
Configuration is done using "ip link":
# ip link add link eth0 eth0.1000 \
type vlan proto 802.1ad id 1000
# ip link add link eth0.1000 eth0.1000.1000 \
type vlan proto 802.1q id 1000
52:54:00:12:34:56 > 92:b1:54:28:e4:8c, ethertype 802.1Q (0x8100), length 106: vlan 1000, p 0, ethertype 802.1Q, vlan 1000, p 0, ethertype IPv4, (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto ICMP (1), length 84)
20.1.0.2 > 20.1.0.1: ICMP echo request, id 3003, seq 8, length 64
92:b1:54:28:e4:8c > 52:54:00:12:34:56, ethertype 802.1Q-QinQ (0x88a8), length 106: vlan 1000, p 0, ethertype 802.1Q, vlan 1000, p 0, ethertype IPv4, (tos 0x0, ttl 64, id 47944, offset 0, flags [none], proto ICMP (1), length 84)
20.1.0.1 > 20.1.0.2: ICMP echo reply, id 3003, seq 8, length 64
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-04-19 02:04:31 +00:00
|
|
|
if (veth->h_vlan_proto != htons(ETH_P_8021Q) &&
|
|
|
|
veth->h_vlan_proto != htons(ETH_P_8021AD))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-07-08 10:24:44 +00:00
|
|
|
*vlan_tci = ntohs(veth->h_vlan_TCI);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
|
|
|
|
* @skb: skbuff to query
|
2008-07-08 10:24:44 +00:00
|
|
|
* @vlan_tci: buffer to store vlaue
|
|
|
|
*
|
2008-07-15 05:49:06 +00:00
|
|
|
* Returns error if @skb->vlan_tci is not set correctly
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-02-06 00:20:22 +00:00
|
|
|
static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
|
2008-07-08 10:24:44 +00:00
|
|
|
u16 *vlan_tci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-15 05:49:06 +00:00
|
|
|
if (vlan_tx_tag_present(skb)) {
|
2009-10-27 01:40:35 +00:00
|
|
|
*vlan_tci = vlan_tx_tag_get(skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
} else {
|
2008-07-08 10:24:44 +00:00
|
|
|
*vlan_tci = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define HAVE_VLAN_GET_TAG
|
|
|
|
|
|
|
|
/**
|
|
|
|
* vlan_get_tag - get the VLAN ID from the skb
|
|
|
|
* @skb: skbuff to query
|
2008-07-08 10:24:44 +00:00
|
|
|
* @vlan_tci: buffer to store vlaue
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Returns error if the skb is not VLAN tagged
|
|
|
|
*/
|
2008-07-08 10:24:44 +00:00
|
|
|
static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-04-19 02:04:27 +00:00
|
|
|
if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) {
|
2008-07-08 10:24:44 +00:00
|
|
|
return __vlan_hwaccel_get_tag(skb, vlan_tci);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2008-07-08 10:24:44 +00:00
|
|
|
return __vlan_get_tag(skb, vlan_tci);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-11 13:47:57 +00:00
|
|
|
/**
|
|
|
|
* vlan_get_protocol - get protocol EtherType.
|
|
|
|
* @skb: skbuff to query
|
|
|
|
*
|
|
|
|
* Returns the EtherType of the packet, regardless of whether it is
|
|
|
|
* vlan encapsulated (normal or hardware accelerated) or not.
|
|
|
|
*/
|
|
|
|
static inline __be16 vlan_get_protocol(const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
__be16 protocol = 0;
|
|
|
|
|
|
|
|
if (vlan_tx_tag_present(skb) ||
|
|
|
|
skb->protocol != cpu_to_be16(ETH_P_8021Q))
|
|
|
|
protocol = skb->protocol;
|
|
|
|
else {
|
|
|
|
__be16 proto, *protop;
|
|
|
|
protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr,
|
|
|
|
h_vlan_encapsulated_proto),
|
|
|
|
sizeof(proto), &proto);
|
|
|
|
if (likely(protop))
|
|
|
|
protocol = *protop;
|
|
|
|
}
|
|
|
|
|
|
|
|
return protocol;
|
|
|
|
}
|
2011-11-18 21:15:54 +00:00
|
|
|
|
|
|
|
static inline void vlan_set_encap_proto(struct sk_buff *skb,
|
|
|
|
struct vlan_hdr *vhdr)
|
|
|
|
{
|
|
|
|
__be16 proto;
|
2013-02-21 23:32:27 +00:00
|
|
|
unsigned short *rawp;
|
2011-11-18 21:15:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Was a VLAN packet, grab the encapsulated protocol, which the layer
|
|
|
|
* three protocols care about.
|
|
|
|
*/
|
|
|
|
|
|
|
|
proto = vhdr->h_vlan_encapsulated_proto;
|
2013-03-28 04:38:25 +00:00
|
|
|
if (ntohs(proto) >= ETH_P_802_3_MIN) {
|
2011-11-18 21:15:54 +00:00
|
|
|
skb->protocol = proto;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-02-21 23:32:27 +00:00
|
|
|
rawp = (unsigned short *)(vhdr + 1);
|
|
|
|
if (*rawp == 0xFFFF)
|
2011-11-18 21:15:54 +00:00
|
|
|
/*
|
|
|
|
* This is a magic hack to spot IPX packets. Older Novell
|
|
|
|
* breaks the protocol design and runs IPX over 802.3 without
|
|
|
|
* an 802.2 LLC layer. We look for FFFF which isn't a used
|
|
|
|
* 802.2 SSAP/DSAP. This won't work for fault tolerant netware
|
|
|
|
* but does for the rest.
|
|
|
|
*/
|
|
|
|
skb->protocol = htons(ETH_P_802_3);
|
|
|
|
else
|
|
|
|
/*
|
|
|
|
* Real 802.2 LLC
|
|
|
|
*/
|
|
|
|
skb->protocol = htons(ETH_P_802_2);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* !(_LINUX_IF_VLAN_H_) */
|