| 1 | /* $NetBSD: if_ether.h,v 1.65 2015/11/19 16:23:54 christos Exp $ */ |
| 2 | |
| 3 | /* |
| 4 | * Copyright (c) 1982, 1986, 1993 |
| 5 | * The Regents of the University of California. All rights reserved. |
| 6 | * |
| 7 | * Redistribution and use in source and binary forms, with or without |
| 8 | * modification, are permitted provided that the following conditions |
| 9 | * are met: |
| 10 | * 1. Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * 2. Redistributions in binary form must reproduce the above copyright |
| 13 | * notice, this list of conditions and the following disclaimer in the |
| 14 | * documentation and/or other materials provided with the distribution. |
| 15 | * 3. Neither the name of the University nor the names of its contributors |
| 16 | * may be used to endorse or promote products derived from this software |
| 17 | * without specific prior written permission. |
| 18 | * |
| 19 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| 20 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 21 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 22 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 23 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 24 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 25 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 26 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 27 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 28 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 29 | * SUCH DAMAGE. |
| 30 | * |
| 31 | * @(#)if_ether.h 8.1 (Berkeley) 6/10/93 |
| 32 | */ |
| 33 | |
| 34 | #ifndef _NET_IF_ETHER_H_ |
| 35 | #define _NET_IF_ETHER_H_ |
| 36 | |
| 37 | #ifdef _KERNEL |
| 38 | #ifdef _KERNEL_OPT |
| 39 | #include "opt_mbuftrace.h" |
| 40 | #endif |
| 41 | #include <sys/mbuf.h> |
| 42 | #endif |
| 43 | |
| 44 | #ifndef _STANDALONE |
| 45 | #include <net/if.h> |
| 46 | #endif |
| 47 | |
| 48 | /* |
| 49 | * Some basic Ethernet constants. |
| 50 | */ |
| 51 | #define ETHER_ADDR_LEN 6 /* length of an Ethernet address */ |
| 52 | #define ETHER_TYPE_LEN 2 /* length of the Ethernet type field */ |
| 53 | #define ETHER_CRC_LEN 4 /* length of the Ethernet CRC */ |
| 54 | #define ETHER_HDR_LEN ((ETHER_ADDR_LEN * 2) + ETHER_TYPE_LEN) |
| 55 | #define ETHER_MIN_LEN 64 /* minimum frame length, including CRC */ |
| 56 | #define ETHER_MAX_LEN 1518 /* maximum frame length, including CRC */ |
| 57 | #define ETHER_MAX_LEN_JUMBO 9018 /* maximum jumbo frame len, including CRC */ |
| 58 | |
| 59 | /* |
| 60 | * Some Ethernet extensions. |
| 61 | */ |
| 62 | #define ETHER_VLAN_ENCAP_LEN 4 /* length of 802.1Q VLAN encapsulation */ |
| 63 | #define ETHER_PPPOE_ENCAP_LEN 8 /* length of PPPoE encapsulation */ |
| 64 | |
| 65 | /* |
| 66 | * Ethernet address - 6 octets |
| 67 | * this is only used by the ethers(3) functions. |
| 68 | */ |
| 69 | struct ether_addr { |
| 70 | uint8_t ether_addr_octet[ETHER_ADDR_LEN]; |
| 71 | } __packed; |
| 72 | |
| 73 | /* |
| 74 | * Structure of a 10Mb/s Ethernet header. |
| 75 | */ |
| 76 | struct { |
| 77 | uint8_t [ETHER_ADDR_LEN]; |
| 78 | uint8_t [ETHER_ADDR_LEN]; |
| 79 | uint16_t ; |
| 80 | } __packed; |
| 81 | |
| 82 | #include <net/ethertypes.h> |
| 83 | |
| 84 | #define ETHER_IS_MULTICAST(addr) (*(addr) & 0x01) /* is address mcast/bcast? */ |
| 85 | #define ETHER_IS_LOCAL(addr) (*(addr) & 0x02) /* is address local? */ |
| 86 | |
| 87 | #define ETHERMTU_JUMBO (ETHER_MAX_LEN_JUMBO - ETHER_HDR_LEN - ETHER_CRC_LEN) |
| 88 | #define ETHERMTU (ETHER_MAX_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN) |
| 89 | #define ETHERMIN (ETHER_MIN_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN) |
| 90 | |
| 91 | /* |
| 92 | * Compute the maximum frame size based on ethertype (i.e. possible |
| 93 | * encapsulation) and whether or not an FCS is present. |
| 94 | */ |
| 95 | #define ETHER_MAX_FRAME(ifp, etype, hasfcs) \ |
| 96 | ((ifp)->if_mtu + ETHER_HDR_LEN + \ |
| 97 | ((hasfcs) ? ETHER_CRC_LEN : 0) + \ |
| 98 | (((etype) == ETHERTYPE_VLAN) ? ETHER_VLAN_ENCAP_LEN : 0) + \ |
| 99 | (((etype) == ETHERTYPE_PPPOE) ? ETHER_PPPOE_ENCAP_LEN : 0)) |
| 100 | |
| 101 | /* |
| 102 | * Ethernet CRC32 polynomials (big- and little-endian verions). |
| 103 | */ |
| 104 | #define ETHER_CRC_POLY_LE 0xedb88320 |
| 105 | #define ETHER_CRC_POLY_BE 0x04c11db6 |
| 106 | |
| 107 | #ifndef _STANDALONE |
| 108 | |
| 109 | /* |
| 110 | * Ethernet-specific mbuf flags. |
| 111 | */ |
| 112 | #define M_HASFCS M_LINK0 /* FCS included at end of frame */ |
| 113 | #define M_PROMISC M_LINK1 /* this packet is not for us */ |
| 114 | |
| 115 | #ifdef _KERNEL |
| 116 | /* |
| 117 | * Macro to map an IP multicast address to an Ethernet multicast address. |
| 118 | * The high-order 25 bits of the Ethernet address are statically assigned, |
| 119 | * and the low-order 23 bits are taken from the low end of the IP address. |
| 120 | */ |
| 121 | #define ETHER_MAP_IP_MULTICAST(ipaddr, enaddr) \ |
| 122 | /* const struct in_addr *ipaddr; */ \ |
| 123 | /* uint8_t enaddr[ETHER_ADDR_LEN]; */ \ |
| 124 | do { \ |
| 125 | (enaddr)[0] = 0x01; \ |
| 126 | (enaddr)[1] = 0x00; \ |
| 127 | (enaddr)[2] = 0x5e; \ |
| 128 | (enaddr)[3] = ((const uint8_t *)ipaddr)[1] & 0x7f; \ |
| 129 | (enaddr)[4] = ((const uint8_t *)ipaddr)[2]; \ |
| 130 | (enaddr)[5] = ((const uint8_t *)ipaddr)[3]; \ |
| 131 | } while (/*CONSTCOND*/0) |
| 132 | /* |
| 133 | * Macro to map an IP6 multicast address to an Ethernet multicast address. |
| 134 | * The high-order 16 bits of the Ethernet address are statically assigned, |
| 135 | * and the low-order 32 bits are taken from the low end of the IP6 address. |
| 136 | */ |
| 137 | #define ETHER_MAP_IPV6_MULTICAST(ip6addr, enaddr) \ |
| 138 | /* struct in6_addr *ip6addr; */ \ |
| 139 | /* uint8_t enaddr[ETHER_ADDR_LEN]; */ \ |
| 140 | { \ |
| 141 | (enaddr)[0] = 0x33; \ |
| 142 | (enaddr)[1] = 0x33; \ |
| 143 | (enaddr)[2] = ((const uint8_t *)ip6addr)[12]; \ |
| 144 | (enaddr)[3] = ((const uint8_t *)ip6addr)[13]; \ |
| 145 | (enaddr)[4] = ((const uint8_t *)ip6addr)[14]; \ |
| 146 | (enaddr)[5] = ((const uint8_t *)ip6addr)[15]; \ |
| 147 | } |
| 148 | #endif |
| 149 | |
| 150 | struct mii_data; |
| 151 | |
| 152 | struct ethercom; |
| 153 | |
| 154 | typedef int (*ether_cb_t)(struct ethercom *); |
| 155 | |
| 156 | /* |
| 157 | * Structure shared between the ethernet driver modules and |
| 158 | * the multicast list code. For example, each ec_softc or il_softc |
| 159 | * begins with this structure. |
| 160 | */ |
| 161 | struct ethercom { |
| 162 | struct ifnet ec_if; /* network-visible interface */ |
| 163 | LIST_HEAD(, ether_multi) ec_multiaddrs; /* list of ether multicast |
| 164 | addrs */ |
| 165 | int ec_multicnt; /* length of ec_multiaddrs |
| 166 | list */ |
| 167 | int ec_capabilities; /* capabilities, provided by |
| 168 | driver */ |
| 169 | int ec_capenable; /* tells hardware which |
| 170 | capabilities to enable */ |
| 171 | |
| 172 | int ec_nvlans; /* # VLANs on this interface */ |
| 173 | /* The device handle for the MII bus child device. */ |
| 174 | struct mii_data *ec_mii; |
| 175 | /* Called after a change to ec_if.if_flags. Returns |
| 176 | * ENETRESET if the device should be reinitialized with |
| 177 | * ec_if.if_init, 0 on success, not 0 on failure. |
| 178 | */ |
| 179 | ether_cb_t ec_ifflags_cb; |
| 180 | #ifdef MBUFTRACE |
| 181 | struct mowner ec_rx_mowner; /* mbufs received */ |
| 182 | struct mowner ec_tx_mowner; /* mbufs transmitted */ |
| 183 | #endif |
| 184 | }; |
| 185 | |
| 186 | #define ETHERCAP_VLAN_MTU 0x00000001 /* VLAN-compatible MTU */ |
| 187 | #define ETHERCAP_VLAN_HWTAGGING 0x00000002 /* hardware VLAN tag support */ |
| 188 | #define ETHERCAP_JUMBO_MTU 0x00000004 /* 9000 byte MTU supported */ |
| 189 | #define ETHERCAP_MASK 0x00000007 |
| 190 | |
| 191 | #define ECCAPBITS \ |
| 192 | "\020" \ |
| 193 | "\1VLAN_MTU" \ |
| 194 | "\2VLAN_HWTAGGING" \ |
| 195 | "\3JUMBO_MTU" |
| 196 | |
| 197 | /* ioctl() for Ethernet capabilities */ |
| 198 | struct eccapreq { |
| 199 | char eccr_name[IFNAMSIZ]; /* if name, e.g. "en0" */ |
| 200 | int eccr_capabilities; /* supported capabiliites */ |
| 201 | int eccr_capenable; /* capabilities enabled */ |
| 202 | }; |
| 203 | |
| 204 | #ifdef _KERNEL |
| 205 | extern const uint8_t etherbroadcastaddr[ETHER_ADDR_LEN]; |
| 206 | extern const uint8_t ethermulticastaddr_slowprotocols[ETHER_ADDR_LEN]; |
| 207 | extern const uint8_t ether_ipmulticast_min[ETHER_ADDR_LEN]; |
| 208 | extern const uint8_t ether_ipmulticast_max[ETHER_ADDR_LEN]; |
| 209 | |
| 210 | void ether_set_ifflags_cb(struct ethercom *, ether_cb_t); |
| 211 | int ether_ioctl(struct ifnet *, u_long, void *); |
| 212 | int ether_addmulti(const struct sockaddr *, struct ethercom *); |
| 213 | int ether_delmulti(const struct sockaddr *, struct ethercom *); |
| 214 | int ether_multiaddr(const struct sockaddr *, uint8_t[], uint8_t[]); |
| 215 | void ether_input(struct ifnet *, struct mbuf *); |
| 216 | #endif /* _KERNEL */ |
| 217 | |
| 218 | /* |
| 219 | * Ethernet multicast address structure. There is one of these for each |
| 220 | * multicast address or range of multicast addresses that we are supposed |
| 221 | * to listen to on a particular interface. They are kept in a linked list, |
| 222 | * rooted in the interface's ethercom structure. |
| 223 | */ |
| 224 | struct ether_multi { |
| 225 | uint8_t enm_addrlo[ETHER_ADDR_LEN]; /* low or only address of range */ |
| 226 | uint8_t enm_addrhi[ETHER_ADDR_LEN]; /* high or only address of range */ |
| 227 | u_int enm_refcount; /* no. claims to this addr/range */ |
| 228 | LIST_ENTRY(ether_multi) enm_list; |
| 229 | }; |
| 230 | |
| 231 | struct ether_multi_sysctl { |
| 232 | u_int enm_refcount; |
| 233 | uint8_t enm_addrlo[ETHER_ADDR_LEN]; |
| 234 | uint8_t enm_addrhi[ETHER_ADDR_LEN]; |
| 235 | }; |
| 236 | |
| 237 | /* |
| 238 | * Structure used by macros below to remember position when stepping through |
| 239 | * all of the ether_multi records. |
| 240 | */ |
| 241 | struct ether_multistep { |
| 242 | struct ether_multi *e_enm; |
| 243 | }; |
| 244 | |
| 245 | /* |
| 246 | * Macro for looking up the ether_multi record for a given range of Ethernet |
| 247 | * multicast addresses connected to a given ethercom structure. If no matching |
| 248 | * record is found, "enm" returns NULL. |
| 249 | */ |
| 250 | #define ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm) \ |
| 251 | /* uint8_t addrlo[ETHER_ADDR_LEN]; */ \ |
| 252 | /* uint8_t addrhi[ETHER_ADDR_LEN]; */ \ |
| 253 | /* struct ethercom *ec; */ \ |
| 254 | /* struct ether_multi *enm; */ \ |
| 255 | { \ |
| 256 | for ((enm) = LIST_FIRST(&(ec)->ec_multiaddrs); \ |
| 257 | (enm) != NULL && \ |
| 258 | (memcmp((enm)->enm_addrlo, (addrlo), ETHER_ADDR_LEN) != 0 || \ |
| 259 | memcmp((enm)->enm_addrhi, (addrhi), ETHER_ADDR_LEN) != 0); \ |
| 260 | (enm) = LIST_NEXT((enm), enm_list)); \ |
| 261 | } |
| 262 | |
| 263 | /* |
| 264 | * Macro to step through all of the ether_multi records, one at a time. |
| 265 | * The current position is remembered in "step", which the caller must |
| 266 | * provide. ETHER_FIRST_MULTI(), below, must be called to initialize "step" |
| 267 | * and get the first record. Both macros return a NULL "enm" when there |
| 268 | * are no remaining records. |
| 269 | */ |
| 270 | #define ETHER_NEXT_MULTI(step, enm) \ |
| 271 | /* struct ether_multistep step; */ \ |
| 272 | /* struct ether_multi *enm; */ \ |
| 273 | { \ |
| 274 | if (((enm) = (step).e_enm) != NULL) \ |
| 275 | (step).e_enm = LIST_NEXT((enm), enm_list); \ |
| 276 | } |
| 277 | |
| 278 | #define ETHER_FIRST_MULTI(step, ec, enm) \ |
| 279 | /* struct ether_multistep step; */ \ |
| 280 | /* struct ethercom *ec; */ \ |
| 281 | /* struct ether_multi *enm; */ \ |
| 282 | { \ |
| 283 | (step).e_enm = LIST_FIRST(&(ec)->ec_multiaddrs); \ |
| 284 | ETHER_NEXT_MULTI((step), (enm)); \ |
| 285 | } |
| 286 | |
| 287 | #ifdef _KERNEL |
| 288 | |
| 289 | /* |
| 290 | * Ethernet 802.1Q VLAN structures. |
| 291 | */ |
| 292 | |
| 293 | /* add VLAN tag to input/received packet */ |
| 294 | static inline int vlan_input_tag(struct ifnet *, struct mbuf *, u_int); |
| 295 | static inline int |
| 296 | vlan_input_tag(struct ifnet *ifp, struct mbuf *m, u_int vlanid) |
| 297 | { |
| 298 | struct m_tag *mtag; |
| 299 | mtag = m_tag_get(PACKET_TAG_VLAN, sizeof(u_int), M_NOWAIT); |
| 300 | if (mtag == NULL) { |
| 301 | ifp->if_ierrors++; |
| 302 | printf("%s: unable to allocate VLAN tag\n" , ifp->if_xname); |
| 303 | m_freem(m); |
| 304 | return 1; |
| 305 | } |
| 306 | *(u_int *)(mtag + 1) = vlanid; |
| 307 | m_tag_prepend(m, mtag); |
| 308 | return 0; |
| 309 | } |
| 310 | |
| 311 | #define VLAN_INPUT_TAG(ifp, m, vlanid, _errcase) \ |
| 312 | if (vlan_input_tag(ifp, m, vlanid) != 0) { \ |
| 313 | _errcase; \ |
| 314 | } |
| 315 | |
| 316 | /* extract VLAN tag from output/trasmit packet */ |
| 317 | #define VLAN_OUTPUT_TAG(ec, m0) \ |
| 318 | (VLAN_ATTACHED(ec) ? m_tag_find((m0), PACKET_TAG_VLAN, NULL) : NULL) |
| 319 | |
| 320 | /* extract VLAN ID value from a VLAN tag */ |
| 321 | #define VLAN_TAG_VALUE(mtag) \ |
| 322 | ((*(u_int *)(mtag + 1)) & 4095) |
| 323 | |
| 324 | /* test if any VLAN is configured for this interface */ |
| 325 | #define VLAN_ATTACHED(ec) ((ec)->ec_nvlans > 0) |
| 326 | |
| 327 | void etherinit(void); |
| 328 | void ether_ifattach(struct ifnet *, const uint8_t *); |
| 329 | void ether_ifdetach(struct ifnet *); |
| 330 | int ether_mediachange(struct ifnet *); |
| 331 | void ether_mediastatus(struct ifnet *, struct ifmediareq *); |
| 332 | |
| 333 | char *ether_sprintf(const uint8_t *); |
| 334 | char *ether_snprintf(char *, size_t, const uint8_t *); |
| 335 | |
| 336 | uint32_t ether_crc32_le(const uint8_t *, size_t); |
| 337 | uint32_t ether_crc32_be(const uint8_t *, size_t); |
| 338 | |
| 339 | int ether_aton_r(u_char *, size_t, const char *); |
| 340 | int ether_enable_vlan_mtu(struct ifnet *); |
| 341 | int ether_disable_vlan_mtu(struct ifnet *); |
| 342 | #else |
| 343 | /* |
| 344 | * Prototype ethers(3) functions. |
| 345 | */ |
| 346 | #include <sys/cdefs.h> |
| 347 | __BEGIN_DECLS |
| 348 | char * ether_ntoa(const struct ether_addr *); |
| 349 | struct ether_addr * |
| 350 | ether_aton(const char *); |
| 351 | int ether_ntohost(char *, const struct ether_addr *); |
| 352 | int ether_hostton(const char *, struct ether_addr *); |
| 353 | int ether_line(const char *, struct ether_addr *, char *); |
| 354 | __END_DECLS |
| 355 | #endif |
| 356 | |
| 357 | #endif /* _STANDALONE */ |
| 358 | |
| 359 | #endif /* !_NET_IF_ETHER_H_ */ |
| 360 | |