1 /* 2 * VLAN An implementation of 802.1Q VLAN tagging. 3 * 4 * Authors: Ben Greear <[email protected]> 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 13 #ifndef _LINUX_IF_VLAN_H_ 14 #define _LINUX_IF_VLAN_H_ 15 16 #ifdef __KERNEL__ 17 #include <linux/netdevice.h> 18 #include <linux/etherdevice.h> 19 #include <linux/rtnetlink.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 struct vlan_info; 77 78 static inline int is_vlan_dev(struct net_device *dev) 79 { 80 return dev->priv_flags & IFF_802_1Q_VLAN; 81 } 82 83 #define vlan_tx_tag_present(__skb) ((__skb)->vlan_tci & VLAN_TAG_PRESENT) 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, bool last_handler); 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 #else 104 static inline struct net_device * 105 __vlan_find_dev_deep(struct net_device *real_dev, u16 vlan_id) 106 { 107 return NULL; 108 } 109 110 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev) 111 { 112 BUG(); 113 return NULL; 114 } 115 116 static inline u16 vlan_dev_vlan_id(const struct net_device *dev) 117 { 118 BUG(); 119 return 0; 120 } 121 122 static inline bool vlan_do_receive(struct sk_buff **skb, bool last_handler) 123 { 124 if (((*skb)->vlan_tci & VLAN_VID_MASK) && last_handler) 125 (*skb)->pkt_type = PACKET_OTHERHOST; 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 #endif 154 155 /** 156 * vlan_insert_tag - regular VLAN tag inserting 157 * @skb: skbuff to tag 158 * @vlan_tci: VLAN TCI to insert 159 * 160 * Inserts the VLAN tag into @skb as part of the payload 161 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 162 * 163 * Following the skb_unshare() example, in case of error, the calling function 164 * doesn't have to worry about freeing the original skb. 165 * 166 * Does not change skb->protocol so this function can be used during receive. 167 */ 168 static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, u16 vlan_tci) 169 { 170 struct vlan_ethhdr *veth; 171 172 if (skb_cow_head(skb, VLAN_HLEN) < 0) { 173 kfree_skb(skb); 174 return NULL; 175 } 176 veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN); 177 178 /* Move the mac addresses to the beginning of the new header. */ 179 memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN); 180 skb->mac_header -= VLAN_HLEN; 181 182 /* first, the ethernet type */ 183 veth->h_vlan_proto = htons(ETH_P_8021Q); 184 185 /* now, the TCI */ 186 veth->h_vlan_TCI = htons(vlan_tci); 187 188 return skb; 189 } 190 191 /** 192 * __vlan_put_tag - regular VLAN tag inserting 193 * @skb: skbuff to tag 194 * @vlan_tci: VLAN TCI to insert 195 * 196 * Inserts the VLAN tag into @skb as part of the payload 197 * Returns a VLAN tagged skb. If a new skb is created, @skb is freed. 198 * 199 * Following the skb_unshare() example, in case of error, the calling function 200 * doesn't have to worry about freeing the original skb. 201 */ 202 static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci) 203 { 204 skb = vlan_insert_tag(skb, vlan_tci); 205 if (skb) 206 skb->protocol = htons(ETH_P_8021Q); 207 return skb; 208 } 209 210 /** 211 * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting 212 * @skb: skbuff to tag 213 * @vlan_tci: VLAN TCI to insert 214 * 215 * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest 216 */ 217 static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb, 218 u16 vlan_tci) 219 { 220 skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci; 221 return skb; 222 } 223 224 #define HAVE_VLAN_PUT_TAG 225 226 /** 227 * vlan_put_tag - inserts VLAN tag according to device features 228 * @skb: skbuff to tag 229 * @vlan_tci: VLAN TCI to insert 230 * 231 * Assumes skb->dev is the target that will xmit this frame. 232 * Returns a VLAN tagged skb. 233 */ 234 static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, u16 vlan_tci) 235 { 236 if (skb->dev->features & NETIF_F_HW_VLAN_TX) { 237 return __vlan_hwaccel_put_tag(skb, vlan_tci); 238 } else { 239 return __vlan_put_tag(skb, vlan_tci); 240 } 241 } 242 243 /** 244 * __vlan_get_tag - get the VLAN ID that is part of the payload 245 * @skb: skbuff to query 246 * @vlan_tci: buffer to store vlaue 247 * 248 * Returns error if the skb is not of VLAN type 249 */ 250 static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 251 { 252 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data; 253 254 if (veth->h_vlan_proto != htons(ETH_P_8021Q)) { 255 return -EINVAL; 256 } 257 258 *vlan_tci = ntohs(veth->h_vlan_TCI); 259 return 0; 260 } 261 262 /** 263 * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[] 264 * @skb: skbuff to query 265 * @vlan_tci: buffer to store vlaue 266 * 267 * Returns error if @skb->vlan_tci is not set correctly 268 */ 269 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb, 270 u16 *vlan_tci) 271 { 272 if (vlan_tx_tag_present(skb)) { 273 *vlan_tci = vlan_tx_tag_get(skb); 274 return 0; 275 } else { 276 *vlan_tci = 0; 277 return -EINVAL; 278 } 279 } 280 281 #define HAVE_VLAN_GET_TAG 282 283 /** 284 * vlan_get_tag - get the VLAN ID from the skb 285 * @skb: skbuff to query 286 * @vlan_tci: buffer to store vlaue 287 * 288 * Returns error if the skb is not VLAN tagged 289 */ 290 static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci) 291 { 292 if (skb->dev->features & NETIF_F_HW_VLAN_TX) { 293 return __vlan_hwaccel_get_tag(skb, vlan_tci); 294 } else { 295 return __vlan_get_tag(skb, vlan_tci); 296 } 297 } 298 299 /** 300 * vlan_get_protocol - get protocol EtherType. 301 * @skb: skbuff to query 302 * 303 * Returns the EtherType of the packet, regardless of whether it is 304 * vlan encapsulated (normal or hardware accelerated) or not. 305 */ 306 static inline __be16 vlan_get_protocol(const struct sk_buff *skb) 307 { 308 __be16 protocol = 0; 309 310 if (vlan_tx_tag_present(skb) || 311 skb->protocol != cpu_to_be16(ETH_P_8021Q)) 312 protocol = skb->protocol; 313 else { 314 __be16 proto, *protop; 315 protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr, 316 h_vlan_encapsulated_proto), 317 sizeof(proto), &proto); 318 if (likely(protop)) 319 protocol = *protop; 320 } 321 322 return protocol; 323 } 324 325 static inline void vlan_set_encap_proto(struct sk_buff *skb, 326 struct vlan_hdr *vhdr) 327 { 328 __be16 proto; 329 unsigned char *rawp; 330 331 /* 332 * Was a VLAN packet, grab the encapsulated protocol, which the layer 333 * three protocols care about. 334 */ 335 336 proto = vhdr->h_vlan_encapsulated_proto; 337 if (ntohs(proto) >= 1536) { 338 skb->protocol = proto; 339 return; 340 } 341 342 rawp = skb->data; 343 if (*(unsigned short *) rawp == 0xFFFF) 344 /* 345 * This is a magic hack to spot IPX packets. Older Novell 346 * breaks the protocol design and runs IPX over 802.3 without 347 * an 802.2 LLC layer. We look for FFFF which isn't a used 348 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 349 * but does for the rest. 350 */ 351 skb->protocol = htons(ETH_P_802_3); 352 else 353 /* 354 * Real 802.2 LLC 355 */ 356 skb->protocol = htons(ETH_P_802_2); 357 } 358 #endif /* __KERNEL__ */ 359 360 /* VLAN IOCTLs are found in sockios.h */ 361 362 /* Passed in vlan_ioctl_args structure to determine behaviour. */ 363 enum vlan_ioctl_cmds { 364 ADD_VLAN_CMD, 365 DEL_VLAN_CMD, 366 SET_VLAN_INGRESS_PRIORITY_CMD, 367 SET_VLAN_EGRESS_PRIORITY_CMD, 368 GET_VLAN_INGRESS_PRIORITY_CMD, 369 GET_VLAN_EGRESS_PRIORITY_CMD, 370 SET_VLAN_NAME_TYPE_CMD, 371 SET_VLAN_FLAG_CMD, 372 GET_VLAN_REALDEV_NAME_CMD, /* If this works, you know it's a VLAN device, btw */ 373 GET_VLAN_VID_CMD /* Get the VID of this VLAN (specified by name) */ 374 }; 375 376 enum vlan_flags { 377 VLAN_FLAG_REORDER_HDR = 0x1, 378 VLAN_FLAG_GVRP = 0x2, 379 VLAN_FLAG_LOOSE_BINDING = 0x4, 380 }; 381 382 enum vlan_name_types { 383 VLAN_NAME_TYPE_PLUS_VID, /* Name will look like: vlan0005 */ 384 VLAN_NAME_TYPE_RAW_PLUS_VID, /* name will look like: eth1.0005 */ 385 VLAN_NAME_TYPE_PLUS_VID_NO_PAD, /* Name will look like: vlan5 */ 386 VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD, /* Name will look like: eth0.5 */ 387 VLAN_NAME_TYPE_HIGHEST 388 }; 389 390 struct vlan_ioctl_args { 391 int cmd; /* Should be one of the vlan_ioctl_cmds enum above. */ 392 char device1[24]; 393 394 union { 395 char device2[24]; 396 int VID; 397 unsigned int skb_priority; 398 unsigned int name_type; 399 unsigned int bind_type; 400 unsigned int flag; /* Matches vlan_dev_priv flags */ 401 } u; 402 403 short vlan_qos; 404 }; 405 406 #endif /* !(_LINUX_IF_VLAN_H_) */ 407