xref: /titanic_51/usr/src/uts/common/inet/ip/ip_netinfo.c (revision b819cea2f73f98c5662230cc9affc8cc84f77fcf)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/param.h>
27 #include <sys/types.h>
28 #include <sys/systm.h>
29 #include <sys/stream.h>
30 #include <sys/strsubr.h>
31 #include <sys/pattr.h>
32 #include <sys/dlpi.h>
33 #include <sys/atomic.h>
34 #include <sys/sunddi.h>
35 #include <sys/socket.h>
36 #include <sys/neti.h>
37 #include <sys/sdt.h>
38 #include <sys/cmn_err.h>
39 
40 #include <netinet/in.h>
41 #include <inet/ipsec_impl.h>
42 #include <inet/common.h>
43 #include <inet/mib2.h>
44 #include <inet/ip.h>
45 #include <inet/ip6.h>
46 #include <inet/ip_if.h>
47 #include <inet/ip_ire.h>
48 #include <inet/ip_impl.h>
49 #include <inet/ip_ndp.h>
50 #include <inet/ipclassifier.h>
51 #include <inet/ipp_common.h>
52 #include <inet/ip_ftable.h>
53 
54 /*
55  * IPv4 netinfo entry point declarations.
56  */
57 static int 		ip_getifname(net_handle_t, phy_if_t, char *,
58 			    const size_t);
59 static int 		ip_getmtu(net_handle_t, phy_if_t, lif_if_t);
60 static int 		ip_getpmtuenabled(net_handle_t);
61 static int 		ip_getlifaddr(net_handle_t, phy_if_t, lif_if_t,
62 			    size_t, net_ifaddr_t [], void *);
63 static int		ip_getlifzone(net_handle_t, phy_if_t, lif_if_t,
64 			    zoneid_t *);
65 static int		ip_getlifflags(net_handle_t, phy_if_t, lif_if_t,
66 			    uint64_t *);
67 static phy_if_t		ip_phygetnext(net_handle_t, phy_if_t);
68 static phy_if_t 	ip_phylookup(net_handle_t, const char *);
69 static lif_if_t 	ip_lifgetnext(net_handle_t, phy_if_t, lif_if_t);
70 static int 		ip_inject(net_handle_t, inject_t, net_inject_t *);
71 static phy_if_t 	ip_routeto(net_handle_t, struct sockaddr *,
72 			    struct sockaddr *);
73 static int 		ip_ispartialchecksum(net_handle_t, mblk_t *);
74 static int 		ip_isvalidchecksum(net_handle_t, mblk_t *);
75 
76 static int 		ipv6_getifname(net_handle_t, phy_if_t, char *,
77 			    const size_t);
78 static int 		ipv6_getmtu(net_handle_t, phy_if_t, lif_if_t);
79 static int 		ipv6_getlifaddr(net_handle_t, phy_if_t, lif_if_t,
80 			    size_t, net_ifaddr_t [], void *);
81 static int		ipv6_getlifzone(net_handle_t, phy_if_t, lif_if_t,
82 			    zoneid_t *);
83 static int		ipv6_getlifflags(net_handle_t, phy_if_t, lif_if_t,
84 			    uint64_t *);
85 static phy_if_t 	ipv6_phygetnext(net_handle_t, phy_if_t);
86 static phy_if_t 	ipv6_phylookup(net_handle_t, const char *);
87 static lif_if_t 	ipv6_lifgetnext(net_handle_t, phy_if_t, lif_if_t);
88 static int 		ipv6_inject(net_handle_t, inject_t, net_inject_t *);
89 static phy_if_t 	ipv6_routeto(net_handle_t, struct sockaddr *,
90 			    struct sockaddr *);
91 static int 		ipv6_isvalidchecksum(net_handle_t, mblk_t *);
92 
93 static int 		net_no_getmtu(net_handle_t, phy_if_t, lif_if_t);
94 static int 		net_no_getpmtuenabled(net_handle_t);
95 static lif_if_t 	net_no_lifgetnext(net_handle_t, phy_if_t, lif_if_t);
96 static int 		net_no_inject(net_handle_t, inject_t, net_inject_t *);
97 static phy_if_t 	net_no_routeto(net_handle_t, struct sockaddr *,
98 			    struct sockaddr *);
99 static int 		net_no_ispartialchecksum(net_handle_t, mblk_t *);
100 static int 		net_no_getlifaddr(net_handle_t, phy_if_t, lif_if_t,
101 			    size_t, net_ifaddr_t [], void *);
102 static int		net_no_getlifzone(net_handle_t, phy_if_t, lif_if_t,
103 			    zoneid_t *);
104 static int		net_no_getlifflags(net_handle_t, phy_if_t, lif_if_t,
105 			    uint64_t *);
106 
107 /* Netinfo private functions */
108 static	int		ip_getifname_impl(phy_if_t, char *,
109 			    const size_t, boolean_t, ip_stack_t *);
110 static	int		ip_getmtu_impl(phy_if_t, lif_if_t, boolean_t,
111 			    ip_stack_t *);
112 static	phy_if_t	ip_phylookup_impl(const char *, boolean_t,
113 			    ip_stack_t *);
114 static	lif_if_t	ip_lifgetnext_impl(phy_if_t, lif_if_t, boolean_t,
115 			    ip_stack_t *);
116 static	int		ip_inject_impl(inject_t, net_inject_t *, boolean_t,
117 			    ip_stack_t *);
118 static	int		ip_getifaddr_type(sa_family_t, ipif_t *, lif_if_t,
119 			    void *);
120 static	phy_if_t	ip_routeto_impl(struct sockaddr *, struct sockaddr *,
121 			    ip_stack_t *);
122 static	int		ip_getlifaddr_impl(sa_family_t, phy_if_t, lif_if_t,
123 			    size_t, net_ifaddr_t [], struct sockaddr *,
124 			    ip_stack_t *);
125 static	void		ip_ni_queue_in_func(void *);
126 static	void		ip_ni_queue_out_func(void *);
127 static	void		ip_ni_queue_func_impl(injection_t *,  boolean_t);
128 
129 static net_protocol_t ipv4info = {
130 	NETINFO_VERSION,
131 	NHF_INET,
132 	ip_getifname,
133 	ip_getmtu,
134 	ip_getpmtuenabled,
135 	ip_getlifaddr,
136 	ip_getlifzone,
137 	ip_getlifflags,
138 	ip_phygetnext,
139 	ip_phylookup,
140 	ip_lifgetnext,
141 	ip_inject,
142 	ip_routeto,
143 	ip_ispartialchecksum,
144 	ip_isvalidchecksum
145 };
146 
147 
148 static net_protocol_t ipv6info = {
149 	NETINFO_VERSION,
150 	NHF_INET6,
151 	ipv6_getifname,
152 	ipv6_getmtu,
153 	ip_getpmtuenabled,
154 	ipv6_getlifaddr,
155 	ipv6_getlifzone,
156 	ipv6_getlifflags,
157 	ipv6_phygetnext,
158 	ipv6_phylookup,
159 	ipv6_lifgetnext,
160 	ipv6_inject,
161 	ipv6_routeto,
162 	ip_ispartialchecksum,
163 	ipv6_isvalidchecksum
164 };
165 
166 static net_protocol_t arp_netinfo = {
167 	NETINFO_VERSION,
168 	NHF_ARP,
169 	ip_getifname,
170 	net_no_getmtu,
171 	net_no_getpmtuenabled,
172 	net_no_getlifaddr,
173 	net_no_getlifzone,
174 	net_no_getlifflags,
175 	ip_phygetnext,
176 	ip_phylookup,
177 	net_no_lifgetnext,
178 	net_no_inject,
179 	net_no_routeto,
180 	net_no_ispartialchecksum,
181 	ip_isvalidchecksum
182 };
183 
184 /*
185  * The taskq eventq_queue_in is used to process the upside inject messages.
186  * The taskq eventq_queue_out is used to process the downside inject messages.
187  * The taskq eventq_queue_nic is used to process the nic event messages.
188  */
189 static ddi_taskq_t 	*eventq_queue_in = NULL;
190 static ddi_taskq_t 	*eventq_queue_out = NULL;
191 ddi_taskq_t 	*eventq_queue_nic = NULL;
192 
193 /*
194  * Initialize queues for inject.
195  */
196 void
197 ip_net_g_init()
198 {
199 	if (eventq_queue_out == NULL) {
200 		eventq_queue_out = ddi_taskq_create(NULL,
201 		    "IP_INJECT_QUEUE_OUT", 1, TASKQ_DEFAULTPRI, 0);
202 
203 		if (eventq_queue_out == NULL)
204 			cmn_err(CE_NOTE, "ipv4_net_init: "
205 			    "ddi_taskq_create failed for IP_INJECT_QUEUE_OUT");
206 	}
207 
208 	if (eventq_queue_in == NULL) {
209 		eventq_queue_in = ddi_taskq_create(NULL,
210 		    "IP_INJECT_QUEUE_IN", 1, TASKQ_DEFAULTPRI, 0);
211 
212 		if (eventq_queue_in == NULL)
213 			cmn_err(CE_NOTE, "ipv4_net_init: "
214 			    "ddi_taskq_create failed for IP_INJECT_QUEUE_IN");
215 	}
216 
217 	if (eventq_queue_nic == NULL) {
218 		eventq_queue_nic = ddi_taskq_create(NULL,
219 		    "IP_NIC_EVENT_QUEUE", 1, TASKQ_DEFAULTPRI, 0);
220 
221 		if (eventq_queue_nic == NULL)
222 			cmn_err(CE_NOTE, "ipv4_net_init: "
223 			    "ddi_taskq_create failed for IP_NIC_EVENT_QUEUE");
224 	}
225 }
226 
227 /*
228  * Destroy inject queues
229  */
230 void
231 ip_net_g_destroy()
232 {
233 	if (eventq_queue_nic != NULL) {
234 		ddi_taskq_destroy(eventq_queue_nic);
235 		eventq_queue_nic = NULL;
236 	}
237 
238 	if (eventq_queue_in != NULL) {
239 		ddi_taskq_destroy(eventq_queue_in);
240 		eventq_queue_in = NULL;
241 	}
242 
243 	if (eventq_queue_out != NULL) {
244 		ddi_taskq_destroy(eventq_queue_out);
245 		eventq_queue_out = NULL;
246 	}
247 }
248 
249 /*
250  * Register IPv4 and IPv6 netinfo functions and initialize queues for inject.
251  */
252 void
253 ip_net_init(ip_stack_t *ipst, netstack_t *ns)
254 {
255 	netid_t id;
256 
257 	id = net_getnetidbynetstackid(ns->netstack_stackid);
258 	ASSERT(id != -1);
259 
260 	ipst->ips_ipv4_net_data = net_protocol_register(id, &ipv4info);
261 	ASSERT(ipst->ips_ipv4_net_data != NULL);
262 
263 	ipst->ips_ipv6_net_data = net_protocol_register(id, &ipv6info);
264 	ASSERT(ipst->ips_ipv6_net_data != NULL);
265 
266 	ipst->ips_arp_net_data = net_protocol_register(id, &arp_netinfo);
267 	ASSERT(ipst->ips_ipv6_net_data != NULL);
268 }
269 
270 
271 /*
272  * Unregister IPv4 and IPv6 functions.
273  */
274 void
275 ip_net_destroy(ip_stack_t *ipst)
276 {
277 	if (ipst->ips_ipv4_net_data != NULL) {
278 		if (net_protocol_unregister(ipst->ips_ipv4_net_data) == 0)
279 			ipst->ips_ipv4_net_data = NULL;
280 	}
281 
282 	if (ipst->ips_ipv6_net_data != NULL) {
283 		if (net_protocol_unregister(ipst->ips_ipv6_net_data) == 0)
284 			ipst->ips_ipv6_net_data = NULL;
285 	}
286 
287 	if (ipst->ips_arp_net_data != NULL) {
288 		if (net_protocol_unregister(ipst->ips_arp_net_data) == 0)
289 			ipst->ips_arp_net_data = NULL;
290 	}
291 }
292 
293 /*
294  * Initialize IPv4 hooks family the event
295  */
296 void
297 ipv4_hook_init(ip_stack_t *ipst)
298 {
299 	HOOK_FAMILY_INIT(&ipst->ips_ipv4root, Hn_IPV4);
300 	if (net_family_register(ipst->ips_ipv4_net_data, &ipst->ips_ipv4root)
301 	    != 0) {
302 		cmn_err(CE_NOTE, "ipv4_hook_init: "
303 		    "net_family_register failed for ipv4");
304 	}
305 
306 	HOOK_EVENT_INIT(&ipst->ips_ip4_physical_in_event, NH_PHYSICAL_IN);
307 	ipst->ips_ipv4firewall_physical_in = net_event_register(
308 	    ipst->ips_ipv4_net_data, &ipst->ips_ip4_physical_in_event);
309 	if (ipst->ips_ipv4firewall_physical_in == NULL) {
310 		cmn_err(CE_NOTE, "ipv4_hook_init: "
311 		    "net_event_register failed for ipv4/physical_in");
312 	}
313 
314 	HOOK_EVENT_INIT(&ipst->ips_ip4_physical_out_event, NH_PHYSICAL_OUT);
315 	ipst->ips_ipv4firewall_physical_out = net_event_register(
316 	    ipst->ips_ipv4_net_data, &ipst->ips_ip4_physical_out_event);
317 	if (ipst->ips_ipv4firewall_physical_out == NULL) {
318 		cmn_err(CE_NOTE, "ipv4_hook_init: "
319 		    "net_event_register failed for ipv4/physical_out");
320 	}
321 
322 	HOOK_EVENT_INIT(&ipst->ips_ip4_forwarding_event, NH_FORWARDING);
323 	ipst->ips_ipv4firewall_forwarding = net_event_register(
324 	    ipst->ips_ipv4_net_data, &ipst->ips_ip4_forwarding_event);
325 	if (ipst->ips_ipv4firewall_forwarding == NULL) {
326 		cmn_err(CE_NOTE, "ipv4_hook_init: "
327 		    "net_event_register failed for ipv4/forwarding");
328 	}
329 
330 	HOOK_EVENT_INIT(&ipst->ips_ip4_loopback_in_event, NH_LOOPBACK_IN);
331 	ipst->ips_ipv4firewall_loopback_in = net_event_register(
332 	    ipst->ips_ipv4_net_data, &ipst->ips_ip4_loopback_in_event);
333 	if (ipst->ips_ipv4firewall_loopback_in == NULL) {
334 		cmn_err(CE_NOTE, "ipv4_hook_init: "
335 		    "net_event_register failed for ipv4/loopback_in");
336 	}
337 
338 	HOOK_EVENT_INIT(&ipst->ips_ip4_loopback_out_event, NH_LOOPBACK_OUT);
339 	ipst->ips_ipv4firewall_loopback_out = net_event_register(
340 	    ipst->ips_ipv4_net_data, &ipst->ips_ip4_loopback_out_event);
341 	if (ipst->ips_ipv4firewall_loopback_out == NULL) {
342 		cmn_err(CE_NOTE, "ipv4_hook_init: "
343 		    "net_event_register failed for ipv4/loopback_out");
344 	}
345 
346 	HOOK_EVENT_INIT(&ipst->ips_ip4_nic_events, NH_NIC_EVENTS);
347 	ipst->ips_ip4_nic_events.he_flags = HOOK_RDONLY;
348 	ipst->ips_ipv4nicevents = net_event_register(
349 	    ipst->ips_ipv4_net_data, &ipst->ips_ip4_nic_events);
350 	if (ipst->ips_ipv4nicevents == NULL) {
351 		cmn_err(CE_NOTE, "ipv4_hook_init: "
352 		    "net_event_register failed for ipv4/nic_events");
353 	}
354 
355 	HOOK_EVENT_INIT(&ipst->ips_ip4_observe, NH_OBSERVE);
356 	ipst->ips_ip4_observe.he_flags = HOOK_RDONLY;
357 	ipst->ips_ipv4observing = net_event_register(
358 	    ipst->ips_ipv4_net_data, &ipst->ips_ip4_observe);
359 	if (ipst->ips_ipv4observing == NULL) {
360 		cmn_err(CE_NOTE, "ipv4_hook_init: "
361 		    "net_event_register failed for ipv4/observe");
362 	}
363 
364 }
365 
366 void
367 ipv4_hook_shutdown(ip_stack_t *ipst)
368 {
369 	if (ipst->ips_ipv4firewall_forwarding != NULL) {
370 		(void) net_event_shutdown(ipst->ips_ipv4_net_data,
371 		    &ipst->ips_ip4_forwarding_event);
372 	}
373 
374 	if (ipst->ips_ipv4firewall_physical_in != NULL) {
375 		(void) net_event_shutdown(ipst->ips_ipv4_net_data,
376 		    &ipst->ips_ip4_physical_in_event);
377 	}
378 
379 	if (ipst->ips_ipv4firewall_physical_out != NULL) {
380 		(void) net_event_shutdown(ipst->ips_ipv4_net_data,
381 		    &ipst->ips_ip4_physical_out_event);
382 	}
383 
384 	if (ipst->ips_ipv4firewall_loopback_in != NULL) {
385 		(void) net_event_shutdown(ipst->ips_ipv4_net_data,
386 		    &ipst->ips_ip4_loopback_in_event);
387 	}
388 
389 	if (ipst->ips_ipv4firewall_loopback_out != NULL) {
390 		(void) net_event_shutdown(ipst->ips_ipv4_net_data,
391 		    &ipst->ips_ip4_loopback_out_event);
392 	}
393 
394 	if (ipst->ips_ipv4nicevents != NULL) {
395 		(void) net_event_shutdown(ipst->ips_ipv4_net_data,
396 		    &ipst->ips_ip4_nic_events);
397 	}
398 
399 	if (ipst->ips_ipv4observing != NULL) {
400 		(void) net_event_shutdown(ipst->ips_ipv4_net_data,
401 		    &ipst->ips_ip4_observe);
402 	}
403 
404 	(void) net_family_shutdown(ipst->ips_ipv4_net_data,
405 	    &ipst->ips_ipv4root);
406 }
407 
408 void
409 ipv4_hook_destroy(ip_stack_t *ipst)
410 {
411 	if (ipst->ips_ipv4firewall_forwarding != NULL) {
412 		if (net_event_unregister(ipst->ips_ipv4_net_data,
413 		    &ipst->ips_ip4_forwarding_event) == 0)
414 			ipst->ips_ipv4firewall_forwarding = NULL;
415 	}
416 
417 	if (ipst->ips_ipv4firewall_physical_in != NULL) {
418 		if (net_event_unregister(ipst->ips_ipv4_net_data,
419 		    &ipst->ips_ip4_physical_in_event) == 0)
420 			ipst->ips_ipv4firewall_physical_in = NULL;
421 	}
422 
423 	if (ipst->ips_ipv4firewall_physical_out != NULL) {
424 		if (net_event_unregister(ipst->ips_ipv4_net_data,
425 		    &ipst->ips_ip4_physical_out_event) == 0)
426 			ipst->ips_ipv4firewall_physical_out = NULL;
427 	}
428 
429 	if (ipst->ips_ipv4firewall_loopback_in != NULL) {
430 		if (net_event_unregister(ipst->ips_ipv4_net_data,
431 		    &ipst->ips_ip4_loopback_in_event) == 0)
432 			ipst->ips_ipv4firewall_loopback_in = NULL;
433 	}
434 
435 	if (ipst->ips_ipv4firewall_loopback_out != NULL) {
436 		if (net_event_unregister(ipst->ips_ipv4_net_data,
437 		    &ipst->ips_ip4_loopback_out_event) == 0)
438 			ipst->ips_ipv4firewall_loopback_out = NULL;
439 	}
440 
441 	if (ipst->ips_ipv4nicevents != NULL) {
442 		if (net_event_unregister(ipst->ips_ipv4_net_data,
443 		    &ipst->ips_ip4_nic_events) == 0)
444 			ipst->ips_ipv4nicevents = NULL;
445 	}
446 
447 	if (ipst->ips_ipv4observing != NULL) {
448 		if (net_event_unregister(ipst->ips_ipv4_net_data,
449 		    &ipst->ips_ip4_observe) == 0)
450 			ipst->ips_ipv4observing = NULL;
451 	}
452 
453 	(void) net_family_unregister(ipst->ips_ipv4_net_data,
454 	    &ipst->ips_ipv4root);
455 }
456 
457 /*
458  * Initialize IPv6 hooks family and event
459  */
460 void
461 ipv6_hook_init(ip_stack_t *ipst)
462 {
463 
464 	HOOK_FAMILY_INIT(&ipst->ips_ipv6root, Hn_IPV6);
465 	if (net_family_register(ipst->ips_ipv6_net_data, &ipst->ips_ipv6root)
466 	    != 0) {
467 		cmn_err(CE_NOTE, "ipv6_hook_init: "
468 		    "net_family_register failed for ipv6");
469 	}
470 
471 	HOOK_EVENT_INIT(&ipst->ips_ip6_physical_in_event, NH_PHYSICAL_IN);
472 	ipst->ips_ipv6firewall_physical_in = net_event_register(
473 	    ipst->ips_ipv6_net_data, &ipst->ips_ip6_physical_in_event);
474 	if (ipst->ips_ipv6firewall_physical_in == NULL) {
475 		cmn_err(CE_NOTE, "ipv6_hook_init: "
476 		    "net_event_register failed for ipv6/physical_in");
477 	}
478 
479 	HOOK_EVENT_INIT(&ipst->ips_ip6_physical_out_event, NH_PHYSICAL_OUT);
480 	ipst->ips_ipv6firewall_physical_out = net_event_register(
481 	    ipst->ips_ipv6_net_data, &ipst->ips_ip6_physical_out_event);
482 	if (ipst->ips_ipv6firewall_physical_out == NULL) {
483 		cmn_err(CE_NOTE, "ipv6_hook_init: "
484 		    "net_event_register failed for ipv6/physical_out");
485 	}
486 
487 	HOOK_EVENT_INIT(&ipst->ips_ip6_forwarding_event, NH_FORWARDING);
488 	ipst->ips_ipv6firewall_forwarding = net_event_register(
489 	    ipst->ips_ipv6_net_data, &ipst->ips_ip6_forwarding_event);
490 	if (ipst->ips_ipv6firewall_forwarding == NULL) {
491 		cmn_err(CE_NOTE, "ipv6_hook_init: "
492 		    "net_event_register failed for ipv6/forwarding");
493 	}
494 
495 	HOOK_EVENT_INIT(&ipst->ips_ip6_loopback_in_event, NH_LOOPBACK_IN);
496 	ipst->ips_ipv6firewall_loopback_in = net_event_register(
497 	    ipst->ips_ipv6_net_data, &ipst->ips_ip6_loopback_in_event);
498 	if (ipst->ips_ipv6firewall_loopback_in == NULL) {
499 		cmn_err(CE_NOTE, "ipv6_hook_init: "
500 		    "net_event_register failed for ipv6/loopback_in");
501 	}
502 
503 	HOOK_EVENT_INIT(&ipst->ips_ip6_loopback_out_event, NH_LOOPBACK_OUT);
504 	ipst->ips_ipv6firewall_loopback_out = net_event_register(
505 	    ipst->ips_ipv6_net_data, &ipst->ips_ip6_loopback_out_event);
506 	if (ipst->ips_ipv6firewall_loopback_out == NULL) {
507 		cmn_err(CE_NOTE, "ipv6_hook_init: "
508 		    "net_event_register failed for ipv6/loopback_out");
509 	}
510 
511 	HOOK_EVENT_INIT(&ipst->ips_ip6_nic_events, NH_NIC_EVENTS);
512 	ipst->ips_ip6_nic_events.he_flags = HOOK_RDONLY;
513 	ipst->ips_ipv6nicevents = net_event_register(
514 	    ipst->ips_ipv6_net_data, &ipst->ips_ip6_nic_events);
515 	if (ipst->ips_ipv6nicevents == NULL) {
516 		cmn_err(CE_NOTE, "ipv6_hook_init: "
517 		    "net_event_register failed for ipv6/nic_events");
518 	}
519 
520 	HOOK_EVENT_INIT(&ipst->ips_ip6_observe, NH_OBSERVE);
521 	ipst->ips_ip6_observe.he_flags = HOOK_RDONLY;
522 	ipst->ips_ipv6observing = net_event_register(
523 	    ipst->ips_ipv6_net_data, &ipst->ips_ip6_observe);
524 	if (ipst->ips_ipv6observing == NULL) {
525 		cmn_err(CE_NOTE, "ipv6_hook_init: "
526 		    "net_event_register failed for ipv6/observe");
527 	}
528 }
529 
530 void
531 ipv6_hook_shutdown(ip_stack_t *ipst)
532 {
533 	if (ipst->ips_ipv6firewall_forwarding != NULL) {
534 		(void) net_event_shutdown(ipst->ips_ipv6_net_data,
535 		    &ipst->ips_ip6_forwarding_event);
536 	}
537 
538 	if (ipst->ips_ipv6firewall_physical_in != NULL) {
539 		(void) net_event_shutdown(ipst->ips_ipv6_net_data,
540 		    &ipst->ips_ip6_physical_in_event);
541 	}
542 
543 	if (ipst->ips_ipv6firewall_physical_out != NULL) {
544 		(void) net_event_shutdown(ipst->ips_ipv6_net_data,
545 		    &ipst->ips_ip6_physical_out_event);
546 	}
547 
548 	if (ipst->ips_ipv6firewall_loopback_in != NULL) {
549 		(void) net_event_shutdown(ipst->ips_ipv6_net_data,
550 		    &ipst->ips_ip6_loopback_in_event);
551 	}
552 
553 	if (ipst->ips_ipv6firewall_loopback_out != NULL) {
554 		(void) net_event_shutdown(ipst->ips_ipv6_net_data,
555 		    &ipst->ips_ip6_loopback_out_event);
556 	}
557 
558 	if (ipst->ips_ipv6nicevents != NULL) {
559 		(void) net_event_shutdown(ipst->ips_ipv6_net_data,
560 		    &ipst->ips_ip6_nic_events);
561 	}
562 
563 	if (ipst->ips_ipv6observing != NULL) {
564 		(void) net_event_shutdown(ipst->ips_ipv6_net_data,
565 		    &ipst->ips_ip6_observe);
566 	}
567 
568 	(void) net_family_shutdown(ipst->ips_ipv6_net_data,
569 	    &ipst->ips_ipv6root);
570 }
571 
572 void
573 ipv6_hook_destroy(ip_stack_t *ipst)
574 {
575 	if (ipst->ips_ipv6firewall_forwarding != NULL) {
576 		if (net_event_unregister(ipst->ips_ipv6_net_data,
577 		    &ipst->ips_ip6_forwarding_event) == 0)
578 			ipst->ips_ipv6firewall_forwarding = NULL;
579 	}
580 
581 	if (ipst->ips_ipv6firewall_physical_in != NULL) {
582 		if (net_event_unregister(ipst->ips_ipv6_net_data,
583 		    &ipst->ips_ip6_physical_in_event) == 0)
584 			ipst->ips_ipv6firewall_physical_in = NULL;
585 	}
586 
587 	if (ipst->ips_ipv6firewall_physical_out != NULL) {
588 		if (net_event_unregister(ipst->ips_ipv6_net_data,
589 		    &ipst->ips_ip6_physical_out_event) == 0)
590 			ipst->ips_ipv6firewall_physical_out = NULL;
591 	}
592 
593 	if (ipst->ips_ipv6firewall_loopback_in != NULL) {
594 		if (net_event_unregister(ipst->ips_ipv6_net_data,
595 		    &ipst->ips_ip6_loopback_in_event) == 0)
596 			ipst->ips_ipv6firewall_loopback_in = NULL;
597 	}
598 
599 	if (ipst->ips_ipv6firewall_loopback_out != NULL) {
600 		if (net_event_unregister(ipst->ips_ipv6_net_data,
601 		    &ipst->ips_ip6_loopback_out_event) == 0)
602 			ipst->ips_ipv6firewall_loopback_out = NULL;
603 	}
604 
605 	if (ipst->ips_ipv6nicevents != NULL) {
606 		if (net_event_unregister(ipst->ips_ipv6_net_data,
607 		    &ipst->ips_ip6_nic_events) == 0)
608 			ipst->ips_ipv6nicevents = NULL;
609 	}
610 
611 	if (ipst->ips_ipv6observing != NULL) {
612 		if (net_event_unregister(ipst->ips_ipv6_net_data,
613 		    &ipst->ips_ip6_observe) == 0)
614 			ipst->ips_ipv6observing = NULL;
615 	}
616 
617 	(void) net_family_unregister(ipst->ips_ipv6_net_data,
618 	    &ipst->ips_ipv6root);
619 }
620 
621 /*
622  * Determine the name of an IPv4 interface
623  */
624 static int
625 ip_getifname(net_handle_t neti, phy_if_t phy_ifdata, char *buffer,
626     const size_t buflen)
627 {
628 	return (ip_getifname_impl(phy_ifdata, buffer, buflen, B_FALSE,
629 	    neti->netd_stack->nts_netstack->netstack_ip));
630 }
631 
632 /*
633  * Determine the name of an IPv6 interface
634  */
635 static int
636 ipv6_getifname(net_handle_t neti, phy_if_t phy_ifdata, char *buffer,
637     const size_t buflen)
638 {
639 	return (ip_getifname_impl(phy_ifdata, buffer, buflen, B_TRUE,
640 	    neti->netd_stack->nts_netstack->netstack_ip));
641 }
642 
643 /*
644  * Shared implementation to determine the name of a given network interface
645  */
646 /* ARGSUSED */
647 static int
648 ip_getifname_impl(phy_if_t phy_ifdata,
649     char *buffer, const size_t buflen, boolean_t isv6, ip_stack_t *ipst)
650 {
651 	ill_t *ill;
652 
653 	ASSERT(buffer != NULL);
654 
655 	ill = ill_lookup_on_ifindex((uint_t)phy_ifdata, isv6, ipst);
656 	if (ill == NULL)
657 		return (1);
658 
659 	(void) strlcpy(buffer, ill->ill_name, buflen);
660 	ill_refrele(ill);
661 	return (0);
662 }
663 
664 /*
665  * Determine the MTU of an IPv4 network interface
666  */
667 static int
668 ip_getmtu(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata)
669 {
670 	netstack_t *ns;
671 
672 	ns = neti->netd_stack->nts_netstack;
673 	ASSERT(ns != NULL);
674 	return (ip_getmtu_impl(phy_ifdata, ifdata, B_FALSE, ns->netstack_ip));
675 }
676 
677 /*
678  * Determine the MTU of an IPv6 network interface
679  */
680 static int
681 ipv6_getmtu(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata)
682 {
683 	netstack_t *ns;
684 
685 	ns = neti->netd_stack->nts_netstack;
686 	ASSERT(ns != NULL);
687 	return (ip_getmtu_impl(phy_ifdata, ifdata, B_TRUE, ns->netstack_ip));
688 }
689 
690 /*
691  * Shared implementation to determine the MTU of a network interface
692  */
693 /* ARGSUSED */
694 static int
695 ip_getmtu_impl(phy_if_t phy_ifdata, lif_if_t ifdata, boolean_t isv6,
696     ip_stack_t *ipst)
697 {
698 	lif_if_t ipifid;
699 	ipif_t *ipif;
700 	int mtu;
701 
702 	ipifid = UNMAP_IPIF_ID(ifdata);
703 
704 	ipif = ipif_getby_indexes((uint_t)phy_ifdata, (uint_t)ipifid,
705 	    isv6, ipst);
706 	if (ipif == NULL)
707 		return (0);
708 
709 	mtu = ipif->ipif_ill->ill_mtu;
710 	ipif_refrele(ipif);
711 
712 	if (mtu == 0) {
713 		ill_t *ill;
714 
715 		if ((ill = ill_lookup_on_ifindex((uint_t)phy_ifdata, isv6,
716 		    ipst)) == NULL) {
717 			return (0);
718 		}
719 		mtu = ill->ill_mtu;
720 		ill_refrele(ill);
721 	}
722 
723 	return (mtu);
724 }
725 
726 /*
727  * Determine if path MTU discovery is enabled for IP
728  */
729 static int
730 ip_getpmtuenabled(net_handle_t neti)
731 {
732 	netstack_t *ns;
733 
734 	ns = neti->netd_stack->nts_netstack;
735 	ASSERT(ns != NULL);
736 	return (ns->netstack_ip->ips_ip_path_mtu_discovery);
737 }
738 
739 /*
740  * Get next interface from the current list of IPv4 physical network interfaces
741  */
742 static phy_if_t
743 ip_phygetnext(net_handle_t neti, phy_if_t phy_ifdata)
744 {
745 	netstack_t *ns;
746 
747 	ns = neti->netd_stack->nts_netstack;
748 	ASSERT(ns != NULL);
749 	return (ill_get_next_ifindex(phy_ifdata, B_FALSE, ns->netstack_ip));
750 }
751 
752 /*
753  * Get next interface from the current list of IPv6 physical network interfaces
754  */
755 static phy_if_t
756 ipv6_phygetnext(net_handle_t neti, phy_if_t phy_ifdata)
757 {
758 	netstack_t *ns;
759 
760 	ns = neti->netd_stack->nts_netstack;
761 	ASSERT(ns != NULL);
762 	return (ill_get_next_ifindex(phy_ifdata, B_TRUE, ns->netstack_ip));
763 }
764 
765 /*
766  * Determine if a network interface name exists for IPv4
767  */
768 static phy_if_t
769 ip_phylookup(net_handle_t neti, const char *name)
770 {
771 	netstack_t *ns;
772 
773 	ns = neti->netd_stack->nts_netstack;
774 	ASSERT(ns != NULL);
775 	return (ip_phylookup_impl(name, B_FALSE, ns->netstack_ip));
776 }
777 
778 /*
779  * Determine if a network interface name exists for IPv6
780  */
781 static phy_if_t
782 ipv6_phylookup(net_handle_t neti, const char *name)
783 {
784 	netstack_t *ns;
785 
786 	ns = neti->netd_stack->nts_netstack;
787 	ASSERT(ns != NULL);
788 	return (ip_phylookup_impl(name, B_TRUE, ns->netstack_ip));
789 }
790 
791 /*
792  * Implement looking up an ill_t based on the name supplied and matching
793  * it up with either IPv4 or IPv6.  ill_get_ifindex_by_name() is not used
794  * because it does not match on the address family in addition to the name.
795  */
796 static phy_if_t
797 ip_phylookup_impl(const char *name, boolean_t isv6, ip_stack_t *ipst)
798 {
799 	phy_if_t phy;
800 	ill_t *ill;
801 
802 	ill = ill_lookup_on_name((char *)name, B_FALSE, isv6, NULL, ipst);
803 	if (ill == NULL)
804 		return (0);
805 
806 	phy = ill->ill_phyint->phyint_ifindex;
807 
808 	ill_refrele(ill);
809 
810 	return (phy);
811 }
812 
813 /*
814  * Get next interface from the current list of IPv4 logical network interfaces
815  */
816 static lif_if_t
817 ip_lifgetnext(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata)
818 {
819 	netstack_t *ns;
820 
821 	ns = neti->netd_stack->nts_netstack;
822 	ASSERT(ns != NULL);
823 	return (ip_lifgetnext_impl(phy_ifdata, ifdata, B_FALSE,
824 	    ns->netstack_ip));
825 }
826 
827 /*
828  * Get next interface from the current list of IPv6 logical network interfaces
829  */
830 static lif_if_t
831 ipv6_lifgetnext(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata)
832 {
833 	netstack_t *ns;
834 
835 	ns = neti->netd_stack->nts_netstack;
836 	ASSERT(ns != NULL);
837 	return (ip_lifgetnext_impl(phy_ifdata, ifdata, B_TRUE,
838 	    ns->netstack_ip));
839 }
840 
841 /*
842  * Shared implementation to get next interface from the current list of
843  * logical network interfaces
844  */
845 static lif_if_t
846 ip_lifgetnext_impl(phy_if_t phy_ifdata, lif_if_t ifdata, boolean_t isv6,
847     ip_stack_t *ipst)
848 {
849 	lif_if_t newidx, oldidx;
850 	boolean_t nextok;
851 	ipif_t *ipif;
852 	ill_t *ill;
853 
854 	ill = ill_lookup_on_ifindex(phy_ifdata, isv6, ipst);
855 	if (ill == NULL)
856 		return (0);
857 
858 	if (ifdata != 0) {
859 		oldidx = UNMAP_IPIF_ID(ifdata);
860 		nextok = B_FALSE;
861 	} else {
862 		oldidx = 0;
863 		nextok = B_TRUE;
864 	}
865 
866 	mutex_enter(&ill->ill_lock);
867 	if (ill->ill_state_flags & ILL_CONDEMNED) {
868 		mutex_exit(&ill->ill_lock);
869 		ill_refrele(ill);
870 		return (0);
871 	}
872 
873 	/*
874 	 * It's safe to iterate the ill_ipif list when holding an ill_lock.
875 	 * And it's also safe to access ipif_id without ipif refhold.
876 	 * See the field access rules in ip.h.
877 	 */
878 	for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
879 		if (!IPIF_CAN_LOOKUP(ipif))
880 			continue;
881 		if (nextok) {
882 			ipif_refhold_locked(ipif);
883 			break;
884 		} else if (oldidx == ipif->ipif_id) {
885 			nextok = B_TRUE;
886 		}
887 	}
888 
889 	mutex_exit(&ill->ill_lock);
890 	ill_refrele(ill);
891 
892 	if (ipif == NULL)
893 		return (0);
894 
895 	newidx = ipif->ipif_id;
896 	ipif_refrele(ipif);
897 
898 	return (MAP_IPIF_ID(newidx));
899 }
900 
901 /*
902  * Inject an IPv4 packet to or from an interface
903  */
904 static int
905 ip_inject(net_handle_t neti, inject_t style, net_inject_t *packet)
906 {
907 	netstack_t *ns;
908 
909 	ns = neti->netd_stack->nts_netstack;
910 	ASSERT(ns != NULL);
911 	return (ip_inject_impl(style, packet, B_FALSE, ns->netstack_ip));
912 }
913 
914 
915 /*
916  * Inject an IPv6 packet to or from an interface
917  */
918 static int
919 ipv6_inject(net_handle_t neti, inject_t style, net_inject_t *packet)
920 {
921 	netstack_t *ns;
922 
923 	ns = neti->netd_stack->nts_netstack;
924 	return (ip_inject_impl(style, packet, B_TRUE, ns->netstack_ip));
925 }
926 
927 /*
928  * Shared implementation to inject a packet to or from an interface
929  * Return value:
930  *   0: successful
931  *  -1: memory allocation failed
932  *   1: other errors
933  */
934 static int
935 ip_inject_impl(inject_t style, net_inject_t *packet, boolean_t isv6,
936     ip_stack_t *ipst)
937 {
938 	ddi_taskq_t *tq = NULL;
939 	void (* func)(void *);
940 	injection_t *inject;
941 	mblk_t *mp;
942 
943 	ASSERT(packet != NULL);
944 	ASSERT(packet->ni_packet != NULL);
945 	ASSERT(packet->ni_packet->b_datap->db_type == M_DATA);
946 
947 	switch (style) {
948 	case NI_QUEUE_IN:
949 		inject = kmem_alloc(sizeof (*inject), KM_NOSLEEP);
950 		if (inject == NULL)
951 			return (-1);
952 		inject->inj_data = *packet;
953 		inject->inj_isv6 = isv6;
954 		/*
955 		 * deliver up into the kernel, immitating its reception by a
956 		 * network interface, add to list and schedule timeout
957 		 */
958 		func = ip_ni_queue_in_func;
959 		tq = eventq_queue_in;
960 		break;
961 
962 	case NI_QUEUE_OUT:
963 		inject = kmem_alloc(sizeof (*inject), KM_NOSLEEP);
964 		if (inject == NULL)
965 			return (-1);
966 		inject->inj_data = *packet;
967 		inject->inj_isv6 = isv6;
968 		/*
969 		 * deliver out of the kernel, as if it were being sent via a
970 		 * raw socket so that IPFilter will see it again, add to list
971 		 * and schedule timeout
972 		 */
973 		func = ip_ni_queue_out_func;
974 		tq = eventq_queue_out;
975 		break;
976 
977 	case NI_DIRECT_OUT: {
978 		struct sockaddr *sock;
979 
980 		mp = packet->ni_packet;
981 
982 		sock = (struct sockaddr *)&packet->ni_addr;
983 		/*
984 		 * ipfil_sendpkt was provided by surya to ease the
985 		 * problems associated with sending out a packet.
986 		 */
987 		switch (ipfil_sendpkt(sock, mp, packet->ni_physical,
988 		    netstackid_to_zoneid(
989 		    ipst->ips_netstack->netstack_stackid))) {
990 		case 0 :
991 		case EINPROGRESS:
992 			return (0);
993 		case ECOMM :
994 		case ENONET :
995 			return (1);
996 		default :
997 			return (1);
998 		}
999 		/* NOTREACHED */
1000 	}
1001 	default:
1002 		freemsg(packet->ni_packet);
1003 		return (1);
1004 	}
1005 
1006 	ASSERT(tq != NULL);
1007 
1008 	inject->inj_ptr = ipst;
1009 	if (ddi_taskq_dispatch(tq, func, (void *)inject,
1010 	    DDI_SLEEP) == DDI_FAILURE) {
1011 		ip2dbg(("ip_inject:  ddi_taskq_dispatch failed\n"));
1012 		freemsg(packet->ni_packet);
1013 		return (1);
1014 	}
1015 	return (0);
1016 }
1017 
1018 /*
1019  * Find the interface used for traffic to a given IPv4 address
1020  */
1021 static phy_if_t
1022 ip_routeto(net_handle_t neti, struct sockaddr *address, struct sockaddr *next)
1023 {
1024 	netstack_t *ns;
1025 
1026 	ASSERT(address != NULL);
1027 
1028 	if (address->sa_family != AF_INET)
1029 		return (0);
1030 
1031 	ns = neti->netd_stack->nts_netstack;
1032 	ASSERT(ns != NULL);
1033 
1034 	return (ip_routeto_impl(address, next, ns->netstack_ip));
1035 }
1036 
1037 /*
1038  * Find the interface used for traffic to a given IPv6 address
1039  */
1040 static phy_if_t
1041 ipv6_routeto(net_handle_t neti, struct sockaddr *address, struct sockaddr *next)
1042 {
1043 	netstack_t *ns;
1044 
1045 	ASSERT(address != NULL);
1046 
1047 	if (address->sa_family != AF_INET6)
1048 		return (0);
1049 
1050 	ns = neti->netd_stack->nts_netstack;
1051 	ASSERT(ns != NULL);
1052 
1053 	return (ip_routeto_impl(address, next, ns->netstack_ip));
1054 }
1055 
1056 
1057 /*
1058  * Find the interface used for traffic to an address.
1059  * For lint reasons, next/next6/sin/sin6 are all declared and assigned
1060  * a value at the top.  The alternative would end up with two bunches
1061  * of assignments, with each bunch setting half to NULL.
1062  */
1063 static phy_if_t
1064 ip_routeto_impl(struct sockaddr *address, struct sockaddr *nexthop,
1065     ip_stack_t *ipst)
1066 {
1067 	struct sockaddr_in6 *next6 = (struct sockaddr_in6 *)nexthop;
1068 	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)address;
1069 	struct sockaddr_in *next = (struct sockaddr_in *)nexthop;
1070 	struct sockaddr_in *sin = (struct sockaddr_in *)address;
1071 	ire_t *ire;
1072 	ire_t *nexthop_ire;
1073 	phy_if_t phy_if;
1074 	zoneid_t zoneid;
1075 
1076 	zoneid = netstackid_to_zoneid(ipst->ips_netstack->netstack_stackid);
1077 
1078 	if (address->sa_family == AF_INET6) {
1079 		ire = ire_route_recursive_v6(&sin6->sin6_addr, 0, NULL,
1080 		    zoneid, NULL, MATCH_IRE_DSTONLY, IRR_ALLOCATE, 0, ipst,
1081 		    NULL, NULL, NULL);
1082 	} else {
1083 		ire = ire_route_recursive_v4(sin->sin_addr.s_addr, 0, NULL,
1084 		    zoneid, NULL, MATCH_IRE_DSTONLY, IRR_ALLOCATE, 0, ipst,
1085 		    NULL, NULL, NULL);
1086 	}
1087 	ASSERT(ire != NULL);
1088 	/*
1089 	 * For some destinations, we have routes that are dead ends, so
1090 	 * return to indicate that no physical interface can be used to
1091 	 * reach the destination.
1092 	 */
1093 	if (ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
1094 		ire_refrele(ire);
1095 		return (NULL);
1096 	}
1097 
1098 	nexthop_ire = ire_nexthop(ire);
1099 	if (nexthop_ire == NULL) {
1100 		ire_refrele(ire);
1101 		return (0);
1102 	}
1103 	if (nexthop_ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
1104 		ire_refrele(nexthop_ire);
1105 		ire_refrele(ire);
1106 		return (0);
1107 	}
1108 
1109 	ASSERT(nexthop_ire->ire_ill != NULL);
1110 
1111 	if (nexthop != NULL) {
1112 		if (address->sa_family == AF_INET6) {
1113 			next6->sin6_addr = nexthop_ire->ire_addr_v6;
1114 		} else {
1115 			next->sin_addr.s_addr = nexthop_ire->ire_addr;
1116 		}
1117 	}
1118 
1119 	phy_if = (phy_if_t)nexthop_ire->ire_ill->ill_phyint->phyint_ifindex;
1120 	ire_refrele(ire);
1121 	ire_refrele(nexthop_ire);
1122 
1123 	return (phy_if);
1124 }
1125 
1126 /*
1127  * Determine if checksumming is being used for the given packet.
1128  *
1129  * Return value:
1130  *   NET_HCK_NONE: full checksum recalculation is required
1131  *   NET_HCK_L3_FULL: full layer 3 checksum
1132  *   NET_HCK_L4_FULL: full layer 4 checksum
1133  *   NET_HCK_L4_PART: partial layer 4 checksum
1134  */
1135 /*ARGSUSED*/
1136 static int
1137 ip_ispartialchecksum(net_handle_t neti, mblk_t *mp)
1138 {
1139 	int ret = 0;
1140 
1141 	ASSERT(mp != NULL);
1142 
1143 	if ((DB_CKSUMFLAGS(mp) & HCK_FULLCKSUM) != 0) {
1144 		ret |= (int)NET_HCK_L4_FULL;
1145 		if ((DB_CKSUMFLAGS(mp) & HCK_IPV4_HDRCKSUM) != 0)
1146 			ret |= (int)NET_HCK_L3_FULL;
1147 	}
1148 	if ((DB_CKSUMFLAGS(mp) & HCK_PARTIALCKSUM) != 0) {
1149 		ret |= (int)NET_HCK_L4_PART;
1150 		if ((DB_CKSUMFLAGS(mp) & HCK_IPV4_HDRCKSUM) != 0)
1151 			ret |= (int)NET_HCK_L3_FULL;
1152 	}
1153 
1154 	return (ret);
1155 }
1156 
1157 /*
1158  * Return true or false, indicating whether the network and transport
1159  * headers are correct.  Use the capabilities flags and flags set in the
1160  * dblk_t to determine whether or not the checksum is valid.
1161  *
1162  * Return:
1163  *   0: the checksum was incorrect
1164  *   1: the original checksum was correct
1165  */
1166 /*ARGSUSED*/
1167 static int
1168 ip_isvalidchecksum(net_handle_t neti, mblk_t *mp)
1169 {
1170 	unsigned char *wptr;
1171 	ipha_t *ipha = (ipha_t *)mp->b_rptr;
1172 	int hlen;
1173 	int ret;
1174 
1175 	ASSERT(mp != NULL);
1176 
1177 	if (dohwcksum &&
1178 	    ((DB_CKSUM16(mp) != 0xFFFF &&
1179 	    (DB_CKSUMFLAGS(mp) & HCK_FULLCKSUM)) ||
1180 	    (DB_CKSUMFLAGS(mp) & HCK_FULLCKSUM_OK)) &&
1181 	    (DB_CKSUMFLAGS(mp) & HCK_IPV4_HDRCKSUM_OK))
1182 		return (1);
1183 
1184 	hlen = (ipha->ipha_version_and_hdr_length & 0x0F) << 2;
1185 
1186 	/*
1187 	 * Check that the mblk being passed in has enough data in it
1188 	 * before blindly checking ip_cksum.
1189 	 */
1190 	if (msgdsize(mp) < hlen)
1191 		return (0);
1192 
1193 	if (mp->b_wptr < mp->b_rptr + hlen) {
1194 		if (pullupmsg(mp, hlen) == 0)
1195 			return (0);
1196 		wptr = mp->b_wptr;
1197 	} else {
1198 		wptr = mp->b_wptr;
1199 		mp->b_wptr = mp->b_rptr + hlen;
1200 	}
1201 
1202 	if (ipha->ipha_hdr_checksum == ip_cksum(mp, 0, ipha->ipha_hdr_checksum))
1203 		ret = 1;
1204 	else
1205 		ret = 0;
1206 	mp->b_wptr = wptr;
1207 
1208 	return (ret);
1209 }
1210 
1211 /*
1212  * Unsupported with IPv6
1213  */
1214 /*ARGSUSED*/
1215 static int
1216 ipv6_isvalidchecksum(net_handle_t neti, mblk_t *mp)
1217 {
1218 	return (-1);
1219 }
1220 
1221 /*
1222  * Determine the network addresses for an IPv4 interface
1223  */
1224 static int
1225 ip_getlifaddr(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1226     size_t nelem, net_ifaddr_t type[], void *storage)
1227 {
1228 	netstack_t *ns;
1229 
1230 	ns = neti->netd_stack->nts_netstack;
1231 	ASSERT(ns != NULL);
1232 	return (ip_getlifaddr_impl(AF_INET, phy_ifdata, ifdata,
1233 	    nelem, type, storage, ns->netstack_ip));
1234 }
1235 
1236 /*
1237  * Determine the network addresses for an IPv6 interface
1238  */
1239 static int
1240 ipv6_getlifaddr(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1241     size_t nelem, net_ifaddr_t type[], void *storage)
1242 {
1243 	netstack_t *ns;
1244 
1245 	ns = neti->netd_stack->nts_netstack;
1246 	ASSERT(ns != NULL);
1247 	return (ip_getlifaddr_impl(AF_INET6, phy_ifdata, ifdata,
1248 	    nelem, type, storage, ns->netstack_ip));
1249 }
1250 
1251 /*
1252  * Shared implementation to determine the network addresses for an interface
1253  */
1254 /* ARGSUSED */
1255 static int
1256 ip_getlifaddr_impl(sa_family_t family, phy_if_t phy_ifdata,
1257     lif_if_t ifdata, size_t nelem, net_ifaddr_t type[],
1258     struct sockaddr *storage, ip_stack_t *ipst)
1259 {
1260 	struct sockaddr_in6 *sin6;
1261 	struct sockaddr_in *sin;
1262 	lif_if_t ipifid;
1263 	ipif_t *ipif;
1264 	int i;
1265 
1266 	ASSERT(type != NULL);
1267 	ASSERT(storage != NULL);
1268 
1269 	ipifid = UNMAP_IPIF_ID(ifdata);
1270 
1271 	if (family == AF_INET) {
1272 		if ((ipif = ipif_getby_indexes((uint_t)phy_ifdata,
1273 		    (uint_t)ipifid, B_FALSE, ipst)) == NULL)
1274 			return (1);
1275 
1276 		sin = (struct sockaddr_in *)storage;
1277 		for (i = 0; i < nelem; i++, sin++) {
1278 			if (ip_getifaddr_type(AF_INET, ipif, type[i],
1279 			    &sin->sin_addr) < 0) {
1280 				ip2dbg(("ip_getlifaddr_impl failed type %d\n",
1281 				    type[i]));
1282 				ipif_refrele(ipif);
1283 				return (1);
1284 			}
1285 			sin->sin_family = AF_INET;
1286 		}
1287 	} else {
1288 		if ((ipif = ipif_getby_indexes((uint_t)phy_ifdata,
1289 		    (uint_t)ipifid, B_TRUE, ipst)) == NULL)
1290 			return (1);
1291 
1292 		sin6 = (struct sockaddr_in6 *)storage;
1293 		for (i = 0; i < nelem; i++, sin6++) {
1294 			if (ip_getifaddr_type(AF_INET6, ipif, type[i],
1295 			    &sin6->sin6_addr) < 0) {
1296 				ip2dbg(("ip_getlifaddr_impl failed type %d\n",
1297 				    type[i]));
1298 				ipif_refrele(ipif);
1299 				return (1);
1300 			}
1301 			sin6->sin6_family = AF_INET6;
1302 		}
1303 	}
1304 	ipif_refrele(ipif);
1305 	return (0);
1306 }
1307 
1308 /*
1309  * ip_getlifaddr private function
1310  */
1311 static int
1312 ip_getifaddr_type(sa_family_t family, ipif_t *ill_ipif,
1313     lif_if_t type, void *storage)
1314 {
1315 	void *src_addr;
1316 	int mem_size;
1317 
1318 	ASSERT(ill_ipif != NULL);
1319 	ASSERT(storage != NULL);
1320 
1321 	if (family == AF_INET) {
1322 		mem_size = sizeof (struct in_addr);
1323 
1324 		switch (type) {
1325 		case NA_ADDRESS:
1326 			src_addr = &(ill_ipif->ipif_lcl_addr);
1327 			break;
1328 		case NA_PEER:
1329 			src_addr = &(ill_ipif->ipif_pp_dst_addr);
1330 			break;
1331 		case NA_BROADCAST:
1332 			src_addr = &(ill_ipif->ipif_brd_addr);
1333 			break;
1334 		case NA_NETMASK:
1335 			src_addr = &(ill_ipif->ipif_net_mask);
1336 			break;
1337 		default:
1338 			return (-1);
1339 			/*NOTREACHED*/
1340 		}
1341 	} else {
1342 		mem_size = sizeof (struct in6_addr);
1343 
1344 		switch (type) {
1345 		case NA_ADDRESS:
1346 			src_addr = &(ill_ipif->ipif_v6lcl_addr);
1347 			break;
1348 		case NA_PEER:
1349 			src_addr = &(ill_ipif->ipif_v6pp_dst_addr);
1350 			break;
1351 		case NA_BROADCAST:
1352 			src_addr = &(ill_ipif->ipif_v6brd_addr);
1353 			break;
1354 		case NA_NETMASK:
1355 			src_addr = &(ill_ipif->ipif_v6net_mask);
1356 			break;
1357 		default:
1358 			return (-1);
1359 			/*NOTREACHED*/
1360 		}
1361 	}
1362 
1363 	(void) memcpy(storage, src_addr, mem_size);
1364 	return (1);
1365 }
1366 
1367 /*
1368  * Shared implementation to determine the zoneid associated with an IPv4/IPv6
1369  * address
1370  */
1371 static int
1372 ip_getlifzone_impl(sa_family_t family, phy_if_t phy_ifdata, lif_if_t ifdata,
1373     ip_stack_t *ipst, zoneid_t *zoneid)
1374 {
1375 	ipif_t  *ipif;
1376 
1377 	ipif = ipif_getby_indexes((uint_t)phy_ifdata,
1378 	    UNMAP_IPIF_ID((uint_t)ifdata), (family == AF_INET6), ipst);
1379 	if (ipif == NULL)
1380 		return (-1);
1381 	*zoneid = IP_REAL_ZONEID(ipif->ipif_zoneid, ipst);
1382 	ipif_refrele(ipif);
1383 	return (0);
1384 }
1385 
1386 /*
1387  * Determine the zoneid associated with an IPv4 address
1388  */
1389 static int
1390 ip_getlifzone(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1391     zoneid_t *zoneid)
1392 {
1393 	return (ip_getlifzone_impl(AF_INET, phy_ifdata, ifdata,
1394 	    neti->netd_stack->nts_netstack->netstack_ip, zoneid));
1395 }
1396 
1397 /*
1398  * Determine the zoneid associated with an IPv6 address
1399  */
1400 static int
1401 ipv6_getlifzone(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1402     zoneid_t *zoneid)
1403 {
1404 	return (ip_getlifzone_impl(AF_INET6, phy_ifdata, ifdata,
1405 	    neti->netd_stack->nts_netstack->netstack_ip, zoneid));
1406 }
1407 
1408 /*
1409  * The behaviour here mirrors that for the SIOCFLIFFLAGS ioctl where the
1410  * union of all of the relevant flags is returned.
1411  */
1412 static int
1413 ip_getlifflags_impl(sa_family_t family, phy_if_t phy_ifdata, lif_if_t ifdata,
1414     ip_stack_t *ipst, uint64_t *flags)
1415 {
1416 	phyint_t *phyi;
1417 	ipif_t *ipif;
1418 	ill_t *ill;
1419 
1420 	ill = ill_lookup_on_ifindex(phy_ifdata, (family == AF_INET6), ipst);
1421 	if (ill == NULL)
1422 		return (-1);
1423 	phyi = ill->ill_phyint;
1424 
1425 	ipif = ipif_getby_indexes((uint_t)phy_ifdata,
1426 	    UNMAP_IPIF_ID((uint_t)ifdata), (family == AF_INET6), ipst);
1427 	if (ipif == NULL) {
1428 		ill_refrele(ill);
1429 		return (-1);
1430 	}
1431 	*flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
1432 	ipif_refrele(ipif);
1433 	ill_refrele(ill);
1434 	return (0);
1435 }
1436 
1437 static int
1438 ip_getlifflags(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1439     uint64_t *flags)
1440 {
1441 	return (ip_getlifflags_impl(AF_INET, phy_ifdata, ifdata,
1442 	    neti->netd_stack->nts_netstack->netstack_ip, flags));
1443 }
1444 
1445 static int
1446 ipv6_getlifflags(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1447     uint64_t *flags)
1448 {
1449 	return (ip_getlifflags_impl(AF_INET6, phy_ifdata, ifdata,
1450 	    neti->netd_stack->nts_netstack->netstack_ip, flags));
1451 }
1452 
1453 /*
1454  * Deliver packet up into the kernel, immitating its reception by a
1455  * network interface.
1456  */
1457 static void
1458 ip_ni_queue_in_func(void *inject)
1459 {
1460 	ip_ni_queue_func_impl(inject, B_FALSE);
1461 }
1462 
1463 /*
1464  * Deliver out of the kernel, as if it were being sent via a
1465  * raw socket so that IPFilter will see it again.
1466  */
1467 static void
1468 ip_ni_queue_out_func(void *inject)
1469 {
1470 	ip_ni_queue_func_impl(inject, B_TRUE);
1471 }
1472 
1473 /*
1474  * Shared implementation for inject via ip_output and ip_input
1475  */
1476 static void
1477 ip_ni_queue_func_impl(injection_t *inject,  boolean_t out)
1478 {
1479 	net_inject_t *packet;
1480 	ill_t *ill;
1481 	ip_stack_t *ipst = (ip_stack_t *)inject->inj_ptr;
1482 	ip_xmit_attr_t	ixas;
1483 
1484 	ASSERT(inject != NULL);
1485 	packet = &inject->inj_data;
1486 	ASSERT(packet->ni_packet != NULL);
1487 
1488 	if (out == 0) {
1489 		ill = ill_lookup_on_ifindex((uint_t)packet->ni_physical,
1490 		    inject->inj_isv6, ipst);
1491 
1492 		if (ill == NULL) {
1493 			kmem_free(inject, sizeof (*inject));
1494 			return;
1495 		}
1496 
1497 		if (inject->inj_isv6) {
1498 			ip_input_v6(ill, NULL, packet->ni_packet, NULL);
1499 		} else {
1500 			ip_input(ill, NULL, packet->ni_packet, NULL);
1501 		}
1502 		ill_refrele(ill);
1503 	} else {
1504 		bzero(&ixas, sizeof (ixas));
1505 		ixas.ixa_ifindex = packet->ni_physical;
1506 		ixas.ixa_ipst = ipst;
1507 		if (inject->inj_isv6) {
1508 			ixas.ixa_flags = IXAF_BASIC_SIMPLE_V6;
1509 		} else {
1510 			ixas.ixa_flags = IXAF_BASIC_SIMPLE_V4;
1511 		}
1512 		ixas.ixa_flags &= ~IXAF_VERIFY_SOURCE;
1513 		(void) ip_output_simple(packet->ni_packet, &ixas);
1514 		ixa_cleanup(&ixas);
1515 	}
1516 
1517 	kmem_free(inject, sizeof (*inject));
1518 }
1519 
1520 /*
1521  * taskq function for nic events.
1522  */
1523 void
1524 ip_ne_queue_func(void *arg)
1525 {
1526 	hook_event_token_t hr;
1527 	hook_nic_event_int_t *info = (hook_nic_event_int_t *)arg;
1528 	ip_stack_t *ipst;
1529 	netstack_t *ns;
1530 
1531 	ns = netstack_find_by_stackid(info->hnei_stackid);
1532 	if (ns == NULL)
1533 		goto done;
1534 
1535 	ipst = ns->netstack_ip;
1536 	if (ipst == NULL)
1537 		goto done;
1538 
1539 	hr = (info->hnei_event.hne_protocol == ipst->ips_ipv6_net_data) ?
1540 	    ipst->ips_ipv6nicevents : ipst->ips_ipv4nicevents;
1541 	(void) hook_run(info->hnei_event.hne_protocol->netd_hooks, hr,
1542 	    (hook_data_t)&info->hnei_event);
1543 
1544 done:
1545 	if (ns != NULL)
1546 		netstack_rele(ns);
1547 	kmem_free(info->hnei_event.hne_data, info->hnei_event.hne_datalen);
1548 	kmem_free(arg, sizeof (hook_nic_event_int_t));
1549 }
1550 
1551 /*
1552  * Initialize ARP hook family and events
1553  */
1554 void
1555 arp_hook_init(ip_stack_t *ipst)
1556 {
1557 	HOOK_FAMILY_INIT(&ipst->ips_arproot, Hn_ARP);
1558 	if (net_family_register(ipst->ips_arp_net_data, &ipst->ips_arproot)
1559 	    != 0) {
1560 		cmn_err(CE_NOTE, "arp_hook_init"
1561 		    "net_family_register failed for arp");
1562 	}
1563 
1564 	HOOK_EVENT_INIT(&ipst->ips_arp_physical_in_event, NH_PHYSICAL_IN);
1565 	ipst->ips_arp_physical_in = net_event_register(ipst->ips_arp_net_data,
1566 	    &ipst->ips_arp_physical_in_event);
1567 	if (ipst->ips_arp_physical_in == NULL) {
1568 		cmn_err(CE_NOTE, "arp_hook_init: "
1569 		    "net_event_register failed for arp/physical_in");
1570 	}
1571 
1572 	HOOK_EVENT_INIT(&ipst->ips_arp_physical_out_event, NH_PHYSICAL_OUT);
1573 	ipst->ips_arp_physical_out = net_event_register(ipst->ips_arp_net_data,
1574 	    &ipst->ips_arp_physical_out_event);
1575 	if (ipst->ips_arp_physical_out == NULL) {
1576 		cmn_err(CE_NOTE, "arp_hook_init: "
1577 		    "net_event_register failed for arp/physical_out");
1578 	}
1579 
1580 	HOOK_EVENT_INIT(&ipst->ips_arp_nic_events, NH_NIC_EVENTS);
1581 	ipst->ips_arpnicevents = net_event_register(ipst->ips_arp_net_data,
1582 	    &ipst->ips_arp_nic_events);
1583 	if (ipst->ips_arpnicevents == NULL) {
1584 		cmn_err(CE_NOTE, "arp_hook_init: "
1585 		    "net_event_register failed for arp/nic_events");
1586 	}
1587 }
1588 
1589 void
1590 arp_hook_destroy(ip_stack_t *ipst)
1591 {
1592 	if (ipst->ips_arpnicevents != NULL) {
1593 		if (net_event_unregister(ipst->ips_arp_net_data,
1594 		    &ipst->ips_arp_nic_events) == 0)
1595 			ipst->ips_arpnicevents = NULL;
1596 	}
1597 
1598 	if (ipst->ips_arp_physical_out != NULL) {
1599 		if (net_event_unregister(ipst->ips_arp_net_data,
1600 		    &ipst->ips_arp_physical_out_event) == 0)
1601 			ipst->ips_arp_physical_out = NULL;
1602 	}
1603 
1604 	if (ipst->ips_arp_physical_in != NULL) {
1605 		if (net_event_unregister(ipst->ips_arp_net_data,
1606 		    &ipst->ips_arp_physical_in_event) == 0)
1607 			ipst->ips_arp_physical_in = NULL;
1608 	}
1609 
1610 	(void) net_family_unregister(ipst->ips_arp_net_data,
1611 	    &ipst->ips_arproot);
1612 }
1613 
1614 void
1615 arp_hook_shutdown(ip_stack_t *ipst)
1616 {
1617 	if (ipst->ips_arp_physical_in != NULL) {
1618 		(void) net_event_shutdown(ipst->ips_arp_net_data,
1619 		    &ipst->ips_arp_physical_in_event);
1620 	}
1621 	if (ipst->ips_arp_physical_out != NULL) {
1622 		(void) net_event_shutdown(ipst->ips_arp_net_data,
1623 		    &ipst->ips_arp_physical_out_event);
1624 	}
1625 	if (ipst->ips_arpnicevents != NULL) {
1626 		(void) net_event_shutdown(ipst->ips_arp_net_data,
1627 		    &ipst->ips_arp_nic_events);
1628 	}
1629 }
1630 
1631 /* netinfo routines for the unsupported cases */
1632 
1633 /* ARGSUSED */
1634 int
1635 net_no_getmtu(net_handle_t handle, phy_if_t phy_ifdata, lif_if_t ifdata)
1636 {
1637 	return (-1);
1638 }
1639 
1640 /* ARGSUSED */
1641 static int
1642 net_no_getpmtuenabled(net_handle_t neti)
1643 {
1644 	return (-1);
1645 }
1646 
1647 /* ARGSUSED */
1648 static lif_if_t
1649 net_no_lifgetnext(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata)
1650 {
1651 	return (-1);
1652 }
1653 
1654 /* ARGSUSED */
1655 static int
1656 net_no_inject(net_handle_t neti, inject_t style, net_inject_t *packet)
1657 {
1658 	return (-1);
1659 }
1660 
1661 /* ARGSUSED */
1662 static phy_if_t
1663 net_no_routeto(net_handle_t neti, struct sockaddr *address,
1664     struct sockaddr *next)
1665 {
1666 	return ((phy_if_t)-1);
1667 }
1668 
1669 /* ARGSUSED */
1670 static int
1671 net_no_ispartialchecksum(net_handle_t neti, mblk_t *mp)
1672 {
1673 	return (-1);
1674 }
1675 
1676 /* ARGSUSED */
1677 static int
1678 net_no_getlifaddr(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1679     size_t nelem, net_ifaddr_t type[], void *storage)
1680 {
1681 	return (-1);
1682 }
1683 
1684 /* ARGSUSED */
1685 static int
1686 net_no_getlifzone(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1687     zoneid_t *zoneid)
1688 {
1689 	return (-1);
1690 }
1691 
1692 /* ARGSUSED */
1693 static int
1694 net_no_getlifflags(net_handle_t neti, phy_if_t phy_ifdata, lif_if_t ifdata,
1695     uint64_t *flags)
1696 {
1697 	return (-1);
1698 }
1699