/usr/src/sys/netinet6/ip6

Bug Summary

File:	netinet6/ip6_output.c
Warning:	line 659, column 30 Assigned value is garbage or undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ip6_output.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/netinet6/ip6_output.c
1/*	$OpenBSD: ip6_output.c,v 1.282 2023/12/01 15:30:47 bluhm Exp $	*/
2/*	$KAME: ip6_output.c,v 1.172 2001/03/25 09:55:56 itojun Exp $	*/

4/*
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the project nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

33/*
* Copyright (c) 1982, 1986, 1988, 1990, 1993
*	The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*	@(#)ip_output.c	8.3 (Berkeley) 1/21/94
*/

64#include "pf.h"

66#include <sys/param.h>
67#include <sys/malloc.h>
68#include <sys/mbuf.h>
69#include <sys/errno.h>
70#include <sys/protosw.h>
71#include <sys/socket.h>
72#include <sys/socketvar.h>
73#include <sys/proc.h>
74#include <sys/systm.h>

76#include <net/if.h>
77#include <net/if_var.h>
78#include <net/if_enc.h>
79#include <net/route.h>

81#include <netinet/in.h>
82#include <netinet/ip.h>
83#include <netinet/in_pcb.h>
84#include <netinet/udp.h>
85#include <netinet/tcp.h>

87#include <netinet/ip_var.h>
88#include <netinet/tcp_timer.h>
89#include <netinet/tcp_var.h>
90#include <netinet/udp_var.h>

92#include <netinet6/in6_var.h>
93#include <netinet/ip6.h>
94#include <netinet/icmp6.h>
95#include <netinet6/ip6_var.h>
96#include <netinet6/nd6.h>

98#include <crypto/idgen.h>

100#if NPF1 > 0
101#include <net/pfvar.h>
102#endif

104#ifdef IPSEC1
105#include <netinet/ip_ipsp.h>
106#include <netinet/ip_ah.h>
107#include <netinet/ip_esp.h>

109#ifdef ENCDEBUG
110#define DPRINTF(fmt, args...)do { } while (0)						\
do {								\
if (encdebug)						\
	printf("%s: " fmt "\n", __func__, ## args);	\
} while (0)
115#else
116#define DPRINTF(fmt, args...)do { } while (0)						\
do { } while (0)
118#endif
119#endif /* IPSEC */

121struct ip6_exthdrs {
struct mbuf *ip6e_ip6;
struct mbuf *ip6e_hbh;
struct mbuf *ip6e_dest1;
struct mbuf *ip6e_rthdr;
struct mbuf *ip6e_dest2;
127};

129int ip6_pcbopt(int, u_char *, int, struct ip6_pktopts **, int, int);
130int ip6_getpcbopt(struct ip6_pktopts *, int, struct mbuf *);
131int ip6_setpktopt(int, u_char *, int, struct ip6_pktopts *, int, int, int);
132int ip6_setmoptions(int, struct ip6_moptions **, struct mbuf *, unsigned int);
133int ip6_getmoptions(int, struct ip6_moptions *, struct mbuf *);
134int ip6_copyexthdr(struct mbuf **, caddr_t, int);
135int ip6_insertfraghdr(struct mbuf *, struct mbuf *, int,
struct ip6_frag **);
137int ip6_insert_jumboopt(struct ip6_exthdrs *, u_int32_t);
138int ip6_splithdr(struct mbuf *, struct ip6_exthdrs *);
139int ip6_getpmtu(struct rtentry *, struct ifnet *, u_long *);
140int copypktopts(struct ip6_pktopts *, struct ip6_pktopts *);
141static __inline u_int16_t __attribute__((__unused__))
  in6_cksum_phdr(const struct in6_addr *, const struct in6_addr *,
  u_int32_t, u_int32_t);
144void in6_delayed_cksum(struct mbuf *, u_int8_t);

146int ip6_output_ipsec_pmtu_update(struct tdb *, struct route_in6 *,
  struct in6_addr *, int, int, int);

149/* Context for non-repeating IDs */
150struct idgen32_ctx ip6_id_ctx;

152/*
* IP6 output. The packet in mbuf chain m contains a skeletal IP6
* header (with pri, len, nxt, hlim, src, dst).
* This function may modify ver and hlim only.
* The mbuf chain containing the packet will be freed.
* The mbuf opt, if present, will not be freed.
*
* type of "mtu": rt_mtu is u_long, ifnet.ifr_mtu is int.
* We use u_long to hold largest one, * which is rt_mtu.
*/
162int
163ip6_output(struct mbuf *m, struct ip6_pktopts *opt, struct route_in6 *ro,
  int flags, struct ip6_moptions *im6o, const u_char seclevel[])
165{
struct ip6_hdr *ip6;
struct ifnet *ifp = NULL((void *)0);
struct mbuf_list ml;
int hlen, tlen;
struct route_in6 ip6route;
struct rtentry *rt = NULL((void *)0);
struct sockaddr_in6 *dst, dstsock;
int error = 0;
u_long mtu;
int dontfrag;
u_int16_t src_scope, dst_scope;
1
'dst_scope' declared without an initial value→
u_int32_t optlen = 0, plen = 0, unfragpartlen = 0;
struct ip6_exthdrs exthdrs;
struct in6_addr finaldst;
struct route_in6 *ro_pmtu = NULL((void *)0);
int hdrsplit = 0;
u_int8_t sproto = 0;
u_char nextproto;
184#ifdef IPSEC1
struct tdb *tdb = NULL((void *)0);
186#endif /* IPSEC */

ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
finaldst = ip6->ip6_dst;

191#define MAKE_EXTHDR(hp, mp)do { if (hp) { struct ip6_ext *eh = (struct ip6_ext *)(hp); error
 = ip6_copyexthdr((mp), (caddr_t)(hp), ((eh)->ip6e_len + 1
) << 3); if (error) goto freehdrs; } } while (0)						\
  do {								\
if (hp) {							\
struct ip6_ext *eh = (struct ip6_ext *)(hp);		\
error = ip6_copyexthdr((mp), (caddr_t)(hp),		\
    ((eh)->ip6e_len + 1) << 3);				\
if (error)						\
	goto freehdrs;					\
}								\
  } while (0)

bzero(&exthdrs, sizeof(exthdrs))__builtin_bzero((&exthdrs), (sizeof(exthdrs)));

if (opt) {
2
←
Assuming 'opt' is null→
/* Hop-by-Hop options header */
MAKE_EXTHDR(opt->ip6po_hbh, &exthdrs.ip6e_hbh)do { if (opt->ip6po_hbh) { struct ip6_ext *eh = (struct ip6_ext
 *)(opt->ip6po_hbh); error = ip6_copyexthdr((&exthdrs.
ip6e_hbh), (caddr_t)(opt->ip6po_hbh), ((eh)->ip6e_len +
 1) << 3); if (error) goto freehdrs; } } while (0);
/* Destination options header(1st part) */
MAKE_EXTHDR(opt->ip6po_dest1, &exthdrs.ip6e_dest1)do { if (opt->ip6po_dest1) { struct ip6_ext *eh = (struct ip6_ext
 *)(opt->ip6po_dest1); error = ip6_copyexthdr((&exthdrs
.ip6e_dest1), (caddr_t)(opt->ip6po_dest1), ((eh)->ip6e_len
 + 1) << 3); if (error) goto freehdrs; } } while (0);
/* Routing header */
MAKE_EXTHDR(opt->ip6po_rthdr, &exthdrs.ip6e_rthdr)do { if (opt->ip6po_rhinfo.ip6po_rhi_rthdr) { struct ip6_ext
 *eh = (struct ip6_ext *)(opt->ip6po_rhinfo.ip6po_rhi_rthdr
); error = ip6_copyexthdr((&exthdrs.ip6e_rthdr), (caddr_t
)(opt->ip6po_rhinfo.ip6po_rhi_rthdr), ((eh)->ip6e_len +
 1) << 3); if (error) goto freehdrs; } } while (0);
/* Destination options header(2nd part) */
MAKE_EXTHDR(opt->ip6po_dest2, &exthdrs.ip6e_dest2)do { if (opt->ip6po_dest2) { struct ip6_ext *eh = (struct ip6_ext
 *)(opt->ip6po_dest2); error = ip6_copyexthdr((&exthdrs
.ip6e_dest2), (caddr_t)(opt->ip6po_dest2), ((eh)->ip6e_len
 + 1) << 3); if (error) goto freehdrs; } } while (0);
}

215#ifdef IPSEC1
if (ipsec_in_use || seclevel != NULL((void *)0)) {
3
←
Assuming 'ipsec_in_use' is 0→
4
←
Assuming 'seclevel' is equal to NULL→
5
←
Taking false branch→
error = ip6_output_ipsec_lookup(m, seclevel, &tdb);
if (error) {
	/*
	 * -EINVAL is used to indicate that the packet should
	 * be silently dropped, typically because we've asked
	 * key management for an SA.
	 */
	if (error == -EINVAL22) /* Should silently drop packet */
		error = 0;

	goto freehdrs;
}
}
230#endif /* IPSEC */

/*
* Calculate the total length of the extension header chain.
* Keep the length of the unfragmentable part for fragmentation.
*/
optlen = 0;
if (exthdrs.ip6e_hbh5.1
Field 'ip6e_hbh' is null
) optlen += exthdrs.ip6e_hbh->m_lenm_hdr.mh_len;
6
←
Taking false branch→
if (exthdrs.ip6e_dest16.1
Field 'ip6e_dest1' is null
) optlen += exthdrs.ip6e_dest1->m_lenm_hdr.mh_len;
7
←
Taking false branch→
if (exthdrs.ip6e_rthdr7.1
Field 'ip6e_rthdr' is null
) optlen += exthdrs.ip6e_rthdr->m_lenm_hdr.mh_len;
8
←
Taking false branch→
unfragpartlen = optlen + sizeof(struct ip6_hdr);
/* NOTE: we don't add AH/ESP length here. do that later. */
if (exthdrs.ip6e_dest28.1
Field 'ip6e_dest2' is null
) optlen += exthdrs.ip6e_dest2->m_lenm_hdr.mh_len;

/*
* If we need IPsec, or there is at least one extension header,
* separate IP6 header from the payload.
*/
if ((sproto8.2
'sproto' is 0
 || optlen8.3
'optlen' is 0
) && !hdrsplit) {
if ((error = ip6_splithdr(m, &exthdrs)) != 0) {
	m = NULL((void *)0);
	goto freehdrs;
}
m = exthdrs.ip6e_ip6;
hdrsplit++;
}

/* adjust pointer */
ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));

/* adjust mbuf packet header length */
m->m_pkthdrM_dat.MH.MH_pkthdr.len += optlen;
plen = m->m_pkthdrM_dat.MH.MH_pkthdr.len - sizeof(*ip6);

/* If this is a jumbo payload, insert a jumbo payload option. */
if (plen > IPV6_MAXPACKET65535) {
9
←
Assuming 'plen' is <= IPV6_MAXPACKET→
if (!hdrsplit) {
	if ((error = ip6_splithdr(m, &exthdrs)) != 0) {
		m = NULL((void *)0);
		goto freehdrs;
	}
	m = exthdrs.ip6e_ip6;
	hdrsplit++;
}
/* adjust pointer */
ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
if ((error = ip6_insert_jumboopt(&exthdrs, plen)) != 0)
	goto freehdrs;
ip6->ip6_plenip6_ctlun.ip6_un1.ip6_un1_plen = 0;
} else
ip6->ip6_plenip6_ctlun.ip6_un1.ip6_un1_plen = htons(plen)(__uint16_t)(__builtin_constant_p(plen) ? (__uint16_t)(((__uint16_t
)(plen) & 0xffU) << 8 | ((__uint16_t)(plen) & 0xff00U
) >> 8) : __swap16md(plen));
10
←
Taking false branch→
11
←
'?' condition is false→

/*
* Concatenate headers and fill in next header fields.
* Here we have, on "m"
*	IPv6 payload
* and we insert headers accordingly.  Finally, we should be getting:
*	IPv6 hbh dest1 rthdr ah* [esp* dest2 payload]
*
* during the header composing process, "m" points to IPv6 header.
* "mprev" points to an extension header prior to esp.
*/
{
u_char *nexthdrp = &ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt;
struct mbuf *mprev = m;

/*
 * we treat dest2 specially.  this makes IPsec processing
 * much easier.  the goal here is to make mprev point the
 * mbuf prior to dest2.
 *
 * result: IPv6 dest2 payload
 * m and mprev will point to IPv6 header.
 */
if (exthdrs.ip6e_dest211.1
Field 'ip6e_dest2' is null
) {
12
←
Taking false branch→
	if (!hdrsplit)
		panic("%s: assumption failed: hdr not split",
		    __func__);
	exthdrs.ip6e_dest2->m_nextm_hdr.mh_next = m->m_nextm_hdr.mh_next;
	m->m_nextm_hdr.mh_next = exthdrs.ip6e_dest2;
	*mtod(exthdrs.ip6e_dest2, u_char *)((u_char *)((exthdrs.ip6e_dest2)->m_hdr.mh_data)) = ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt;
	ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt = IPPROTO_DSTOPTS60;
}

314#define MAKE_CHAIN(m, mp, p, i)do { if (m) { if (!hdrsplit) panic("assumption failed: hdr not split"
); *((u_char *)(((m))->m_hdr.mh_data)) = *(p); *(p) = (i);
 p = ((u_char *)(((m))->m_hdr.mh_data)); (m)->m_hdr.mh_next
 = (mp)->m_hdr.mh_next; (mp)->m_hdr.mh_next = (m); (mp)
 = (m); } } while (0)\
  do {\
if (m) {\
if (!hdrsplit) \
	panic("assumption failed: hdr not split"); \
*mtod((m), u_char *)((u_char *)(((m))->m_hdr.mh_data)) = *(p);\
*(p) = (i);\
p = mtod((m), u_char *)((u_char *)(((m))->m_hdr.mh_data));\
(m)->m_nextm_hdr.mh_next = (mp)->m_nextm_hdr.mh_next;\
(mp)->m_nextm_hdr.mh_next = (m);\
(mp) = (m);\
}\
  } while (0)
/*
 * result: IPv6 hbh dest1 rthdr dest2 payload
 * m will point to IPv6 header.  mprev will point to the
 * extension header prior to dest2 (rthdr in the above case).
 */
MAKE_CHAIN(exthdrs.ip6e_hbh, mprev, nexthdrp, IPPROTO_HOPOPTS)do { if (exthdrs.ip6e_hbh) { if (!hdrsplit) panic("assumption failed: hdr not split"
); *((u_char *)(((exthdrs.ip6e_hbh))->m_hdr.mh_data)) = *(
nexthdrp); *(nexthdrp) = (0); nexthdrp = ((u_char *)(((exthdrs
.ip6e_hbh))->m_hdr.mh_data)); (exthdrs.ip6e_hbh)->m_hdr
.mh_next = (mprev)->m_hdr.mh_next; (mprev)->m_hdr.mh_next
 = (exthdrs.ip6e_hbh); (mprev) = (exthdrs.ip6e_hbh); } } while
 (0);
13
←
Taking false branch→
14
←
Loop condition is false.  Exiting loop→
MAKE_CHAIN(exthdrs.ip6e_dest1, mprev, nexthdrp,do { if (exthdrs.ip6e_dest1) { if (!hdrsplit) panic("assumption failed: hdr not split"
); *((u_char *)(((exthdrs.ip6e_dest1))->m_hdr.mh_data)) = *
(nexthdrp); *(nexthdrp) = (60); nexthdrp = ((u_char *)(((exthdrs
.ip6e_dest1))->m_hdr.mh_data)); (exthdrs.ip6e_dest1)->m_hdr
.mh_next = (mprev)->m_hdr.mh_next; (mprev)->m_hdr.mh_next
 = (exthdrs.ip6e_dest1); (mprev) = (exthdrs.ip6e_dest1); } } while
 (0)
15
←
Taking false branch→
16
←
Loop condition is false.  Exiting loop→
    IPPROTO_DSTOPTS)do { if (exthdrs.ip6e_dest1) { if (!hdrsplit) panic("assumption failed: hdr not split"
); *((u_char *)(((exthdrs.ip6e_dest1))->m_hdr.mh_data)) = *
(nexthdrp); *(nexthdrp) = (60); nexthdrp = ((u_char *)(((exthdrs
.ip6e_dest1))->m_hdr.mh_data)); (exthdrs.ip6e_dest1)->m_hdr
.mh_next = (mprev)->m_hdr.mh_next; (mprev)->m_hdr.mh_next
 = (exthdrs.ip6e_dest1); (mprev) = (exthdrs.ip6e_dest1); } } while
 (0);
MAKE_CHAIN(exthdrs.ip6e_rthdr, mprev, nexthdrp,do { if (exthdrs.ip6e_rthdr) { if (!hdrsplit) panic("assumption failed: hdr not split"
); *((u_char *)(((exthdrs.ip6e_rthdr))->m_hdr.mh_data)) = *
(nexthdrp); *(nexthdrp) = (43); nexthdrp = ((u_char *)(((exthdrs
.ip6e_rthdr))->m_hdr.mh_data)); (exthdrs.ip6e_rthdr)->m_hdr
.mh_next = (mprev)->m_hdr.mh_next; (mprev)->m_hdr.mh_next
 = (exthdrs.ip6e_rthdr); (mprev) = (exthdrs.ip6e_rthdr); } } while
 (0)
17
←
Taking false branch→
18
←
Loop condition is false.  Exiting loop→
    IPPROTO_ROUTING)do { if (exthdrs.ip6e_rthdr) { if (!hdrsplit) panic("assumption failed: hdr not split"
); *((u_char *)(((exthdrs.ip6e_rthdr))->m_hdr.mh_data)) = *
(nexthdrp); *(nexthdrp) = (43); nexthdrp = ((u_char *)(((exthdrs
.ip6e_rthdr))->m_hdr.mh_data)); (exthdrs.ip6e_rthdr)->m_hdr
.mh_next = (mprev)->m_hdr.mh_next; (mprev)->m_hdr.mh_next
 = (exthdrs.ip6e_rthdr); (mprev) = (exthdrs.ip6e_rthdr); } } while
 (0);
}

/*
* If there is a routing header, replace the destination address field
* with the first hop of the routing header.
*/
if (exthdrs.ip6e_rthdr18.1
Field 'ip6e_rthdr' is null
) {
struct ip6_rthdr *rh;
struct ip6_rthdr0 *rh0;
struct in6_addr *addr;

rh = (struct ip6_rthdr *)(mtod(exthdrs.ip6e_rthdr,((struct ip6_rthdr *)((exthdrs.ip6e_rthdr)->m_hdr.mh_data)
)
    struct ip6_rthdr *)((struct ip6_rthdr *)((exthdrs.ip6e_rthdr)->m_hdr.mh_data)
));
switch (rh->ip6r_type) {
case IPV6_RTHDR_TYPE_00:
	rh0 = (struct ip6_rthdr0 *)rh;
	addr = (struct in6_addr *)(rh0 + 1);
	ip6->ip6_dst = addr[0];
	bcopy(&addr[1], &addr[0],
	    sizeof(struct in6_addr) * (rh0->ip6r0_segleft - 1));
	addr[rh0->ip6r0_segleft - 1] = finaldst;
	break;
default:	/* is it possible? */
	error = EINVAL22;
	goto bad;
}
}

/* Source address validation */
if (!(flags & IPV6_UNSPECSRC0x01) &&
19
←
Assuming the condition is false→
   IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)((*(const u_int32_t *)(const void *)(&(&ip6->ip6_src
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&ip6->ip6_src)->__u6_addr.__u6_addr8
[4]) == 0) && (*(const u_int32_t *)(const void *)(&
(&ip6->ip6_src)->__u6_addr.__u6_addr8[8]) == 0) &&
 (*(const u_int32_t *)(const void *)(&(&ip6->ip6_src
)->__u6_addr.__u6_addr8[12]) == 0))) {
/*
 * XXX: we can probably assume validation in the caller, but
 * we explicitly check the address here for safety.
 */
error = EOPNOTSUPP45;
ip6stat_inc(ip6s_badscope);
goto bad;
}
if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)((&ip6->ip6_src)->__u6_addr.__u6_addr8[0] == 0xff)) {
20
←
Assuming the condition is false→
21
←
Taking false branch→
error = EOPNOTSUPP45;
ip6stat_inc(ip6s_badscope);
goto bad;
}

ip6stat_inc(ip6s_localout);

/*
* Route packet.
*/
387#if NPF1 > 0
388reroute:
389#endif

/* initialize cached route */
if (ro == NULL((void *)0)) {
22
←
Assuming 'ro' is not equal to NULL→
23
←
Taking false branch→
ro = &ip6route;
bzero((caddr_t)ro, sizeof(*ro))__builtin_bzero(((caddr_t)ro), (sizeof(*ro)));
}
ro_pmtu = ro;
if (opt23.1
'opt' is null
 && opt->ip6po_rthdrip6po_rhinfo.ip6po_rhi_rthdr)
ro = &opt->ip6po_routeip6po_rhinfo.ip6po_rhi_route;
dst = &ro->ro_dst;

/*
* if specified, try to fill in the traffic class field.
* do not override if a non-zero value is already set.
* we check the diffserv field and the ecn field separately.
*/
if (opt23.2
'opt' is null
 && opt->ip6po_tclass >= 0) {
int mask = 0;

if ((ip6->ip6_flowip6_ctlun.ip6_un1.ip6_un1_flow & htonl(0xfc << 20)(__uint32_t)(__builtin_constant_p(0xfc << 20) ? (__uint32_t
)(((__uint32_t)(0xfc << 20) & 0xff) << 24 | (
(__uint32_t)(0xfc << 20) & 0xff00) << 8 | ((__uint32_t
)(0xfc << 20) & 0xff0000) >> 8 | ((__uint32_t
)(0xfc << 20) & 0xff000000) >> 24) : __swap32md
(0xfc << 20))) == 0)
	mask |= 0xfc;
if ((ip6->ip6_flowip6_ctlun.ip6_un1.ip6_un1_flow & htonl(0x03 << 20)(__uint32_t)(__builtin_constant_p(0x03 << 20) ? (__uint32_t
)(((__uint32_t)(0x03 << 20) & 0xff) << 24 | (
(__uint32_t)(0x03 << 20) & 0xff00) << 8 | ((__uint32_t
)(0x03 << 20) & 0xff0000) >> 8 | ((__uint32_t
)(0x03 << 20) & 0xff000000) >> 24) : __swap32md
(0x03 << 20))) == 0)
	mask |= 0x03;
if (mask != 0)
	ip6->ip6_flowip6_ctlun.ip6_un1.ip6_un1_flow |=
	    htonl((opt->ip6po_tclass & mask) << 20)(__uint32_t)(__builtin_constant_p((opt->ip6po_tclass &
 mask) << 20) ? (__uint32_t)(((__uint32_t)((opt->ip6po_tclass
 & mask) << 20) & 0xff) << 24 | ((__uint32_t
)((opt->ip6po_tclass & mask) << 20) & 0xff00
) << 8 | ((__uint32_t)((opt->ip6po_tclass & mask
) << 20) & 0xff0000) >> 8 | ((__uint32_t)((opt
->ip6po_tclass & mask) << 20) & 0xff000000) >>
 24) : __swap32md((opt->ip6po_tclass & mask) << 20
));
}

/* fill in or override the hop limit field, if necessary. */
if (opt23.3
'opt' is null
 && opt->ip6po_hlim != -1)
ip6->ip6_hlimip6_ctlun.ip6_un1.ip6_un1_hlim = opt->ip6po_hlim & 0xff;
else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)((&ip6->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xff)) {
24
←
Assuming the condition is false→
25
←
Taking false branch→
if (im6o != NULL((void *)0))
	ip6->ip6_hlimip6_ctlun.ip6_un1.ip6_un1_hlim = im6o->im6o_hlim;
else
	ip6->ip6_hlimip6_ctlun.ip6_un1.ip6_un1_hlim = ip6_defmcasthlim;
}

428#ifdef IPSEC1
if (tdb25.1
'tdb' is equal to NULL
 != NULL((void *)0)) {
26
←
Taking false branch→
/*
 * XXX what should we do if ip6_hlim == 0 and the
 * packet gets tunneled?
 */
/*
 * if we are source-routing, do not attempt to tunnel the
 * packet just because ip6_dst is different from what tdb has.
 * XXX
 */
error = ip6_output_ipsec_send(tdb, m, ro,
    exthdrs.ip6e_rthdr ? 1 : 0, 0);
goto done;
}
443#endif /* IPSEC */

bzero(&dstsock, sizeof(dstsock))__builtin_bzero((&dstsock), (sizeof(dstsock)));
dstsock.sin6_family = AF_INET624;
dstsock.sin6_addr = ip6->ip6_dst;
dstsock.sin6_len = sizeof(dstsock);
ro->ro_tableid = m->m_pkthdrM_dat.MH.MH_pkthdr.ph_rtableid;

if (IN6_IS_ADDR_MULTICAST(&dstsock.sin6_addr)((&dstsock.sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff
)) {
27
←
Assuming the condition is false→
28
←
Taking false branch→
struct in6_pktinfo *pi = NULL((void *)0);

/*
 * If the caller specify the outgoing interface
 * explicitly, use it.
 */
if (opt != NULL((void *)0) && (pi = opt->ip6po_pktinfo) != NULL((void *)0))
	ifp = if_get(pi->ipi6_ifindex);

if (ifp == NULL((void *)0) && im6o != NULL((void *)0))
	ifp = if_get(im6o->im6o_ifidx);
}

if (ifp28.1
'ifp' is equal to NULL
 == NULL((void *)0)) {
29
←
Taking true branch→
rt = in6_selectroute(&dstsock, opt, ro, ro->ro_tableid);
if (rt == NULL((void *)0)) {
30
←
Assuming 'rt' is not equal to NULL→
31
←
Taking false branch→
	ip6stat_inc(ip6s_noroute);
	error = EHOSTUNREACH65;
	goto bad;
}
if (ISSET(rt->rt_flags, RTF_LOCAL)((rt->rt_flags) & (0x200000)))
32
←
Assuming the condition is false→
33
←
Taking false branch→
	ifp = if_get(rtable_loindex(m->m_pkthdrM_dat.MH.MH_pkthdr.ph_rtableid));
else
	ifp = if_get(rt->rt_ifidx);
/*
 * We aren't using rtisvalid() here because the UP/DOWN state
 * machine is broken with some Ethernet drivers like em(4).
 * As a result we might try to use an invalid cached route
 * entry while an interface is being detached.
 */
if (ifp == NULL((void *)0)) {
34
←
Assuming 'ifp' is not equal to NULL→
	ip6stat_inc(ip6s_noroute);
	error = EHOSTUNREACH65;
	goto bad;
}
} else {
*dst = dstsock;
}

if (rt34.1
'rt' is non-null
 && (rt->rt_flags & RTF_GATEWAY0x2) &&
35
←
Assuming the condition is false→
   !IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)((&ip6->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xff))
dst = satosin6(rt->rt_gateway);

if (!IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)((&ip6->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xff)) {
36
←
Assuming the condition is false→
37
←
Taking false branch→
/* Unicast */

m->m_flagsm_hdr.mh_flags &= ~(M_BCAST0x0100 | M_MCAST0x0200);	/* just in case */
} else {
/* Multicast */

m->m_flagsm_hdr.mh_flags = (m->m_flagsm_hdr.mh_flags & ~M_BCAST0x0100) | M_MCAST0x0200;

/*
 * Confirm that the outgoing interface supports multicast.
 */
if ((ifp->if_flags & IFF_MULTICAST0x8000) == 0) {
38
←
Assuming the condition is false→
	ip6stat_inc(ip6s_noroute);
	error = ENETUNREACH51;
	goto bad;
}

if ((im6o == NULL((void *)0) || im6o->im6o_loop) &&
39
←
Assuming 'im6o' is not equal to NULL→
40
←
Assuming field 'im6o_loop' is 0→
    in6_hasmulti(&ip6->ip6_dst, ifp)) {
	/*
	 * If we belong to the destination multicast group
	 * on the outgoing interface, and the caller did not
	 * forbid loopback, loop back a copy.
	 * Can't defer TCP/UDP checksumming, do the
	 * computation now.
	 */
	in6_proto_cksum_out(m, NULL((void *)0));
	ip6_mloopback(ifp, m, dst);
}
525#ifdef MROUTING1
else {
	/*
	 * If we are acting as a multicast router, perform
	 * multicast forwarding as if the packet had just
	 * arrived on the interface to which we are about
	 * to send.  The multicast forwarding function
	 * recursively calls this function, using the
	 * IPV6_FORWARDING flag to prevent infinite recursion.
	 *
	 * Multicasts that are looped back by ip6_mloopback(),
	 * above, will be forwarded by the ip6_input() routine,
	 * if necessary.
	 */
	if (ip6_mforwarding && ip6_mrouter[ifp->if_rdomainif_data.ifi_rdomain] &&
41
←
Assuming 'ip6_mforwarding' is 0→
	    (flags & IPV6_FORWARDING0x02) == 0) {
		if (ip6_mforward(ip6, ifp, m) != 0) {
			m_freem(m);
			goto done;
		}
	}
}
547#endif
/*
 * Multicasts with a hoplimit of zero may be looped back,
 * above, but must not be transmitted on a network.
 * Also, multicasts addressed to the loopback interface
 * are not sent -- the above call to ip6_mloopback() will
 * loop back a copy if this host actually belongs to the
 * destination group on the loopback interface.
 */
if (ip6->ip6_hlimip6_ctlun.ip6_un1.ip6_un1_hlim == 0 || (ifp->if_flags & IFF_LOOPBACK0x8) ||
42
←
Assuming field 'ip6_un1_hlim' is not equal to 0→
43
←
Assuming the condition is false→
    IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst)(((&ip6->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xff)
 && (((&ip6->ip6_dst)->__u6_addr.__u6_addr8
[1] & 0x0f) == 0x01))) {
44
←
Assuming the condition is false→
	m_freem(m);
	goto done;
}
}

/*
* If this packet is going through a loopback interface we won't
* be able to restore its scope ID using the interface index.
*/
if (IN6_IS_SCOPE_EMBED(&ip6->ip6_src)(((((&ip6->ip6_src)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&ip6->ip6_src)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) || ((((&ip6->ip6_src)->__u6_addr
.__u6_addr8[0] == 0xff) && (((&ip6->ip6_src)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) || ((((&ip6
->ip6_src)->__u6_addr.__u6_addr8[0] == 0xff) &&
 (((&ip6->ip6_src)->__u6_addr.__u6_addr8[1] & 0x0f
) == 0x01))))) {
45
←
Assuming the condition is false→
46
←
Assuming the condition is false→
47
←
Assuming the condition is false→
if (ifp->if_flags & IFF_LOOPBACK0x8)
	src_scope = ip6->ip6_src.s6_addr16__u6_addr.__u6_addr16[1];
ip6->ip6_src.s6_addr16__u6_addr.__u6_addr16[1] = 0;
}
if (IN6_IS_SCOPE_EMBED(&ip6->ip6_dst)(((((&ip6->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&ip6->ip6_dst)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) || ((((&ip6->ip6_dst)->__u6_addr
.__u6_addr8[0] == 0xff) && (((&ip6->ip6_dst)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) || ((((&ip6
->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xff) &&
 (((&ip6->ip6_dst)->__u6_addr.__u6_addr8[1] & 0x0f
) == 0x01))))) {
48
←
Assuming the condition is false→
49
←
Assuming the condition is false→
50
←
Assuming the condition is false→
if (ifp->if_flags & IFF_LOOPBACK0x8)
	dst_scope = ip6->ip6_dst.s6_addr16__u6_addr.__u6_addr16[1];
ip6->ip6_dst.s6_addr16__u6_addr.__u6_addr16[1] = 0;
}

/* Determine path MTU. */
if ((error = ip6_getpmtu(ro_pmtu->ro_rt, ifp, &mtu)) != 0)
51
←
Taking false branch→
goto bad;

/*
* The caller of this function may specify to use the minimum MTU
* in some cases.
* An advanced API option (IPV6_USE_MIN_MTU) can also override MTU
* setting.  The logic is a bit complicated; by default, unicast
* packets will follow path MTU while multicast packets will be sent at
* the minimum MTU.  If IP6PO_MINMTU_ALL is specified, all packets
* including unicast ones will be sent at the minimum MTU.  Multicast
* packets will always be sent at the minimum MTU unless
* IP6PO_MINMTU_DISABLE is explicitly specified.
* See RFC 3542 for more details.
*/
if (mtu > IPV6_MMTU1280) {
52
←
Assuming 'mtu' is <= IPV6_MMTU→
53
←
Taking false branch→
if ((flags & IPV6_MINMTU0x04))
	mtu = IPV6_MMTU1280;
else if (opt && opt->ip6po_minmtu == IP6PO_MINMTU_ALL1)
	mtu = IPV6_MMTU1280;
else if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)((&ip6->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xff) && (opt == NULL((void *)0) ||
    opt->ip6po_minmtu != IP6PO_MINMTU_DISABLE0)) {
	mtu = IPV6_MMTU1280;
}
}

/*
* If the outgoing packet contains a hop-by-hop options header,
* it must be examined and processed even by the source node.
* (RFC 2460, section 4.)
*/
if (exthdrs.ip6e_hbh53.1
Field 'ip6e_hbh' is null
) {
54
←
Taking false branch→
struct ip6_hbh *hbh = mtod(exthdrs.ip6e_hbh, struct ip6_hbh *)((struct ip6_hbh *)((exthdrs.ip6e_hbh)->m_hdr.mh_data));
u_int32_t rtalert; /* returned value is ignored */
u_int32_t plen = 0; /* no more than 1 jumbo payload option! */

m->m_pkthdrM_dat.MH.MH_pkthdr.ph_ifidx = ifp->if_index;
if (ip6_process_hopopts(&m, (u_int8_t *)(hbh + 1),
    ((hbh->ip6h_len + 1) << 3) - sizeof(struct ip6_hbh),
    &rtalert, &plen) < 0) {
	/* m was already freed at this point */
	error = EINVAL22;/* better error? */
	goto done;
}
m->m_pkthdrM_dat.MH.MH_pkthdr.ph_ifidx = 0;
}

626#if NPF1 > 0
if (pf_test(AF_INET624, PF_OUT, ifp, &m) != PF_PASS) {
55
←
Assuming the condition is false→
56
←
Taking false branch→
error = EACCES13;
m_freem(m);
goto done;
}
if (m == NULL((void *)0))
57
←
Assuming 'm' is not equal to NULL→
58
←
Taking false branch→
goto done;
ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
if ((m->m_pkthdrM_dat.MH.MH_pkthdr.pf.flags & (PF_TAG_REROUTE0x20 | PF_TAG_GENERATED0x01)) ==
59
←
Assuming the condition is false→
60
←
Taking false branch→
   (PF_TAG_REROUTE0x20 | PF_TAG_GENERATED0x01)) {
/* already rerun the route lookup, go on */
m->m_pkthdrM_dat.MH.MH_pkthdr.pf.flags &= ~(PF_TAG_GENERATED0x01 | PF_TAG_REROUTE0x20);
} else if (m->m_pkthdrM_dat.MH.MH_pkthdr.pf.flags & PF_TAG_REROUTE0x20) {
61
←
Assuming the condition is false→
62
←
Taking false branch→
/* tag as generated to skip over pf_test on rerun */
m->m_pkthdrM_dat.MH.MH_pkthdr.pf.flags |= PF_TAG_GENERATED0x01;
finaldst = ip6->ip6_dst;
ro = NULL((void *)0);
if_put(ifp); /* drop reference since destination changed */
ifp = NULL((void *)0);
goto reroute;
}
648#endif

/*
* If the packet is not going on the wire it can be destined
* to any local address.  In this case do not clear its scopes
* to let ip6_input() find a matching local route.
*/
if (ifp->if_flags & IFF_LOOPBACK0x8) {
63
←
Assuming the condition is true→
if (IN6_IS_SCOPE_EMBED(&ip6->ip6_src)(((((&ip6->ip6_src)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&ip6->ip6_src)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) || ((((&ip6->ip6_src)->__u6_addr
.__u6_addr8[0] == 0xff) && (((&ip6->ip6_src)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) || ((((&ip6
->ip6_src)->__u6_addr.__u6_addr8[0] == 0xff) &&
 (((&ip6->ip6_src)->__u6_addr.__u6_addr8[1] & 0x0f
) == 0x01)))))
64
←
Taking true branch→
65
←
Assuming the condition is false→
66
←
Assuming the condition is false→
	ip6->ip6_src.s6_addr16__u6_addr.__u6_addr16[1] = src_scope;
if (IN6_IS_SCOPE_EMBED(&ip6->ip6_dst)(((((&ip6->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&ip6->ip6_dst)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) || ((((&ip6->ip6_dst)->__u6_addr
.__u6_addr8[0] == 0xff) && (((&ip6->ip6_dst)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) || ((((&ip6
->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xff) &&
 (((&ip6->ip6_dst)->__u6_addr.__u6_addr8[1] & 0x0f
) == 0x01)))))
67
←
Assuming the condition is true→
68
←
Assuming the condition is true→
	ip6->ip6_dst.s6_addr16__u6_addr.__u6_addr16[1] = dst_scope;
69
←
Assigned value is garbage or undefined
}

/*
* Send the packet to the outgoing interface.
* If necessary, do IPv6 fragmentation before sending.
*
* the logic here is rather complex:
* 1: normal case (dontfrag == 0)
* 1-a: send as is if tlen <= path mtu
* 1-b: fragment if tlen > path mtu
*
* 2: if user asks us not to fragment (dontfrag == 1)
* 2-a: send as is if tlen <= interface mtu
* 2-b: error if tlen > interface mtu
*/
tlen = ISSET(m->m_pkthdr.csum_flags, M_TCP_TSO)((m->M_dat.MH.MH_pkthdr.csum_flags) & (0x8000)) ?
   m->m_pkthdrM_dat.MH.MH_pkthdr.ph_mss : m->m_pkthdrM_dat.MH.MH_pkthdr.len;

if (ISSET(m->m_pkthdr.csum_flags, M_IPV6_DF_OUT)((m->M_dat.MH.MH_pkthdr.csum_flags) & (0x1000))) {
CLR(m->m_pkthdr.csum_flags, M_IPV6_DF_OUT)((m->M_dat.MH.MH_pkthdr.csum_flags) &= ~(0x1000));
dontfrag = 1;
} else if (opt && ISSET(opt->ip6po_flags, IP6PO_DONTFRAG)((opt->ip6po_flags) & (0x04)))
dontfrag = 1;
else
dontfrag = 0;

if (dontfrag && tlen > ifp->if_mtuif_data.ifi_mtu) {		/* case 2-b */
687#ifdef IPSEC1
if (ip_mtudisc)
	ipsec_adjust_mtu(m, mtu);
690#endif
error = EMSGSIZE40;
goto bad;
}

/*
* transmit packet without fragmentation
*/
if (dontfrag || tlen <= mtu) {			/* case 1-a and 2-a */
error = if_output_tso(ifp, &m, sin6tosa(dst), ro->ro_rt,
    ifp->if_mtuif_data.ifi_mtu);
if (error || m == NULL((void *)0))
	goto done;
goto bad;				/* should not happen */
}

/*
* try to fragment the packet.  case 1-b
*/
if (mtu < IPV6_MMTU1280) {
/* path MTU cannot be less than IPV6_MMTU */
error = EMSGSIZE40;
goto bad;
} else if (ip6->ip6_plenip6_ctlun.ip6_un1.ip6_un1_plen == 0) {
/* jumbo payload cannot be fragmented */
error = EMSGSIZE40;
goto bad;
}

/*
* Too large for the destination or interface;
* fragment if possible.
* Must be able to put at least 8 bytes per fragment.
*/
hlen = unfragpartlen;
if (mtu > IPV6_MAXPACKET65535)
mtu = IPV6_MAXPACKET65535;

/*
* If we are doing fragmentation, we can't defer TCP/UDP
* checksumming; compute the checksum and clear the flag.
*/
      in6_proto_cksum_out(m, NULL((void *)0));

/*
* Change the next header field of the last header in the
* unfragmentable part.
*/
if (exthdrs.ip6e_rthdr) {
nextproto = *mtod(exthdrs.ip6e_rthdr, u_char *)((u_char *)((exthdrs.ip6e_rthdr)->m_hdr.mh_data));
*mtod(exthdrs.ip6e_rthdr, u_char *)((u_char *)((exthdrs.ip6e_rthdr)->m_hdr.mh_data)) = IPPROTO_FRAGMENT44;
} else if (exthdrs.ip6e_dest1) {
nextproto = *mtod(exthdrs.ip6e_dest1, u_char *)((u_char *)((exthdrs.ip6e_dest1)->m_hdr.mh_data));
*mtod(exthdrs.ip6e_dest1, u_char *)((u_char *)((exthdrs.ip6e_dest1)->m_hdr.mh_data)) = IPPROTO_FRAGMENT44;
} else if (exthdrs.ip6e_hbh) {
nextproto = *mtod(exthdrs.ip6e_hbh, u_char *)((u_char *)((exthdrs.ip6e_hbh)->m_hdr.mh_data));
*mtod(exthdrs.ip6e_hbh, u_char *)((u_char *)((exthdrs.ip6e_hbh)->m_hdr.mh_data)) = IPPROTO_FRAGMENT44;
} else {
nextproto = ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt;
ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt = IPPROTO_FRAGMENT44;
}

if ((error = ip6_fragment(m, &ml, hlen, nextproto, mtu)) ||
   (error = if_output_ml(ifp, &ml, sin6tosa(dst), ro->ro_rt)))
goto done;
ip6stat_inc(ip6s_fragmented);

757done:
if (ro == &ip6route && ro->ro_rt) {
rtfree(ro->ro_rt);
} else if (ro_pmtu == &ip6route && ro_pmtu->ro_rt) {
rtfree(ro_pmtu->ro_rt);
}
if_put(ifp);
764#ifdef IPSEC1
tdb_unref(tdb);
766#endif /* IPSEC */
return (error);

769freehdrs:
m_freem(exthdrs.ip6e_hbh);	/* m_freem will check if mbuf is 0 */
m_freem(exthdrs.ip6e_dest1);
m_freem(exthdrs.ip6e_rthdr);
m_freem(exthdrs.ip6e_dest2);
/* FALLTHROUGH */
775bad:
m_freem(m);
goto done;
778}

780int
781ip6_fragment(struct mbuf *m0, struct mbuf_list *ml, int hlen, u_char nextproto,
  u_long mtu)
783{
struct ip6_hdr *ip6;
u_int32_t id;
int tlen, len, off;
int error;

ml_init(ml);

ip6 = mtod(m0, struct ip6_hdr *)((struct ip6_hdr *)((m0)->m_hdr.mh_data));
tlen = m0->m_pkthdrM_dat.MH.MH_pkthdr.len;
len = (mtu - hlen - sizeof(struct ip6_frag)) & ~7;
if (len < 8) {
error = EMSGSIZE40;
goto bad;
}
id = htonl(ip6_randomid())(__uint32_t)(__builtin_constant_p(ip6_randomid()) ? (__uint32_t
)(((__uint32_t)(ip6_randomid()) & 0xff) << 24 | ((__uint32_t
)(ip6_randomid()) & 0xff00) << 8 | ((__uint32_t)(ip6_randomid
()) & 0xff0000) >> 8 | ((__uint32_t)(ip6_randomid()
) & 0xff000000) >> 24) : __swap32md(ip6_randomid())
);

/*
* Loop through length of payload,
* make new header and copy data of each part and link onto chain.
*/
for (off = hlen; off < tlen; off += len) {
struct mbuf *m;
struct mbuf *mlast;
struct ip6_hdr *mhip6;
struct ip6_frag *ip6f;

MGETHDR(m, M_DONTWAIT, MT_HEADER)m = m_gethdr((0x0002), (2));
if (m == NULL((void *)0)) {
	error = ENOBUFS55;
	goto bad;
}
ml_enqueue(ml, m);
if ((error = m_dup_pkthdr(m, m0, M_DONTWAIT0x0002)) != 0)
	goto bad;
m->m_datam_hdr.mh_data += max_linkhdr;
mhip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
*mhip6 = *ip6;
m->m_lenm_hdr.mh_len = sizeof(struct ip6_hdr);

if ((error = ip6_insertfraghdr(m0, m, hlen, &ip6f)) != 0)
	goto bad;
ip6f->ip6f_offlg = htons((off - hlen) & ~7)(__uint16_t)(__builtin_constant_p((off - hlen) & ~7) ? (__uint16_t
)(((__uint16_t)((off - hlen) & ~7) & 0xffU) << 8
 | ((__uint16_t)((off - hlen) & ~7) & 0xff00U) >>
 8) : __swap16md((off - hlen) & ~7));
if (off + len >= tlen)
	len = tlen - off;
else
	ip6f->ip6f_offlg |= IP6F_MORE_FRAG0x0100;

m->m_pkthdrM_dat.MH.MH_pkthdr.len = hlen + sizeof(struct ip6_frag) + len;
mhip6->ip6_plenip6_ctlun.ip6_un1.ip6_un1_plen = htons(m->m_pkthdr.len -(__uint16_t)(__builtin_constant_p(m->M_dat.MH.MH_pkthdr.len
 - sizeof(struct ip6_hdr)) ? (__uint16_t)(((__uint16_t)(m->
M_dat.MH.MH_pkthdr.len - sizeof(struct ip6_hdr)) & 0xffU)
 << 8 | ((__uint16_t)(m->M_dat.MH.MH_pkthdr.len - sizeof
(struct ip6_hdr)) & 0xff00U) >> 8) : __swap16md(m->
M_dat.MH.MH_pkthdr.len - sizeof(struct ip6_hdr)))
    sizeof(struct ip6_hdr))(__uint16_t)(__builtin_constant_p(m->M_dat.MH.MH_pkthdr.len
 - sizeof(struct ip6_hdr)) ? (__uint16_t)(((__uint16_t)(m->
M_dat.MH.MH_pkthdr.len - sizeof(struct ip6_hdr)) & 0xffU)
 << 8 | ((__uint16_t)(m->M_dat.MH.MH_pkthdr.len - sizeof
(struct ip6_hdr)) & 0xff00U) >> 8) : __swap16md(m->
M_dat.MH.MH_pkthdr.len - sizeof(struct ip6_hdr)));
for (mlast = m; mlast->m_nextm_hdr.mh_next; mlast = mlast->m_nextm_hdr.mh_next)
	;
mlast->m_nextm_hdr.mh_next = m_copym(m0, off, len, M_DONTWAIT0x0002);
if (mlast->m_nextm_hdr.mh_next == NULL((void *)0)) {
	error = ENOBUFS55;
	goto bad;
}

ip6f->ip6f_reserved = 0;
ip6f->ip6f_ident = id;
ip6f->ip6f_nxt = nextproto;
}

ip6stat_add(ip6s_ofragments, ml_len(ml)((ml)->ml_len));
m_freem(m0);
return (0);

851bad:
ip6stat_inc(ip6s_odropped);
ml_purge(ml);
m_freem(m0);
return (error);
856}

858int
859ip6_copyexthdr(struct mbuf **mp, caddr_t hdr, int hlen)
860{
struct mbuf *m;

if (hlen > MCLBYTES(1 << 11))
return (ENOBUFS55); /* XXX */

MGET(m, M_DONTWAIT, MT_DATA)m = m_get((0x0002), (1));
if (!m)
return (ENOBUFS55);

if (hlen > MLEN(256 - sizeof(struct m_hdr))) {
MCLGET(m, M_DONTWAIT)(void) m_clget((m), (0x0002), (1 << 11));
if ((m->m_flagsm_hdr.mh_flags & M_EXT0x0001) == 0) {
	m_free(m);
	return (ENOBUFS55);
}
}
m->m_lenm_hdr.mh_len = hlen;
if (hdr)
memcpy(mtod(m, caddr_t), hdr, hlen)__builtin_memcpy((((caddr_t)((m)->m_hdr.mh_data))), (hdr),
 (hlen));

*mp = m;
return (0);
883}

885/*
* Insert jumbo payload option.
*/
888int
889ip6_insert_jumboopt(struct ip6_exthdrs *exthdrs, u_int32_t plen)
890{
struct mbuf *mopt;
u_int8_t *optbuf;
u_int32_t v;

895#define JUMBOOPTLEN	8	/* length of jumbo payload option and padding */

/*
* If there is no hop-by-hop options header, allocate new one.
* If there is one but it doesn't have enough space to store the
* jumbo payload option, allocate a cluster to store the whole options.
* Otherwise, use it to store the options.
*/
if (exthdrs->ip6e_hbh == 0) {
MGET(mopt, M_DONTWAIT, MT_DATA)mopt = m_get((0x0002), (1));
if (mopt == NULL((void *)0))
	return (ENOBUFS55);
mopt->m_lenm_hdr.mh_len = JUMBOOPTLEN;
optbuf = mtod(mopt, u_int8_t *)((u_int8_t *)((mopt)->m_hdr.mh_data));
optbuf[1] = 0;	/* = ((JUMBOOPTLEN) >> 3) - 1 */
exthdrs->ip6e_hbh = mopt;
} else {
struct ip6_hbh *hbh;

mopt = exthdrs->ip6e_hbh;
if (m_trailingspace(mopt) < JUMBOOPTLEN) {
	/*
	 * XXX assumption:
	 * - exthdrs->ip6e_hbh is not referenced from places
	 *   other than exthdrs.
	 * - exthdrs->ip6e_hbh is not an mbuf chain.
	 */
	int oldoptlen = mopt->m_lenm_hdr.mh_len;
	struct mbuf *n;

	/*
	 * XXX: give up if the whole (new) hbh header does
	 * not fit even in an mbuf cluster.
	 */
	if (oldoptlen + JUMBOOPTLEN > MCLBYTES(1 << 11))
		return (ENOBUFS55);

	/*
	 * As a consequence, we must always prepare a cluster
	 * at this point.
	 */
	MGET(n, M_DONTWAIT, MT_DATA)n = m_get((0x0002), (1));
	if (n) {
		MCLGET(n, M_DONTWAIT)(void) m_clget((n), (0x0002), (1 << 11));
		if ((n->m_flagsm_hdr.mh_flags & M_EXT0x0001) == 0) {
			m_freem(n);
			n = NULL((void *)0);
		}
	}
	if (!n)
		return (ENOBUFS55);
	n->m_lenm_hdr.mh_len = oldoptlen + JUMBOOPTLEN;
	memcpy(mtod(n, caddr_t), mtod(mopt, caddr_t),__builtin_memcpy((((caddr_t)((n)->m_hdr.mh_data))), (((caddr_t
)((mopt)->m_hdr.mh_data))), (oldoptlen))
	      oldoptlen)__builtin_memcpy((((caddr_t)((n)->m_hdr.mh_data))), (((caddr_t
)((mopt)->m_hdr.mh_data))), (oldoptlen));
	optbuf = mtod(n, u_int8_t *)((u_int8_t *)((n)->m_hdr.mh_data)) + oldoptlen;
	m_freem(mopt);
	mopt = exthdrs->ip6e_hbh = n;
} else {
	optbuf = mtod(mopt, u_int8_t *)((u_int8_t *)((mopt)->m_hdr.mh_data)) + mopt->m_lenm_hdr.mh_len;
	mopt->m_lenm_hdr.mh_len += JUMBOOPTLEN;
}
optbuf[0] = IP6OPT_PADN0x01;
optbuf[1] = 0;

/*
 * Adjust the header length according to the pad and
 * the jumbo payload option.
 */
hbh = mtod(mopt, struct ip6_hbh *)((struct ip6_hbh *)((mopt)->m_hdr.mh_data));
hbh->ip6h_len += (JUMBOOPTLEN >> 3);
}

/* fill in the option. */
optbuf[2] = IP6OPT_JUMBO0xC2;
optbuf[3] = 4;
v = (u_int32_t)htonl(plen + JUMBOOPTLEN)(__uint32_t)(__builtin_constant_p(plen + JUMBOOPTLEN) ? (__uint32_t
)(((__uint32_t)(plen + JUMBOOPTLEN) & 0xff) << 24 |
 ((__uint32_t)(plen + JUMBOOPTLEN) & 0xff00) << 8 |
 ((__uint32_t)(plen + JUMBOOPTLEN) & 0xff0000) >> 8
 | ((__uint32_t)(plen + JUMBOOPTLEN) & 0xff000000) >>
 24) : __swap32md(plen + JUMBOOPTLEN));
memcpy(&optbuf[4], &v, sizeof(u_int32_t))__builtin_memcpy((&optbuf[4]), (&v), (sizeof(u_int32_t
)));

/* finally, adjust the packet header length */
exthdrs->ip6e_ip6->m_pkthdrM_dat.MH.MH_pkthdr.len += JUMBOOPTLEN;

return (0);
977#undef JUMBOOPTLEN
978}

980/*
* Insert fragment header and copy unfragmentable header portions.
*/
983int
984ip6_insertfraghdr(struct mbuf *m0, struct mbuf *m, int hlen,
  struct ip6_frag **frghdrp)
986{
struct mbuf *n, *mlast;

if (hlen > sizeof(struct ip6_hdr)) {
n = m_copym(m0, sizeof(struct ip6_hdr),
    hlen - sizeof(struct ip6_hdr), M_DONTWAIT0x0002);
if (n == NULL((void *)0))
	return (ENOBUFS55);
m->m_nextm_hdr.mh_next = n;
} else
n = m;

/* Search for the last mbuf of unfragmentable part. */
for (mlast = n; mlast->m_nextm_hdr.mh_next; mlast = mlast->m_nextm_hdr.mh_next)
;

if ((mlast->m_flagsm_hdr.mh_flags & M_EXT0x0001) == 0 &&
   m_trailingspace(mlast) >= sizeof(struct ip6_frag)) {
/* use the trailing space of the last mbuf for fragment hdr */
*frghdrp = (struct ip6_frag *)(mtod(mlast, caddr_t)((caddr_t)((mlast)->m_hdr.mh_data)) +
    mlast->m_lenm_hdr.mh_len);
mlast->m_lenm_hdr.mh_len += sizeof(struct ip6_frag);
m->m_pkthdrM_dat.MH.MH_pkthdr.len += sizeof(struct ip6_frag);
} else {
/* allocate a new mbuf for the fragment header */
struct mbuf *mfrg;

MGET(mfrg, M_DONTWAIT, MT_DATA)mfrg = m_get((0x0002), (1));
if (mfrg == NULL((void *)0))
	return (ENOBUFS55);
mfrg->m_lenm_hdr.mh_len = sizeof(struct ip6_frag);
*frghdrp = mtod(mfrg, struct ip6_frag *)((struct ip6_frag *)((mfrg)->m_hdr.mh_data));
mlast->m_nextm_hdr.mh_next = mfrg;
}

return (0);
1022}

1024int
1025ip6_getpmtu(struct rtentry *rt, struct ifnet *ifp, u_long *mtup)
1026{
u_int32_t mtu = 0;
int error = 0;

if (rt != NULL((void *)0)) {
mtu = rt->rt_mturt_rmx.rmx_mtu;
if (mtu == 0)
	mtu = ifp->if_mtuif_data.ifi_mtu;
else if (mtu < IPV6_MMTU1280) {
	/* RFC8021 IPv6 Atomic Fragments Considered Harmful */
	mtu = IPV6_MMTU1280;
} else if (mtu > ifp->if_mtuif_data.ifi_mtu) {
	/*
	 * The MTU on the route is larger than the MTU on
	 * the interface!  This shouldn't happen, unless the
	 * MTU of the interface has been changed after the
	 * interface was brought up.  Change the MTU in the
	 * route to match the interface MTU (as long as the
	 * field isn't locked).
	 */
	mtu = ifp->if_mtuif_data.ifi_mtu;
	if (!(rt->rt_locksrt_rmx.rmx_locks & RTV_MTU0x1))
		rt->rt_mturt_rmx.rmx_mtu = mtu;
}
} else {
mtu = ifp->if_mtuif_data.ifi_mtu;
}

*mtup = mtu;
return (error);
1056}

1058/*
* IP6 socket option processing.
*/
1061int
1062ip6_ctloutput(int op, struct socket *so, int level, int optname,
  struct mbuf *m)
1064{
int privileged, optdatalen, uproto;
void *optdata;
struct inpcb *inp = sotoinpcb(so)((struct inpcb *)(so)->so_pcb);
int error, optval;
struct proc *p = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc; /* For IPsec and rdomain */
u_int rtableid, rtid = 0;

error = optval = 0;

privileged = (inp->inp_socket->so_state & SS_PRIV0x080);
uproto = (int)so->so_proto->pr_protocol;

if (level != IPPROTO_IPV641)
return (EINVAL22);

rtableid = p->p_p->ps_rtableid;

switch (op) {
case PRCO_SETOPT1:
switch (optname) {
/*
 * Use of some Hop-by-Hop options or some
 * Destination options, might require special
 * privilege.  That is, normal applications
 * (without special privilege) might be forbidden
 * from setting certain options in outgoing packets,
 * and might never see certain options in received
 * packets. [RFC 2292 Section 6]
 * KAME specific note:
 *  KAME prevents non-privileged users from sending or
 *  receiving ANY hbh/dst options in order to avoid
 *  overhead of parsing options in the kernel.
 */
case IPV6_RECVHOPOPTS39:
case IPV6_RECVDSTOPTS40:
	if (!privileged) {
		error = EPERM1;
		break;
	}
	/* FALLTHROUGH */
case IPV6_UNICAST_HOPS4:
case IPV6_MINHOPCOUNT65:
case IPV6_HOPLIMIT47:

case IPV6_RECVPKTINFO36:
case IPV6_RECVHOPLIMIT37:
case IPV6_RECVRTHDR38:
case IPV6_RECVPATHMTU43:
case IPV6_RECVTCLASS57:
case IPV6_V6ONLY27:
case IPV6_AUTOFLOWLABEL59:
case IPV6_RECVDSTPORT64:
	if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(int)) {
		error = EINVAL22;
		break;
	}
	optval = *mtod(m, int *)((int *)((m)->m_hdr.mh_data));
	switch (optname) {

	case IPV6_UNICAST_HOPS4:
		if (optval < -1 || optval >= 256)
			error = EINVAL22;
		else {
			/* -1 = kernel default */
			inp->inp_hops = optval;
		}
		break;

	case IPV6_MINHOPCOUNT65:
		if (optval < 0 || optval > 255)
			error = EINVAL22;
		else
			inp->inp_ip6_minhliminp_ip_minttl = optval;
		break;

1140#define OPTSET(bit) \
1141do { \
if (optval) \
inp->inp_flags |= (bit); \
else \
inp->inp_flags &= ~(bit); \
1146} while (/*CONSTCOND*/ 0)
1147#define OPTBIT(bit)(inp->inp_flags & (bit) ? 1 : 0) (inp->inp_flags & (bit) ? 1 : 0)

	case IPV6_RECVPKTINFO36:
		OPTSET(IN6P_PKTINFO0x010000);
		break;

	case IPV6_HOPLIMIT47:
	{
		struct ip6_pktopts **optp;

		optp = &inp->inp_outputopts6;
		error = ip6_pcbopt(IPV6_HOPLIMIT47,
		    (u_char *)&optval, sizeof(optval), optp,
		    privileged, uproto);
		break;
	}

	case IPV6_RECVHOPLIMIT37:
		OPTSET(IN6P_HOPLIMIT0x020000);
		break;

	case IPV6_RECVHOPOPTS39:
		OPTSET(IN6P_HOPOPTS0x040000);
		break;

	case IPV6_RECVDSTOPTS40:
		OPTSET(IN6P_DSTOPTS0x080000);
		break;

	case IPV6_RECVRTHDR38:
		OPTSET(IN6P_RTHDR0x100000);
		break;

	case IPV6_RECVPATHMTU43:
		/*
		 * We ignore this option for TCP
		 * sockets.
		 * (RFC3542 leaves this case
		 * unspecified.)
		 */
		if (uproto != IPPROTO_TCP6)
			OPTSET(IN6P_MTU0x80000000);
		break;

	case IPV6_V6ONLY27:
		/*
		 * make setsockopt(IPV6_V6ONLY)
		 * available only prior to bind(2).
		 * see ipng mailing list, Jun 22 2001.
		 */
		if (inp->inp_lport || !IN6_IS_ADDR_UNSPECIFIED(((*(const u_int32_t *)(const void *)(&(&inp->inp_laddru
.iau_addr6)->__u6_addr.__u6_addr8[0]) == 0) && (*(
const u_int32_t *)(const void *)(&(&inp->inp_laddru
.iau_addr6)->__u6_addr.__u6_addr8[4]) == 0) && (*(
const u_int32_t *)(const void *)(&(&inp->inp_laddru
.iau_addr6)->__u6_addr.__u6_addr8[8]) == 0) && (*(
const u_int32_t *)(const void *)(&(&inp->inp_laddru
.iau_addr6)->__u6_addr.__u6_addr8[12]) == 0))
		    &inp->inp_laddr6)((*(const u_int32_t *)(const void *)(&(&inp->inp_laddru
.iau_addr6)->__u6_addr.__u6_addr8[0]) == 0) && (*(
const u_int32_t *)(const void *)(&(&inp->inp_laddru
.iau_addr6)->__u6_addr.__u6_addr8[4]) == 0) && (*(
const u_int32_t *)(const void *)(&(&inp->inp_laddru
.iau_addr6)->__u6_addr.__u6_addr8[8]) == 0) && (*(
const u_int32_t *)(const void *)(&(&inp->inp_laddru
.iau_addr6)->__u6_addr.__u6_addr8[12]) == 0))) {
			error = EINVAL22;
			break;
		}
		/* No support for IPv4-mapped addresses. */
		if (!optval)
			error = EINVAL22;
		else
			error = 0;
		break;
	case IPV6_RECVTCLASS57:
		OPTSET(IN6P_TCLASS0x400000);
		break;
	case IPV6_AUTOFLOWLABEL59:
		OPTSET(IN6P_AUTOFLOWLABEL0x800000);
		break;

	case IPV6_RECVDSTPORT64:
		OPTSET(IN6P_RECVDSTPORT0x200);
		break;
	}
	break;

case IPV6_TCLASS61:
case IPV6_DONTFRAG62:
case IPV6_USE_MIN_MTU42:
	if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(optval)) {
		error = EINVAL22;
		break;
	}
	optval = *mtod(m, int *)((int *)((m)->m_hdr.mh_data));
	{
		struct ip6_pktopts **optp;
		optp = &inp->inp_outputopts6;
		error = ip6_pcbopt(optname, (u_char *)&optval,
		    sizeof(optval), optp, privileged, uproto);
		break;
	}

case IPV6_PKTINFO46:
case IPV6_HOPOPTS49:
case IPV6_RTHDR51:
case IPV6_DSTOPTS50:
case IPV6_RTHDRDSTOPTS35:
{
	/* new advanced API (RFC3542) */
	u_char *optbuf;
	int optbuflen;
	struct ip6_pktopts **optp;

	if (m && m->m_nextm_hdr.mh_next) {
		error = EINVAL22;	/* XXX */
		break;
	}
	if (m) {
		optbuf = mtod(m, u_char *)((u_char *)((m)->m_hdr.mh_data));
		optbuflen = m->m_lenm_hdr.mh_len;
	} else {
		optbuf = NULL((void *)0);
		optbuflen = 0;
	}
	optp = &inp->inp_outputopts6;
	error = ip6_pcbopt(optname, optbuf, optbuflen, optp,
	    privileged, uproto);
	break;
}
1264#undef OPTSET

case IPV6_MULTICAST_IF9:
case IPV6_MULTICAST_HOPS10:
case IPV6_MULTICAST_LOOP11:
case IPV6_JOIN_GROUP12:
case IPV6_LEAVE_GROUP13:
	error =	ip6_setmoptions(optname,
				&inp->inp_moptions6inp_mou.mou_mo6,
				m, inp->inp_rtableid);
	break;

case IPV6_PORTRANGE14:
	if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(int)) {
		error = EINVAL22;
		break;
	}
	optval = *mtod(m, int *)((int *)((m)->m_hdr.mh_data));

	switch (optval) {
	case IPV6_PORTRANGE_DEFAULT0:
		inp->inp_flags &= ~(IN6P_LOWPORT0x020);
		inp->inp_flags &= ~(IN6P_HIGHPORT0x010);
		break;

	case IPV6_PORTRANGE_HIGH1:
		inp->inp_flags &= ~(IN6P_LOWPORT0x020);
		inp->inp_flags |= IN6P_HIGHPORT0x010;
		break;

	case IPV6_PORTRANGE_LOW2:
		inp->inp_flags &= ~(IN6P_HIGHPORT0x010);
		inp->inp_flags |= IN6P_LOWPORT0x020;
		break;

	default:
		error = EINVAL22;
		break;
	}
	break;

case IPSEC6_OUTSA56:
	error = EINVAL22;
	break;

case IPV6_AUTH_LEVEL53:
case IPV6_ESP_TRANS_LEVEL54:
case IPV6_ESP_NETWORK_LEVEL55:
case IPV6_IPCOMP_LEVEL60:
1313#ifndef IPSEC1
	error = EINVAL22;
1315#else
	if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(int)) {
		error = EINVAL22;
		break;
	}
	optval = *mtod(m, int *)((int *)((m)->m_hdr.mh_data));

	if (optval < IPSEC_LEVEL_BYPASS0x00 ||
	    optval > IPSEC_LEVEL_UNIQUE0x04) {
		error = EINVAL22;
		break;
	}

	switch (optname) {
	case IPV6_AUTH_LEVEL53:
		if (optval < IPSEC_AUTH_LEVEL_DEFAULT0x01 &&
		    suser(p)) {
			error = EACCES13;
			break;
		}
		inp->inp_seclevel[SL_AUTH0] = optval;
		break;

	case IPV6_ESP_TRANS_LEVEL54:
		if (optval < IPSEC_ESP_TRANS_LEVEL_DEFAULT0x01 &&
		    suser(p)) {
			error = EACCES13;
			break;
		}
		inp->inp_seclevel[SL_ESP_TRANS1] = optval;
		break;

	case IPV6_ESP_NETWORK_LEVEL55:
		if (optval < IPSEC_ESP_NETWORK_LEVEL_DEFAULT0x01 &&
		    suser(p)) {
			error = EACCES13;
			break;
		}
		inp->inp_seclevel[SL_ESP_NETWORK2] = optval;
		break;

	case IPV6_IPCOMP_LEVEL60:
		if (optval < IPSEC_IPCOMP_LEVEL_DEFAULT0x01 &&
		    suser(p)) {
			error = EACCES13;
			break;
		}
		inp->inp_seclevel[SL_IPCOMP3] = optval;
		break;
	}
1365#endif
	break;
case SO_RTABLE0x1021:
	if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len < sizeof(u_int)) {
		error = EINVAL22;
		break;
	}
	rtid = *mtod(m, u_int *)((u_int *)((m)->m_hdr.mh_data));
	if (inp->inp_rtableid == rtid)
		break;
	/* needs privileges to switch when already set */
	if (rtableid != rtid && rtableid != 0 &&
	    (error = suser(p)) != 0)
		break;
	/* table must exist */
	if (!rtable_exists(rtid)) {
		error = EINVAL22;
		break;
	}
	error = in_pcbset_rtableid(inp, rtid);
	break;
case IPV6_PIPEX63:
	if (m != NULL((void *)0) && m->m_lenm_hdr.mh_len == sizeof(int))
		inp->inp_pipex = *mtod(m, int *)((int *)((m)->m_hdr.mh_data));
	else
		error = EINVAL22;
	break;

default:
	error = ENOPROTOOPT42;
	break;
}
break;

case PRCO_GETOPT0:
switch (optname) {

case IPV6_RECVHOPOPTS39:
case IPV6_RECVDSTOPTS40:
case IPV6_UNICAST_HOPS4:
case IPV6_MINHOPCOUNT65:
case IPV6_RECVPKTINFO36:
case IPV6_RECVHOPLIMIT37:
case IPV6_RECVRTHDR38:
case IPV6_RECVPATHMTU43:

case IPV6_V6ONLY27:
case IPV6_PORTRANGE14:
case IPV6_RECVTCLASS57:
case IPV6_AUTOFLOWLABEL59:
case IPV6_RECVDSTPORT64:
	switch (optname) {

	case IPV6_RECVHOPOPTS39:
		optval = OPTBIT(IN6P_HOPOPTS)(inp->inp_flags & (0x040000) ? 1 : 0);
		break;

	case IPV6_RECVDSTOPTS40:
		optval = OPTBIT(IN6P_DSTOPTS)(inp->inp_flags & (0x080000) ? 1 : 0);
		break;

	case IPV6_UNICAST_HOPS4:
		optval = inp->inp_hops;
		break;

	case IPV6_MINHOPCOUNT65:
		optval = inp->inp_ip6_minhliminp_ip_minttl;
		break;

	case IPV6_RECVPKTINFO36:
		optval = OPTBIT(IN6P_PKTINFO)(inp->inp_flags & (0x010000) ? 1 : 0);
		break;

	case IPV6_RECVHOPLIMIT37:
		optval = OPTBIT(IN6P_HOPLIMIT)(inp->inp_flags & (0x020000) ? 1 : 0);
		break;

	case IPV6_RECVRTHDR38:
		optval = OPTBIT(IN6P_RTHDR)(inp->inp_flags & (0x100000) ? 1 : 0);
		break;

	case IPV6_RECVPATHMTU43:
		optval = OPTBIT(IN6P_MTU)(inp->inp_flags & (0x80000000) ? 1 : 0);
		break;

	case IPV6_V6ONLY27:
		optval = 1;
		break;

	case IPV6_PORTRANGE14:
	    {
		int flags;
		flags = inp->inp_flags;
		if (flags & IN6P_HIGHPORT0x010)
			optval = IPV6_PORTRANGE_HIGH1;
		else if (flags & IN6P_LOWPORT0x020)
			optval = IPV6_PORTRANGE_LOW2;
		else
			optval = 0;
		break;
	    }
	case IPV6_RECVTCLASS57:
		optval = OPTBIT(IN6P_TCLASS)(inp->inp_flags & (0x400000) ? 1 : 0);
		break;

	case IPV6_AUTOFLOWLABEL59:
		optval = OPTBIT(IN6P_AUTOFLOWLABEL)(inp->inp_flags & (0x800000) ? 1 : 0);
		break;

	case IPV6_RECVDSTPORT64:
		optval = OPTBIT(IN6P_RECVDSTPORT)(inp->inp_flags & (0x200) ? 1 : 0);
		break;
	}
	if (error)
		break;
	m->m_lenm_hdr.mh_len = sizeof(int);
	*mtod(m, int *)((int *)((m)->m_hdr.mh_data)) = optval;
	break;

case IPV6_PATHMTU44:
{
	u_long pmtu = 0;
	struct ip6_mtuinfo mtuinfo;
	struct ifnet *ifp;
	struct rtentry *rt;

	if (!(so->so_state & SS_ISCONNECTED0x002))
		return (ENOTCONN57);

	rt = in_pcbrtentry(inp);
	if (!rtisvalid(rt))
		return (EHOSTUNREACH65);

	ifp = if_get(rt->rt_ifidx);
	if (ifp == NULL((void *)0))
		return (EHOSTUNREACH65);
	/*
	 * XXX: we dot not consider the case of source
	 * routing, or optional information to specify
	 * the outgoing interface.
	 */
	error = ip6_getpmtu(rt, ifp, &pmtu);
	if_put(ifp);
	if (error)
		break;
	if (pmtu > IPV6_MAXPACKET65535)
		pmtu = IPV6_MAXPACKET65535;

	bzero(&mtuinfo, sizeof(mtuinfo))__builtin_bzero((&mtuinfo), (sizeof(mtuinfo)));
	mtuinfo.ip6m_mtu = (u_int32_t)pmtu;
	optdata = (void *)&mtuinfo;
	optdatalen = sizeof(mtuinfo);
	if (optdatalen > MCLBYTES(1 << 11))
		return (EMSGSIZE40); /* XXX */
	if (optdatalen > MLEN(256 - sizeof(struct m_hdr)))
		MCLGET(m, M_WAIT)(void) m_clget((m), (0x0001), (1 << 11));
	m->m_lenm_hdr.mh_len = optdatalen;
	bcopy(optdata, mtod(m, void *)((void *)((m)->m_hdr.mh_data)), optdatalen);
	break;
}

case IPV6_PKTINFO46:
case IPV6_HOPOPTS49:
case IPV6_RTHDR51:
case IPV6_DSTOPTS50:
case IPV6_RTHDRDSTOPTS35:
case IPV6_TCLASS61:
case IPV6_DONTFRAG62:
case IPV6_USE_MIN_MTU42:
	error = ip6_getpcbopt(inp->inp_outputopts6,
	    optname, m);
	break;

case IPV6_MULTICAST_IF9:
case IPV6_MULTICAST_HOPS10:
case IPV6_MULTICAST_LOOP11:
case IPV6_JOIN_GROUP12:
case IPV6_LEAVE_GROUP13:
	error = ip6_getmoptions(optname,
	    inp->inp_moptions6inp_mou.mou_mo6, m);
	break;

case IPSEC6_OUTSA56:
	error = EINVAL22;
	break;

case IPV6_AUTH_LEVEL53:
case IPV6_ESP_TRANS_LEVEL54:
case IPV6_ESP_NETWORK_LEVEL55:
case IPV6_IPCOMP_LEVEL60:
1555#ifndef IPSEC1
	m->m_lenm_hdr.mh_len = sizeof(int);
	*mtod(m, int *)((int *)((m)->m_hdr.mh_data)) = IPSEC_LEVEL_NONE0x00;
1558#else
	m->m_lenm_hdr.mh_len = sizeof(int);
	switch (optname) {
	case IPV6_AUTH_LEVEL53:
		optval = inp->inp_seclevel[SL_AUTH0];
		break;

	case IPV6_ESP_TRANS_LEVEL54:
		optval =
		    inp->inp_seclevel[SL_ESP_TRANS1];
		break;

	case IPV6_ESP_NETWORK_LEVEL55:
		optval =
		    inp->inp_seclevel[SL_ESP_NETWORK2];
		break;

	case IPV6_IPCOMP_LEVEL60:
		optval = inp->inp_seclevel[SL_IPCOMP3];
		break;
	}
	*mtod(m, int *)((int *)((m)->m_hdr.mh_data)) = optval;
1580#endif
	break;
case SO_RTABLE0x1021:
	m->m_lenm_hdr.mh_len = sizeof(u_int);
	*mtod(m, u_int *)((u_int *)((m)->m_hdr.mh_data)) = inp->inp_rtableid;
	break;
case IPV6_PIPEX63:
	m->m_lenm_hdr.mh_len = sizeof(int);
	*mtod(m, int *)((int *)((m)->m_hdr.mh_data)) = inp->inp_pipex;
	break;

default:
	error = ENOPROTOOPT42;
	break;
}
break;
}
return (error);
1598}

1600int
1601ip6_raw_ctloutput(int op, struct socket *so, int level, int optname,
  struct mbuf *m)
1603{
int error = 0, optval;
const int icmp6off = offsetof(struct icmp6_hdr, icmp6_cksum)__builtin_offsetof(struct icmp6_hdr, icmp6_cksum);
struct inpcb *inp = sotoinpcb(so)((struct inpcb *)(so)->so_pcb);

if (level != IPPROTO_IPV641)
return (EINVAL22);

switch (optname) {
case IPV6_CHECKSUM26:
/*
 * For ICMPv6 sockets, no modification allowed for checksum
 * offset, permit "no change" values to help existing apps.
 *
 * RFC3542 says: "An attempt to set IPV6_CHECKSUM
 * for an ICMPv6 socket will fail."
 * The current behavior does not meet RFC3542.
 */
switch (op) {
case PRCO_SETOPT1:
	if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(int)) {
		error = EINVAL22;
		break;
	}
	optval = *mtod(m, int *)((int *)((m)->m_hdr.mh_data));
	if (optval < -1 ||
	    (optval > 0 && (optval % 2) != 0)) {
		/*
		 * The API assumes non-negative even offset
		 * values or -1 as a special value.
		 */
		error = EINVAL22;
	} else if (so->so_proto->pr_protocol ==
	    IPPROTO_ICMPV658) {
		if (optval != icmp6off)
			error = EINVAL22;
	} else
		inp->inp_cksum6 = optval;
	break;

case PRCO_GETOPT0:
	if (so->so_proto->pr_protocol == IPPROTO_ICMPV658)
		optval = icmp6off;
	else
		optval = inp->inp_cksum6;

	m->m_lenm_hdr.mh_len = sizeof(int);
	*mtod(m, int *)((int *)((m)->m_hdr.mh_data)) = optval;
	break;

default:
	error = EINVAL22;
	break;
}
break;

default:
error = ENOPROTOOPT42;
break;
}

return (error);
1665}

1667/*
* initialize ip6_pktopts.  beware that there are non-zero default values in
* the struct.
*/
1671void
1672ip6_initpktopts(struct ip6_pktopts *opt)
1673{
bzero(opt, sizeof(*opt))__builtin_bzero((opt), (sizeof(*opt)));
opt->ip6po_hlim = -1;	/* -1 means default hop limit */
opt->ip6po_tclass = -1;	/* -1 means default traffic class */
opt->ip6po_minmtu = IP6PO_MINMTU_MCASTONLY-1;
1678}

1680int
1681ip6_pcbopt(int optname, u_char *buf, int len, struct ip6_pktopts **pktopt,
  int priv, int uproto)
1683{
struct ip6_pktopts *opt;

if (*pktopt == NULL((void *)0)) {
*pktopt = malloc(sizeof(struct ip6_pktopts), M_IP6OPT123,
    M_WAITOK0x0001);
ip6_initpktopts(*pktopt);
}
opt = *pktopt;

return (ip6_setpktopt(optname, buf, len, opt, priv, 1, uproto));
1694}

1696int
1697ip6_getpcbopt(struct ip6_pktopts *pktopt, int optname, struct mbuf *m)
1698{
void *optdata = NULL((void *)0);
int optdatalen = 0;
struct ip6_ext *ip6e;
int error = 0;
struct in6_pktinfo null_pktinfo;
int deftclass = 0, on;
int defminmtu = IP6PO_MINMTU_MCASTONLY-1;

switch (optname) {
case IPV6_PKTINFO46:
if (pktopt && pktopt->ip6po_pktinfo)
	optdata = (void *)pktopt->ip6po_pktinfo;
else {
	/* XXX: we don't have to do this every time... */
	bzero(&null_pktinfo, sizeof(null_pktinfo))__builtin_bzero((&null_pktinfo), (sizeof(null_pktinfo)));
	optdata = (void *)&null_pktinfo;
}
optdatalen = sizeof(struct in6_pktinfo);
break;
case IPV6_TCLASS61:
if (pktopt && pktopt->ip6po_tclass >= 0)
	optdata = (void *)&pktopt->ip6po_tclass;
else
	optdata = (void *)&deftclass;
optdatalen = sizeof(int);
break;
case IPV6_HOPOPTS49:
if (pktopt && pktopt->ip6po_hbh) {
	optdata = (void *)pktopt->ip6po_hbh;
	ip6e = (struct ip6_ext *)pktopt->ip6po_hbh;
	optdatalen = (ip6e->ip6e_len + 1) << 3;
}
break;
case IPV6_RTHDR51:
if (pktopt && pktopt->ip6po_rthdrip6po_rhinfo.ip6po_rhi_rthdr) {
	optdata = (void *)pktopt->ip6po_rthdrip6po_rhinfo.ip6po_rhi_rthdr;
	ip6e = (struct ip6_ext *)pktopt->ip6po_rthdrip6po_rhinfo.ip6po_rhi_rthdr;
	optdatalen = (ip6e->ip6e_len + 1) << 3;
}
break;
case IPV6_RTHDRDSTOPTS35:
if (pktopt && pktopt->ip6po_dest1) {
	optdata = (void *)pktopt->ip6po_dest1;
	ip6e = (struct ip6_ext *)pktopt->ip6po_dest1;
	optdatalen = (ip6e->ip6e_len + 1) << 3;
}
break;
case IPV6_DSTOPTS50:
if (pktopt && pktopt->ip6po_dest2) {
	optdata = (void *)pktopt->ip6po_dest2;
	ip6e = (struct ip6_ext *)pktopt->ip6po_dest2;
	optdatalen = (ip6e->ip6e_len + 1) << 3;
}
break;
case IPV6_USE_MIN_MTU42:
if (pktopt)
	optdata = (void *)&pktopt->ip6po_minmtu;
else
	optdata = (void *)&defminmtu;
optdatalen = sizeof(int);
break;
case IPV6_DONTFRAG62:
if (pktopt && ((pktopt->ip6po_flags) & IP6PO_DONTFRAG0x04))
	on = 1;
else
	on = 0;
optdata = (void *)&on;
optdatalen = sizeof(on);
break;
default:		/* should not happen */
1769#ifdef DIAGNOSTIC1
panic("%s: unexpected option", __func__);
1771#endif
return (ENOPROTOOPT42);
}

if (optdatalen > MCLBYTES(1 << 11))
return (EMSGSIZE40); /* XXX */
if (optdatalen > MLEN(256 - sizeof(struct m_hdr)))
MCLGET(m, M_WAIT)(void) m_clget((m), (0x0001), (1 << 11));
m->m_lenm_hdr.mh_len = optdatalen;
if (optdatalen)
bcopy(optdata, mtod(m, void *)((void *)((m)->m_hdr.mh_data)), optdatalen);

return (error);
1784}

1786void
1787ip6_clearpktopts(struct ip6_pktopts *pktopt, int optname)
1788{
if (optname == -1 || optname == IPV6_PKTINFO46) {
if (pktopt->ip6po_pktinfo)
	free(pktopt->ip6po_pktinfo, M_IP6OPT123, 0);
pktopt->ip6po_pktinfo = NULL((void *)0);
}
if (optname == -1 || optname == IPV6_HOPLIMIT47)
pktopt->ip6po_hlim = -1;
if (optname == -1 || optname == IPV6_TCLASS61)
pktopt->ip6po_tclass = -1;
if (optname == -1 || optname == IPV6_HOPOPTS49) {
if (pktopt->ip6po_hbh)
	free(pktopt->ip6po_hbh, M_IP6OPT123, 0);
pktopt->ip6po_hbh = NULL((void *)0);
}
if (optname == -1 || optname == IPV6_RTHDRDSTOPTS35) {
if (pktopt->ip6po_dest1)
	free(pktopt->ip6po_dest1, M_IP6OPT123, 0);
pktopt->ip6po_dest1 = NULL((void *)0);
}
if (optname == -1 || optname == IPV6_RTHDR51) {
if (pktopt->ip6po_rhinfo.ip6po_rhi_rthdr)
	free(pktopt->ip6po_rhinfo.ip6po_rhi_rthdr, M_IP6OPT123, 0);
pktopt->ip6po_rhinfo.ip6po_rhi_rthdr = NULL((void *)0);
if (pktopt->ip6po_routeip6po_rhinfo.ip6po_rhi_route.ro_rt) {
	rtfree(pktopt->ip6po_routeip6po_rhinfo.ip6po_rhi_route.ro_rt);
	pktopt->ip6po_routeip6po_rhinfo.ip6po_rhi_route.ro_rt = NULL((void *)0);
}
}
if (optname == -1 || optname == IPV6_DSTOPTS50) {
if (pktopt->ip6po_dest2)
	free(pktopt->ip6po_dest2, M_IP6OPT123, 0);
pktopt->ip6po_dest2 = NULL((void *)0);
}
1822}

1824#define PKTOPT_EXTHDRCPY(type) \
1825do {\
if (src->type) {\
size_t hlen;\
hlen = (((struct ip6_ext *)src->type)->ip6e_len + 1) << 3;\
dst->type = malloc(hlen, M_IP6OPT123, M_NOWAIT0x0002);\
if (dst->type == NULL((void *)0))\
	goto bad;\
memcpy(dst->type, src->type, hlen)__builtin_memcpy((dst->type), (src->type), (hlen));\
}\
1834} while (/*CONSTCOND*/ 0)

1836int
1837copypktopts(struct ip6_pktopts *dst, struct ip6_pktopts *src)
1838{
dst->ip6po_hlim = src->ip6po_hlim;
dst->ip6po_tclass = src->ip6po_tclass;
dst->ip6po_flags = src->ip6po_flags;
if (src->ip6po_pktinfo) {
dst->ip6po_pktinfo = malloc(sizeof(*dst->ip6po_pktinfo),
    M_IP6OPT123, M_NOWAIT0x0002);
if (dst->ip6po_pktinfo == NULL((void *)0))
	goto bad;
*dst->ip6po_pktinfo = *src->ip6po_pktinfo;
}
PKTOPT_EXTHDRCPY(ip6po_hbh);
PKTOPT_EXTHDRCPY(ip6po_dest1);
PKTOPT_EXTHDRCPY(ip6po_dest2);
PKTOPT_EXTHDRCPY(ip6po_rthdrip6po_rhinfo.ip6po_rhi_rthdr); /* not copy the cached route */
return (0);

bad:
ip6_clearpktopts(dst, -1);
return (ENOBUFS55);
1858}
1859#undef PKTOPT_EXTHDRCPY

1861void
1862ip6_freepcbopts(struct ip6_pktopts *pktopt)
1863{
if (pktopt == NULL((void *)0))
return;

ip6_clearpktopts(pktopt, -1);

free(pktopt, M_IP6OPT123, 0);
1870}

1872/*
* Set the IP6 multicast options in response to user setsockopt().
*/
1875int
1876ip6_setmoptions(int optname, struct ip6_moptions **im6op, struct mbuf *m,
  unsigned int rtableid)
1878{
int error = 0;
u_int loop, ifindex;
struct ipv6_mreq *mreq;
struct ifnet *ifp;
struct ip6_moptions *im6o = *im6op;
struct in6_multi_mship *imm;
struct proc *p = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r"
 (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self)));
 __ci;})->ci_curproc;	/* XXX */

if (im6o == NULL((void *)0)) {
/*
 * No multicast option buffer attached to the pcb;
 * allocate one and initialize to default values.
 */
im6o = malloc(sizeof(*im6o), M_IPMOPTS53, M_WAITOK0x0001);
if (im6o == NULL((void *)0))
	return (ENOBUFS55);
*im6op = im6o;
im6o->im6o_ifidx = 0;
im6o->im6o_hlim = ip6_defmcasthlim;
im6o->im6o_loop = IPV6_DEFAULT_MULTICAST_LOOP1;
LIST_INIT(&im6o->im6o_memberships)do { ((&im6o->im6o_memberships)->lh_first) = ((void
 *)0); } while (0);
}

switch (optname) {

case IPV6_MULTICAST_IF9:
/*
 * Select the interface for outgoing multicast packets.
 */
if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(u_int)) {
	error = EINVAL22;
	break;
}
memcpy(&ifindex, mtod(m, u_int *), sizeof(ifindex))__builtin_memcpy((&ifindex), (((u_int *)((m)->m_hdr.mh_data
))), (sizeof(ifindex)));
if (ifindex != 0) {
	ifp = if_get(ifindex);
	if (ifp == NULL((void *)0)) {
		error = ENXIO6;	/* XXX EINVAL? */
		break;
	}
	if (ifp->if_rdomainif_data.ifi_rdomain != rtable_l2(rtableid) ||
	    (ifp->if_flags & IFF_MULTICAST0x8000) == 0) {
		error = EADDRNOTAVAIL49;
		if_put(ifp);
		break;
	}
	if_put(ifp);
}
im6o->im6o_ifidx = ifindex;
break;

case IPV6_MULTICAST_HOPS10:
   {
/*
 * Set the IP6 hoplimit for outgoing multicast packets.
 */
int optval;
if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(int)) {
	error = EINVAL22;
	break;
}
memcpy(&optval, mtod(m, u_int *), sizeof(optval))__builtin_memcpy((&optval), (((u_int *)((m)->m_hdr.mh_data
))), (sizeof(optval)));
if (optval < -1 || optval >= 256)
	error = EINVAL22;
else if (optval == -1)
	im6o->im6o_hlim = ip6_defmcasthlim;
else
	im6o->im6o_hlim = optval;
break;
   }

case IPV6_MULTICAST_LOOP11:
/*
 * Set the loopback flag for outgoing multicast packets.
 * Must be zero or one.
 */
if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(u_int)) {
	error = EINVAL22;
	break;
}
memcpy(&loop, mtod(m, u_int *), sizeof(loop))__builtin_memcpy((&loop), (((u_int *)((m)->m_hdr.mh_data
))), (sizeof(loop)));
if (loop > 1) {
	error = EINVAL22;
	break;
}
im6o->im6o_loop = loop;
break;

case IPV6_JOIN_GROUP12:
/*
 * Add a multicast group membership.
 * Group must be a valid IP6 multicast address.
 */
if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(struct ipv6_mreq)) {
	error = EINVAL22;
	break;
}
mreq = mtod(m, struct ipv6_mreq *)((struct ipv6_mreq *)((m)->m_hdr.mh_data));
if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)((*(const u_int32_t *)(const void *)(&(&mreq->ipv6mr_multiaddr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&mreq->ipv6mr_multiaddr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8
[8]) == 0) && (*(const u_int32_t *)(const void *)(&
(&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8[12]
) == 0))) {
	/*
	 * We use the unspecified address to specify to accept
	 * all multicast addresses. Only super user is allowed
	 * to do this.
	 */
	if (suser(p))
	{
		error = EACCES13;
		break;
	}
} else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)((&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8[0]
 == 0xff)) {
	error = EINVAL22;
	break;
}

/*
 * If no interface was explicitly specified, choose an
 * appropriate one according to the given multicast address.
 */
if (mreq->ipv6mr_interface == 0) {
	struct rtentry *rt;
	struct sockaddr_in6 dst;

	memset(&dst, 0, sizeof(dst))__builtin_memset((&dst), (0), (sizeof(dst)));
	dst.sin6_len = sizeof(dst);
	dst.sin6_family = AF_INET624;
	dst.sin6_addr = mreq->ipv6mr_multiaddr;
	rt = rtalloc(sin6tosa(&dst), RT_RESOLVE1, rtableid);
	if (rt == NULL((void *)0)) {
		error = EADDRNOTAVAIL49;
		break;
	}
	ifp = if_get(rt->rt_ifidx);
	rtfree(rt);
} else {
	/*
	 * If the interface is specified, validate it.
	 */
	ifp = if_get(mreq->ipv6mr_interface);
	if (ifp == NULL((void *)0)) {
		error = ENXIO6;	/* XXX EINVAL? */
		break;
	}
}

/*
 * See if we found an interface, and confirm that it
 * supports multicast
 */
if (ifp == NULL((void *)0) || ifp->if_rdomainif_data.ifi_rdomain != rtable_l2(rtableid) ||
    (ifp->if_flags & IFF_MULTICAST0x8000) == 0) {
	if_put(ifp);
	error = EADDRNOTAVAIL49;
	break;
}
/*
 * Put interface index into the multicast address,
 * if the address has link/interface-local scope.
 */
if (IN6_IS_SCOPE_EMBED(&mreq->ipv6mr_multiaddr)(((((&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8
[0] == 0xfe) && (((&mreq->ipv6mr_multiaddr)->
__u6_addr.__u6_addr8[1] & 0xc0) == 0x80))) || ((((&mreq
->ipv6mr_multiaddr)->__u6_addr.__u6_addr8[0] == 0xff) &&
 (((&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8[
1] & 0x0f) == 0x02))) || ((((&mreq->ipv6mr_multiaddr
)->__u6_addr.__u6_addr8[0] == 0xff) && (((&mreq
->ipv6mr_multiaddr)->__u6_addr.__u6_addr8[1] & 0x0f
) == 0x01))))) {
	mreq->ipv6mr_multiaddr.s6_addr16__u6_addr.__u6_addr16[1] =
	    htons(ifp->if_index)(__uint16_t)(__builtin_constant_p(ifp->if_index) ? (__uint16_t
)(((__uint16_t)(ifp->if_index) & 0xffU) << 8 | (
(__uint16_t)(ifp->if_index) & 0xff00U) >> 8) : __swap16md
(ifp->if_index));
}
/*
 * See if the membership already exists.
 */
LIST_FOREACH(imm, &im6o->im6o_memberships, i6mm_chain)for((imm) = ((&im6o->im6o_memberships)->lh_first); (
imm)!= ((void *)0); (imm) = ((imm)->i6mm_chain.le_next))
	if (imm->i6mm_maddr->in6m_ifidxin6m_ifma.ifma_ifidx == ifp->if_index &&
	    IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,(__builtin_memcmp((&(&imm->i6mm_maddr->in6m_sin
.sin6_addr)->__u6_addr.__u6_addr8[0]), (&(&mreq->
ipv6mr_multiaddr)->__u6_addr.__u6_addr8[0]), (sizeof(struct
 in6_addr))) == 0)
	    &mreq->ipv6mr_multiaddr)(__builtin_memcmp((&(&imm->i6mm_maddr->in6m_sin
.sin6_addr)->__u6_addr.__u6_addr8[0]), (&(&mreq->
ipv6mr_multiaddr)->__u6_addr.__u6_addr8[0]), (sizeof(struct
 in6_addr))) == 0))
		break;
if (imm != NULL((void *)0)) {
	if_put(ifp);
	error = EADDRINUSE48;
	break;
}
/*
 * Everything looks good; add a new record to the multicast
 * address list for the given interface.
 */
imm = in6_joingroup(ifp, &mreq->ipv6mr_multiaddr, &error);
if_put(ifp);
if (!imm)
	break;
LIST_INSERT_HEAD(&im6o->im6o_memberships, imm, i6mm_chain)do { if (((imm)->i6mm_chain.le_next = (&im6o->im6o_memberships
)->lh_first) != ((void *)0)) (&im6o->im6o_memberships
)->lh_first->i6mm_chain.le_prev = &(imm)->i6mm_chain
.le_next; (&im6o->im6o_memberships)->lh_first = (imm
); (imm)->i6mm_chain.le_prev = &(&im6o->im6o_memberships
)->lh_first; } while (0);
break;

case IPV6_LEAVE_GROUP13:
/*
 * Drop a multicast group membership.
 * Group must be a valid IP6 multicast address.
 */
if (m == NULL((void *)0) || m->m_lenm_hdr.mh_len != sizeof(struct ipv6_mreq)) {
	error = EINVAL22;
	break;
}
mreq = mtod(m, struct ipv6_mreq *)((struct ipv6_mreq *)((m)->m_hdr.mh_data));
if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)((*(const u_int32_t *)(const void *)(&(&mreq->ipv6mr_multiaddr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&mreq->ipv6mr_multiaddr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8
[8]) == 0) && (*(const u_int32_t *)(const void *)(&
(&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8[12]
) == 0))) {
	if (suser(p)) {
		error = EACCES13;
		break;
	}
} else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)((&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8[0]
 == 0xff)) {
	error = EINVAL22;
	break;
}

/*
 * Put interface index into the multicast address,
 * if the address has link-local scope.
 */
if (IN6_IS_ADDR_MC_LINKLOCAL(&mreq->ipv6mr_multiaddr)(((&mreq->ipv6mr_multiaddr)->__u6_addr.__u6_addr8[0
] == 0xff) && (((&mreq->ipv6mr_multiaddr)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) {
	mreq->ipv6mr_multiaddr.s6_addr16__u6_addr.__u6_addr16[1] =
	    htons(mreq->ipv6mr_interface)(__uint16_t)(__builtin_constant_p(mreq->ipv6mr_interface) ?
 (__uint16_t)(((__uint16_t)(mreq->ipv6mr_interface) & 0xffU
) << 8 | ((__uint16_t)(mreq->ipv6mr_interface) &
 0xff00U) >> 8) : __swap16md(mreq->ipv6mr_interface)
);
}

/*
 * If an interface address was specified, get a pointer
 * to its ifnet structure.
 */
if (mreq->ipv6mr_interface == 0)
	ifp = NULL((void *)0);
else {
	ifp = if_get(mreq->ipv6mr_interface);
	if (ifp == NULL((void *)0)) {
		error = ENXIO6;	/* XXX EINVAL? */
		break;
	}
}

/*
 * Find the membership in the membership list.
 */
LIST_FOREACH(imm, &im6o->im6o_memberships, i6mm_chain)for((imm) = ((&im6o->im6o_memberships)->lh_first); (
imm)!= ((void *)0); (imm) = ((imm)->i6mm_chain.le_next)) {
	if ((ifp == NULL((void *)0) ||
	    imm->i6mm_maddr->in6m_ifidxin6m_ifma.ifma_ifidx == ifp->if_index) &&
	    IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,(__builtin_memcmp((&(&imm->i6mm_maddr->in6m_sin
.sin6_addr)->__u6_addr.__u6_addr8[0]), (&(&mreq->
ipv6mr_multiaddr)->__u6_addr.__u6_addr8[0]), (sizeof(struct
 in6_addr))) == 0)
	    &mreq->ipv6mr_multiaddr)(__builtin_memcmp((&(&imm->i6mm_maddr->in6m_sin
.sin6_addr)->__u6_addr.__u6_addr8[0]), (&(&mreq->
ipv6mr_multiaddr)->__u6_addr.__u6_addr8[0]), (sizeof(struct
 in6_addr))) == 0))
		break;
}

if_put(ifp);

if (imm == NULL((void *)0)) {
	/* Unable to resolve interface */
	error = EADDRNOTAVAIL49;
	break;
}
/*
 * Give up the multicast address record to which the
 * membership points.
 */
LIST_REMOVE(imm, i6mm_chain)do { if ((imm)->i6mm_chain.le_next != ((void *)0)) (imm)->
i6mm_chain.le_next->i6mm_chain.le_prev = (imm)->i6mm_chain
.le_prev; *(imm)->i6mm_chain.le_prev = (imm)->i6mm_chain
.le_next; ((imm)->i6mm_chain.le_prev) = ((void *)-1); ((imm
)->i6mm_chain.le_next) = ((void *)-1); } while (0);
in6_leavegroup(imm);
break;

default:
error = EOPNOTSUPP45;
break;
}

/*
* If all options have default values, no need to keep the option
* structure.
*/
if (im6o->im6o_ifidx == 0 &&
   im6o->im6o_hlim == ip6_defmcasthlim &&
   im6o->im6o_loop == IPV6_DEFAULT_MULTICAST_LOOP1 &&
   LIST_EMPTY(&im6o->im6o_memberships)(((&im6o->im6o_memberships)->lh_first) == ((void *)
0))) {
free(*im6op, M_IPMOPTS53, sizeof(**im6op));
*im6op = NULL((void *)0);
}

return (error);
2152}

2154/*
* Return the IP6 multicast options in response to user getsockopt().
*/
2157int
2158ip6_getmoptions(int optname, struct ip6_moptions *im6o, struct mbuf *m)
2159{
u_int *hlim, *loop, *ifindex;

switch (optname) {
case IPV6_MULTICAST_IF9:
ifindex = mtod(m, u_int *)((u_int *)((m)->m_hdr.mh_data));
m->m_lenm_hdr.mh_len = sizeof(u_int);
if (im6o == NULL((void *)0) || im6o->im6o_ifidx == 0)
	*ifindex = 0;
else
	*ifindex = im6o->im6o_ifidx;
return (0);

case IPV6_MULTICAST_HOPS10:
hlim = mtod(m, u_int *)((u_int *)((m)->m_hdr.mh_data));
m->m_lenm_hdr.mh_len = sizeof(u_int);
if (im6o == NULL((void *)0))
	*hlim = ip6_defmcasthlim;
else
	*hlim = im6o->im6o_hlim;
return (0);

case IPV6_MULTICAST_LOOP11:
loop = mtod(m, u_int *)((u_int *)((m)->m_hdr.mh_data));
m->m_lenm_hdr.mh_len = sizeof(u_int);
if (im6o == NULL((void *)0))
	*loop = ip6_defmcasthlim;
else
	*loop = im6o->im6o_loop;
return (0);

default:
return (EOPNOTSUPP45);
}
2193}

2195/*
* Discard the IP6 multicast options.
*/
2198void
2199ip6_freemoptions(struct ip6_moptions *im6o)
2200{
struct in6_multi_mship *imm;

if (im6o == NULL((void *)0))
return;

while (!LIST_EMPTY(&im6o->im6o_memberships)(((&im6o->im6o_memberships)->lh_first) == ((void *)
0))) {
imm = LIST_FIRST(&im6o->im6o_memberships)((&im6o->im6o_memberships)->lh_first);
LIST_REMOVE(imm, i6mm_chain)do { if ((imm)->i6mm_chain.le_next != ((void *)0)) (imm)->
i6mm_chain.le_next->i6mm_chain.le_prev = (imm)->i6mm_chain
.le_prev; *(imm)->i6mm_chain.le_prev = (imm)->i6mm_chain
.le_next; ((imm)->i6mm_chain.le_prev) = ((void *)-1); ((imm
)->i6mm_chain.le_next) = ((void *)-1); } while (0);
in6_leavegroup(imm);
}
free(im6o, M_IPMOPTS53, sizeof(*im6o));
2212}

2214/*
* Set IPv6 outgoing packet options based on advanced API.
*/
2217int
2218ip6_setpktopts(struct mbuf *control, struct ip6_pktopts *opt,
  struct ip6_pktopts *stickyopt, int priv, int uproto)
2220{
u_int clen;
struct cmsghdr *cm = 0;
caddr_t cmsgs;
int error;

if (control == NULL((void *)0) || opt == NULL((void *)0))
return (EINVAL22);

ip6_initpktopts(opt);
if (stickyopt) {
int error;

/*
 * If stickyopt is provided, make a local copy of the options
 * for this particular packet, then override them by ancillary
 * objects.
 * XXX: copypktopts() does not copy the cached route to a next
 * hop (if any).  This is not very good in terms of efficiency,
 * but we can allow this since this option should be rarely
 * used.
 */
if ((error = copypktopts(opt, stickyopt)) != 0)
	return (error);
}

/*
* XXX: Currently, we assume all the optional information is stored
* in a single mbuf.
*/
if (control->m_nextm_hdr.mh_next)
return (EINVAL22);

clen = control->m_lenm_hdr.mh_len;
cmsgs = mtod(control, caddr_t)((caddr_t)((control)->m_hdr.mh_data));
do {
if (clen < CMSG_LEN(0)((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (0)))
	return (EINVAL22);
cm = (struct cmsghdr *)cmsgs;
if (cm->cmsg_len < CMSG_LEN(0)((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (0)) || cm->cmsg_len > clen ||
    CMSG_ALIGN(cm->cmsg_len)(((unsigned long)(cm->cmsg_len) + (sizeof(long) - 1)) &
~(sizeof(long) - 1)) > clen)
	return (EINVAL22);
if (cm->cmsg_level == IPPROTO_IPV641) {
	error = ip6_setpktopt(cm->cmsg_type, CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1))),
	    cm->cmsg_len - CMSG_LEN(0)((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (0)), opt, priv, 0, uproto);
	if (error)
		return (error);
}

clen -= CMSG_ALIGN(cm->cmsg_len)(((unsigned long)(cm->cmsg_len) + (sizeof(long) - 1)) &
~(sizeof(long) - 1));
cmsgs += CMSG_ALIGN(cm->cmsg_len)(((unsigned long)(cm->cmsg_len) + (sizeof(long) - 1)) &
~(sizeof(long) - 1));
} while (clen);

return (0);
2274}

2276/*
* Set a particular packet option, as a sticky option or an ancillary data
* item.  "len" can be 0 only when it's a sticky option.
*/
2280int
2281ip6_setpktopt(int optname, u_char *buf, int len, struct ip6_pktopts *opt,
  int priv, int sticky, int uproto)
2283{
int minmtupolicy;

switch (optname) {
case IPV6_PKTINFO46:
{
struct ifnet *ifp = NULL((void *)0);
struct in6_pktinfo *pktinfo;

if (len != sizeof(struct in6_pktinfo))
	return (EINVAL22);

pktinfo = (struct in6_pktinfo *)buf;

/*
 * An application can clear any sticky IPV6_PKTINFO option by
 * doing a "regular" setsockopt with ipi6_addr being
 * in6addr_any and ipi6_ifindex being zero.
 * [RFC 3542, Section 6]
 */
if (opt->ip6po_pktinfo &&
    pktinfo->ipi6_ifindex == 0 &&
    IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)((*(const u_int32_t *)(const void *)(&(&pktinfo->ipi6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&pktinfo->ipi6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&pktinfo->ipi6_addr)->__u6_addr.__u6_addr8
[8]) == 0) && (*(const u_int32_t *)(const void *)(&
(&pktinfo->ipi6_addr)->__u6_addr.__u6_addr8[12]) ==
 0))) {
	ip6_clearpktopts(opt, optname);
	break;
}

if (uproto == IPPROTO_TCP6 &&
    sticky && !IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)((*(const u_int32_t *)(const void *)(&(&pktinfo->ipi6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&pktinfo->ipi6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&pktinfo->ipi6_addr)->__u6_addr.__u6_addr8
[8]) == 0) && (*(const u_int32_t *)(const void *)(&
(&pktinfo->ipi6_addr)->__u6_addr.__u6_addr8[12]) ==
 0))) {
	return (EINVAL22);
}

if (pktinfo->ipi6_ifindex) {
	ifp = if_get(pktinfo->ipi6_ifindex);
	if (ifp == NULL((void *)0))
		return (ENXIO6);
	if_put(ifp);
}

/*
 * We store the address anyway, and let in6_selectsrc()
 * validate the specified address.  This is because ipi6_addr
 * may not have enough information about its scope zone, and
 * we may need additional information (such as outgoing
 * interface or the scope zone of a destination address) to
 * disambiguate the scope.
 * XXX: the delay of the validation may confuse the
 * application when it is used as a sticky option.
 */
if (opt->ip6po_pktinfo == NULL((void *)0)) {
	opt->ip6po_pktinfo = malloc(sizeof(*pktinfo),
	    M_IP6OPT123, M_NOWAIT0x0002);
	if (opt->ip6po_pktinfo == NULL((void *)0))
		return (ENOBUFS55);
}
bcopy(pktinfo, opt->ip6po_pktinfo, sizeof(*pktinfo));
break;
}

case IPV6_HOPLIMIT47:
{
int *hlimp;

/*
 * RFC 3542 deprecated the usage of sticky IPV6_HOPLIMIT
 * to simplify the ordering among hoplimit options.
 */
if (sticky)
	return (ENOPROTOOPT42);

if (len != sizeof(int))
	return (EINVAL22);
hlimp = (int *)buf;
if (*hlimp < -1 || *hlimp > 255)
	return (EINVAL22);

opt->ip6po_hlim = *hlimp;
break;
}

case IPV6_TCLASS61:
{
int tclass;

if (len != sizeof(int))
	return (EINVAL22);
tclass = *(int *)buf;
if (tclass < -1 || tclass > 255)
	return (EINVAL22);

opt->ip6po_tclass = tclass;
break;
}
case IPV6_HOPOPTS49:
{
struct ip6_hbh *hbh;
int hbhlen;

/*
 * XXX: We don't allow a non-privileged user to set ANY HbH
 * options, since per-option restriction has too much
 * overhead.
 */
if (!priv)
	return (EPERM1);

if (len == 0) {
	ip6_clearpktopts(opt, IPV6_HOPOPTS49);
	break;	/* just remove the option */
}

/* message length validation */
if (len < sizeof(struct ip6_hbh))
	return (EINVAL22);
hbh = (struct ip6_hbh *)buf;
hbhlen = (hbh->ip6h_len + 1) << 3;
if (len != hbhlen)
	return (EINVAL22);

/* turn off the previous option, then set the new option. */
ip6_clearpktopts(opt, IPV6_HOPOPTS49);
opt->ip6po_hbh = malloc(hbhlen, M_IP6OPT123, M_NOWAIT0x0002);
if (opt->ip6po_hbh == NULL((void *)0))
	return (ENOBUFS55);
memcpy(opt->ip6po_hbh, hbh, hbhlen)__builtin_memcpy((opt->ip6po_hbh), (hbh), (hbhlen));

break;
}

case IPV6_DSTOPTS50:
case IPV6_RTHDRDSTOPTS35:
{
struct ip6_dest *dest, **newdest = NULL((void *)0);
int destlen;

if (!priv)	/* XXX: see the comment for IPV6_HOPOPTS */
	return (EPERM1);

if (len == 0) {
	ip6_clearpktopts(opt, optname);
	break;	/* just remove the option */
}

/* message length validation */
if (len < sizeof(struct ip6_dest))
	return (EINVAL22);
dest = (struct ip6_dest *)buf;
destlen = (dest->ip6d_len + 1) << 3;
if (len != destlen)
	return (EINVAL22);
/*
 * Determine the position that the destination options header
 * should be inserted; before or after the routing header.
 */
switch (optname) {
case IPV6_RTHDRDSTOPTS35:
	newdest = &opt->ip6po_dest1;
	break;
case IPV6_DSTOPTS50:
	newdest = &opt->ip6po_dest2;
	break;
}

/* turn off the previous option, then set the new option. */
ip6_clearpktopts(opt, optname);
*newdest = malloc(destlen, M_IP6OPT123, M_NOWAIT0x0002);
if (*newdest == NULL((void *)0))
	return (ENOBUFS55);
memcpy(*newdest, dest, destlen)__builtin_memcpy((*newdest), (dest), (destlen));

break;
}

case IPV6_RTHDR51:
{
struct ip6_rthdr *rth;
int rthlen;

if (len == 0) {
	ip6_clearpktopts(opt, IPV6_RTHDR51);
	break;	/* just remove the option */
}

/* message length validation */
if (len < sizeof(struct ip6_rthdr))
	return (EINVAL22);
rth = (struct ip6_rthdr *)buf;
rthlen = (rth->ip6r_len + 1) << 3;
if (len != rthlen)
	return (EINVAL22);

switch (rth->ip6r_type) {
case IPV6_RTHDR_TYPE_00:
	if (rth->ip6r_len == 0)	/* must contain one addr */
		return (EINVAL22);
	if (rth->ip6r_len % 2) /* length must be even */
		return (EINVAL22);
	if (rth->ip6r_len / 2 != rth->ip6r_segleft)
		return (EINVAL22);
	break;
default:
	return (EINVAL22);	/* not supported */
}
/* turn off the previous option */
ip6_clearpktopts(opt, IPV6_RTHDR51);
opt->ip6po_rthdrip6po_rhinfo.ip6po_rhi_rthdr = malloc(rthlen, M_IP6OPT123, M_NOWAIT0x0002);
if (opt->ip6po_rthdrip6po_rhinfo.ip6po_rhi_rthdr == NULL((void *)0))
	return (ENOBUFS55);
memcpy(opt->ip6po_rthdr, rth, rthlen)__builtin_memcpy((opt->ip6po_rhinfo.ip6po_rhi_rthdr), (rth
), (rthlen));
break;
}

case IPV6_USE_MIN_MTU42:
if (len != sizeof(int))
	return (EINVAL22);
minmtupolicy = *(int *)buf;
if (minmtupolicy != IP6PO_MINMTU_MCASTONLY-1 &&
    minmtupolicy != IP6PO_MINMTU_DISABLE0 &&
    minmtupolicy != IP6PO_MINMTU_ALL1) {
	return (EINVAL22);
}
opt->ip6po_minmtu = minmtupolicy;
break;

case IPV6_DONTFRAG62:
if (len != sizeof(int))
	return (EINVAL22);

if (uproto == IPPROTO_TCP6 || *(int *)buf == 0) {
	/*
	 * we ignore this option for TCP sockets.
	 * (RFC3542 leaves this case unspecified.)
	 */
	opt->ip6po_flags &= ~IP6PO_DONTFRAG0x04;
} else
	opt->ip6po_flags |= IP6PO_DONTFRAG0x04;
break;

default:
return (ENOPROTOOPT42);
} /* end of switch */

return (0);
2526}

2528/*
* Routine called from ip6_output() to loop back a copy of an IP6 multicast
* packet to the input queue of a specified interface.
*/
2532void
2533ip6_mloopback(struct ifnet *ifp, struct mbuf *m, struct sockaddr_in6 *dst)
2534{
struct mbuf *copym;
struct ip6_hdr *ip6;

/*
* Duplicate the packet.
*/
copym = m_copym(m, 0, M_COPYALL1000000000, M_NOWAIT0x0002);
if (copym == NULL((void *)0))
return;

/*
* Make sure to deep-copy IPv6 header portion in case the data
* is in an mbuf cluster, so that we can safely override the IPv6
* header portion later.
*/
if ((copym->m_flagsm_hdr.mh_flags & M_EXT0x0001) != 0 ||
   copym->m_lenm_hdr.mh_len < sizeof(struct ip6_hdr)) {
copym = m_pullup(copym, sizeof(struct ip6_hdr));
if (copym == NULL((void *)0))
	return;
}

2557#ifdef DIAGNOSTIC1
if (copym->m_lenm_hdr.mh_len < sizeof(*ip6)) {
m_freem(copym);
return;
}
2562#endif

ip6 = mtod(copym, struct ip6_hdr *)((struct ip6_hdr *)((copym)->m_hdr.mh_data));
if (IN6_IS_SCOPE_EMBED(&ip6->ip6_src)(((((&ip6->ip6_src)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&ip6->ip6_src)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) || ((((&ip6->ip6_src)->__u6_addr
.__u6_addr8[0] == 0xff) && (((&ip6->ip6_src)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) || ((((&ip6
->ip6_src)->__u6_addr.__u6_addr8[0] == 0xff) &&
 (((&ip6->ip6_src)->__u6_addr.__u6_addr8[1] & 0x0f
) == 0x01)))))
ip6->ip6_src.s6_addr16__u6_addr.__u6_addr16[1] = 0;
if (IN6_IS_SCOPE_EMBED(&ip6->ip6_dst)(((((&ip6->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&ip6->ip6_dst)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) || ((((&ip6->ip6_dst)->__u6_addr
.__u6_addr8[0] == 0xff) && (((&ip6->ip6_dst)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) || ((((&ip6
->ip6_dst)->__u6_addr.__u6_addr8[0] == 0xff) &&
 (((&ip6->ip6_dst)->__u6_addr.__u6_addr8[1] & 0x0f
) == 0x01)))))
ip6->ip6_dst.s6_addr16__u6_addr.__u6_addr16[1] = 0;

if_input_local(ifp, copym, dst->sin6_family);
2571}

2573/*
* Chop IPv6 header off from the payload.
*/
2576int
2577ip6_splithdr(struct mbuf *m, struct ip6_exthdrs *exthdrs)
2578{
struct mbuf *mh;
struct ip6_hdr *ip6;

ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
if (m->m_lenm_hdr.mh_len > sizeof(*ip6)) {
MGET(mh, M_DONTWAIT, MT_HEADER)mh = m_get((0x0002), (2));
if (mh == NULL((void *)0)) {
	m_freem(m);
	return ENOBUFS55;
}
M_MOVE_PKTHDR(mh, m)do { (mh)->m_hdr.mh_flags = ((mh)->m_hdr.mh_flags &
 (0x0001 | 0x0008)); (mh)->m_hdr.mh_flags |= (m)->m_hdr
.mh_flags & (0x0002|0x0004|0x0010|0x0100|0x0200|0x0400|0x4000
| 0x0800|0x0040|0x1000|0x8000|0x0020|0x2000); do { ((mh))->
M_dat.MH.MH_pkthdr = ((m))->M_dat.MH.MH_pkthdr; ((m))->
m_hdr.mh_flags &= ~0x0002; { ((&((m))->M_dat.MH.MH_pkthdr
.ph_tags)->slh_first) = ((void *)0); }; ((m))->M_dat.MH
.MH_pkthdr.pf.statekey = ((void *)0); } while ( 0); if (((mh)
->m_hdr.mh_flags & 0x0001) == 0) (mh)->m_hdr.mh_data
 = (mh)->M_dat.MH.MH_dat.MH_databuf; } while ( 0);
m_align(mh, sizeof(*ip6));
m->m_lenm_hdr.mh_len -= sizeof(*ip6);
m->m_datam_hdr.mh_data += sizeof(*ip6);
mh->m_nextm_hdr.mh_next = m;
m = mh;
m->m_lenm_hdr.mh_len = sizeof(*ip6);
bcopy((caddr_t)ip6, mtod(m, caddr_t)((caddr_t)((m)->m_hdr.mh_data)), sizeof(*ip6));
}
exthdrs->ip6e_ip6 = m;
return 0;
2600}

2602u_int32_t
2603ip6_randomid(void)
2604{
return idgen32(&ip6_id_ctx);
2606}

2608void
2609ip6_randomid_init(void)
2610{
idgen32_init(&ip6_id_ctx);
2612}

2614/*
*	Compute significant parts of the IPv6 checksum pseudo-header
*	for use in a delayed TCP/UDP checksum calculation.
*/
2618static __inline u_int16_t __attribute__((__unused__))
2619in6_cksum_phdr(const struct in6_addr *src, const struct in6_addr *dst,
  u_int32_t len, u_int32_t nxt)
2621{
u_int32_t sum = 0;
const u_int16_t *w;

w = (const u_int16_t *) src;
sum += w[0];
if (!IN6_IS_SCOPE_EMBED(src)(((((src)->__u6_addr.__u6_addr8[0] == 0xfe) && (((
src)->__u6_addr.__u6_addr8[1] & 0xc0) == 0x80))) || ((
((src)->__u6_addr.__u6_addr8[0] == 0xff) && (((src
)->__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) || ((((src
)->__u6_addr.__u6_addr8[0] == 0xff) && (((src)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x01)))))
sum += w[1];
sum += w[2]; sum += w[3]; sum += w[4]; sum += w[5];
sum += w[6]; sum += w[7];

w = (const u_int16_t *) dst;
sum += w[0];
if (!IN6_IS_SCOPE_EMBED(dst)(((((dst)->__u6_addr.__u6_addr8[0] == 0xfe) && (((
dst)->__u6_addr.__u6_addr8[1] & 0xc0) == 0x80))) || ((
((dst)->__u6_addr.__u6_addr8[0] == 0xff) && (((dst
)->__u6_addr.__u6_addr8[1] & 0x0f) == 0x02))) || ((((dst
)->__u6_addr.__u6_addr8[0] == 0xff) && (((dst)->
__u6_addr.__u6_addr8[1] & 0x0f) == 0x01)))))
sum += w[1];
sum += w[2]; sum += w[3]; sum += w[4]; sum += w[5];
sum += w[6]; sum += w[7];

sum += (u_int16_t)(len >> 16) + (u_int16_t)(len /*& 0xffff*/);

sum += (u_int16_t)(nxt >> 16) + (u_int16_t)(nxt /*& 0xffff*/);

sum = (u_int16_t)(sum >> 16) + (u_int16_t)(sum /*& 0xffff*/);

if (sum > 0xffff)
sum -= 0xffff;

return (sum);
2649}

2651/*
* Process a delayed payload checksum calculation.
*/
2654void
2655in6_delayed_cksum(struct mbuf *m, u_int8_t nxt)
2656{
int nxtp, offset;
u_int16_t csum;

offset = ip6_lasthdr(m, 0, IPPROTO_IPV641, &nxtp);
if (offset <= 0 || nxtp != nxt)
/* If the desired next protocol isn't found, punt. */
return;
csum = (u_int16_t)(in6_cksum(m, 0, offset, m->m_pkthdrM_dat.MH.MH_pkthdr.len - offset));

switch (nxt) {
case IPPROTO_TCP6:
offset += offsetof(struct tcphdr, th_sum)__builtin_offsetof(struct tcphdr, th_sum);
break;

case IPPROTO_UDP17:
offset += offsetof(struct udphdr, uh_sum)__builtin_offsetof(struct udphdr, uh_sum);
if (csum == 0)
	csum = 0xffff;
break;

case IPPROTO_ICMPV658:
offset += offsetof(struct icmp6_hdr, icmp6_cksum)__builtin_offsetof(struct icmp6_hdr, icmp6_cksum);
break;
}

if ((offset + sizeof(u_int16_t)) > m->m_lenm_hdr.mh_len)
m_copyback(m, offset, sizeof(csum), &csum, M_NOWAIT0x0002);
else
*(u_int16_t *)(mtod(m, caddr_t)((caddr_t)((m)->m_hdr.mh_data)) + offset) = csum;
2686}

2688void
2689in6_proto_cksum_out(struct mbuf *m, struct ifnet *ifp)
2690{
struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));

/* some hw and in6_delayed_cksum need the pseudo header cksum */
if (m->m_pkthdrM_dat.MH.MH_pkthdr.csum_flags &
   (M_TCP_CSUM_OUT0x0002|M_UDP_CSUM_OUT0x0004|M_ICMP_CSUM_OUT0x0200)) {
int nxt, offset;
u_int16_t csum;

offset = ip6_lasthdr(m, 0, IPPROTO_IPV641, &nxt);
if (ISSET(m->m_pkthdr.csum_flags, M_TCP_TSO)((m->M_dat.MH.MH_pkthdr.csum_flags) & (0x8000)) &&
    in_ifcap_cksum(m, ifp, IFCAP_TSOv60x00002000)) {
	csum = in6_cksum_phdr(&ip6->ip6_src, &ip6->ip6_dst,
	    htonl(0)(__uint32_t)(__builtin_constant_p(0) ? (__uint32_t)(((__uint32_t
)(0) & 0xff) << 24 | ((__uint32_t)(0) & 0xff00)
 << 8 | ((__uint32_t)(0) & 0xff0000) >> 8 | (
(__uint32_t)(0) & 0xff000000) >> 24) : __swap32md(0
)), htonl(nxt)(__uint32_t)(__builtin_constant_p(nxt) ? (__uint32_t)(((__uint32_t
)(nxt) & 0xff) << 24 | ((__uint32_t)(nxt) & 0xff00
) << 8 | ((__uint32_t)(nxt) & 0xff0000) >> 8 |
 ((__uint32_t)(nxt) & 0xff000000) >> 24) : __swap32md
(nxt)));
} else {
	csum = in6_cksum_phdr(&ip6->ip6_src, &ip6->ip6_dst,
	    htonl(m->m_pkthdr.len - offset)(__uint32_t)(__builtin_constant_p(m->M_dat.MH.MH_pkthdr.len
 - offset) ? (__uint32_t)(((__uint32_t)(m->M_dat.MH.MH_pkthdr
.len - offset) & 0xff) << 24 | ((__uint32_t)(m->
M_dat.MH.MH_pkthdr.len - offset) & 0xff00) << 8 | (
(__uint32_t)(m->M_dat.MH.MH_pkthdr.len - offset) & 0xff0000
) >> 8 | ((__uint32_t)(m->M_dat.MH.MH_pkthdr.len - offset
) & 0xff000000) >> 24) : __swap32md(m->M_dat.MH.
MH_pkthdr.len - offset)), htonl(nxt)(__uint32_t)(__builtin_constant_p(nxt) ? (__uint32_t)(((__uint32_t
)(nxt) & 0xff) << 24 | ((__uint32_t)(nxt) & 0xff00
) << 8 | ((__uint32_t)(nxt) & 0xff0000) >> 8 |
 ((__uint32_t)(nxt) & 0xff000000) >> 24) : __swap32md
(nxt)));
}
if (nxt == IPPROTO_TCP6)
	offset += offsetof(struct tcphdr, th_sum)__builtin_offsetof(struct tcphdr, th_sum);
else if (nxt == IPPROTO_UDP17)
	offset += offsetof(struct udphdr, uh_sum)__builtin_offsetof(struct udphdr, uh_sum);
else if (nxt == IPPROTO_ICMPV658)
	offset += offsetof(struct icmp6_hdr, icmp6_cksum)__builtin_offsetof(struct icmp6_hdr, icmp6_cksum);
if ((offset + sizeof(u_int16_t)) > m->m_lenm_hdr.mh_len)
	m_copyback(m, offset, sizeof(csum), &csum, M_NOWAIT0x0002);
else
	*(u_int16_t *)(mtod(m, caddr_t)((caddr_t)((m)->m_hdr.mh_data)) + offset) = csum;
}

if (m->m_pkthdrM_dat.MH.MH_pkthdr.csum_flags & M_TCP_CSUM_OUT0x0002) {
if (!ifp || !(ifp->if_capabilitiesif_data.ifi_capabilities & IFCAP_CSUM_TCPv60x00000080) ||
    ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt != IPPROTO_TCP6 ||
    ifp->if_bridgeidx != 0) {
	tcpstat_inc(tcps_outswcsum);
	in6_delayed_cksum(m, IPPROTO_TCP6);
	m->m_pkthdrM_dat.MH.MH_pkthdr.csum_flags &= ~M_TCP_CSUM_OUT0x0002; /* Clear */
}
} else if (m->m_pkthdrM_dat.MH.MH_pkthdr.csum_flags & M_UDP_CSUM_OUT0x0004) {
if (!ifp || !(ifp->if_capabilitiesif_data.ifi_capabilities & IFCAP_CSUM_UDPv60x00000100) ||
    ip6->ip6_nxtip6_ctlun.ip6_un1.ip6_un1_nxt != IPPROTO_UDP17 ||
    ifp->if_bridgeidx != 0) {
	udpstat_inc(udps_outswcsum);
	in6_delayed_cksum(m, IPPROTO_UDP17);
	m->m_pkthdrM_dat.MH.MH_pkthdr.csum_flags &= ~M_UDP_CSUM_OUT0x0004; /* Clear */
}
} else if (m->m_pkthdrM_dat.MH.MH_pkthdr.csum_flags & M_ICMP_CSUM_OUT0x0200) {
in6_delayed_cksum(m, IPPROTO_ICMPV658);
m->m_pkthdrM_dat.MH.MH_pkthdr.csum_flags &= ~M_ICMP_CSUM_OUT0x0200; /* Clear */
}
2740}

2742#ifdef IPSEC1
2743int
2744ip6_output_ipsec_lookup(struct mbuf *m, const u_char seclevel[],
  struct tdb **tdbout)
2746{
struct tdb *tdb;
struct m_tag *mtag;
struct tdb_ident *tdbi;
int error;

/*
* Check if there was an outgoing SA bound to the flow
* from a transport protocol.
*/

/* Do we have any pending SAs to apply ? */
error = ipsp_spd_lookup(m, AF_INET624, sizeof(struct ip6_hdr),
   IPSP_DIRECTION_OUT0x2, NULL((void *)0), seclevel, &tdb, NULL((void *)0));
if (error || tdb == NULL((void *)0)) {
*tdbout = NULL((void *)0);
return error;
}
/* Loop detection */
for (mtag = m_tag_first(m); mtag != NULL((void *)0); mtag = m_tag_next(m, mtag)) {
if (mtag->m_tag_id != PACKET_TAG_IPSEC_OUT_DONE0x0002)
	continue;
tdbi = (struct tdb_ident *)(mtag + 1);
if (tdbi->spi == tdb->tdb_spi &&
    tdbi->proto == tdb->tdb_sproto &&
    tdbi->rdomain == tdb->tdb_rdomain &&
    !memcmp(&tdbi->dst, &tdb->tdb_dst,__builtin_memcmp((&tdbi->dst), (&tdb->tdb_dst),
 (sizeof(union sockaddr_union)))
    sizeof(union sockaddr_union))__builtin_memcmp((&tdbi->dst), (&tdb->tdb_dst),
 (sizeof(union sockaddr_union)))) {
	/* no IPsec needed */
	tdb_unref(tdb);
	*tdbout = NULL((void *)0);
	return 0;
}
}
*tdbout = tdb;
return 0;
2782}

2784int
2785ip6_output_ipsec_pmtu_update(struct tdb *tdb, struct route_in6 *ro,
  struct in6_addr *dst, int ifidx, int rtableid, int transportmode)
2787{
struct rtentry *rt = NULL((void *)0);
int rt_mtucloned = 0;

/* Find a host route to store the mtu in */
if (ro != NULL((void *)0))
rt = ro->ro_rt;
/* but don't add a PMTU route for transport mode SAs */
if (transportmode)
rt = NULL((void *)0);
else if (rt == NULL((void *)0) || (rt->rt_flags & RTF_HOST0x4) == 0) {
struct sockaddr_in6 sin6;
int error;

memset(&sin6, 0, sizeof(sin6))__builtin_memset((&sin6), (0), (sizeof(sin6)));
sin6.sin6_family = AF_INET624;
sin6.sin6_len = sizeof(sin6);
sin6.sin6_addr = *dst;
sin6.sin6_scope_id = in6_addr2scopeid(ifidx, dst);
error = in6_embedscope(dst, &sin6, NULL((void *)0), NULL((void *)0));
if (error) {
	/* should be impossible */
	return error;
}
rt = icmp6_mtudisc_clone(&sin6, rtableid, 1);
rt_mtucloned = 1;
}
DPRINTF("spi %08x mtu %d rt %p cloned %d",do { } while (0)
   ntohl(tdb->tdb_spi), tdb->tdb_mtu, rt, rt_mtucloned)do { } while (0);
if (rt != NULL((void *)0)) {
rt->rt_mturt_rmx.rmx_mtu = tdb->tdb_mtu;
if (ro != NULL((void *)0) && ro->ro_rt != NULL((void *)0)) {
	rtfree(ro->ro_rt);
	ro->ro_rt = rtalloc(sin6tosa(&ro->ro_dst), RT_RESOLVE1,
	    rtableid);
}
if (rt_mtucloned)
	rtfree(rt);
}
return 0;
2827}

2829int
2830ip6_output_ipsec_send(struct tdb *tdb, struct mbuf *m, struct route_in6 *ro,
  int tunalready, int fwd)
2832{
struct mbuf_list ml;
struct ifnet *encif = NULL((void *)0);
struct ip6_hdr *ip6;
struct in6_addr dst;
u_int len;
int error, ifidx, rtableid, tso = 0;

2840#if NPF1 > 0
/*
* Packet filter
*/
if ((encif = enc_getif(tdb->tdb_rdomain, tdb->tdb_tap)) == NULL((void *)0) ||
   pf_test(AF_INET624, fwd ? PF_FWD : PF_OUT, encif, &m) != PF_PASS) {
m_freem(m);
return EACCES13;
}
if (m == NULL((void *)0))
return 0;
/*
* PF_TAG_REROUTE handling or not...
* Packet is entering IPsec so the routing is
* already overruled by the IPsec policy.
* Until now the change was not reconsidered.
* What's the behaviour?
*/
2858#endif

/* Check if we can chop the TCP packet */
ip6 = mtod(m, struct ip6_hdr *)((struct ip6_hdr *)((m)->m_hdr.mh_data));
if (ISSET(m->m_pkthdr.csum_flags, M_TCP_TSO)((m->M_dat.MH.MH_pkthdr.csum_flags) & (0x8000)) &&
   m->m_pkthdrM_dat.MH.MH_pkthdr.ph_mss <= tdb->tdb_mtu) {
tso = 1;
len = m->m_pkthdrM_dat.MH.MH_pkthdr.ph_mss;
} else
len = sizeof(struct ip6_hdr) + ntohs(ip6->ip6_plen)(__uint16_t)(__builtin_constant_p(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen
) ? (__uint16_t)(((__uint16_t)(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen
) & 0xffU) << 8 | ((__uint16_t)(ip6->ip6_ctlun.ip6_un1
.ip6_un1_plen) & 0xff00U) >> 8) : __swap16md(ip6->
ip6_ctlun.ip6_un1.ip6_un1_plen));

/* Check if we are allowed to fragment */
dst = ip6->ip6_dst;
ifidx = m->m_pkthdrM_dat.MH.MH_pkthdr.ph_ifidx;
rtableid = m->m_pkthdrM_dat.MH.MH_pkthdr.ph_rtableid;
if (ip_mtudisc && tdb->tdb_mtu &&
   len > tdb->tdb_mtu && tdb->tdb_mtutimeout > gettime()) {
int transportmode;

transportmode = (tdb->tdb_dst.sa.sa_family == AF_INET624) &&
    (IN6_ARE_ADDR_EQUAL(&tdb->tdb_dst.sin6.sin6_addr, &dst)(__builtin_memcmp((&(&tdb->tdb_dst.sin6.sin6_addr)
->__u6_addr.__u6_addr8[0]), (&(&dst)->__u6_addr
.__u6_addr8[0]), (sizeof(struct in6_addr))) == 0));
error = ip6_output_ipsec_pmtu_update(tdb, ro, &dst, ifidx,
    rtableid, transportmode);
if (error) {
	ipsecstat_inc(ipsec_odrops);
	tdbstat_inc(tdb, tdb_odrops);
	m_freem(m);
	return error;
}
ipsec_adjust_mtu(m, tdb->tdb_mtu);
m_freem(m);
return EMSGSIZE40;
}
/* propagate don't fragment for v6-over-v6 */
if (ip_mtudisc)
SET(m->m_pkthdr.csum_flags, M_IPV6_DF_OUT)((m->M_dat.MH.MH_pkthdr.csum_flags) |= (0x1000));

/*
* Clear these -- they'll be set in the recursive invocation
* as needed.
*/
m->m_flagsm_hdr.mh_flags &= ~(M_BCAST0x0100 | M_MCAST0x0200);

if (tso) {
error = tcp_chopper(m, &ml, encif, len);
if (error)
	goto done;
} else {
CLR(m->m_pkthdr.csum_flags, M_TCP_TSO)((m->M_dat.MH.MH_pkthdr.csum_flags) &= ~(0x8000));
in6_proto_cksum_out(m, encif);
ml_init(&ml);
ml_enqueue(&ml, m);
}

KERNEL_LOCK()_kernel_lock();
while ((m = ml_dequeue(&ml)) != NULL((void *)0)) {
/* Callee frees mbuf */
error = ipsp_process_packet(m, tdb, AF_INET624, tunalready);
if (error)
	break;
}
KERNEL_UNLOCK()_kernel_unlock();
done:
if (error) {
ml_purge(&ml);
ipsecstat_inc(ipsec_odrops);
tdbstat_inc(tdb, tdb_odrops);
}
if (!error && tso)
tcpstat_inc(tcps_outswtso);
if (ip_mtudisc && error == EMSGSIZE40)
ip6_output_ipsec_pmtu_update(tdb, ro, &dst, ifidx, rtableid, 0);
return error;
2931}
2932#endif /* IPSEC */