1 | /* |
2 | * Copyright (c) 2000-2013 Apple Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* |
29 | * Copyright (c) 1982, 1989, 1993 |
30 | * The Regents of the University of California. All rights reserved. |
31 | * |
32 | * Redistribution and use in source and binary forms, with or without |
33 | * modification, are permitted provided that the following conditions |
34 | * are met: |
35 | * 1. Redistributions of source code must retain the above copyright |
36 | * notice, this list of conditions and the following disclaimer. |
37 | * 2. Redistributions in binary form must reproduce the above copyright |
38 | * notice, this list of conditions and the following disclaimer in the |
39 | * documentation and/or other materials provided with the distribution. |
40 | * 3. All advertising materials mentioning features or use of this software |
41 | * must display the following acknowledgement: |
42 | * This product includes software developed by the University of |
43 | * California, Berkeley and its contributors. |
44 | * 4. Neither the name of the University nor the names of its contributors |
45 | * may be used to endorse or promote products derived from this software |
46 | * without specific prior written permission. |
47 | * |
48 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
49 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
50 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
51 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
52 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
53 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
54 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
55 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
56 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
57 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
58 | * SUCH DAMAGE. |
59 | * |
60 | */ |
61 | |
62 | #include <sys/param.h> |
63 | #include <sys/systm.h> |
64 | #include <sys/kernel.h> |
65 | #include <sys/malloc.h> |
66 | #include <sys/mbuf.h> |
67 | #include <sys/socket.h> |
68 | #include <sys/sockio.h> |
69 | #include <sys/sysctl.h> |
70 | |
71 | #include <pexpert/pexpert.h> |
72 | |
73 | #define etherbroadcastaddr fugly |
74 | #include <net/if.h> |
75 | #include <net/route.h> |
76 | #include <net/if_llc.h> |
77 | #include <net/if_dl.h> |
78 | #include <net/if_types.h> |
79 | #include <net/if_ether.h> |
80 | #include <net/if_gif.h> |
81 | #include <netinet/if_ether.h> |
82 | #include <netinet/in.h> /* For M_LOOP */ |
83 | #include <net/kpi_interface.h> |
84 | #include <net/kpi_protocol.h> |
85 | #undef etherbroadcastaddr |
86 | |
87 | /* |
88 | #if INET |
89 | #include <netinet/in.h> |
90 | #include <netinet/in_var.h> |
91 | |
92 | #include <netinet/in_systm.h> |
93 | #include <netinet/ip.h> |
94 | #endif |
95 | */ |
96 | #include <net/ether_if_module.h> |
97 | #include <sys/socketvar.h> |
98 | #include <net/if_vlan_var.h> |
99 | #if BOND |
100 | #include <net/if_bond_internal.h> |
101 | #endif /* BOND */ |
102 | #if IF_BRIDGE |
103 | #include <net/if_bridgevar.h> |
104 | #endif /* IF_BRIDGE */ |
105 | #if IF_FAKE |
106 | #include <net/if_fake_var.h> |
107 | #endif /* IF_FAKE */ |
108 | |
109 | #include <net/dlil.h> |
110 | |
111 | SYSCTL_DECL(_net_link); |
112 | SYSCTL_NODE(_net_link, IFT_ETHER, ether, CTLFLAG_RW|CTLFLAG_LOCKED, 0, |
113 | "Ethernet" ); |
114 | |
115 | struct en_desc { |
116 | u_int16_t type; /* Type of protocol stored in data */ |
117 | u_int32_t protocol_family; /* Protocol family */ |
118 | u_int32_t data[2]; /* Protocol data */ |
119 | }; |
120 | |
121 | /* descriptors are allocated in blocks of ETHER_DESC_BLK_SIZE */ |
122 | #if CONFIG_EMBEDDED |
123 | #define ETHER_DESC_BLK_SIZE (2) /* IP, ARP */ |
124 | #else |
125 | #define ETHER_DESC_BLK_SIZE (10) |
126 | #endif |
127 | |
128 | /* |
129 | * Header for the demux list, hangs off of IFP at if_family_cookie |
130 | */ |
131 | struct ether_desc_blk_str { |
132 | u_int32_t n_max_used; |
133 | u_int32_t n_count; |
134 | u_int32_t n_used; |
135 | struct en_desc block_ptr[1]; |
136 | }; |
137 | |
138 | /* Size of the above struct before the array of struct en_desc */ |
139 | #define \ |
140 | ((size_t) offsetof(struct ether_desc_blk_str, block_ptr)) |
141 | |
142 | __private_extern__ u_char etherbroadcastaddr[ETHER_ADDR_LEN] = |
143 | { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; |
144 | |
145 | /* |
146 | * Release all descriptor entries owned by this protocol (there may be several). |
147 | * Setting the type to 0 releases the entry. Eventually we should compact-out |
148 | * the unused entries. |
149 | */ |
150 | int |
151 | ether_del_proto(ifnet_t ifp, protocol_family_t protocol_family) |
152 | { |
153 | struct ether_desc_blk_str *desc_blk = |
154 | (struct ether_desc_blk_str *)ifp->if_family_cookie; |
155 | u_int32_t current = 0; |
156 | int found = 0; |
157 | |
158 | if (desc_blk == NULL) |
159 | return (0); |
160 | |
161 | for (current = desc_blk->n_max_used; current > 0; current--) { |
162 | if (desc_blk->block_ptr[current - 1].protocol_family == |
163 | protocol_family) { |
164 | found = 1; |
165 | desc_blk->block_ptr[current - 1].type = 0; |
166 | desc_blk->n_used--; |
167 | } |
168 | } |
169 | |
170 | if (desc_blk->n_used == 0) { |
171 | FREE(ifp->if_family_cookie, M_IFADDR); |
172 | ifp->if_family_cookie = 0; |
173 | } else { |
174 | /* Decrement n_max_used */ |
175 | for (; desc_blk->n_max_used > 0 && |
176 | desc_blk->block_ptr[desc_blk->n_max_used - 1].type == 0; |
177 | desc_blk->n_max_used--) |
178 | ; |
179 | } |
180 | |
181 | return (0); |
182 | } |
183 | |
184 | static int |
185 | ether_add_proto_internal(struct ifnet *ifp, protocol_family_t protocol, |
186 | const struct ifnet_demux_desc *demux) |
187 | { |
188 | struct en_desc *ed; |
189 | struct ether_desc_blk_str *desc_blk = |
190 | (struct ether_desc_blk_str *)ifp->if_family_cookie; |
191 | u_int32_t i; |
192 | |
193 | switch (demux->type) { |
194 | /* These types are supported */ |
195 | /* Top three are preferred */ |
196 | case DLIL_DESC_ETYPE2: |
197 | if (demux->datalen != 2) |
198 | return (EINVAL); |
199 | break; |
200 | |
201 | case DLIL_DESC_SAP: |
202 | if (demux->datalen != 3) |
203 | return (EINVAL); |
204 | break; |
205 | |
206 | case DLIL_DESC_SNAP: |
207 | if (demux->datalen != 5) |
208 | return (EINVAL); |
209 | break; |
210 | |
211 | default: |
212 | return (ENOTSUP); |
213 | } |
214 | |
215 | /* Verify a matching descriptor does not exist */ |
216 | if (desc_blk != NULL) { |
217 | switch (demux->type) { |
218 | case DLIL_DESC_ETYPE2: |
219 | for (i = 0; i < desc_blk->n_max_used; i++) { |
220 | if (desc_blk->block_ptr[i].type == |
221 | DLIL_DESC_ETYPE2 && |
222 | desc_blk->block_ptr[i].data[0] == |
223 | *(u_int16_t*)demux->data) { |
224 | return (EADDRINUSE); |
225 | } |
226 | } |
227 | break; |
228 | case DLIL_DESC_SAP: |
229 | case DLIL_DESC_SNAP: |
230 | for (i = 0; i < desc_blk->n_max_used; i++) { |
231 | if (desc_blk->block_ptr[i].type == |
232 | demux->type && |
233 | bcmp(desc_blk->block_ptr[i].data, |
234 | demux->data, demux->datalen) == 0) { |
235 | return (EADDRINUSE); |
236 | } |
237 | } |
238 | break; |
239 | } |
240 | } |
241 | |
242 | /* Check for case where all of the descriptor blocks are in use */ |
243 | if (desc_blk == NULL || desc_blk->n_used == desc_blk->n_count) { |
244 | struct ether_desc_blk_str *tmp; |
245 | u_int32_t new_count = ETHER_DESC_BLK_SIZE; |
246 | u_int32_t new_size; |
247 | u_int32_t old_size = 0; |
248 | |
249 | i = 0; |
250 | |
251 | if (desc_blk) { |
252 | new_count += desc_blk->n_count; |
253 | old_size = desc_blk->n_count * sizeof (struct en_desc) + |
254 | ETHER_DESC_HEADER_SIZE; |
255 | i = desc_blk->n_used; |
256 | } |
257 | |
258 | new_size = new_count * sizeof (struct en_desc) + |
259 | ETHER_DESC_HEADER_SIZE; |
260 | |
261 | tmp = _MALLOC(new_size, M_IFADDR, M_WAITOK); |
262 | if (tmp == NULL) { |
263 | /* |
264 | * Remove any previous descriptors set in the call. |
265 | */ |
266 | return (ENOMEM); |
267 | } |
268 | |
269 | bzero(((char *)tmp) + old_size, new_size - old_size); |
270 | if (desc_blk) { |
271 | bcopy(desc_blk, tmp, old_size); |
272 | FREE(desc_blk, M_IFADDR); |
273 | } |
274 | desc_blk = tmp; |
275 | ifp->if_family_cookie = (uintptr_t)desc_blk; |
276 | desc_blk->n_count = new_count; |
277 | } else { |
278 | /* Find a free entry */ |
279 | for (i = 0; i < desc_blk->n_count; i++) { |
280 | if (desc_blk->block_ptr[i].type == 0) { |
281 | break; |
282 | } |
283 | } |
284 | } |
285 | |
286 | /* Bump n_max_used if appropriate */ |
287 | if (i + 1 > desc_blk->n_max_used) { |
288 | desc_blk->n_max_used = i + 1; |
289 | } |
290 | |
291 | ed = &desc_blk->block_ptr[i]; |
292 | ed->protocol_family = protocol; |
293 | ed->data[0] = 0; |
294 | ed->data[1] = 0; |
295 | |
296 | switch (demux->type) { |
297 | case DLIL_DESC_ETYPE2: |
298 | /* 2 byte ethernet raw protocol type is at native_type */ |
299 | /* prtocol must be in network byte order */ |
300 | ed->type = DLIL_DESC_ETYPE2; |
301 | ed->data[0] = *(u_int16_t*)demux->data; |
302 | break; |
303 | |
304 | case DLIL_DESC_SAP: |
305 | ed->type = DLIL_DESC_SAP; |
306 | bcopy(demux->data, &ed->data[0], 3); |
307 | break; |
308 | |
309 | case DLIL_DESC_SNAP: { |
310 | u_int8_t* pDest = ((u_int8_t*)&ed->data[0]) + 3; |
311 | ed->type = DLIL_DESC_SNAP; |
312 | bcopy(demux->data, pDest, 5); |
313 | break; |
314 | } |
315 | } |
316 | |
317 | desc_blk->n_used++; |
318 | |
319 | return (0); |
320 | } |
321 | |
322 | int |
323 | ether_add_proto(ifnet_t ifp, protocol_family_t protocol, |
324 | const struct ifnet_demux_desc *demux_list, u_int32_t demux_count) |
325 | { |
326 | int error = 0; |
327 | u_int32_t i; |
328 | |
329 | for (i = 0; i < demux_count; i++) { |
330 | error = ether_add_proto_internal(ifp, protocol, &demux_list[i]); |
331 | if (error) { |
332 | ether_del_proto(ifp, protocol); |
333 | break; |
334 | } |
335 | } |
336 | |
337 | return (error); |
338 | } |
339 | |
340 | int |
341 | ether_demux(ifnet_t ifp, mbuf_t m, char *, |
342 | protocol_family_t *protocol_family) |
343 | { |
344 | struct ether_header *eh = (struct ether_header *)(void *)frame_header; |
345 | u_short ether_type = eh->ether_type; |
346 | u_int16_t type; |
347 | u_int8_t *data; |
348 | u_int32_t i = 0; |
349 | struct ether_desc_blk_str *desc_blk = |
350 | (struct ether_desc_blk_str *)ifp->if_family_cookie; |
351 | u_int32_t maxd = desc_blk ? desc_blk->n_max_used : 0; |
352 | struct en_desc *ed = desc_blk ? desc_blk->block_ptr : NULL; |
353 | u_int32_t extProto1 = 0; |
354 | u_int32_t extProto2 = 0; |
355 | |
356 | if (eh->ether_dhost[0] & 1) { |
357 | /* Check for broadcast */ |
358 | if (_ether_cmp(etherbroadcastaddr, eh->ether_dhost) == 0) |
359 | m->m_flags |= M_BCAST; |
360 | else |
361 | m->m_flags |= M_MCAST; |
362 | } |
363 | |
364 | if (m->m_flags & M_HASFCS) { |
365 | /* |
366 | * If the M_HASFCS is set by the driver we want to make sure |
367 | * that we strip off the trailing FCS data before handing it |
368 | * up the stack. |
369 | */ |
370 | m_adj(m, -ETHER_CRC_LEN); |
371 | m->m_flags &= ~M_HASFCS; |
372 | } |
373 | |
374 | if (ifp->if_eflags & IFEF_BOND) { |
375 | /* if we're bonded, bond "protocol" gets all the packets */ |
376 | *protocol_family = PF_BOND; |
377 | return (0); |
378 | } |
379 | |
380 | if ((eh->ether_dhost[0] & 1) == 0) { |
381 | /* |
382 | * When the driver is put into promiscuous mode we may receive |
383 | * unicast frames that are not intended for our interfaces. |
384 | * They are marked here as being promiscuous so the caller may |
385 | * dispose of them after passing the packets to any interface |
386 | * filters. |
387 | */ |
388 | if (_ether_cmp(eh->ether_dhost, IF_LLADDR(ifp))) { |
389 | m->m_flags |= M_PROMISC; |
390 | } |
391 | } |
392 | |
393 | /* check for VLAN */ |
394 | if ((m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) != 0) { |
395 | if (EVL_VLANOFTAG(m->m_pkthdr.vlan_tag) != 0) { |
396 | *protocol_family = PF_VLAN; |
397 | return (0); |
398 | } |
399 | /* the packet is just priority-tagged, clear the bit */ |
400 | m->m_pkthdr.csum_flags &= ~CSUM_VLAN_TAG_VALID; |
401 | } else if (ether_type == htons(ETHERTYPE_VLAN)) { |
402 | struct ether_vlan_header * evl; |
403 | |
404 | evl = (struct ether_vlan_header *)(void *)frame_header; |
405 | if (m->m_len < ETHER_VLAN_ENCAP_LEN || |
406 | ntohs(evl->evl_proto) == ETHERTYPE_VLAN || |
407 | EVL_VLANOFTAG(ntohs(evl->evl_tag)) != 0) { |
408 | *protocol_family = PF_VLAN; |
409 | return (0); |
410 | } |
411 | /* the packet is just priority-tagged */ |
412 | |
413 | /* make the encapsulated ethertype the actual ethertype */ |
414 | ether_type = evl->evl_encap_proto = evl->evl_proto; |
415 | |
416 | /* remove the encapsulation header */ |
417 | m->m_len -= ETHER_VLAN_ENCAP_LEN; |
418 | m->m_data += ETHER_VLAN_ENCAP_LEN; |
419 | m->m_pkthdr.len -= ETHER_VLAN_ENCAP_LEN; |
420 | m->m_pkthdr.csum_flags = 0; /* can't trust hardware checksum */ |
421 | } else if (ether_type == htons(ETHERTYPE_ARP)) |
422 | m->m_pkthdr.pkt_flags |= PKTF_INET_RESOLVE; /* ARP packet */ |
423 | |
424 | data = mtod(m, u_int8_t*); |
425 | |
426 | /* |
427 | * Determine the packet's protocol type and stuff the protocol into |
428 | * longs for quick compares. |
429 | */ |
430 | if (ntohs(ether_type) <= 1500) { |
431 | bcopy(data, &extProto1, sizeof (u_int32_t)); |
432 | |
433 | /* SAP or SNAP */ |
434 | if ((extProto1 & htonl(0xFFFFFF00)) == htonl(0xAAAA0300)) { |
435 | /* SNAP */ |
436 | type = DLIL_DESC_SNAP; |
437 | bcopy(data + sizeof (u_int32_t), &extProto2, |
438 | sizeof (u_int32_t)); |
439 | extProto1 &= htonl(0x000000FF); |
440 | } else { |
441 | type = DLIL_DESC_SAP; |
442 | extProto1 &= htonl(0xFFFFFF00); |
443 | } |
444 | } else { |
445 | type = DLIL_DESC_ETYPE2; |
446 | } |
447 | |
448 | /* |
449 | * Search through the connected protocols for a match. |
450 | */ |
451 | switch (type) { |
452 | case DLIL_DESC_ETYPE2: |
453 | for (i = 0; i < maxd; i++) { |
454 | if ((ed[i].type == type) && |
455 | (ed[i].data[0] == ether_type)) { |
456 | *protocol_family = ed[i].protocol_family; |
457 | return (0); |
458 | } |
459 | } |
460 | break; |
461 | |
462 | case DLIL_DESC_SAP: |
463 | for (i = 0; i < maxd; i++) { |
464 | if ((ed[i].type == type) && |
465 | (ed[i].data[0] == extProto1)) { |
466 | *protocol_family = ed[i].protocol_family; |
467 | return (0); |
468 | } |
469 | } |
470 | break; |
471 | |
472 | case DLIL_DESC_SNAP: |
473 | for (i = 0; i < maxd; i++) { |
474 | if ((ed[i].type == type) && |
475 | (ed[i].data[0] == extProto1) && |
476 | (ed[i].data[1] == extProto2)) { |
477 | *protocol_family = ed[i].protocol_family; |
478 | return (0); |
479 | } |
480 | } |
481 | break; |
482 | } |
483 | |
484 | return (ENOENT); |
485 | } |
486 | |
487 | /* |
488 | * On embedded, ether_frameout is practicaly ether_frameout_extended. |
489 | * On non-embedded, ether_frameout has long been exposed as a public KPI, |
490 | * and therefore its signature must remain the same (without the pre- and |
491 | * postpend length parameters.) |
492 | */ |
493 | #if KPI_INTERFACE_EMBEDDED |
494 | int |
495 | ether_frameout(struct ifnet *ifp, struct mbuf **m, |
496 | const struct sockaddr *ndest, const char *edst, |
497 | const char *ether_type, u_int32_t *prepend_len, u_int32_t *postpend_len) |
498 | #else /* !KPI_INTERFACE_EMBEDDED */ |
499 | int |
500 | ether_frameout(struct ifnet *ifp, struct mbuf **m, |
501 | const struct sockaddr *ndest, const char *edst, |
502 | const char *ether_type) |
503 | #endif /* KPI_INTERFACE_EMBEDDED */ |
504 | { |
505 | #if KPI_INTERFACE_EMBEDDED |
506 | return (ether_frameout_extended(ifp, m, ndest, edst, ether_type, |
507 | prepend_len, postpend_len)); |
508 | #else /* !KPI_INTERFACE_EMBEDDED */ |
509 | return (ether_frameout_extended(ifp, m, ndest, edst, ether_type, |
510 | NULL, NULL)); |
511 | #endif /* !KPI_INTERFACE_EMBEDDED */ |
512 | } |
513 | |
514 | /* |
515 | * Ethernet output routine. |
516 | * Encapsulate a packet of type family for the local net. |
517 | * Use trailer local net encapsulation if enough data in first |
518 | * packet leaves a multiple of 512 bytes of data in remainder. |
519 | */ |
520 | int |
521 | ether_frameout_extended(struct ifnet *ifp, struct mbuf **m, |
522 | const struct sockaddr *ndest, const char *edst, |
523 | const char *ether_type, u_int32_t *prepend_len, u_int32_t *postpend_len) |
524 | { |
525 | struct ether_header *eh; |
526 | int hlen; /* link layer header length */ |
527 | |
528 | hlen = ETHER_HDR_LEN; |
529 | |
530 | /* |
531 | * If a simplex interface, and the packet is being sent to our |
532 | * Ethernet address or a broadcast address, loopback a copy. |
533 | * XXX To make a simplex device behave exactly like a duplex |
534 | * device, we should copy in the case of sending to our own |
535 | * ethernet address (thus letting the original actually appear |
536 | * on the wire). However, we don't do that here for security |
537 | * reasons and compatibility with the original behavior. |
538 | */ |
539 | if ((ifp->if_flags & IFF_SIMPLEX) && |
540 | ((*m)->m_flags & M_LOOP) && lo_ifp != NULL) { |
541 | if ((*m)->m_flags & M_BCAST) { |
542 | struct mbuf *n = m_copy(*m, 0, (int)M_COPYALL); |
543 | if (n != NULL) { |
544 | dlil_output(lo_ifp, ndest->sa_family, |
545 | n, NULL, ndest, 0, NULL); |
546 | } |
547 | } else if (_ether_cmp(edst, IF_LLADDR(ifp)) == 0) { |
548 | dlil_output(lo_ifp, ndest->sa_family, *m, |
549 | NULL, ndest, 0, NULL); |
550 | return (EJUSTRETURN); |
551 | } |
552 | } |
553 | |
554 | /* |
555 | * Add local net header. If no space in first mbuf, |
556 | * allocate another. |
557 | */ |
558 | M_PREPEND(*m, sizeof (struct ether_header), M_DONTWAIT, 0); |
559 | if (*m == NULL) |
560 | return (EJUSTRETURN); |
561 | |
562 | if (prepend_len != NULL) |
563 | *prepend_len = sizeof (struct ether_header); |
564 | if (postpend_len != NULL) |
565 | *postpend_len = 0; |
566 | |
567 | eh = mtod(*m, struct ether_header *); |
568 | (void) memcpy(&eh->ether_type, ether_type, sizeof(eh->ether_type)); |
569 | (void) memcpy(eh->ether_dhost, edst, ETHER_ADDR_LEN); |
570 | ifnet_lladdr_copy_bytes(ifp, eh->ether_shost, ETHER_ADDR_LEN); |
571 | |
572 | return (0); |
573 | } |
574 | |
575 | errno_t |
576 | ether_check_multi(ifnet_t ifp, const struct sockaddr *proto_addr) |
577 | { |
578 | #pragma unused(ifp) |
579 | errno_t result = EAFNOSUPPORT; |
580 | const u_char *e_addr; |
581 | |
582 | /* |
583 | * AF_SPEC and AF_LINK don't require translation. We do |
584 | * want to verify that they specify a valid multicast. |
585 | */ |
586 | switch(proto_addr->sa_family) { |
587 | case AF_UNSPEC: |
588 | e_addr = (const u_char*)&proto_addr->sa_data[0]; |
589 | if ((e_addr[0] & 0x01) != 0x01) |
590 | result = EADDRNOTAVAIL; |
591 | else |
592 | result = 0; |
593 | break; |
594 | |
595 | case AF_LINK: |
596 | e_addr = CONST_LLADDR((const struct sockaddr_dl*) |
597 | (uintptr_t)(size_t)proto_addr); |
598 | if ((e_addr[0] & 0x01) != 0x01) |
599 | result = EADDRNOTAVAIL; |
600 | else |
601 | result = 0; |
602 | break; |
603 | } |
604 | |
605 | return (result); |
606 | } |
607 | |
608 | int |
609 | ether_ioctl(ifnet_t ifp, u_int32_t command, void *data) |
610 | { |
611 | #pragma unused(ifp, command, data) |
612 | return (EOPNOTSUPP); |
613 | } |
614 | |
615 | __private_extern__ int |
616 | ether_family_init(void) |
617 | { |
618 | errno_t error = 0; |
619 | |
620 | /* Register protocol registration functions */ |
621 | if ((error = proto_register_plumber(PF_INET, APPLE_IF_FAM_ETHERNET, |
622 | ether_attach_inet, ether_detach_inet)) != 0) { |
623 | printf("proto_register_plumber failed for PF_INET error=%d\n" , |
624 | error); |
625 | goto done; |
626 | } |
627 | #if INET6 |
628 | if ((error = proto_register_plumber(PF_INET6, APPLE_IF_FAM_ETHERNET, |
629 | ether_attach_inet6, ether_detach_inet6)) != 0) { |
630 | printf("proto_register_plumber failed for PF_INET6 error=%d\n" , |
631 | error); |
632 | goto done; |
633 | } |
634 | #endif /* INET6 */ |
635 | #if VLAN |
636 | vlan_family_init(); |
637 | #endif /* VLAN */ |
638 | #if BOND |
639 | bond_family_init(); |
640 | #endif /* BOND */ |
641 | #if IF_BRIDGE |
642 | bridgeattach(0); |
643 | #endif /* IF_BRIDGE */ |
644 | #if IF_FAKE |
645 | if_fake_init(); |
646 | #endif /* IF_FAKE */ |
647 | |
648 | done: |
649 | |
650 | return (error); |
651 | } |
652 | |