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#include <sys/socketvar.h> 71#include <kern/lock.h> 72 73#include <net/dlil.h> 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/ndrv.h> 80#include <net/kpi_protocol.h> 81#include <net/dlil.h> 82 83#include <netinet/in.h> 84#include <netinet/in_var.h> 85#include <netinet/if_ether.h> 86#include <netinet/in_systm.h> 87#include <netinet/ip.h> 88 89#if INET6 90#include <netinet6/nd6.h> 91#include <netinet6/in6_ifattach.h> 92#include <netinet6/ip6_var.h> 93#endif 94 95/* #include "vlan.h" */ 96#if NVLAN > 0 97#include <net/if_vlan_var.h> 98#endif /* NVLAN > 0 */ 99 100#include <net/ether_if_module.h> 101 102static const u_char etherip6allnodes[ETHER_ADDR_LEN] = 103 { 0x33, 0x33, 0, 0, 0, 1 }; 104 105/* 106 * Process a received Ethernet packet; 107 * the packet is in the mbuf chain m without 108 * the ether header, which is provided separately. 109 */ 110static errno_t 111ether_inet6_input(ifnet_t ifp, protocol_family_t protocol, 112 mbuf_t packet, char *header) 113{ 114#pragma unused(ifp, protocol) 115 struct ether_header *eh = (struct ether_header *)(void *)header; 116 u_int16_t ether_type; 117 118 bcopy(&eh->ether_type, ðer_type, sizeof (ether_type)); 119 120 if (ether_type == htons(ETHERTYPE_IPV6)) { 121 struct ifnet *mifp; 122 /* 123 * Trust the ifp in the mbuf, rather than ifproto's 124 * since the packet could have been injected via 125 * a dlil_input_packet_list() using an ifp that is 126 * different than the one where the packet really 127 * came from. 128 */ 129 mifp = mbuf_pkthdr_rcvif(packet); 130 131 /* Update L2 reachability record, if present (and not bcast) */ 132 if (bcmp(eh->ether_shost, etherbroadcastaddr, 133 ETHER_ADDR_LEN) != 0) { 134 nd6_llreach_set_reachable(mifp, eh->ether_shost, 135 ETHER_ADDR_LEN); 136 } 137 138 /* Save the Ethernet source address for all-nodes multicasts */ 139 if (!bcmp(eh->ether_dhost, etherip6allnodes, ETHER_ADDR_LEN)) { 140 struct ip6aux *ip6a; 141 142 ip6a = ip6_addaux(packet); 143 if (ip6a) { 144 ip6a->ip6a_flags |= IP6A_HASEEN; 145 bcopy(eh->ether_shost, ip6a->ip6a_ehsrc, 146 ETHER_ADDR_LEN); 147 } 148 } 149 150 if (proto_input(protocol, packet) != 0) 151 m_freem(packet); 152 } else { 153 m_freem(packet); 154 } 155 156 return (EJUSTRETURN); 157} 158 159static errno_t 160ether_inet6_pre_output(ifnet_t ifp, protocol_family_t protocol_family, 161 mbuf_t *m0, const struct sockaddr *dst_netaddr, void *route, 162 char *type, char *edst) 163{ 164#pragma unused(protocol_family) 165 errno_t result; 166 struct sockaddr_dl sdl; 167 struct mbuf *m = *m0; 168 169 /* 170 * Tell ether_frameout it's ok to loop packet if necessary 171 */ 172 m->m_flags |= M_LOOP; 173 174 result = nd6_lookup_ipv6(ifp, (const struct sockaddr_in6 *) 175 (uintptr_t)(size_t)dst_netaddr, &sdl, sizeof (sdl), route, *m0); 176 177 if (result == 0) { 178 u_int16_t ethertype_ipv6 = htons(ETHERTYPE_IPV6); 179 180 bcopy(ðertype_ipv6, type, sizeof (ethertype_ipv6)); 181 bcopy(LLADDR(&sdl), edst, sdl.sdl_alen); 182 } 183 184 return (result); 185} 186 187static int 188ether_inet6_resolve_multi(ifnet_t ifp, const struct sockaddr *proto_addr, 189 struct sockaddr_dl *out_ll, size_t ll_len) 190{ 191 static const size_t minsize = 192 offsetof(struct sockaddr_dl, sdl_data[0]) + ETHER_ADDR_LEN; 193 const struct sockaddr_in6 *sin6 = 194 (const struct sockaddr_in6 *)(uintptr_t)(size_t)proto_addr; 195 196 if (proto_addr->sa_family != AF_INET6) 197 return (EAFNOSUPPORT); 198 199 if (proto_addr->sa_len < sizeof (struct sockaddr_in6)) 200 return (EINVAL); 201 202 if (ll_len < minsize) 203 return (EMSGSIZE); 204 205 bzero(out_ll, minsize); 206 out_ll->sdl_len = minsize; 207 out_ll->sdl_family = AF_LINK; 208 out_ll->sdl_index = ifp->if_index; 209 out_ll->sdl_type = IFT_ETHER; 210 out_ll->sdl_nlen = 0; 211 out_ll->sdl_alen = ETHER_ADDR_LEN; 212 out_ll->sdl_slen = 0; 213 ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, LLADDR(out_ll)); 214 215 return (0); 216} 217 218static errno_t 219ether_inet6_prmod_ioctl(ifnet_t ifp, protocol_family_t protocol_family, 220 u_long command, void *data) 221{ 222#pragma unused(protocol_family) 223 int error = 0; 224 225 switch (command) { 226 case SIOCSIFADDR: /* struct ifaddr pointer */ 227 /* 228 * Note: caller of ifnet_ioctl() passes in pointer to 229 * struct ifaddr as parameter to SIOCSIFADDR, for legacy 230 * reasons. 231 */ 232 if ((ifp->if_flags & IFF_RUNNING) == 0) { 233 ifnet_set_flags(ifp, IFF_UP, IFF_UP); 234 ifnet_ioctl(ifp, 0, SIOCSIFFLAGS, NULL); 235 } 236 break; 237 238 case SIOCGIFADDR: { /* struct ifreq */ 239 struct ifreq *ifr = (struct ifreq *)(void *)data; 240 (void) ifnet_guarded_lladdr_copy_bytes(ifp, 241 ifr->ifr_addr.sa_data, ETHER_ADDR_LEN); 242 break; 243 } 244 245 default: 246 error = EOPNOTSUPP; 247 break; 248 } 249 return (error); 250} 251 252errno_t 253ether_attach_inet6(struct ifnet *ifp, protocol_family_t protocol_family) 254{ 255#pragma unused(protocol_family) 256 struct ifnet_attach_proto_param proto; 257 struct ifnet_demux_desc demux[1]; 258 u_short en_6native = htons(ETHERTYPE_IPV6); 259 errno_t error; 260 261 bzero(&proto, sizeof (proto)); 262 demux[0].type = DLIL_DESC_ETYPE2; 263 demux[0].data = &en_6native; 264 demux[0].datalen = sizeof (en_6native); 265 proto.demux_list = demux; 266 proto.demux_count = 1; 267 proto.input = ether_inet6_input; 268 proto.pre_output = ether_inet6_pre_output; 269 proto.ioctl = ether_inet6_prmod_ioctl; 270 proto.resolve = ether_inet6_resolve_multi; 271 error = ifnet_attach_protocol(ifp, protocol_family, &proto); 272 if (error && error != EEXIST) { 273 printf("WARNING: %s can't attach ipv6 to %s\n", __func__, 274 if_name(ifp)); 275 } 276 277 return (error); 278} 279 280void 281ether_detach_inet6(struct ifnet *ifp, protocol_family_t protocol_family) 282{ 283 (void) ifnet_detach_protocol(ifp, protocol_family); 284} 285