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 | |