xref: /netbsd-src/sys/netinet6/ip6_forward.c (revision 267197ec1eebfcb9810ea27a89625b6ddf68e3e7)
1 /*	$NetBSD: ip6_forward.c,v 1.62 2008/01/14 04:16:45 dyoung Exp $	*/
2 /*	$KAME: ip6_forward.c,v 1.109 2002/09/11 08:10:17 sakane Exp $	*/
3 
4 /*
5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the project nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: ip6_forward.c,v 1.62 2008/01/14 04:16:45 dyoung Exp $");
35 
36 #include "opt_ipsec.h"
37 #include "opt_pfil_hooks.h"
38 
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/malloc.h>
42 #include <sys/mbuf.h>
43 #include <sys/domain.h>
44 #include <sys/protosw.h>
45 #include <sys/socket.h>
46 #include <sys/errno.h>
47 #include <sys/time.h>
48 #include <sys/kernel.h>
49 #include <sys/syslog.h>
50 
51 #include <net/if.h>
52 #include <net/route.h>
53 
54 #include <netinet/in.h>
55 #include <netinet/in_var.h>
56 #include <netinet/ip_var.h>
57 #include <netinet/ip6.h>
58 #include <netinet6/ip6_var.h>
59 #include <netinet6/scope6_var.h>
60 #include <netinet/icmp6.h>
61 #include <netinet6/nd6.h>
62 
63 #ifdef IPSEC
64 #include <netinet6/ipsec.h>
65 #include <netkey/key.h>
66 #endif /* IPSEC */
67 
68 #ifdef FAST_IPSEC
69 #include <netipsec/ipsec.h>
70 #include <netipsec/ipsec6.h>
71 #include <netipsec/key.h>
72 #include <netipsec/xform.h>
73 #endif /* FAST_IPSEC */
74 
75 #ifdef PFIL_HOOKS
76 #include <net/pfil.h>
77 #endif
78 
79 #include <net/net_osdep.h>
80 
81 struct	route ip6_forward_rt;
82 
83 #ifdef PFIL_HOOKS
84 extern struct pfil_head inet6_pfil_hook;	/* XXX */
85 #endif
86 
87 /*
88  * Forward a packet.  If some error occurs return the sender
89  * an icmp packet.  Note we can't always generate a meaningful
90  * icmp message because icmp doesn't have a large enough repertoire
91  * of codes and types.
92  *
93  * If not forwarding, just drop the packet.  This could be confusing
94  * if ipforwarding was zero but some routing protocol was advancing
95  * us as a gateway to somewhere.  However, we must let the routing
96  * protocol deal with that.
97  *
98  */
99 
100 void
101 ip6_forward(struct mbuf *m, int srcrt)
102 {
103 	struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
104 	const struct sockaddr_in6 *dst;
105 	struct rtentry *rt;
106 	int error = 0, type = 0, code = 0;
107 	struct mbuf *mcopy = NULL;
108 	struct ifnet *origifp;	/* maybe unnecessary */
109 	u_int32_t inzone, outzone;
110 	struct in6_addr src_in6, dst_in6;
111 #ifdef IPSEC
112 	struct secpolicy *sp = NULL;
113 	int ipsecrt = 0;
114 #endif
115 #ifdef FAST_IPSEC
116     struct secpolicy *sp = NULL;
117     int needipsec = 0;
118     int s;
119 #endif
120 
121 
122 #ifdef IPSEC
123 	/*
124 	 * Check AH/ESP integrity.
125 	 */
126 	/*
127 	 * Don't increment ip6s_cantforward because this is the check
128 	 * before forwarding packet actually.
129 	 */
130 	if (ipsec6_in_reject(m, NULL)) {
131 		ipsec6stat.in_polvio++;
132 		m_freem(m);
133 		return;
134 	}
135 #endif /* IPSEC */
136 
137 	/*
138 	 * Do not forward packets to multicast destination (should be handled
139 	 * by ip6_mforward().
140 	 * Do not forward packets with unspecified source.  It was discussed
141 	 * in July 2000, on ipngwg mailing list.
142 	 */
143 	if ((m->m_flags & (M_BCAST|M_MCAST)) != 0 ||
144 	    IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst) ||
145 	    IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)) {
146 		ip6stat.ip6s_cantforward++;
147 		/* XXX in6_ifstat_inc(rt->rt_ifp, ifs6_in_discard) */
148 		if (ip6_log_time + ip6_log_interval < time_second) {
149 			ip6_log_time = time_second;
150 			log(LOG_DEBUG,
151 			    "cannot forward "
152 			    "from %s to %s nxt %d received on %s\n",
153 			    ip6_sprintf(&ip6->ip6_src),
154 			    ip6_sprintf(&ip6->ip6_dst),
155 			    ip6->ip6_nxt,
156 			    if_name(m->m_pkthdr.rcvif));
157 		}
158 		m_freem(m);
159 		return;
160 	}
161 
162 	if (ip6->ip6_hlim <= IPV6_HLIMDEC) {
163 		/* XXX in6_ifstat_inc(rt->rt_ifp, ifs6_in_discard) */
164 		icmp6_error(m, ICMP6_TIME_EXCEEDED,
165 				ICMP6_TIME_EXCEED_TRANSIT, 0);
166 		return;
167 	}
168 	ip6->ip6_hlim -= IPV6_HLIMDEC;
169 
170 	/*
171 	 * Save at most ICMPV6_PLD_MAXLEN (= the min IPv6 MTU -
172 	 * size of IPv6 + ICMPv6 headers) bytes of the packet in case
173 	 * we need to generate an ICMP6 message to the src.
174 	 * Thanks to M_EXT, in most cases copy will not occur.
175 	 *
176 	 * It is important to save it before IPsec processing as IPsec
177 	 * processing may modify the mbuf.
178 	 */
179 	mcopy = m_copy(m, 0, imin(m->m_pkthdr.len, ICMPV6_PLD_MAXLEN));
180 
181 #ifdef IPSEC
182 	/* get a security policy for this packet */
183 	sp = ipsec6_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND,
184 	    IP_FORWARDING, &error);
185 	if (sp == NULL) {
186 		ipsec6stat.out_inval++;
187 		ip6stat.ip6s_cantforward++;
188 		if (mcopy) {
189 #if 0
190 			/* XXX: what icmp ? */
191 #else
192 			m_freem(mcopy);
193 #endif
194 		}
195 		m_freem(m);
196 		return;
197 	}
198 
199 	error = 0;
200 
201 	/* check policy */
202 	switch (sp->policy) {
203 	case IPSEC_POLICY_DISCARD:
204 		/*
205 		 * This packet is just discarded.
206 		 */
207 		ipsec6stat.out_polvio++;
208 		ip6stat.ip6s_cantforward++;
209 		key_freesp(sp);
210 		if (mcopy) {
211 #if 0
212 			/* XXX: what icmp ? */
213 #else
214 			m_freem(mcopy);
215 #endif
216 		}
217 		m_freem(m);
218 		return;
219 
220 	case IPSEC_POLICY_BYPASS:
221 	case IPSEC_POLICY_NONE:
222 		/* no need to do IPsec. */
223 		key_freesp(sp);
224 		goto skip_ipsec;
225 
226 	case IPSEC_POLICY_IPSEC:
227 		if (sp->req == NULL) {
228 			/* XXX should be panic ? */
229 			printf("ip6_forward: No IPsec request specified.\n");
230 			ip6stat.ip6s_cantforward++;
231 			key_freesp(sp);
232 			if (mcopy) {
233 #if 0
234 				/* XXX: what icmp ? */
235 #else
236 				m_freem(mcopy);
237 #endif
238 			}
239 			m_freem(m);
240 			return;
241 		}
242 		/* do IPsec */
243 		break;
244 
245 	case IPSEC_POLICY_ENTRUST:
246 	default:
247 		/* should be panic ?? */
248 		printf("ip6_forward: Invalid policy found. %d\n", sp->policy);
249 		key_freesp(sp);
250 		goto skip_ipsec;
251 	}
252 
253     {
254 	struct ipsecrequest *isr = NULL;
255 	struct ipsec_output_state state;
256 
257 	/*
258 	 * when the kernel forwards a packet, it is not proper to apply
259 	 * IPsec transport mode to the packet is not proper.  this check
260 	 * avoid from this.
261 	 * at present, if there is even a transport mode SA request in the
262 	 * security policy, the kernel does not apply IPsec to the packet.
263 	 * this check is not enough because the following case is valid.
264 	 *      ipsec esp/tunnel/xxx-xxx/require esp/transport//require;
265 	 */
266 	for (isr = sp->req; isr; isr = isr->next) {
267 		if (isr->saidx.mode == IPSEC_MODE_ANY)
268 			goto doipsectunnel;
269 		if (isr->saidx.mode == IPSEC_MODE_TUNNEL)
270 			goto doipsectunnel;
271 	}
272 
273 	/*
274 	 * if there's no need for tunnel mode IPsec, skip.
275 	 */
276 	if (!isr)
277 		goto skip_ipsec;
278 
279     doipsectunnel:
280 	/*
281 	 * All the extension headers will become inaccessible
282 	 * (since they can be encrypted).
283 	 * Don't panic, we need no more updates to extension headers
284 	 * on inner IPv6 packet (since they are now encapsulated).
285 	 *
286 	 * IPv6 [ESP|AH] IPv6 [extension headers] payload
287 	 */
288 	bzero(&state, sizeof(state));
289 	state.m = m;
290 	state.ro = NULL;	/* update at ipsec6_output_tunnel() */
291 	state.dst = NULL;	/* update at ipsec6_output_tunnel() */
292 
293 	error = ipsec6_output_tunnel(&state, sp, 0);
294 
295 	m = state.m;
296 	key_freesp(sp);
297 
298 	if (error) {
299 		/* mbuf is already reclaimed in ipsec6_output_tunnel. */
300 		switch (error) {
301 		case EHOSTUNREACH:
302 		case ENETUNREACH:
303 		case EMSGSIZE:
304 		case ENOBUFS:
305 		case ENOMEM:
306 			break;
307 		default:
308 			printf("ip6_forward (ipsec): error code %d\n", error);
309 			/* FALLTHROUGH */
310 		case ENOENT:
311 			/* don't show these error codes to the user */
312 			break;
313 		}
314 		ip6stat.ip6s_cantforward++;
315 		if (mcopy) {
316 #if 0
317 			/* XXX: what icmp ? */
318 #else
319 			m_freem(mcopy);
320 #endif
321 		}
322 		m_freem(m);
323 		return;
324 	}
325 
326 	if (ip6 != mtod(m, struct ip6_hdr *)) {
327 		/*
328 		 * now tunnel mode headers are added.  we are originating
329 		 * packet instead of forwarding the packet.
330 		 */
331 		ip6_output(m, NULL, NULL, IPV6_FORWARDING/*XXX*/, NULL, NULL,
332 		    NULL);
333 		goto freecopy;
334 	}
335 
336 	/* adjust pointer */
337 	rt = state.ro ? rtcache_validate(state.ro) : NULL;
338 	dst = (const struct sockaddr_in6 *)state.dst;
339 	if (dst != NULL && rt != NULL) {
340 		ipsecrt = 1;
341 		goto skip_routing;
342 	}
343     }
344     skip_ipsec:
345 #endif /* IPSEC */
346 #ifdef FAST_IPSEC
347 	/* Check the security policy (SP) for the packet */
348 
349 	sp = ipsec6_check_policy(m,NULL,0,&needipsec,&error);
350 	if (error != 0) {
351 		/*
352 		 * Hack: -EINVAL is used to signal that a packet
353 		 * should be silently discarded.  This is typically
354 		 * because we asked key management for an SA and
355 		 * it was delayed (e.g. kicked up to IKE).
356 		 */
357 	if (error == -EINVAL)
358 		error = 0;
359 	goto freecopy;
360 	}
361 #endif /* FAST_IPSEC */
362 
363 	if (srcrt) {
364 		union {
365 			struct sockaddr		dst;
366 			struct sockaddr_in6	dst6;
367 		} u;
368 
369 		sockaddr_in6_init(&u.dst6, &ip6->ip6_dst, 0, 0, 0);
370 		if ((rt = rtcache_lookup(&ip6_forward_rt, &u.dst)) == NULL) {
371 			ip6stat.ip6s_noroute++;
372 			/* XXX in6_ifstat_inc(rt->rt_ifp, ifs6_in_noroute) */
373 			if (mcopy) {
374 				icmp6_error(mcopy, ICMP6_DST_UNREACH,
375 					    ICMP6_DST_UNREACH_NOROUTE, 0);
376 			}
377 			m_freem(m);
378 			return;
379 		}
380 	} else if ((rt = rtcache_validate(&ip6_forward_rt)) == NULL &&
381 	           (rt = rtcache_update(&ip6_forward_rt, 1)) == NULL) {
382 		/*
383 		 * rtcache_getdst(ip6_forward_rt)->sin6_addr was equal to
384 		 * ip6->ip6_dst
385 		 */
386 		ip6stat.ip6s_noroute++;
387 		/* XXX in6_ifstat_inc(rt->rt_ifp, ifs6_in_noroute) */
388 		if (mcopy) {
389 			icmp6_error(mcopy, ICMP6_DST_UNREACH,
390 			    ICMP6_DST_UNREACH_NOROUTE, 0);
391 		}
392 		m_freem(m);
393 		return;
394 	}
395 	dst = satocsin6(rtcache_getdst(&ip6_forward_rt));
396 #ifdef IPSEC
397     skip_routing:;
398 #endif /* IPSEC */
399 
400 	/*
401 	 * Source scope check: if a packet can't be delivered to its
402 	 * destination for the reason that the destination is beyond the scope
403 	 * of the source address, discard the packet and return an icmp6
404 	 * destination unreachable error with Code 2 (beyond scope of source
405 	 * address).  We use a local copy of ip6_src, since in6_setscope()
406 	 * will possibly modify its first argument.
407 	 * [draft-ietf-ipngwg-icmp-v3-07, Section 3.1]
408 	 */
409 	src_in6 = ip6->ip6_src;
410 	if (in6_setscope(&src_in6, rt->rt_ifp, &outzone)) {
411 		/* XXX: this should not happen */
412 		ip6stat.ip6s_cantforward++;
413 		ip6stat.ip6s_badscope++;
414 		m_freem(m);
415 		return;
416 	}
417 	if (in6_setscope(&src_in6, m->m_pkthdr.rcvif, &inzone)) {
418 		ip6stat.ip6s_cantforward++;
419 		ip6stat.ip6s_badscope++;
420 		m_freem(m);
421 		return;
422 	}
423 	if (inzone != outzone
424 #ifdef IPSEC
425 	    && !ipsecrt
426 #endif
427 	    ) {
428 		ip6stat.ip6s_cantforward++;
429 		ip6stat.ip6s_badscope++;
430 		in6_ifstat_inc(rt->rt_ifp, ifs6_in_discard);
431 
432 		if (ip6_log_time + ip6_log_interval < time_second) {
433 			ip6_log_time = time_second;
434 			log(LOG_DEBUG,
435 			    "cannot forward "
436 			    "src %s, dst %s, nxt %d, rcvif %s, outif %s\n",
437 			    ip6_sprintf(&ip6->ip6_src),
438 			    ip6_sprintf(&ip6->ip6_dst),
439 			    ip6->ip6_nxt,
440 			    if_name(m->m_pkthdr.rcvif), if_name(rt->rt_ifp));
441 		}
442 		if (mcopy)
443 			icmp6_error(mcopy, ICMP6_DST_UNREACH,
444 				    ICMP6_DST_UNREACH_BEYONDSCOPE, 0);
445 		m_freem(m);
446 		return;
447 	}
448 #ifdef FAST_IPSEC
449     /*
450      * If we need to encapsulate the packet, do it here
451      * ipsec6_proces_packet will send the packet using ip6_output
452      */
453 	if (needipsec) {
454 		s = splsoftnet();
455 		error = ipsec6_process_packet(m,sp->req);
456 		splx(s);
457 		if (mcopy)
458 			goto freecopy;
459     }
460 #endif
461 
462 
463 
464 	/*
465 	 * Destination scope check: if a packet is going to break the scope
466 	 * zone of packet's destination address, discard it.  This case should
467 	 * usually be prevented by appropriately-configured routing table, but
468 	 * we need an explicit check because we may mistakenly forward the
469 	 * packet to a different zone by (e.g.) a default route.
470 	 */
471 	dst_in6 = ip6->ip6_dst;
472 	if (in6_setscope(&dst_in6, m->m_pkthdr.rcvif, &inzone) != 0 ||
473 	    in6_setscope(&dst_in6, rt->rt_ifp, &outzone) != 0 ||
474 	    inzone != outzone) {
475 		ip6stat.ip6s_cantforward++;
476 		ip6stat.ip6s_badscope++;
477 		m_freem(m);
478 		return;
479 	}
480 
481 	if (m->m_pkthdr.len > IN6_LINKMTU(rt->rt_ifp)) {
482 		in6_ifstat_inc(rt->rt_ifp, ifs6_in_toobig);
483 		if (mcopy) {
484 			u_long mtu;
485 #ifdef IPSEC
486 			struct secpolicy *xsp;
487 			int ipsecerror;
488 			size_t ipsechdrsiz;
489 #endif
490 
491 			mtu = IN6_LINKMTU(rt->rt_ifp);
492 #ifdef IPSEC
493 			/*
494 			 * When we do IPsec tunnel ingress, we need to play
495 			 * with the link value (decrement IPsec header size
496 			 * from mtu value).  The code is much simpler than v4
497 			 * case, as we have the outgoing interface for
498 			 * encapsulated packet as "rt->rt_ifp".
499 			 */
500 			xsp = ipsec6_getpolicybyaddr(mcopy, IPSEC_DIR_OUTBOUND,
501 				IP_FORWARDING, &ipsecerror);
502 			if (xsp) {
503 				ipsechdrsiz = ipsec6_hdrsiz(mcopy,
504 					IPSEC_DIR_OUTBOUND, NULL);
505 				if (ipsechdrsiz < mtu)
506 					mtu -= ipsechdrsiz;
507 			}
508 
509 			/*
510 			 * if mtu becomes less than minimum MTU,
511 			 * tell minimum MTU (and I'll need to fragment it).
512 			 */
513 			if (mtu < IPV6_MMTU)
514 				mtu = IPV6_MMTU;
515 #endif
516 			icmp6_error(mcopy, ICMP6_PACKET_TOO_BIG, 0, mtu);
517 		}
518 		m_freem(m);
519 		return;
520 	}
521 
522 	if (rt->rt_flags & RTF_GATEWAY)
523 		dst = (struct sockaddr_in6 *)rt->rt_gateway;
524 
525 	/*
526 	 * If we are to forward the packet using the same interface
527 	 * as one we got the packet from, perhaps we should send a redirect
528 	 * to sender to shortcut a hop.
529 	 * Only send redirect if source is sending directly to us,
530 	 * and if packet was not source routed (or has any options).
531 	 * Also, don't send redirect if forwarding using a route
532 	 * modified by a redirect.
533 	 */
534 	if (rt->rt_ifp == m->m_pkthdr.rcvif && !srcrt && ip6_sendredirects &&
535 #ifdef IPSEC
536 	    !ipsecrt &&
537 #endif
538 	    (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0) {
539 		if ((rt->rt_ifp->if_flags & IFF_POINTOPOINT) &&
540 		    nd6_is_addr_neighbor(
541 		        satocsin6(rtcache_getdst(&ip6_forward_rt)),
542 			rt->rt_ifp)) {
543 			/*
544 			 * If the incoming interface is equal to the outgoing
545 			 * one, the link attached to the interface is
546 			 * point-to-point, and the IPv6 destination is
547 			 * regarded as on-link on the link, then it will be
548 			 * highly probable that the destination address does
549 			 * not exist on the link and that the packet is going
550 			 * to loop.  Thus, we immediately drop the packet and
551 			 * send an ICMPv6 error message.
552 			 * For other routing loops, we dare to let the packet
553 			 * go to the loop, so that a remote diagnosing host
554 			 * can detect the loop by traceroute.
555 			 * type/code is based on suggestion by Rich Draves.
556 			 * not sure if it is the best pick.
557 			 */
558 			icmp6_error(mcopy, ICMP6_DST_UNREACH,
559 				    ICMP6_DST_UNREACH_ADDR, 0);
560 			m_freem(m);
561 			return;
562 		}
563 		type = ND_REDIRECT;
564 	}
565 
566 	/*
567 	 * Fake scoped addresses. Note that even link-local source or
568 	 * destinaion can appear, if the originating node just sends the
569 	 * packet to us (without address resolution for the destination).
570 	 * Since both icmp6_error and icmp6_redirect_output fill the embedded
571 	 * link identifiers, we can do this stuff after making a copy for
572 	 * returning an error.
573 	 */
574 	if ((rt->rt_ifp->if_flags & IFF_LOOPBACK) != 0) {
575 		/*
576 		 * See corresponding comments in ip6_output.
577 		 * XXX: but is it possible that ip6_forward() sends a packet
578 		 *      to a loopback interface? I don't think so, and thus
579 		 *      I bark here. (jinmei@kame.net)
580 		 * XXX: it is common to route invalid packets to loopback.
581 		 *	also, the codepath will be visited on use of ::1 in
582 		 *	rthdr. (itojun)
583 		 */
584 #if 1
585 		if (0)
586 #else
587 		if ((rt->rt_flags & (RTF_BLACKHOLE|RTF_REJECT)) == 0)
588 #endif
589 		{
590 			printf("ip6_forward: outgoing interface is loopback. "
591 			       "src %s, dst %s, nxt %d, rcvif %s, outif %s\n",
592 			       ip6_sprintf(&ip6->ip6_src),
593 			       ip6_sprintf(&ip6->ip6_dst),
594 			       ip6->ip6_nxt, if_name(m->m_pkthdr.rcvif),
595 			       if_name(rt->rt_ifp));
596 		}
597 
598 		/* we can just use rcvif in forwarding. */
599 		origifp = m->m_pkthdr.rcvif;
600 	}
601 	else
602 		origifp = rt->rt_ifp;
603 	/*
604 	 * clear embedded scope identifiers if necessary.
605 	 * in6_clearscope will touch the addresses only when necessary.
606 	 */
607 	in6_clearscope(&ip6->ip6_src);
608 	in6_clearscope(&ip6->ip6_dst);
609 
610 #ifdef PFIL_HOOKS
611 	/*
612 	 * Run through list of hooks for output packets.
613 	 */
614 	if ((error = pfil_run_hooks(&inet6_pfil_hook, &m, rt->rt_ifp,
615 	    PFIL_OUT)) != 0)
616 		goto senderr;
617 	if (m == NULL)
618 		goto freecopy;
619 	ip6 = mtod(m, struct ip6_hdr *);
620 #endif /* PFIL_HOOKS */
621 
622 	error = nd6_output(rt->rt_ifp, origifp, m, dst, rt);
623 	if (error) {
624 		in6_ifstat_inc(rt->rt_ifp, ifs6_out_discard);
625 		ip6stat.ip6s_cantforward++;
626 	} else {
627 		ip6stat.ip6s_forward++;
628 		in6_ifstat_inc(rt->rt_ifp, ifs6_out_forward);
629 		if (type)
630 			ip6stat.ip6s_redirectsent++;
631 		else {
632 #ifdef GATEWAY
633 			if (m->m_flags & M_CANFASTFWD)
634 				ip6flow_create(&ip6_forward_rt, m);
635 #endif
636 			if (mcopy)
637 				goto freecopy;
638 		}
639 	}
640 
641 #ifdef PFIL_HOOKS
642  senderr:
643 #endif
644 	if (mcopy == NULL)
645 		return;
646 	switch (error) {
647 	case 0:
648 		if (type == ND_REDIRECT) {
649 			icmp6_redirect_output(mcopy, rt);
650 			return;
651 		}
652 		goto freecopy;
653 
654 	case EMSGSIZE:
655 		/* xxx MTU is constant in PPP? */
656 		goto freecopy;
657 
658 	case ENOBUFS:
659 		/* Tell source to slow down like source quench in IP? */
660 		goto freecopy;
661 
662 	case ENETUNREACH:	/* shouldn't happen, checked above */
663 	case EHOSTUNREACH:
664 	case ENETDOWN:
665 	case EHOSTDOWN:
666 	default:
667 		type = ICMP6_DST_UNREACH;
668 		code = ICMP6_DST_UNREACH_ADDR;
669 		break;
670 	}
671 	icmp6_error(mcopy, type, code, 0);
672 	return;
673 
674  freecopy:
675 	m_freem(mcopy);
676 	return;
677 }
678