1 /* 2 * VLAN An implementation of 802.1Q VLAN tagging. 3 * 4 * Authors: Ben Greear <greearb@candelatech.com> 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 * 11 */ 12 #ifndef _LINUX_IF_VLAN_H_ 13 #define _LINUX_IF_VLAN_H_ 14 15 #include <linux/netdevice.h> 16 #include <linux/etherdevice.h> 17 #include <linux/rtnetlink.h> 18 #include <linux/bug.h> 19 #include <uapi/linux/if_vlan.h> 20 21 #define VLAN_HLEN 4 /* The additional bytes required by VLAN 22 * (in addition to the Ethernet header) 23 */ 24 #define VLAN_ETH_HLEN 18 /* Total octets in header. */ 25 #define VLAN_ETH_ZLEN 64 /* Min. octets in frame sans FCS */ 26 27 /* 28 * According to 802.3ac, the packet can be 4 bytes longer. --Klika Jan 29 */ 30 #define VLAN_ETH_DATA_LEN 1500 /* Max. octets in payload */ 31 #define VLAN_ETH_FRAME_LEN 1518 /* Max. octets in frame sans FCS */ 32 33 /* 34 * struct vlan_hdr - vlan header 35 * @h_vlan_TCI: priority and VLAN ID 36 * @h_vlan_encapsulated_proto: packet type ID or len 37 */ 38 struct vlan_hdr { 39 __be16 h_vlan_TCI; 40 __be16 h_vlan_encapsulated_proto; 41 }; 42 43 /** 44 * struct vlan_ethhdr - vlan ethernet header (ethhdr + vlan_hdr) 45 * @h_dest: destination ethernet address 46 * @h_source: source ethernet address 47 * @h_vlan_proto: ethernet protocol (always 0x8100) 48 * @h_vlan_TCI: priority and VLAN ID 49 * @h_vlan_encapsulated_proto: packet type ID or len 50 */ 51 struct vlan_ethhdr { 52 unsigned char h_dest[ETH_ALEN]; 53 unsigned char h_source[ETH_ALEN]; 54 __be16 h_vlan_proto; 55 __be16 h_vlan_TCI; 56 __be16 h_vlan_encapsulated_proto; 57 }; 58 59 #include <linux/skbuff.h> 60 61 static inline struct vlan_ethhdr *vlan_eth_hdr(const struct sk_buff *skb) 62 { 63 return (struct vlan_ethhdr *)skb_mac_header(skb); 64 } 65 66 #define VLAN_PRIO_MASK 0xe000 /* Priority Code Point */ 67 #define VLAN_PRIO_SHIFT 13 68 #define VLAN_CFI_MASK 0x1000 /* Canonical Format Indicator */ 69 #define VLAN_TAG_PRESENT VLAN_CFI_MASK 70 #define VLAN_VID_MASK 0x0fff /* VLAN Identifier */ 71 #define VLAN_N_VID 4096 72 73 /* found in socket.c */ 74 extern void vlan_ioctl_set(int (*hook)(struct net *, void __user *)); 75 76 static inline int is_vlan_dev(struct net_device *dev) 77 { 78 return dev->priv_flags & IFF_802_1Q_VLAN; 79 } 80 81 #define vlan_tx_tag_present(__skb) ((__skb)->vlan_tci & VLAN_TAG_PRESENT) 82 #define vlan_tx_nonzero_tag_present(__skb) \ 83 (vlan_tx_tag_present(__skb) && ((__skb)->vlan_tci & VLAN_VID_MASK)) 84 #define vlan_tx_tag_get(__skb) ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT) 85 86 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) 87 88 extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev, 89 u16 vlan_id); 90 extern struct net_device *vlan_dev_real_dev(const struct net_device *dev); 91 extern u16 vlan_dev_vlan_id(const struct net_device *dev); 92 93 extern bool vlan_do_receive(struct sk_buff **skb); 94 extern struct sk_buff *vlan_untag(struct sk_buff *skb); 95 96 extern int vlan_vid_add(struct net_device *dev, unsigned short vid); 97 extern void vlan_vid_del(struct net_device *dev, unsigned short vid); 98 99 extern int vlan_vids_add_by_dev(struct net_device *dev, 100 const struct net_device *by_dev); 101 extern void vlan_vids_del_by_dev(struct net_device *dev, 102 const struct net_device *by_dev); 103 104 extern bool vlan_uses_dev(const struct net_device *dev); 105 #else 106 static inline struct net_device * 107 __vlan_find_dev_deep(struct net_device *real_dev, u16 vlan_id) 108 { 109 return NULL; 110 } 111 112 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev) 113 { 114 BUG(); 115 return NULL; 116 } 117 118 static inline u16 vlan_dev_vlan_id(const struct net_device *dev) 119 { 120 BUG(); 121 return 0; 122 } 123 124 static inline bool vlan_do_receive(struct sk_buff **skb) 125 { 126 return false; 127 } 128 129 static inline struct sk_buff *vlan_untag(struct sk_buff *skb) 130 { 131 return skb; 132 } 133 134 static inline int vlan_vid_add(struct net_device *dev, unsigned short vid) 135 { 136 return 0; 137 } 138 139 static inline void vlan_vid_del(struct net_device *dev, unsigned short vid) 140 { 141 } 142 143 static inline int vlan_vids_add_by_dev(struct net_device *dev, 144 const struct net_device *by_dev) 145 { 146 return 0; 147 } 148 149 static inline void vlan_vids_del_by_dev(struct net_device *dev, 150 const struct net_device *by_dev) 151 { 152 } 153 154 static inline bool vlan_uses_dev(const struct net_device *dev) 155 { 156 return false; 157 } 158 #endif 159 160 /** 161 * vlan_insert_tag - regular VLAN tag inserting 162 * @skb: skbuff to tag 163 * @vlan_tci: VLAN TCI to insert 164 * 165 * Inserts the VLAN tag into @skb as part of the payload 166 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 167 * 168 * Following the skb_unshare() example, in case of error, the calling function 169 * doesn't have to worry about freeing the original skb. 170 * 171 * Does not change skb->protocol so this function can be used during receive. 172 */ 173 static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, u16 vlan_tci) 174 { 175 struct vlan_ethhdr *veth; 176 177 if (skb_cow_head(skb, VLAN_HLEN) < 0) { 178 kfree_skb(skb); 179 return NULL; 180 } 181 veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN); 182 183 /* Move the mac addresses to the beginning of the new header. */ 184 memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN); 185 skb->mac_header -= VLAN_HLEN; 186 187 /* first, the ethernet type */ 188 veth->h_vlan_proto = htons(ETH_P_8021Q); 189 190 /* now, the TCI */ 191 veth->h_vlan_TCI = htons(vlan_tci); 192 193 return skb; 194 } 195 196 /** 197 * __vlan_put_tag - regular VLAN tag inserting 198 * @skb: skbuff to tag 199 * @vlan_tci: VLAN TCI to insert 200 * 201 * Inserts the VLAN tag into @skb as part of the payload 202 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 203 * 204 * Following the skb_unshare() example, in case of error, the calling function 205 * doesn't have to worry about freeing the original skb. 206 */ 207 static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci) 208 { 209 skb = vlan_insert_tag(skb, vlan_tci); 210 if (skb) 211 skb->protocol = htons(ETH_P_8021Q); 212 return skb; 213 } 214 215 /** 216 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting 217 * @skb: skbuff to tag 218 * @vlan_tci: VLAN TCI to insert 219 * 220 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest 221 */ 222 static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb, 223 u16 vlan_tci) 224 { 225 skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci; 226 return skb; 227 } 228 229 #define HAVE_VLAN_PUT_TAG 230 231 /** 232 * vlan_put_tag - inserts VLAN tag according to device features 233 * @skb: skbuff to tag 234 * @vlan_tci: VLAN TCI to insert 235 * 236 * Assumes skb->dev is the target that will xmit this frame. 237 * Returns a VLAN tagged skb. 238 */ 239 static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, u16 vlan_tci) 240 { 241 if (skb->dev->features & NETIF_F_HW_VLAN_TX) { 242 return __vlan_hwaccel_put_tag(skb, vlan_tci); 243 } else { 244 return __vlan_put_tag(skb, vlan_tci); 245 } 246 } 247 248 /** 249 * __vlan_get_tag - get the VLAN ID that is part of the payload 250 * @skb: skbuff to query 251 * @vlan_tci: buffer to store vlaue 252 * 253 * Returns error if the skb is not of VLAN type 254 */ 255 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 256 { 257 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; 258 259 if (veth->h_vlan_proto != htons(ETH_P_8021Q)) { 260 return -EINVAL; 261 } 262 263 *vlan_tci = ntohs(veth->h_vlan_TCI); 264 return 0; 265 } 266 267 /** 268 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] 269 * @skb: skbuff to query 270 * @vlan_tci: buffer to store vlaue 271 * 272 * Returns error if @skb->vlan_tci is not set correctly 273 */ 274 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, 275 u16 *vlan_tci) 276 { 277 if (vlan_tx_tag_present(skb)) { 278 *vlan_tci = vlan_tx_tag_get(skb); 279 return 0; 280 } else { 281 *vlan_tci = 0; 282 return -EINVAL; 283 } 284 } 285 286 #define HAVE_VLAN_GET_TAG 287 288 /** 289 * vlan_get_tag - get the VLAN ID from the skb 290 * @skb: skbuff to query 291 * @vlan_tci: buffer to store vlaue 292 * 293 * Returns error if the skb is not VLAN tagged 294 */ 295 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 296 { 297 if (skb->dev->features & NETIF_F_HW_VLAN_TX) { 298 return __vlan_hwaccel_get_tag(skb, vlan_tci); 299 } else { 300 return __vlan_get_tag(skb, vlan_tci); 301 } 302 } 303 304 /** 305 * vlan_get_protocol - get protocol EtherType. 306 * @skb: skbuff to query 307 * 308 * Returns the EtherType of the packet, regardless of whether it is 309 * vlan encapsulated (normal or hardware accelerated) or not. 310 */ 311 static inline __be16 vlan_get_protocol(const struct sk_buff *skb) 312 { 313 __be16 protocol = 0; 314 315 if (vlan_tx_tag_present(skb) || 316 skb->protocol != cpu_to_be16(ETH_P_8021Q)) 317 protocol = skb->protocol; 318 else { 319 __be16 proto, *protop; 320 protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr, 321 h_vlan_encapsulated_proto), 322 sizeof(proto), &proto); 323 if (likely(protop)) 324 protocol = *protop; 325 } 326 327 return protocol; 328 } 329 330 static inline void vlan_set_encap_proto(struct sk_buff *skb, 331 struct vlan_hdr *vhdr) 332 { 333 __be16 proto; 334 unsigned char *rawp; 335 336 /* 337 * Was a VLAN packet, grab the encapsulated protocol, which the layer 338 * three protocols care about. 339 */ 340 341 proto = vhdr->h_vlan_encapsulated_proto; 342 if (ntohs(proto) >= 1536) { 343 skb->protocol = proto; 344 return; 345 } 346 347 rawp = skb->data; 348 if (*(unsigned short *) rawp == 0xFFFF) 349 /* 350 * This is a magic hack to spot IPX packets. Older Novell 351 * breaks the protocol design and runs IPX over 802.3 without 352 * an 802.2 LLC layer. We look for FFFF which isn't a used 353 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 354 * but does for the rest. 355 */ 356 skb->protocol = htons(ETH_P_802_3); 357 else 358 /* 359 * Real 802.2 LLC 360 */ 361 skb->protocol = htons(ETH_P_802_2); 362 } 363 #endif /* !(_LINUX_IF_VLAN_H_) */ 364