/usr/src/sbin/iked/ikev2.c

Bug Summary

File:	src/sbin/iked/ikev2.c
Warning:	line 7227, column 9 Dereference of null pointer
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 ikev2.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 pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sbin/iked/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sbin/iked -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/iked/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -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 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/sbin/iked/ikev2.c
1/*	$OpenBSD: ikev2.c,v 1.380 2023/11/24 14:43:00 tobhe Exp $	*/

3/*
* Copyright (c) 2019 Tobias Heider <tobias.heider@stusta.de>
* Copyright (c) 2010-2013 Reyk Floeter <reyk@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

20#include <sys/types.h>
21#include <sys/queue.h>
22#include <sys/socket.h>
23#include <sys/uio.h>

25#include <netinet/in.h>
26#include <netinet/ip_ipsp.h>
27#include <arpa/inet.h>

29#include <stdlib.h>
30#include <stdio.h>
31#include <syslog.h>
32#include <unistd.h>
33#include <string.h>
34#include <signal.h>
35#include <endian.h>
36#include <errno(*__errno()).h>
37#include <err.h>
38#include <event.h>

40#include <openssl/sha.h>
41#include <openssl/evp.h>
42#include <openssl/x509.h>

44#include "iked.h"
45#include "ikev2.h"
46#include "eap.h"
47#include "dh.h"
48#include "chap_ms.h"
49#include "version.h"

51void	 ikev2_info(struct iked *, int);
52void	 ikev2_info_sa(struct iked *, int, const char *, struct iked_sa *);
53void	 ikev2_info_csa(struct iked *, int, const char *, struct iked_childsa *);
54void	 ikev2_info_flow(struct iked *, int, const char *, struct iked_flow *);
55void	 ikev2_log_established(struct iked_sa *);
56void	 ikev2_log_proposal(struct iked_sa *, struct iked_proposals *);
57void	 ikev2_log_cert_info(const char *, struct iked_id *);

59void	 ikev2_run(struct privsep *, struct privsep_proc *, void *);
60void	 ikev2_shutdown(void);
61int	 ikev2_dispatch_parent(int, struct privsep_proc *, struct imsg *);
62int	 ikev2_dispatch_cert(int, struct privsep_proc *, struct imsg *);
63int	 ikev2_dispatch_control(int, struct privsep_proc *, struct imsg *);

65struct iked_sa *
ikev2_getimsgdata(struct iked *, struct imsg *, struct iked_sahdr *,
   uint8_t *, uint8_t **, size_t *);

69void	 ikev2_recv(struct iked *, struct iked_message *);
70int	 ikev2_ike_auth_compatible(struct iked_sa *, uint8_t, uint8_t);
71int	 ikev2_ike_auth_recv(struct iked *, struct iked_sa *,
   struct iked_message *);
73int	 ikev2_ike_auth(struct iked *, struct iked_sa *);
74int	 ikev2_auth_verify(struct iked *, struct iked_sa *);

76void	 ikev2_init_recv(struct iked *, struct iked_message *,
   struct ike_header *);
78void	 ikev2_init_ike_sa_timeout(struct iked *, void *);
79int	 ikev2_init_ike_sa_peer(struct iked *, struct iked_policy *,
   struct iked_addr *, struct iked_message *);
81int	 ikev2_init_ike_auth(struct iked *, struct iked_sa *);
82int	 ikev2_init_auth(struct iked *, struct iked_message *);
83int	 ikev2_init_done(struct iked *, struct iked_sa *);

85int	 ikev2_record_dstid(struct iked *, struct iked_sa *);

87void	 ikev2_enable_timer(struct iked *, struct iked_sa *);
88void	 ikev2_disable_timer(struct iked *, struct iked_sa *);

90void	 ikev2_resp_recv(struct iked *, struct iked_message *,
   struct ike_header *);
92int	 ikev2_resp_ike_sa_init(struct iked *, struct iked_message *);
93int	 ikev2_resp_ike_eap(struct iked *, struct iked_sa *,
   struct iked_message *);
95int	 ikev2_resp_ike_eap_mschap(struct iked *, struct iked_sa *,
   struct iked_message *);
97int	 ikev2_resp_ike_auth(struct iked *, struct iked_sa *);
98int	 ikev2_send_auth_failed(struct iked *, struct iked_sa *);
99int	 ikev2_send_error(struct iked *, struct iked_sa *,
   struct iked_message *, uint8_t);
101int	 ikev2_send_init_error(struct iked *, struct iked_message *);

103int	 ikev2_handle_certreq(struct iked*, struct iked_message *);
104ssize_t	 ikev2_handle_delete(struct iked *, struct iked_message *,
   struct ibuf *, struct ikev2_payload **, uint8_t *);

107int	 ikev2_send_create_child_sa(struct iked *, struct iked_sa *,
   struct iked_spi *, uint8_t, uint16_t);
109int	 ikev2_ikesa_enable(struct iked *, struct iked_sa *, struct iked_sa *);
110void	 ikev2_ikesa_delete(struct iked *, struct iked_sa *, int);
111int	 ikev2_nonce_cmp(struct ibuf *, struct ibuf *);
112int	 ikev2_init_create_child_sa(struct iked *, struct iked_message *);
113int	 ikev2_resp_create_child_sa(struct iked *, struct iked_message *);
114void	 ikev2_ike_sa_rekey(struct iked *, void *);
115void	 ikev2_ike_sa_rekey_timeout(struct iked *, void *);
116void	 ikev2_ike_sa_rekey_schedule(struct iked *, struct iked_sa *);
117void	 ikev2_ike_sa_rekey_schedule_fast(struct iked *, struct iked_sa *);
118void	 ikev2_ike_sa_alive(struct iked *, void *);
119void	 ikev2_ike_sa_keepalive(struct iked *, void *);

121int	 ikev2_sa_negotiate_common(struct iked *, struct iked_sa *,
   struct iked_message *, int);
123int	 ikev2_sa_initiator(struct iked *, struct iked_sa *,
   struct iked_sa *, struct iked_message *);
125int	 ikev2_sa_responder(struct iked *, struct iked_sa *, struct iked_sa *,
   struct iked_message *);
127int	 ikev2_sa_initiator_dh(struct iked_sa *, struct iked_message *,
   unsigned int, struct iked_sa *);
129int	 ikev2_sa_responder_dh(struct iked_kex *, struct iked_proposals *,
   struct iked_message *, unsigned int);
131void	 ikev2_sa_cleanup_dh(struct iked_sa *);
132int	 ikev2_sa_keys(struct iked *, struct iked_sa *, struct ibuf *);
133int	 ikev2_sa_tag(struct iked_sa *, struct iked_id *);
134int	 ikev2_set_sa_proposal(struct iked_sa *, struct iked_policy *,
   unsigned int);

137int	 ikev2_childsa_negotiate(struct iked *, struct iked_sa *,
   struct iked_kex *, struct iked_proposals *, int, int);
139int	 ikev2_childsa_delete_proposed(struct iked *, struct iked_sa *,
   struct iked_proposals *);
141int	 ikev2_valid_proposal(struct iked_proposal *,
   struct iked_transform **, struct iked_transform **, int *);

144int	 ikev2_handle_notifies(struct iked *, struct iked_message *);

146ssize_t	 ikev2_add_proposals(struct iked *, struct iked_sa *, struct ibuf *,
   struct iked_proposals *, uint8_t, int, int, int);
148ssize_t	 ikev2_add_cp(struct iked *, struct iked_sa *, int, struct ibuf *);
149ssize_t	 ikev2_init_add_cp(struct iked *, struct iked_sa *, struct ibuf *);
150ssize_t	 ikev2_resp_add_cp(struct iked *, struct iked_sa *, struct ibuf *);
151ssize_t	 ikev2_add_transform(struct ibuf *,
   uint8_t, uint8_t, uint16_t, uint16_t);
153ssize_t	 ikev2_add_ts(struct ibuf *, struct ikev2_payload **, ssize_t,
   struct iked_sa *, int);
155ssize_t	 ikev2_add_certreq(struct ibuf *, struct ikev2_payload **, ssize_t,
   struct ibuf *, uint8_t);
157ssize_t	 ikev2_add_ipcompnotify(struct iked *, struct ibuf *,
   struct ikev2_payload **, ssize_t, struct iked_sa *, int);
159ssize_t	 ikev2_add_ts_payload(struct ibuf *, unsigned int, struct iked_sa *);
160ssize_t	 ikev2_add_error(struct iked *, struct ibuf *, struct iked_message *);
161int	 ikev2_add_data(struct ibuf *, void *, size_t);
162int	 ikev2_add_buf(struct ibuf *buf, struct ibuf *);

164int	 ikev2_cp_setaddr(struct iked *, struct iked_sa *, sa_family_t);
165int	 ikev2_cp_setaddr_pool(struct iked *, struct iked_sa *,
   struct iked_cfg *, const char **, sa_family_t);
167int	 ikev2_cp_fixaddr(struct iked_sa *, struct iked_addr *,
   struct iked_addr *);
169int	 ikev2_cp_fixflow(struct iked_sa *, struct iked_flow *,
   struct iked_flow *);
171int	 ikev2_cp_request_configured(struct iked_sa *);

173ssize_t	 ikev2_add_sighashnotify(struct ibuf *, struct ikev2_payload **,
   ssize_t);
175ssize_t	 ikev2_add_nat_detection(struct iked *, struct ibuf *,
   struct ikev2_payload **, struct iked_message *, ssize_t);
177ssize_t	 ikev2_add_vendor_id(struct ibuf *, struct ikev2_payload **,
   ssize_t, struct ibuf *);
179ssize_t	 ikev2_add_notify(struct ibuf *, struct ikev2_payload **, ssize_t,
   uint16_t);
181ssize_t	 ikev2_add_mobike(struct ibuf *, struct ikev2_payload **, ssize_t);
182ssize_t	 ikev2_add_fragmentation(struct ibuf *, struct ikev2_payload **,
   ssize_t);
184ssize_t	 ikev2_add_transport_mode(struct iked *, struct ibuf *,
   struct ikev2_payload **, ssize_t, struct iked_sa *);
186int	 ikev2_update_sa_addresses(struct iked *, struct iked_sa *);
187int	 ikev2_resp_informational(struct iked *, struct iked_sa *,
   struct iked_message *);

190void	ikev2_ctl_reset_id(struct iked *, struct imsg *, unsigned int);
191void	ikev2_ctl_show_sa(struct iked *);
192void	ikev2_ctl_show_stats(struct iked *);

194static struct privsep_proc procs[] = {
{ "parent",	PROC_PARENT,	ikev2_dispatch_parent },
{ "certstore",	PROC_CERT,	ikev2_dispatch_cert },
{ "control",	PROC_CONTROL,	ikev2_dispatch_control }
198};

200void
201ikev2(struct privsep *ps, struct privsep_proc *p)
202{
proc_run(ps, p, procs, nitems(procs)(sizeof((procs)) / sizeof((procs)[0])), ikev2_run, NULL((void *)0));
204}

206void
207ikev2_run(struct privsep *ps, struct privsep_proc *p, void *arg)
208{
/*
* pledge in the ikev2 process:
* stdio - for malloc and basic I/O including events.
* inet - for sendto with specified peer address.
* recvfd - for PFKEYv2 and the listening UDP sockets.
* In theory, recvfd could be dropped after getting the fds once.
*/
p->p_shutdown = ikev2_shutdown;
if (pledge("stdio inet recvfd", NULL((void *)0)) == -1)
fatal("pledge");
219}

221void
222ikev2_shutdown(void)
223{
struct iked		*env = iked_env;

ibuf_free(env->sc_certreq);
env->sc_certreq = NULL((void *)0);
config_doreset(env, RESET_ALL);
229}

231int
232ikev2_dispatch_parent(int fd, struct privsep_proc *p, struct imsg *imsg)
233{
struct iked		*env = iked_env;
struct iked_sa		*sa, *satmp;
struct iked_policy	*pol, *old;

switch (imsg->hdr.type) {
case IMSG_CTL_RESET:
return (config_getreset(env, imsg));
case IMSG_CTL_COUPLE:
case IMSG_CTL_DECOUPLE:
return (config_getcoupled(env, imsg->hdr.type));
case IMSG_CTL_ACTIVE:
case IMSG_CTL_PASSIVE:
if (config_getmode(env, imsg->hdr.type) == -1)
	return (0);	/* ignore error */
timer_del(env, &env->sc_inittmr);
TAILQ_FOREACH(pol, &env->sc_policies, pol_entry)for((pol) = ((&env->sc_policies)->tqh_first); (pol)
 != ((void *)0); (pol) = ((pol)->pol_entry.tqe_next)) {
	if (policy_generate_ts(pol) == -1)
		fatalx("%s: too many traffic selectors", __func__);
}
/* Find new policies for dangling SAs */
RB_FOREACH_SAFE(sa, iked_sas, &env->sc_sas, satmp)for ((sa) = iked_sas_RB_MINMAX(&env->sc_sas, -1); ((sa
) != ((void *)0)) && ((satmp) = iked_sas_RB_NEXT(sa),
 1); (sa) = (satmp)) {
	if (sa->sa_state != IKEV2_STATE_ESTABLISHED9) {
		sa_state(env, sa, IKEV2_STATE_CLOSING10);
		ikev2_ike_sa_setreason(sa, "reload");
		sa_free(env, sa);
		continue;
	}

	old = sa->sa_policy;
	if (policy_lookup_sa(env, sa) == -1) {
		log_info("%s: No matching Policy found, terminating SA.",
		    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
		ikev2_ike_sa_setreason(sa, "Policy no longer exists");
		ikev2_ikesa_delete(env, sa, sa->sa_hdr.sh_initiator);
	}
	if (old != sa->sa_policy) {
		/* Cleanup old policy */
		TAILQ_REMOVE(&old->pol_sapeers, sa, sa_peer_entry)do { if (((sa)->sa_peer_entry.tqe_next) != ((void *)0)) (sa
)->sa_peer_entry.tqe_next->sa_peer_entry.tqe_prev = (sa
)->sa_peer_entry.tqe_prev; else (&old->pol_sapeers)
->tqh_last = (sa)->sa_peer_entry.tqe_prev; *(sa)->sa_peer_entry
.tqe_prev = (sa)->sa_peer_entry.tqe_next; ; ; } while (0);
		policy_unref(env, old);
		policy_ref(env, sa->sa_policy);
		TAILQ_INSERT_TAIL(&sa->sa_policy->pol_sapeers, sa, sa_peer_entry)do { (sa)->sa_peer_entry.tqe_next = ((void *)0); (sa)->
sa_peer_entry.tqe_prev = (&sa->sa_policy->pol_sapeers
)->tqh_last; *(&sa->sa_policy->pol_sapeers)->
tqh_last = (sa); (&sa->sa_policy->pol_sapeers)->
tqh_last = &(sa)->sa_peer_entry.tqe_next; } while (0);
	}
}
if (!env->sc_passive) {
	timer_set(env, &env->sc_inittmr, ikev2_init_ike_sa,
	    NULL((void *)0));
	timer_add(env, &env->sc_inittmr,
	    IKED_INITIATOR_INITIAL2);
}
return (0);
case IMSG_UDP_SOCKET:
return (config_getsocket(env, imsg, ikev2_msg_cb));
case IMSG_PFKEY_SOCKET:
return (config_getpfkey(env, imsg));
case IMSG_CFG_POLICY:
return (config_getpolicy(env, imsg));
case IMSG_CFG_FLOW:
return (config_getflow(env, imsg));
case IMSG_CFG_USER:
return (config_getuser(env, imsg));
case IMSG_COMPILE:
return (config_getcompile(env));
case IMSG_CTL_STATIC:
return (config_getstatic(env, imsg));
case IMSG_CERT_PARTIAL_CHAIN:
return(config_getcertpartialchain(env, imsg));
default:
break;
}

return (-1);
305}

307int
308ikev2_dispatch_cert(int fd, struct privsep_proc *p, struct imsg *imsg)
309{
struct iked		*env = iked_env;
struct iked_sahdr	 sh;
struct iked_sa		*sa;
uint8_t			 type;
uint8_t			*ptr;
size_t			 len;
struct iked_id		*id = NULL((void *)0);
int			 ignore = 0;
int			 i;

switch (imsg->hdr.type) {
case IMSG_CERTREQ:
IMSG_SIZE_CHECK(imsg, &type)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&type)) fatalx("bad length imsg received"); } while (0);

ptr = imsg->data;
memcpy(&type, ptr, sizeof(type));
ptr += sizeof(type);

ibuf_free(env->sc_certreq);
env->sc_certreqtype = type;
env->sc_certreq = ibuf_new(ptr,
    IMSG_DATA_SIZE(imsg)((imsg)->hdr.len - sizeof(struct imsg_hdr)) - sizeof(type));

log_debug("%s: updated local CERTREQ type %s length %zu",
    __func__, print_map(type, ikev2_cert_map),
    ibuf_length(env->sc_certreq));

break;
case IMSG_CERTVALID:
case IMSG_CERTINVALID:
/* Ignore invalid or unauthenticated SAs */
if ((sa = ikev2_getimsgdata(env, imsg,
    &sh, &type, &ptr, &len)) == NULL((void *)0) ||
    sa->sa_state < IKEV2_STATE_EAP3)
	break;

if (sh.sh_initiator)
	id = &sa->sa_rcert;
else
	id = &sa->sa_icert;

id->id_type = type;
id->id_offset = 0;
ibuf_free(id->id_buf);
id->id_buf = NULL((void *)0);

if (len > 0 && (id->id_buf = ibuf_new(ptr, len)) == NULL((void *)0)) {
	log_debug("%s: failed to get cert payload",
	    __func__);
	break;
}

if (imsg->hdr.type == IMSG_CERTVALID) {
	if (sa->sa_peerauth.id_type && ikev2_auth_verify(env, sa))
		break;

	log_debug("%s: peer certificate is valid", __func__);
	sa_stateflags(sa, IKED_REQ_CERTVALID0x0002);

	if (ikev2_ike_auth(env, sa) != 0)
		log_debug("%s: failed to send ike auth", __func__);
} else {
	log_warnx("%s: peer certificate is invalid",
		SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	ikev2_send_auth_failed(env, sa);
}
break;
case IMSG_CERT:
if ((sa = ikev2_getimsgdata(env, imsg,
    &sh, &type, &ptr, &len)) == NULL((void *)0)) {
	log_debug("%s: invalid cert reply", __func__);
	break;
}

/*
 * Ignore the message if we already got a valid certificate.
 * This might happen if the peer sent multiple CERTREQs.
 */
if (sa->sa_stateflags & IKED_REQ_CERT0x0001 ||
    type == IKEV2_CERT_NONE0)
	ignore = 1;

log_debug("%s: cert type %s length %zu, %s", __func__,
    print_map(type, ikev2_cert_map), len,
    ignore ? "ignored" : "ok");

if (ignore)
	break;

if (sh.sh_initiator)
	id = &sa->sa_icert;
else
	id = &sa->sa_rcert;

id->id_type = type;
id->id_offset = 0;
ibuf_free(id->id_buf);
id->id_buf = NULL((void *)0);

if (len <= 0 || (id->id_buf = ibuf_new(ptr, len)) == NULL((void *)0)) {
	log_debug("%s: failed to get cert payload",
	    __func__);
	break;
}

sa_stateflags(sa, IKED_REQ_CERT0x0001);

if (ikev2_ike_auth(env, sa) != 0)
	log_debug("%s: failed to send ike auth", __func__);
break;
case IMSG_SCERT:
if ((sa = ikev2_getimsgdata(env, imsg,
    &sh, &type, &ptr, &len)) == NULL((void *)0)) {
	log_debug("%s: invalid supplemental cert reply",
	    __func__);
	break;
}

if (sa->sa_stateflags & IKED_REQ_CERT0x0001 ||
    type == IKEV2_CERT_NONE0)
	ignore = 1;

log_debug("%s: supplemental cert type %s length %zu, %s",
    __func__,
    print_map(type, ikev2_cert_map), len,
    ignore ? "ignored" : "ok");

if (ignore)
	break;

for (i = 0; i < IKED_SCERT_MAX3; i++) {
	id = &sa->sa_scert[i];
	if (id->id_type == IKEV2_CERT_NONE0)
		break;
	id = NULL((void *)0);
}

if (id == NULL((void *)0)) {
	log_debug("%s: too many supplemental cert. ignored",
	    __func__);
	break;
}

id->id_type = type;
id->id_offset = 0;
ibuf_free(id->id_buf);
id->id_buf = NULL((void *)0);

if (len <= 0 || (id->id_buf = ibuf_new(ptr, len)) == NULL((void *)0)) {
	log_debug("%s: failed to get supplemental cert payload",
	    __func__);
	break;
}

break;
case IMSG_AUTH:
if ((sa = ikev2_getimsgdata(env, imsg,
    &sh, &type, &ptr, &len)) == NULL((void *)0)) {
	log_debug("%s: invalid auth reply", __func__);
	break;
}
if (sa_stateok(sa, IKEV2_STATE_VALID7)) {
	log_warnx("%s: ignoring AUTH in state %s",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
	    print_map(sa->sa_state, ikev2_state_map));
	break;
}

log_debug("%s: AUTH type %d len %zu", __func__, type, len);

id = &sa->sa_localauth;
id->id_type = type;
id->id_offset = 0;
ibuf_free(id->id_buf);
id->id_buf = NULL((void *)0);

if (type != IKEV2_AUTH_NONE0) {
	if (len <= 0 ||
	    (id->id_buf = ibuf_new(ptr, len)) == NULL((void *)0)) {
		log_debug("%s: failed to get auth payload",
		    __func__);
		break;
	}
}

sa_stateflags(sa, IKED_REQ_AUTH0x0008);

if (ikev2_ike_auth(env, sa) != 0)
	log_debug("%s: failed to send ike auth", __func__);
break;
default:
return (-1);
}

return (0);
505}

507int
508ikev2_dispatch_control(int fd, struct privsep_proc *p, struct imsg *imsg)
509{
struct iked		*env = iked_env;

switch (imsg->hdr.type) {
case IMSG_CTL_RESET_ID:
ikev2_ctl_reset_id(env, imsg, imsg->hdr.type);
break;
case IMSG_CTL_SHOW_SA:
ikev2_ctl_show_sa(env);
break;
case IMSG_CTL_SHOW_STATS:
ikev2_ctl_show_stats(env);
break;
default:
return (-1);
}

return (0);
527}

529/* try to delete established SA if no other exchange is active */
530int
531ikev2_ike_sa_delete(struct iked *env, struct iked_sa *sa)
532{
if (sa->sa_state != IKEV2_STATE_ESTABLISHED9)
return (-1);
if (sa->sa_stateflags & (IKED_REQ_CHILDSA0x0080|IKED_REQ_INF0x0100))
return (-1);
ikev2_disable_timer(env, sa);
ikev2_ike_sa_setreason(sa, "reset sa control message");
ikev2_ikesa_delete(env, sa, 1);
timer_add(env, &sa->sa_timer, 0);
return (0);
542}

544void
545ikev2_ctl_reset_id(struct iked *env, struct imsg *imsg, unsigned int type)
546{
struct iked_sa			*sa;
char				*reset_id = NULL((void *)0);
char				 sa_id[IKED_ID_SIZE1024];

if ((reset_id = get_string(imsg->data, IMSG_DATA_SIZE(imsg)((imsg)->hdr.len - sizeof(struct imsg_hdr)))) == NULL((void *)0))
return;

log_debug("%s: %s %d", __func__, reset_id, type);
RB_FOREACH(sa, iked_sas, &env->sc_sas)for ((sa) = iked_sas_RB_MINMAX(&env->sc_sas, -1); (sa)
 != ((void *)0); (sa) = iked_sas_RB_NEXT(sa)) {
if (ikev2_print_id(IKESA_DSTID(sa)((sa)->sa_hdr.sh_initiator ? &(sa)->sa_rid : &(
sa)->sa_iid), sa_id, sizeof(sa_id)) == -1)
	continue;
if (strcmp(reset_id, sa_id) != 0)
	continue;
if (sa->sa_state == IKEV2_STATE_CLOSED11)
	continue;
if (sa->sa_state == IKEV2_STATE_ESTABLISHED9)
	ikev2_disable_timer(env, sa);
log_info("%s: IKE SA %p id %s ispi %s rspi %s", __func__,
    sa, sa_id,
    print_spi(sa->sa_hdr.sh_ispi, 8),
    print_spi(sa->sa_hdr.sh_rspi, 8));
ikev2_ike_sa_setreason(sa, "reset control message");
ikev2_ikesa_delete(env, sa, 1);
/* default IKED_IKE_SA_DELETE_TIMEOUT is 120s, so switch to 6s */
timer_add(env, &sa->sa_timer, 3 * IKED_RETRANSMIT_TIMEOUT2);
}
free(reset_id);
574}

576void
577ikev2_ctl_show_sa(struct iked *env)
578{
ikev2_info(env, 0);
580}

582void
583ikev2_ctl_show_stats(struct iked *env)
584{
proc_compose(&env->sc_ps, PROC_CONTROL, IMSG_CTL_SHOW_STATS,
   &env->sc_stats, sizeof(env->sc_stats));
587}

589struct iked_sa *
590ikev2_getimsgdata(struct iked *env, struct imsg *imsg, struct iked_sahdr *sh,
  uint8_t *type, uint8_t **buf, size_t *size)
592{
uint8_t		*ptr;
size_t		 len;
struct iked_sa	*sa;

ptr = imsg->data;
len = IMSG_DATA_SIZE(imsg)((imsg)->hdr.len - sizeof(struct imsg_hdr));
if (len < sizeof(*sh))
fatalx("ikev2_getimsgdata: length too small for sh");
memcpy(sh, ptr, sizeof(*sh));
len -= sizeof(*sh);
ptr += sizeof(*sh);
if (len < sizeof(*type))
fatalx("ikev2_getimsgdata: length too small for type");
memcpy(type, ptr, sizeof(*type));
len -= sizeof(*type);
ptr += sizeof(*type);

sa = sa_lookup(env, sh->sh_ispi, sh->sh_rspi, sh->sh_initiator);

log_debug("%s: imsg %d rspi %s ispi %s initiator %d sa %s"
   " type %d data length %zd",
   __func__, imsg->hdr.type,
   print_spi(sh->sh_rspi, 8),
   print_spi(sh->sh_ispi, 8),
   sh->sh_initiator,
   sa == NULL((void *)0) ? "invalid" : "valid", *type, len);

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

*buf = ptr;
*size = len;

return (sa);
627}

629static time_t
630gettime(void)
631{
struct timeval tv;
gettimeofday(&tv, NULL((void *)0));
return tv.tv_sec;
635}

637void
638ikev2_recv(struct iked *env, struct iked_message *msg)
639{
struct ike_header	*hdr;
struct iked_sa		*sa;
struct iked_msg_retransmit *mr;
unsigned int		 initiator, flag = 0;
int			 r;

hdr = ibuf_seek(msg->msg_data, msg->msg_offset, sizeof(*hdr));

if (hdr == NULL((void *)0) || ibuf_size(msg->msg_data) <
   (betoh32(hdr->ike_length)(__uint32_t)(__builtin_constant_p(hdr->ike_length) ? (__uint32_t
)(((__uint32_t)(hdr->ike_length) & 0xff) << 24 |
 ((__uint32_t)(hdr->ike_length) & 0xff00) << 8 |
 ((__uint32_t)(hdr->ike_length) & 0xff0000) >> 8
 | ((__uint32_t)(hdr->ike_length) & 0xff000000) >>
 24) : __swap32md(hdr->ike_length)) - msg->msg_offset))
return;

ikestat_inc(env, ikes_msg_rcvd)do { env->sc_stats.ikes_msg_rcvd += (1); } while(0);

initiator = (hdr->ike_flags & IKEV2_FLAG_INITIATOR0x08) ? 0 : 1;
msg->msg_response = (hdr->ike_flags & IKEV2_FLAG_RESPONSE0x20) ? 1 : 0;
msg->msg_exchange = hdr->ike_exchange;
msg->msg_sa = sa_lookup(env,
   betoh64(hdr->ike_ispi)(__uint64_t)(__builtin_constant_p(hdr->ike_ispi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_ispi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_ispi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_ispi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_ispi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_ispi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_ispi)), betoh64(hdr->ike_rspi)(__uint64_t)(__builtin_constant_p(hdr->ike_rspi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_rspi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_rspi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_rspi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_rspi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_rspi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_rspi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_rspi)),
   initiator);
msg->msg_msgid = betoh32(hdr->ike_msgid)(__uint32_t)(__builtin_constant_p(hdr->ike_msgid) ? (__uint32_t
)(((__uint32_t)(hdr->ike_msgid) & 0xff) << 24 | (
(__uint32_t)(hdr->ike_msgid) & 0xff00) << 8 | ((
__uint32_t)(hdr->ike_msgid) & 0xff0000) >> 8 | (
(__uint32_t)(hdr->ike_msgid) & 0xff000000) >> 24
) : __swap32md(hdr->ike_msgid));
if (policy_lookup(env, msg, NULL((void *)0), NULL((void *)0), 0) != 0) {
ikestat_inc(env, ikes_msg_rcvd_dropped)do { env->sc_stats.ikes_msg_rcvd_dropped += (1); } while(0
);
return;
}

logit(hdr->ike_exchange == IKEV2_EXCHANGE_INFORMATIONAL37 ?
   LOG_DEBUG7 : LOG_INFO6,
   "%srecv %s %s %u peer %s local %s, %zu bytes, policy '%s'",
   SPI_IH(hdr)ikev2_ikesa_info((__uint64_t)(__builtin_constant_p((hdr)->
ike_ispi) ? (__uint64_t)((((__uint64_t)((hdr)->ike_ispi) &
 0xff) << 56) | ((__uint64_t)((hdr)->ike_ispi) &
 0xff00ULL) << 40 | ((__uint64_t)((hdr)->ike_ispi) &
 0xff0000ULL) << 24 | ((__uint64_t)((hdr)->ike_ispi)
 & 0xff000000ULL) << 8 | ((__uint64_t)((hdr)->ike_ispi
) & 0xff00000000ULL) >> 8 | ((__uint64_t)((hdr)->
ike_ispi) & 0xff0000000000ULL) >> 24 | ((__uint64_t
)((hdr)->ike_ispi) & 0xff000000000000ULL) >> 40 |
 ((__uint64_t)((hdr)->ike_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md((hdr)->ike_ispi)), ((void *)0)
),
   print_map(hdr->ike_exchange, ikev2_exchange_map),
   msg->msg_response ? "res" : "req",
   msg->msg_msgid,
   print_addr(&msg->msg_peer),
   print_addr(&msg->msg_local),
   ibuf_size(msg->msg_data),
   msg->msg_policy->pol_name);
log_debug("%s: ispi %s rspi %s", __func__,
   print_spi(betoh64(hdr->ike_ispi)(__uint64_t)(__builtin_constant_p(hdr->ike_ispi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_ispi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_ispi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_ispi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_ispi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_ispi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_ispi)), 8),
   print_spi(betoh64(hdr->ike_rspi)(__uint64_t)(__builtin_constant_p(hdr->ike_rspi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_rspi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_rspi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_rspi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_rspi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_rspi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_rspi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_rspi)), 8));

if ((sa = msg->msg_sa) == NULL((void *)0))
goto done;

sa->sa_last_recvd = gettime();

if (hdr->ike_exchange == IKEV2_EXCHANGE_CREATE_CHILD_SA36)
flag = IKED_REQ_CHILDSA0x0080;
if (hdr->ike_exchange == IKEV2_EXCHANGE_INFORMATIONAL37)
flag = IKED_REQ_INF0x0100;

if (hdr->ike_exchange != IKEV2_EXCHANGE_IKE_SA_INIT34 &&
   hdr->ike_nextpayload != IKEV2_PAYLOAD_SK46 &&
   hdr->ike_nextpayload != IKEV2_PAYLOAD_SKF53) {
ikestat_inc(env, ikes_msg_rcvd_dropped)do { env->sc_stats.ikes_msg_rcvd_dropped += (1); } while(0
);
return;
}

if (msg->msg_response) {
if (msg->msg_msgid > sa->sa_reqid) {
	ikestat_inc(env, ikes_msg_rcvd_dropped)do { env->sc_stats.ikes_msg_rcvd_dropped += (1); } while(0
);
	return;
}
mr = ikev2_msg_lookup(env, &sa->sa_requests, msg,
    hdr->ike_exchange);
if (hdr->ike_exchange != IKEV2_EXCHANGE_INFORMATIONAL37 &&
    mr == NULL((void *)0) && sa->sa_fragments.frag_count == 0) {
	ikestat_inc(env, ikes_msg_rcvd_dropped)do { env->sc_stats.ikes_msg_rcvd_dropped += (1); } while(0
);
	return;
}
if (flag) {
	if ((sa->sa_stateflags & flag) == 0) {
		ikestat_inc(env, ikes_msg_rcvd_dropped)do { env->sc_stats.ikes_msg_rcvd_dropped += (1); } while(0
);
		return;
	}
	/*
	 * We have initiated this exchange, even if
	 * we are not the initiator of the IKE SA.
	 */
	initiator = 1;
}
/*
 * There's no need to keep the request (fragments) around
 */
if (mr != NULL((void *)0) && hdr->ike_nextpayload != IKEV2_PAYLOAD_SKF53)
	ikev2_msg_dispose(env, &sa->sa_requests, mr);
} else {
/*
 * IKE_SA_INIT is special since it always uses the message id 0.
 * Even when the message was rejected, and the new message has
 * different proposals, the id will be the same.  To discern
 * retransmits and new messages, the RFC suggests to compare the
 * the messages.
 */
if (sa->sa_state == IKEV2_STATE_CLOSED11 && sa->sa_1stmsg &&
    hdr->ike_exchange == IKEV2_EXCHANGE_IKE_SA_INIT34 &&
    msg->msg_msgid == 0 &&
    (ibuf_size(msg->msg_data) != ibuf_size(sa->sa_1stmsg) ||
    memcmp(ibuf_data(msg->msg_data), ibuf_data(sa->sa_1stmsg),
    ibuf_size(sa->sa_1stmsg)) != 0)) {
	ikev2_ike_sa_setreason(sa, NULL((void *)0));
	sa_free(env, sa);
	msg->msg_sa = sa = NULL((void *)0);
	goto done;
}
if (msg->msg_msgid < sa->sa_msgid) {
	ikestat_inc(env, ikes_msg_rcvd_dropped)do { env->sc_stats.ikes_msg_rcvd_dropped += (1); } while(0
);
	return;
}
if (flag)
	initiator = 0;
/*
 * See if we have responded to this request before
 * For return values 0 and -1 we have.
 */
if ((r = ikev2_msg_retransmit_response(env, sa, msg,
    hdr->ike_exchange)) != -2) {
	if (r == -1) {
		log_warn("%s: failed to retransmit a "
		    "response", __func__);
		ikev2_ike_sa_setreason(sa,
		    "retransmitting response failed");
		sa_free(env, sa);
	}
	return;
} else if (sa->sa_msgid_set && msg->msg_msgid == sa->sa_msgid) {
	/*
	 * Response is being worked on, most likely we're
	 * waiting for the CA process to get back to us
	 */
	ikestat_inc(env, ikes_msg_rcvd_busy)do { env->sc_stats.ikes_msg_rcvd_busy += (1); } while(0);
	return;
}
sa->sa_msgid_current = msg->msg_msgid;
}

if (sa_address(sa, &sa->sa_peer, (struct sockaddr *)&msg->msg_peer)
   == -1 ||
   sa_address(sa, &sa->sa_local, (struct sockaddr *)&msg->msg_local)
   == -1) {
ikestat_inc(env, ikes_msg_rcvd_dropped)do { env->sc_stats.ikes_msg_rcvd_dropped += (1); } while(0
);
return;
}

sa->sa_fd = msg->msg_fd;

log_debug("%s: updated SA to peer %s local %s", __func__,
   print_addr(&sa->sa_peer.addr), print_addr(&sa->sa_local.addr));

789done:
if (initiator)
ikev2_init_recv(env, msg, hdr);
else
ikev2_resp_recv(env, msg, hdr);

if (sa != NULL((void *)0) && !msg->msg_response && msg->msg_valid) {
/*
 * If it's a valid request, make sure to update the peer's
 * message ID and dispose of all previous responses.
 * We need to set sa_msgid_set in order to distinguish between
 * "last msgid was 0" and "msgid not set yet".
 */
sa->sa_msgid = sa->sa_msgid_current;
sa->sa_msgid_set = 1;
ikev2_msg_prevail(env, &sa->sa_responses, msg);
}

if (sa != NULL((void *)0) && sa->sa_state == IKEV2_STATE_CLOSED11) {
log_debug("%s: closing SA", __func__);
ikev2_ike_sa_setreason(sa, "closed");
sa_free(env, sa);
}
812}

814int
815ikev2_ike_auth_compatible(struct iked_sa *sa, uint8_t policy, uint8_t wire)
816{
if (wire == IKEV2_AUTH_SIG_ANY255)		/* internal, not on wire */
return (-1);
if (policy == wire || policy == IKEV2_AUTH_NONE0)
return (0);
switch (policy) {
case IKEV2_AUTH_SIG_ANY255:
switch (wire) {
case IKEV2_AUTH_SIG14:
case IKEV2_AUTH_RSA_SIG1:
case IKEV2_AUTH_ECDSA_2569:
case IKEV2_AUTH_ECDSA_38410:
case IKEV2_AUTH_ECDSA_52111:
	return (0);
}
break;
case IKEV2_AUTH_SIG14:
case IKEV2_AUTH_RSA_SIG1:
case IKEV2_AUTH_ECDSA_2569:
case IKEV2_AUTH_ECDSA_38410:
case IKEV2_AUTH_ECDSA_52111:
switch (wire) {
/*
 * XXX Maybe we need an indication saying:
 * XXX Accept AUTH_SIG as long as its DSA?
 */
case IKEV2_AUTH_SIG14:
	if (sa->sa_sigsha2)
		return (0);
}
break;
}
return (-1);
849}

851int
852ikev2_auth_verify(struct iked *env, struct iked_sa *sa)
853{
struct iked_auth	 ikeauth;
struct ibuf		*authmsg;
int			 ret;

memcpy(&ikeauth, &sa->sa_policy->pol_auth,
   sizeof(ikeauth));

if (sa->sa_policy->pol_auth.auth_eap &&
   sa->sa_eapmsk != NULL((void *)0)) {
/*
 * The initiator EAP auth is a PSK derived
 * from the EAP-specific MSK
 */
ikeauth.auth_method = IKEV2_AUTH_SHARED_KEY_MIC2;

/* Copy session key as PSK */
memcpy(ikeauth.auth_data,
    ibuf_data(sa->sa_eapmsk),
    ibuf_size(sa->sa_eapmsk));
ikeauth.auth_length = ibuf_size(sa->sa_eapmsk);
}

if (ikev2_ike_auth_compatible(sa,
   ikeauth.auth_method, sa->sa_peerauth.id_type) < 0) {
log_warnx("%s: unexpected auth method %s, was "
    "expecting %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    print_map(sa->sa_peerauth.id_type,
    ikev2_auth_map),
    print_map(ikeauth.auth_method,
    ikev2_auth_map));
ikev2_send_auth_failed(env, sa);
explicit_bzero(&ikeauth, sizeof(ikeauth));
return (-1);
}
ikeauth.auth_method = sa->sa_peerauth.id_type;

if ((authmsg = ikev2_msg_auth(env, sa,
   sa->sa_hdr.sh_initiator)) == NULL((void *)0)) {
log_debug("%s: failed to get auth data",
    __func__);
ikev2_send_auth_failed(env, sa);
explicit_bzero(&ikeauth, sizeof(ikeauth));
return (-1);
}

ret = ikev2_msg_authverify(env, sa, &ikeauth,
   ibuf_data(sa->sa_peerauth.id_buf),
   ibuf_size(sa->sa_peerauth.id_buf),
   authmsg);
ibuf_free(authmsg);
if (ret != 0) {
log_info("%s: ikev2_msg_authverify failed",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
ikev2_send_auth_failed(env, sa);
explicit_bzero(&ikeauth, sizeof(ikeauth));
return (-1);
}
if (sa->sa_eapmsk != NULL((void *)0)) {
if ((authmsg = ikev2_msg_auth(env, sa,
    !sa->sa_hdr.sh_initiator)) == NULL((void *)0)) {
	log_debug("%s: failed to get auth data",
	    __func__);
	explicit_bzero(&ikeauth, sizeof(ikeauth));
	return (-1);
}

/* XXX 2nd AUTH for EAP messages */
ret = ikev2_msg_authsign(env, sa, &ikeauth, authmsg);
ibuf_free(authmsg);
if (ret != 0) {
	ikev2_send_auth_failed(env, sa);
	explicit_bzero(&ikeauth, sizeof(ikeauth));
	return (-1);
}

/* ikev2_msg_authverify verified AUTH */
sa_stateflags(sa, IKED_REQ_AUTHVALID0x0010);
sa_stateflags(sa, IKED_REQ_EAPVALID0x0040);
sa_state(env, sa, IKEV2_STATE_EAP_SUCCESS4);
}

explicit_bzero(&ikeauth, sizeof(ikeauth));
return (0);
937}

939int
940ikev2_ike_auth_recv(struct iked *env, struct iked_sa *sa,
  struct iked_message *msg)
942{
struct iked_id		*id;
struct ibuf		*authmsg, *buf;
struct iked_policy	*old;
uint8_t			*cert = NULL((void *)0);
size_t			 certlen = 0;
int			 certtype = IKEV2_CERT_NONE0;
int			 i;

/* The AUTH payload indicates if the responder wants EAP or not */
if (msg->msg_auth.id_type != IKEV2_AUTH_NONE0 &&
   !sa_stateok(sa, IKEV2_STATE_EAP3))
sa_state(env, sa, IKEV2_STATE_AUTH_REQUEST5);

if (!sa->sa_hdr.sh_initiator &&
   !sa_stateok(sa, IKEV2_STATE_AUTH_REQUEST5) &&
   sa->sa_policy->pol_auth.auth_eap)
sa_state(env, sa, IKEV2_STATE_EAP3);

if (sa->sa_hdr.sh_initiator)
id = &sa->sa_rid;
else
id = &sa->sa_iid;

/* try to relookup the policy based on the peerid */
if (msg->msg_peerid.id_type && !sa->sa_hdr.sh_initiator) {
old = sa->sa_policy;

sa->sa_policy = NULL((void *)0);
if (policy_lookup(env, msg, &sa->sa_proposals, NULL((void *)0), 0) != 0 ||
    msg->msg_policy == NULL((void *)0)) {
	log_info("%s: no compatible policy found",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	ikev2_send_auth_failed(env, sa);
	TAILQ_REMOVE(&old->pol_sapeers, sa, sa_peer_entry)do { if (((sa)->sa_peer_entry.tqe_next) != ((void *)0)) (sa
)->sa_peer_entry.tqe_next->sa_peer_entry.tqe_prev = (sa
)->sa_peer_entry.tqe_prev; else (&old->pol_sapeers)
->tqh_last = (sa)->sa_peer_entry.tqe_prev; *(sa)->sa_peer_entry
.tqe_prev = (sa)->sa_peer_entry.tqe_next; ; ; } while (0);
	policy_unref(env, old);
	return (-1);
}
if (msg->msg_policy != old) {
	/* Clean up old policy */
	TAILQ_REMOVE(&old->pol_sapeers, sa, sa_peer_entry)do { if (((sa)->sa_peer_entry.tqe_next) != ((void *)0)) (sa
)->sa_peer_entry.tqe_next->sa_peer_entry.tqe_prev = (sa
)->sa_peer_entry.tqe_prev; else (&old->pol_sapeers)
->tqh_last = (sa)->sa_peer_entry.tqe_prev; *(sa)->sa_peer_entry
.tqe_prev = (sa)->sa_peer_entry.tqe_next; ; ; } while (0);
	policy_unref(env, old);

	/* Update SA with new policy*/
	if (sa_new(env, sa->sa_hdr.sh_ispi,
	    sa->sa_hdr.sh_rspi, 0, msg->msg_policy) != sa) {
		log_warnx("%s: failed to update SA",
		    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
		ikev2_send_auth_failed(env, sa);
		return (-1);
	}
} else {
	/* restore */
	msg->msg_policy = sa->sa_policy = old;
}
if (ikev2_handle_certreq(env, msg) != 0)
	return (-1);
} else if (sa->sa_hdr.sh_initiator) {
old = sa->sa_policy;

/* verify policy on initiator */
sa->sa_policy = NULL((void *)0);
if (policy_lookup(env, msg, &sa->sa_proposals, &old->pol_flows,
    old->pol_nflows) != 0 || msg->msg_policy != old) {

	/* get dstid */
	if (msg->msg_peerid.id_type) {
		memcpy(id, &msg->msg_peerid, sizeof(*id));
		bzero(&msg->msg_peerid, sizeof(msg->msg_peerid));
	}
	log_warnx("%s: policy mismatch", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	ikev2_send_auth_failed(env, sa);
	TAILQ_REMOVE(&old->pol_sapeers, sa, sa_peer_entry)do { if (((sa)->sa_peer_entry.tqe_next) != ((void *)0)) (sa
)->sa_peer_entry.tqe_next->sa_peer_entry.tqe_prev = (sa
)->sa_peer_entry.tqe_prev; else (&old->pol_sapeers)
->tqh_last = (sa)->sa_peer_entry.tqe_prev; *(sa)->sa_peer_entry
.tqe_prev = (sa)->sa_peer_entry.tqe_next; ; ; } while (0);
	policy_unref(env, old);
	return (-1);
}
/* restore */
msg->msg_policy = sa->sa_policy = old;
}

/* AUTH payload is required for non-EAP */
if (!msg->msg_auth.id_type &&
   !sa->sa_policy->pol_auth.auth_eap) {
/* get dstid */
if (msg->msg_peerid.id_type) {
	memcpy(id, &msg->msg_peerid, sizeof(*id));
	bzero(&msg->msg_peerid, sizeof(msg->msg_peerid));
}
log_debug("%s: missing auth payload", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
ikev2_send_auth_failed(env, sa);
return (-1);
}

if (msg->msg_peerid.id_type) {
memcpy(id, &msg->msg_peerid, sizeof(*id));
bzero(&msg->msg_peerid, sizeof(msg->msg_peerid));

if (!sa->sa_hdr.sh_initiator) {
	if ((authmsg = ikev2_msg_auth(env, sa,
	    !sa->sa_hdr.sh_initiator)) == NULL((void *)0)) {
		log_debug("%s: failed to get response "
		    "auth data", __func__);
		return (-1);
	}

	ca_setauth(env, sa, authmsg, PROC_CERT);
	ibuf_free(authmsg);
}
}

/* Encode all received certs as single blob */
if (msg->msg_cert.id_type != IKEV2_CERT_BUNDLE254 &&
   msg->msg_scert[0].id_type != IKEV2_CERT_NONE0) {
if ((buf = ibuf_new(NULL((void *)0), 0)) == NULL((void *)0))
	return (-1);
/* begin with certificate */
if (ca_certbundle_add(buf, &msg->msg_cert) != 0) {
	ibuf_free(buf);
	return (-1);
}
/* add intermediate CAs */
for (i = 0; i < IKED_SCERT_MAX3; i++) {
	if (msg->msg_scert[i].id_type == IKEV2_CERT_NONE0)
		break;
	if (ca_certbundle_add(buf, &msg->msg_scert[i]) != 0) {
		ibuf_free(buf);
		return (-1);
	}
}
ibuf_free(msg->msg_cert.id_buf);
msg->msg_cert.id_buf = buf;
msg->msg_cert.id_type = IKEV2_CERT_BUNDLE254;
}

if (!TAILQ_EMPTY(&msg->msg_proposals)(((&msg->msg_proposals)->tqh_first) == ((void *)0))) {
if (proposals_negotiate(&sa->sa_proposals,
    &sa->sa_policy->pol_proposals, &msg->msg_proposals,
    0, -1) != 0) {
	log_info("%s: no proposal chosen", __func__);
	msg->msg_error = IKEV2_N_NO_PROPOSAL_CHOSEN14;
	ikestat_inc(env, ikes_sa_proposals_negotiate_failures)do { env->sc_stats.ikes_sa_proposals_negotiate_failures +=
 (1); } while(0);
	return (-1);
} else
	sa_stateflags(sa, IKED_REQ_SA0x0020);
}

if (msg->msg_auth.id_type) {
memcpy(&sa->sa_peerauth, &msg->msg_auth, sizeof(sa->sa_peerauth));
bzero(&msg->msg_auth, sizeof(msg->msg_auth));
}

if (msg->msg_cp) {
if (msg->msg_cp_addr) {
	sa->sa_cp_addr = msg->msg_cp_addr;
	msg->msg_cp_addr = NULL((void *)0);
}
if (msg->msg_cp_addr6) {
	sa->sa_cp_addr6 = msg->msg_cp_addr6;
	msg->msg_cp_addr6 = NULL((void *)0);
}
if (msg->msg_cp_dns) {
	sa->sa_cp_dns = msg->msg_cp_dns;
	msg->msg_cp_dns = NULL((void *)0);
}
sa->sa_cp = msg->msg_cp;
}

/* For EAP and PSK AUTH can be verified without the CA process*/
if ((sa->sa_policy->pol_auth.auth_eap &&
   sa->sa_eapmsk != NULL((void *)0)) ||
   sa->sa_policy->pol_auth.auth_method == IKEV2_AUTH_SHARED_KEY_MIC2)
ikev2_auth_verify(env, sa);
/* For CERT and Pubkey AUTH the CA process must find a matching key */
else if (sa->sa_peerauth.id_type) {
if (msg->msg_cert.id_type) {
	certtype = msg->msg_cert.id_type;
	cert = ibuf_data(msg->msg_cert.id_buf);
	certlen = ibuf_size(msg->msg_cert.id_buf);
}
sa->sa_stateflags &= ~IKED_REQ_CERTVALID0x0002;
if (ca_setcert(env, &sa->sa_hdr, id, certtype, cert, certlen, PROC_CERT) == -1)
	return (-1);
}

if (sa->sa_cp == IKEV2_CP_REPLY2) {
if (sa->sa_cp_addr)
	log_info("%s: obtained lease: %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
	    print_addr(&sa->sa_cp_addr->addr));
if (sa->sa_cp_addr6)
	log_info("%s: obtained lease: %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
	    print_addr(&sa->sa_cp_addr6->addr));
if (sa->sa_cp_dns)
	log_info("%s: obtained DNS: %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
	    print_addr(&sa->sa_cp_dns->addr));
}

return ikev2_ike_auth(env, sa);
1139}

1141int
1142ikev2_ike_auth(struct iked *env, struct iked_sa *sa)
1143{
/* Attempt state transition */
if (sa->sa_state == IKEV2_STATE_EAP_SUCCESS4)
sa_state(env, sa, IKEV2_STATE_EAP_VALID8);
else if (sa->sa_state == IKEV2_STATE_AUTH_SUCCESS6)
sa_state(env, sa, IKEV2_STATE_VALID7);

if (sa->sa_hdr.sh_initiator) {
if (sa_stateok(sa, IKEV2_STATE_AUTH_SUCCESS6))
	return (ikev2_init_done(env, sa));
/* AUTH exchange is awaiting response from CA process, ignore */
else if (sa_stateok(sa, IKEV2_STATE_AUTH_REQUEST5))
	return (0);
else
	return (ikev2_init_ike_auth(env, sa));
}
return (ikev2_resp_ike_auth(env, sa));
1160}

1162void
1163ikev2_init_recv(struct iked *env, struct iked_message *msg,
  struct ike_header *hdr)
1165{
struct iked_sa		*sa;
struct iked_policy	*pol;

if (ikev2_msg_valid_ike_sa(env, hdr, msg) == -1) {
log_debug("%s: unknown SA", __func__);
return;
}
sa = msg->msg_sa;

switch (hdr->ike_exchange) {
case IKEV2_EXCHANGE_IKE_SA_INIT34:
/* Update the SPIs */
if ((sa = sa_new(env,
    betoh64(hdr->ike_ispi)(__uint64_t)(__builtin_constant_p(hdr->ike_ispi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_ispi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_ispi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_ispi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_ispi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_ispi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_ispi)), betoh64(hdr->ike_rspi)(__uint64_t)(__builtin_constant_p(hdr->ike_rspi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_rspi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_rspi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_rspi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_rspi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_rspi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_rspi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_rspi)), 1,
    NULL((void *)0))) == NULL((void *)0) || sa != msg->msg_sa) {
	log_debug("%s: invalid new SA", __func__);
	if (sa) {
		ikev2_ike_sa_setreason(sa, "invalid new SA");
		sa_free(env, sa);
	}
	return;
}
break;
case IKEV2_EXCHANGE_IKE_AUTH35:
case IKEV2_EXCHANGE_CREATE_CHILD_SA36:
case IKEV2_EXCHANGE_INFORMATIONAL37:
break;
default:
log_debug("%s: unsupported exchange: %s", __func__,
    print_map(hdr->ike_exchange, ikev2_exchange_map));
return;
}

if (ikev2_pld_parse(env, hdr, msg, msg->msg_offset) != 0) {
log_debug("%s: failed to parse message", __func__);
return;
}

if (sa->sa_fragments.frag_count != 0)
return;

if (!ikev2_msg_frompeer(msg))
return;

if (ikev2_handle_notifies(env, msg) != 0)
return;

if (msg->msg_nat_detected && sa->sa_natt == 0)
ikev2_enable_natt(env, sa, msg, 1);

switch (hdr->ike_exchange) {
case IKEV2_EXCHANGE_IKE_SA_INIT34:
if (ibuf_length(msg->msg_cookie)) {
	pol = sa->sa_policy;
	if (ikev2_init_ike_sa_peer(env, pol,
	    &pol->pol_peer, msg) != 0)
		log_warnx("%s: failed to initiate a "
		    "IKE_SA_INIT exchange", SPI_SA(sa,ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
)))
		    __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	break;
}
if (msg->msg_flags & IKED_MSG_FLAGS_NO_PROPOSAL_CHOSEN0x0400) {
	log_info("%s: failed to negotiate IKE SA",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	ikev2_ike_sa_setreason(sa, "no proposal chosen");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	msg->msg_sa = NULL((void *)0);
	return;
}
if (ikev2_handle_certreq(env, msg) != 0)
	return;

if (ikev2_init_auth(env, msg) != 0) {
	ikev2_ike_sa_setreason(sa,
	    "failed to initiate IKE_AUTH exchange");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	msg->msg_sa = NULL((void *)0);
	return;
}
break;
case IKEV2_EXCHANGE_IKE_AUTH35:
if (msg->msg_flags & IKED_MSG_FLAGS_AUTHENTICATION_FAILED0x0020) {
	log_debug("%s: AUTHENTICATION_FAILED, closing SA",
	    __func__);
	ikev2_log_cert_info(SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
	    sa->sa_hdr.sh_initiator ? &sa->sa_rcert
	    : &sa->sa_icert);
	ikev2_ike_sa_setreason(sa,
	    "authentication failed notification from peer");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	msg->msg_sa = NULL((void *)0);
	return;
}
if (msg->msg_flags & IKED_MSG_FLAGS_NO_PROPOSAL_CHOSEN0x0400) {
	log_info("%s: failed to negotiate IKE SA",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	ikev2_ike_sa_setreason(sa, "no proposal chosen (IKE SA)");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	msg->msg_sa = NULL((void *)0);
	return;
}

(void)ikev2_ike_auth_recv(env, sa, msg);
break;
case IKEV2_EXCHANGE_CREATE_CHILD_SA36:
if (msg->msg_flags & IKED_MSG_FLAGS_NO_PROPOSAL_CHOSEN0x0400) {
	log_info("%s: CREATE_CHILD_SA failed",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	ikev2_ike_sa_setreason(sa, "no proposal chosen (CHILD SA)");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	msg->msg_sa = NULL((void *)0);
	return;
}
(void)ikev2_init_create_child_sa(env, msg);
break;
case IKEV2_EXCHANGE_INFORMATIONAL37:
sa->sa_stateflags &= ~IKED_REQ_INF0x0100;
break;
default:
log_debug("%s: exchange %s not implemented", __func__,
    print_map(hdr->ike_exchange, ikev2_exchange_map));
break;
}
1289}

1291void
1292ikev2_enable_natt(struct iked *env, struct iked_sa *sa,
  struct iked_message *msg, int udpencap)
1294{
struct iked_socket	*sock;
in_port_t		 port;

sock = ikev2_msg_getsocket(env, sa->sa_local.addr_af, 1);
if (sock == NULL((void *)0))
return;

/*
* Update address information and use the NAT-T
* port and socket, if available.
*/
port = htons(socket_getport((__uint16_t)(__builtin_constant_p(socket_getport( (struct sockaddr
 *)&sock->sock_addr)) ? (__uint16_t)(((__uint16_t)(socket_getport
( (struct sockaddr *)&sock->sock_addr)) & 0xffU) <<
| ((__uint16_t)(socket_getport( (struct sockaddr *)&sock
->sock_addr)) & 0xff00U) >> 8) : __swap16md(socket_getport
( (struct sockaddr *)&sock->sock_addr)))
   (struct sockaddr *)&sock->sock_addr))(__uint16_t)(__builtin_constant_p(socket_getport( (struct sockaddr
 *)&sock->sock_addr)) ? (__uint16_t)(((__uint16_t)(socket_getport
( (struct sockaddr *)&sock->sock_addr)) & 0xffU) <<
| ((__uint16_t)(socket_getport( (struct sockaddr *)&sock
->sock_addr)) & 0xff00U) >> 8) : __swap16md(socket_getport
( (struct sockaddr *)&sock->sock_addr)));
sa->sa_local.addr_port = port;
sa->sa_peer.addr_port = port;
(void)socket_af((struct sockaddr *)&sa->sa_local.addr, port);
(void)socket_af((struct sockaddr *)&sa->sa_peer.addr, port);

msg->msg_fd = sa->sa_fd = sock->sock_fd;
msg->msg_sock = sock;
sa->sa_natt = 1;
if (udpencap)
sa->sa_udpencap = 1;

log_debug("%s: detected NAT, enabling UDP encapsulation,"
   " updated SA to peer %s local %s", __func__,
   print_addr(&sa->sa_peer.addr), print_addr(&sa->sa_local.addr));
1322}

1324void
1325ikev2_init_ike_sa(struct iked *env, void *arg)
1326{
struct iked_policy	*pol;

TAILQ_FOREACH(pol, &env->sc_policies, pol_entry)for((pol) = ((&env->sc_policies)->tqh_first); (pol)
 != ((void *)0); (pol) = ((pol)->pol_entry.tqe_next)) {
if ((pol->pol_flags & IKED_POLICY_ACTIVE0x02) == 0)
	continue;
if (!TAILQ_EMPTY(&pol->pol_sapeers)(((&pol->pol_sapeers)->tqh_first) == ((void *)0))) {
	log_debug("%s: \"%s\" is already active",
	    __func__, pol->pol_name);
	continue;
}

log_info("%s: initiating \"%s\"", __func__, pol->pol_name);

if (ikev2_init_ike_sa_peer(env, pol, &pol->pol_peer, NULL((void *)0)))
	log_debug("%s: failed to initiate with peer %s",
	    __func__, print_addr(&pol->pol_peer.addr));
}

timer_set(env, &env->sc_inittmr, ikev2_init_ike_sa, NULL((void *)0));
timer_add(env, &env->sc_inittmr, IKED_INITIATOR_INTERVAL60);
1347}

1349void
1350ikev2_init_ike_sa_timeout(struct iked *env, void *arg)
1351{
struct iked_sa	 *sa = arg;

log_debug("%s: ispi %s rspi %s", __func__,
   print_spi(sa->sa_hdr.sh_ispi, 8),
   print_spi(sa->sa_hdr.sh_rspi, 8));

ikev2_ike_sa_setreason(sa, "SA_INIT timeout");
sa_free(env, sa);
1360}

1362int
1363ikev2_init_ike_sa_peer(struct iked *env, struct iked_policy *pol,
  struct iked_addr *peer, struct iked_message *retry)
1365{
struct sockaddr_storage		 ss;
struct iked_message		 req;
struct ike_header		*hdr;
struct ikev2_payload		*pld;
struct ikev2_keyexchange	*ke;
struct ikev2_notify		*n;
struct iked_sa			*sa = NULL((void *)0);
struct ibuf			*buf, *cookie = NULL((void *)0), *vendor_id = NULL((void *)0);
struct dh_group			*group;
ssize_t				 len;
int				 ret = -1;
struct iked_socket		*sock;
in_port_t			 port;

if ((sock = ikev2_msg_getsocket(env, peer->addr_af, 0)) == NULL((void *)0))
return (-1);

if (retry != NULL((void *)0)) {
sa = retry->msg_sa;
cookie = retry->msg_cookie;
sa_state(env, sa, IKEV2_STATE_INIT0);
}

/* Create a new initiator SA */
if (sa == NULL((void *)0) &&
   (sa = sa_new(env, 0, 0, 1, pol)) == NULL((void *)0))
return (-1);

/* Pick peer's DH group if asked */
if (pol->pol_peerdh > 0 && sa->sa_dhgroupsa_kex.kex_dhgroup == NULL((void *)0) &&
   (sa->sa_dhgroupsa_kex.kex_dhgroup = group_get(pol->pol_peerdh)) == NULL((void *)0)) {
log_warnx("%s: invalid peer DH group %u", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    pol->pol_peerdh);
goto closeonly;
}
sa->sa_reqid = 0;

if (ikev2_sa_initiator(env, sa, NULL((void *)0), NULL((void *)0)) == -1)
goto closeonly;

if (pol->pol_local.addr.ss_family == AF_UNSPEC0) {
if (socket_getaddr(sock->sock_fd, &ss) == -1)
	goto closeonly;
} else
memcpy(&ss, &pol->pol_local.addr, pol->pol_local.addr.ss_len);

if ((buf = ikev2_msg_init(env, &req, &peer->addr, peer->addr.ss_len,
   &ss, ss.ss_len, 0)) == NULL((void *)0))
goto done;

/* Inherit the port from the 1st send socket */
port = htons(socket_getport((struct sockaddr *)&sock->sock_addr))(__uint16_t)(__builtin_constant_p(socket_getport((struct sockaddr
 *)&sock->sock_addr)) ? (__uint16_t)(((__uint16_t)(socket_getport
((struct sockaddr *)&sock->sock_addr)) & 0xffU) <<
| ((__uint16_t)(socket_getport((struct sockaddr *)&sock
->sock_addr)) & 0xff00U) >> 8) : __swap16md(socket_getport
((struct sockaddr *)&sock->sock_addr)));
(void)socket_af((struct sockaddr *)&req.msg_local, port);
(void)socket_af((struct sockaddr *)&req.msg_peer, port);

req.msg_fd = sock->sock_fd;
req.msg_sa = sa;
req.msg_sock = sock;
req.msg_msgid = ikev2_msg_id(env, sa);

/* IKE header */
if ((hdr = ikev2_add_header(buf, sa, req.msg_msgid,
   cookie == NULL((void *)0) ? IKEV2_PAYLOAD_SA33 : IKEV2_PAYLOAD_NOTIFY41,
   IKEV2_EXCHANGE_IKE_SA_INIT34, 0)) == NULL((void *)0))
goto done;

/* Reflect COOKIE */
if (cookie) {
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
	goto done;
if ((n = ibuf_reserve(buf, sizeof(*n))) == NULL((void *)0))
	goto done;
n->n_protoid = IKEV2_SAPROTO_NONE0;
n->n_spisize = 0;
n->n_type = htobe16(IKEV2_N_COOKIE)(__uint16_t)(__builtin_constant_p(16390) ? (__uint16_t)(((__uint16_t
)(16390) & 0xffU) << 8 | ((__uint16_t)(16390) &
 0xff00U) >> 8) : __swap16md(16390));
if (ikev2_add_buf(buf, cookie) == -1)
	goto done;
len = sizeof(*n) + ibuf_size(cookie);

log_debug("%s: added cookie, len %zu", __func__,
    ibuf_size(cookie));
print_hexbuf(cookie);

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_SA33) == -1)
	goto done;
}

/* SA payload */
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
goto done;
if ((len = ikev2_add_proposals(env, sa, buf, &pol->pol_proposals,
   IKEV2_SAPROTO_IKE1, sa->sa_hdr.sh_initiator, 0, 0)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_KE34) == -1)
goto done;

/* KE payload */
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
goto done;
if ((ke = ibuf_reserve(buf, sizeof(*ke))) == NULL((void *)0))
goto done;
if ((group = sa->sa_dhgroupsa_kex.kex_dhgroup) == NULL((void *)0)) {
log_debug("%s: invalid dh", __func__);
goto done;
}
ke->kex_dhgroup = htobe16(group->id)(__uint16_t)(__builtin_constant_p(group->id) ? (__uint16_t
)(((__uint16_t)(group->id) & 0xffU) << 8 | ((__uint16_t
)(group->id) & 0xff00U) >> 8) : __swap16md(group
->id));
if (ikev2_add_buf(buf, sa->sa_dhiexchangesa_kex.kex_dhiexchange) == -1)
goto done;
len = sizeof(*ke) + ibuf_size(sa->sa_dhiexchangesa_kex.kex_dhiexchange);

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONCE40) == -1)
goto done;

/* NONCE payload */
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
goto done;
if (ikev2_add_buf(buf, sa->sa_inoncesa_kex.kex_inonce) == -1)
goto done;
len = ibuf_size(sa->sa_inoncesa_kex.kex_inonce);

if (env->sc_vendoridsc_static.st_vendorid != 0) {
vendor_id = ibuf_new(IKED_VENDOR_ID"OpenIKED-", strlen(IKED_VENDOR_ID"OpenIKED-"));
ibuf_add(vendor_id, IKED_VERSION"7.2", strlen(IKED_VERSION"7.2"));
if ((len = ikev2_add_vendor_id(buf, &pld, len, vendor_id))
    == -1)
	goto done;
}

/* Fragmentation Notify */
if (env->sc_fragsc_static.st_frag) {
if ((len = ikev2_add_fragmentation(buf, &pld, len))
    == -1)
	goto done;
}

if (env->sc_nattmode != NATT_DISABLE) {
if (ntohs(port)(__uint16_t)(__builtin_constant_p(port) ? (__uint16_t)(((__uint16_t
)(port) & 0xffU) << 8 | ((__uint16_t)(port) & 0xff00U
) >> 8) : __swap16md(port)) == env->sc_nattportsc_static.st_nattport) {
	/* Enforce NAT-T on the initiator side */
	log_debug("%s: enforcing NAT-T", __func__);
	req.msg_natt = sa->sa_natt = sa->sa_udpencap = 1;
}
if ((len = ikev2_add_nat_detection(env, buf, &pld, &req, len))
    == -1)
	goto done;
}

if ((len = ikev2_add_sighashnotify(buf, &pld, len)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
goto done;

if (ikev2_set_header(hdr, ibuf_size(buf) - sizeof(*hdr)) == -1)
goto done;

(void)ikev2_pld_parse(env, hdr, &req, 0);

ibuf_free(sa->sa_1stmsg);
if ((sa->sa_1stmsg = ibuf_dup(buf)) == NULL((void *)0)) {
log_debug("%s: failed to copy 1st message", __func__);
goto done;
}

if ((ret = ikev2_msg_send(env, &req)) == 0)
sa_state(env, sa, IKEV2_STATE_SA_INIT2);

/* Setup exchange timeout. */
timer_set(env, &sa->sa_timer, ikev2_init_ike_sa_timeout, sa);
timer_add(env, &sa->sa_timer, IKED_IKE_SA_EXCHANGE_TIMEOUT300);

done:
ikev2_msg_cleanup(env, &req);
closeonly:
if (ret == -1) {
log_debug("%s: closing SA", __func__);
ikev2_ike_sa_setreason(sa, "failed to send SA_INIT");
sa_free(env, sa);
}
ibuf_free(vendor_id);

return (ret);
1548}

1550int
1551ikev2_init_auth(struct iked *env, struct iked_message *msg)
1552{
struct iked_sa			*sa = msg->msg_sa;
struct ibuf			*authmsg;

if (sa == NULL((void *)0))
return (-1);

if (ikev2_sa_initiator(env, sa, NULL((void *)0), msg) == -1) {
log_info("%s: failed to get IKE keys", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (-1);
}

if ((authmsg = ikev2_msg_auth(env, sa,
   !sa->sa_hdr.sh_initiator)) == NULL((void *)0)) {
log_info("%s: failed to get auth data", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (-1);
}

if (ca_setauth(env, sa, authmsg, PROC_CERT) == -1) {
log_info("%s: failed to get cert", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
ibuf_free(authmsg);
return (-1);
}
ibuf_free(authmsg);

return (ikev2_init_ike_auth(env, sa));
1578}

1580int
1581ikev2_init_ike_auth(struct iked *env, struct iked_sa *sa)
1582{
struct iked_policy		*pol = sa->sa_policy;
struct ikev2_payload		*pld;
struct ikev2_cert		*cert;
struct ikev2_auth		*auth;
struct iked_id			*id, *certid, peerid;
struct ibuf			*e = NULL((void *)0);
uint8_t				 firstpayload;
int				 ret = -1;
ssize_t				 len;
int				 i;

if (!sa_stateok(sa, IKEV2_STATE_SA_INIT2))
return (0);

if (!sa->sa_localauth.id_type) {
log_debug("%s: no local auth", __func__);
return (0);
}

/* New encrypted message buffer */
if ((e = ibuf_static()) == NULL((void *)0))
goto done;

id = &sa->sa_iid;
certid = &sa->sa_icert;

/* ID payloads */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
firstpayload = IKEV2_PAYLOAD_IDi35;
if (ibuf_add_buf(e, id->id_buf) != 0)
goto done;
len = ibuf_size(id->id_buf);

if (pol->pol_peerid.id_type) {
bzero(&peerid, sizeof(peerid));
if (ikev2_policy2id(&pol->pol_peerid, &peerid, 0) != 0) {
	log_debug("%s: failed to get remote id", __func__);
	goto done;
}
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_IDr36) == -1)
	goto done;
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;
if (ibuf_add_buf(e, peerid.id_buf) != 0)
	goto done;
len = ibuf_size(peerid.id_buf);
}

/* CERT payload */
if ((sa->sa_stateinit & IKED_REQ_CERT0x0001) &&
   (certid->id_type != IKEV2_CERT_NONE0)) {
if (ikev2_next_payload(pld, len,
    IKEV2_PAYLOAD_CERT37) == -1)
	goto done;
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;
if ((cert = ibuf_reserve(e, sizeof(*cert))) == NULL((void *)0))
	goto done;
cert->cert_type = certid->id_type;
if (ibuf_add_buf(e, certid->id_buf) != 0)
	goto done;
len = ibuf_size(certid->id_buf) + sizeof(*cert);

for (i = 0; i < IKED_SCERT_MAX3; i++) {
	if (sa->sa_scert[i].id_type == IKEV2_CERT_NONE0)
		break;
	if (ikev2_next_payload(pld, len,
	    IKEV2_PAYLOAD_CERT37) == -1)
		goto done;
	if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
		goto done;
	if ((cert = ibuf_reserve(e, sizeof(*cert))) == NULL((void *)0))
		goto done;
	cert->cert_type = sa->sa_scert[i].id_type;
	if (ibuf_add_buf(e, sa->sa_scert[i].id_buf) != 0)
		goto done;
	len = ibuf_size(sa->sa_scert[i].id_buf) + sizeof(*cert);
}

/* CERTREQ payload(s) */
if ((len = ikev2_add_certreq(e, &pld,
    len, env->sc_certreq, env->sc_certreqtype)) == -1)
	goto done;

if (env->sc_certreqtype != pol->pol_certreqtype &&
    (len = ikev2_add_certreq(e, &pld,
    len, NULL((void *)0), pol->pol_certreqtype)) == -1)
	goto done;
}

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_AUTH39) == -1)
goto done;

/* AUTH payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
if ((auth = ibuf_reserve(e, sizeof(*auth))) == NULL((void *)0))
goto done;
auth->auth_method = sa->sa_localauth.id_type;
if (ibuf_add_buf(e, sa->sa_localauth.id_buf) != 0)
goto done;
len = ibuf_size(sa->sa_localauth.id_buf) + sizeof(*auth);

/* CP payload */
if (ikev2_cp_request_configured(sa)) {
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_CP47) == -1)
	goto done;
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;
if ((len = ikev2_init_add_cp(env, sa, e)) == -1)
	goto done;
}

if ((pol->pol_flags & IKED_POLICY_IPCOMP0x20) &&
   (len = ikev2_add_ipcompnotify(env, e, &pld, len, sa, 1)) == -1)
goto done;
if ((pol->pol_flags & IKED_POLICY_TRANSPORT0x40) &&
   (len = ikev2_add_transport_mode(env, e, &pld, len, sa)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_SA33) == -1)
goto done;

/* SA payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
if ((len = ikev2_add_proposals(env, sa, e, &pol->pol_proposals, 0,
   sa->sa_hdr.sh_initiator, 0, 1)) == -1)
goto done;

if ((len = ikev2_add_ts(e, &pld, len, sa, 0)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
goto done;

ret = ikev2_msg_send_encrypt(env, sa, &e,
   IKEV2_EXCHANGE_IKE_AUTH35, firstpayload, 0);

done:
ibuf_free(e);

return (ret);
1727}

1729void
1730ikev2_enable_timer(struct iked *env, struct iked_sa *sa)
1731{
sa->sa_last_recvd = gettime();
timer_set(env, &sa->sa_timer, ikev2_ike_sa_alive, sa);
if (env->sc_alive_timeoutsc_static.st_alive_timeout > 0)
timer_add(env, &sa->sa_timer, env->sc_alive_timeoutsc_static.st_alive_timeout);
timer_set(env, &sa->sa_keepalive, ikev2_ike_sa_keepalive, sa);
if (sa->sa_usekeepalive)
timer_add(env, &sa->sa_keepalive,
    IKED_IKE_SA_KEEPALIVE_TIMEOUT20);
timer_set(env, &sa->sa_rekey, ikev2_ike_sa_rekey, sa);
if (sa->sa_policy->pol_rekey)
ikev2_ike_sa_rekey_schedule(env, sa);
1743}

1745void
1746ikev2_reset_alive_timer(struct iked *env)
1747{
struct iked_sa			*sa;

RB_FOREACH(sa, iked_sas, &env->sc_sas)for ((sa) = iked_sas_RB_MINMAX(&env->sc_sas, -1); (sa)
 != ((void *)0); (sa) = iked_sas_RB_NEXT(sa)) {
if (sa->sa_state != IKEV2_STATE_ESTABLISHED9)
	continue;
timer_del(env, &sa->sa_timer);
if (env->sc_alive_timeoutsc_static.st_alive_timeout > 0)
	timer_add(env, &sa->sa_timer, env->sc_alive_timeoutsc_static.st_alive_timeout);
}
1757}

1759void
1760ikev2_disable_timer(struct iked *env, struct iked_sa *sa)
1761{
timer_del(env, &sa->sa_timer);
timer_del(env, &sa->sa_keepalive);
timer_del(env, &sa->sa_rekey);
1765}

1767int
1768ikev2_init_done(struct iked *env, struct iked_sa *sa)
1769{
int		 ret;

if (!sa_stateok(sa, IKEV2_STATE_VALID7))
return (0);	/* ignored */

ret = ikev2_childsa_negotiate(env, sa, &sa->sa_kex, &sa->sa_proposals,
   sa->sa_hdr.sh_initiator, 0);
if (ret == 0)
ret = ikev2_childsa_enable(env, sa);
if (ret == 0) {
sa_state(env, sa, IKEV2_STATE_ESTABLISHED9);
/* Delete exchange timeout. */
timer_del(env, &sa->sa_timer);
ikev2_enable_timer(env, sa);
ikev2_log_established(sa);
ikev2_record_dstid(env, sa);
sa_configure_iface(env, sa, 1);
}

if (ret)
ikev2_childsa_delete(env, sa, 0, 0, NULL((void *)0), 1);
return (ret);
1792}

1794int
1795ikev2_policy2id(struct iked_static_id *polid, struct iked_id *id, int srcid)
1796{
struct ikev2_id		 hdr;
struct iked_static_id	 localpid;
char			 idstr[IKED_ID_SIZE1024];
struct in_addr		 in4;
struct in6_addr		 in6;
X509_NAME		*name = NULL((void *)0);
uint8_t			*p;
int			 len;

/* Fixup the local Id if not specified */
if (srcid && polid->id_type == 0) {
polid = &localpid;
bzero(polid, sizeof(*polid));

/* Create a default local ID based on our FQDN */
polid->id_type = IKEV2_ID_FQDN2;
if (gethostname((char *)polid->id_data,
    sizeof(polid->id_data)) != 0)
	return (-1);
polid->id_offset = 0;
polid->id_length =
    strlen((char *)polid->id_data); /* excluding NUL */
}

if (!polid->id_length)
return (-1);

/* Create an IKEv2 ID payload */
bzero(&hdr, sizeof(hdr));
hdr.id_type = id->id_type = polid->id_type;
id->id_offset = sizeof(hdr);

ibuf_free(id->id_buf);
if ((id->id_buf = ibuf_new(&hdr, sizeof(hdr))) == NULL((void *)0))
return (-1);

switch (id->id_type) {
case IKEV2_ID_IPV41:
if (inet_pton(AF_INET2, (char *)polid->id_data, &in4) != 1 ||
    ibuf_add(id->id_buf, &in4, sizeof(in4)) != 0) {
	ibuf_free(id->id_buf);
	id->id_buf = NULL((void *)0);
	return (-1);
}
break;
case IKEV2_ID_IPV65:
if (inet_pton(AF_INET624, (char *)polid->id_data, &in6) != 1 ||
    ibuf_add(id->id_buf, &in6, sizeof(in6)) != 0) {
	ibuf_free(id->id_buf);
	id->id_buf = NULL((void *)0);
	return (-1);
}
break;
case IKEV2_ID_ASN1_DN9:
/* policy has ID in string-format, convert to ASN1 */
if ((name = ca_x509_name_parse(polid->id_data)) == NULL((void *)0) ||
    (len = i2d_X509_NAME(name, NULL((void *)0))) < 0 ||
    (p = ibuf_reserve(id->id_buf, len)) == NULL((void *)0) ||
    (i2d_X509_NAME(name, &p)) < 0) {
	if (name)
		X509_NAME_free(name);
	ibuf_free(id->id_buf);
	id->id_buf = NULL((void *)0);
	return (-1);
}
X509_NAME_free(name);
break;
default:
if (ibuf_add(id->id_buf,
    polid->id_data, polid->id_length) != 0) {
	ibuf_free(id->id_buf);
	id->id_buf = NULL((void *)0);
	return (-1);
}
break;
}

if (ikev2_print_id(id, idstr, sizeof(idstr)) == -1)
return (-1);

log_debug("%s: %s %s length %zu", __func__,
   srcid ? "srcid" : "dstid",
   idstr, ibuf_size(id->id_buf));

return (0);
1882}

1884struct ike_header *
1885ikev2_add_header(struct ibuf *buf, struct iked_sa *sa,
  uint32_t msgid, uint8_t nextpayload,
  uint8_t exchange, uint8_t flags)
1888{
struct ike_header	*hdr;

if ((hdr = ibuf_reserve(buf, sizeof(*hdr))) == NULL((void *)0)) {
log_debug("%s: failed to add header", __func__);
return (NULL((void *)0));
}

hdr->ike_ispi = htobe64(sa->sa_hdr.sh_ispi)(__uint64_t)(__builtin_constant_p(sa->sa_hdr.sh_ispi) ? (__uint64_t
)((((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff) << 56
) | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00ULL) <<
| ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff0000ULL)
 << 24 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff000000ULL
) << 8 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00000000ULL
) >> 8 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md(sa->sa_hdr.sh_ispi));
hdr->ike_rspi = htobe64(sa->sa_hdr.sh_rspi)(__uint64_t)(__builtin_constant_p(sa->sa_hdr.sh_rspi) ? (__uint64_t
)((((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff) << 56
) | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00ULL) <<
| ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff0000ULL)
 << 24 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff000000ULL
) << 8 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00000000ULL
) >> 8 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00000000000000ULL
) >> 56) : __swap64md(sa->sa_hdr.sh_rspi));
hdr->ike_nextpayload = nextpayload;
hdr->ike_version = IKEV2_VERSION0x20;
hdr->ike_exchange = exchange;
hdr->ike_msgid = htobe32(msgid)(__uint32_t)(__builtin_constant_p(msgid) ? (__uint32_t)(((__uint32_t
)(msgid) & 0xff) << 24 | ((__uint32_t)(msgid) &
 0xff00) << 8 | ((__uint32_t)(msgid) & 0xff0000) >>
| ((__uint32_t)(msgid) & 0xff000000) >> 24) : __swap32md
(msgid));
hdr->ike_length = htobe32(sizeof(*hdr))(__uint32_t)(__builtin_constant_p(sizeof(*hdr)) ? (__uint32_t
)(((__uint32_t)(sizeof(*hdr)) & 0xff) << 24 | ((__uint32_t
)(sizeof(*hdr)) & 0xff00) << 8 | ((__uint32_t)(sizeof
(*hdr)) & 0xff0000) >> 8 | ((__uint32_t)(sizeof(*hdr
)) & 0xff000000) >> 24) : __swap32md(sizeof(*hdr)));
hdr->ike_flags = flags;

if (sa->sa_hdr.sh_initiator)
hdr->ike_flags |= IKEV2_FLAG_INITIATOR0x08;

return (hdr);
1909}

1911int
1912ikev2_set_header(struct ike_header *hdr, size_t length)
1913{
uint32_t	 hdrlength = sizeof(*hdr) + length;

if (hdrlength > UINT32_MAX0xffffffffU) {
log_debug("%s: message too long", __func__);
return (-1);
}

hdr->ike_length = htobe32(sizeof(*hdr) + length)(__uint32_t)(__builtin_constant_p(sizeof(*hdr) + length) ? (__uint32_t
)(((__uint32_t)(sizeof(*hdr) + length) & 0xff) << 24
 | ((__uint32_t)(sizeof(*hdr) + length) & 0xff00) <<
| ((__uint32_t)(sizeof(*hdr) + length) & 0xff0000) >>
| ((__uint32_t)(sizeof(*hdr) + length) & 0xff000000) >>
 24) : __swap32md(sizeof(*hdr) + length));

return (0);
1924}

1926struct ikev2_payload *
1927ikev2_add_payload(struct ibuf *buf)
1928{
struct ikev2_payload	*pld;

if ((pld = ibuf_reserve(buf, sizeof(*pld))) == NULL((void *)0)) {
log_debug("%s: failed to add payload", __func__);
return (NULL((void *)0));
}

pld->pld_nextpayload = IKEV2_PAYLOAD_NONE0;
pld->pld_length = sizeof(*pld);

return (pld);
1940}

1942ssize_t
1943ikev2_add_ts_payload(struct ibuf *buf, unsigned int type, struct iked_sa *sa)
1944{
struct iked_policy	*pol = sa->sa_policy;
struct ikev2_tsp	*tsp;
struct ikev2_ts		*ts;
struct iked_addr	*addr;
struct iked_addr	 pooladdr;
uint8_t			*ptr;
size_t			 len = 0;
uint32_t		 av[4], bv[4], mv[4];
struct sockaddr_in	*in4;
struct sockaddr_in6	*in6;
struct iked_tss		*tss;
struct iked_ts		*tsi;

bzero(&pooladdr, sizeof(pooladdr));

if ((tsp = ibuf_reserve(buf, sizeof(*tsp))) == NULL((void *)0))
return (-1);
len = sizeof(*tsp);

if (type == IKEV2_PAYLOAD_TSi44) {
if (sa->sa_hdr.sh_initiator) {
	tss = &pol->pol_tssrc;
	tsp->tsp_count = pol->pol_tssrc_count;
} else {
	tss = &pol->pol_tsdst;
	tsp->tsp_count = pol->pol_tsdst_count;
}
} else if (type == IKEV2_PAYLOAD_TSr45) {
if (sa->sa_hdr.sh_initiator) {
	tss = &pol->pol_tsdst;
	tsp->tsp_count = pol->pol_tsdst_count;
} else {
	tss = &pol->pol_tssrc;
	tsp->tsp_count = pol->pol_tssrc_count;
}
} else
return (-1);

TAILQ_FOREACH(tsi, tss, ts_entry)for((tsi) = ((tss)->tqh_first); (tsi) != ((void *)0); (tsi
) = ((tsi)->ts_entry.tqe_next)) {
if ((ts = ibuf_reserve(buf, sizeof(*ts))) == NULL((void *)0))
	return (-1);

addr = &tsi->ts_addr;

/* patch remote address (if configured to 0.0.0.0) */
if ((type == IKEV2_PAYLOAD_TSi44 && !sa->sa_hdr.sh_initiator) ||
    (type == IKEV2_PAYLOAD_TSr45 && sa->sa_hdr.sh_initiator)) {
	if (ikev2_cp_fixaddr(sa, addr, &pooladdr) == 0)
		addr = &pooladdr;
}

ts->ts_protoid = tsi->ts_ipproto;

if (addr->addr_port) {
	ts->ts_startport = addr->addr_port;
	ts->ts_endport = addr->addr_port;
} else {
	ts->ts_startport = 0;
	ts->ts_endport = 0xffff;
}

switch (addr->addr_af) {
case AF_INET2:
	ts->ts_type = IKEV2_TS_IPV4_ADDR_RANGE7;
	ts->ts_length = htobe16(sizeof(*ts) + 8)(__uint16_t)(__builtin_constant_p(sizeof(*ts) + 8) ? (__uint16_t
)(((__uint16_t)(sizeof(*ts) + 8) & 0xffU) << 8 | ((
__uint16_t)(sizeof(*ts) + 8) & 0xff00U) >> 8) : __swap16md
(sizeof(*ts) + 8));

	if ((ptr = ibuf_reserve(buf, 8)) == NULL((void *)0))
		return (-1);

	in4 = (struct sockaddr_in *)&addr->addr;
	if (addr->addr_net) {
		/* Convert IPv4 network to address range */
		mv[0] = prefixlen2mask(addr->addr_mask);
		av[0] = in4->sin_addr.s_addr & mv[0];
		bv[0] = in4->sin_addr.s_addr | ~mv[0];
	} else
		av[0] = bv[0] = in4->sin_addr.s_addr;

	memcpy(ptr, &av[0], 4);
	memcpy(ptr + 4, &bv[0], 4);
	break;
case AF_INET624:
	ts->ts_type = IKEV2_TS_IPV6_ADDR_RANGE8;
	ts->ts_length = htobe16(sizeof(*ts) + 32)(__uint16_t)(__builtin_constant_p(sizeof(*ts) + 32) ? (__uint16_t
)(((__uint16_t)(sizeof(*ts) + 32) & 0xffU) << 8 | (
(__uint16_t)(sizeof(*ts) + 32) & 0xff00U) >> 8) : __swap16md
(sizeof(*ts) + 32));

	if ((ptr = ibuf_reserve(buf, 32)) == NULL((void *)0))
		return (-1);

	in6 = (struct sockaddr_in6 *)&addr->addr;

	memcpy(&av, &in6->sin6_addr.s6_addr__u6_addr.__u6_addr8, 16);
	memcpy(&bv, &in6->sin6_addr.s6_addr__u6_addr.__u6_addr8, 16);
	if (addr->addr_net) {
		/* Convert IPv6 network to address range */
		prefixlen2mask6(addr->addr_mask, mv);
		av[0] &= mv[0];
		av[1] &= mv[1];
		av[2] &= mv[2];
		av[3] &= mv[3];
		bv[0] |= ~mv[0];
		bv[1] |= ~mv[1];
		bv[2] |= ~mv[2];
		bv[3] |= ~mv[3];
	}

	memcpy(ptr, &av, 16);
	memcpy(ptr + 16, &bv, 16);
	break;
}

len += betoh16(ts->ts_length)(__uint16_t)(__builtin_constant_p(ts->ts_length) ? (__uint16_t
)(((__uint16_t)(ts->ts_length) & 0xffU) << 8 | (
(__uint16_t)(ts->ts_length) & 0xff00U) >> 8) : __swap16md
(ts->ts_length));
}

return (len);
2059}

2061ssize_t
2062ikev2_add_ts(struct ibuf *e, struct ikev2_payload **pld, ssize_t len,
  struct iked_sa *sa, int reverse)
2064{
if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_TSi44) == -1)
return (-1);

/* TSi payload */
if ((*pld = ikev2_add_payload(e)) == NULL((void *)0))
return (-1);
if ((len = ikev2_add_ts_payload(e, reverse ? IKEV2_PAYLOAD_TSr45 :
   IKEV2_PAYLOAD_TSi44, sa)) == -1)
return (-1);

if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_TSr45) == -1)
return (-1);

/* TSr payload */
if ((*pld = ikev2_add_payload(e)) == NULL((void *)0))
return (-1);
if ((len = ikev2_add_ts_payload(e, reverse ? IKEV2_PAYLOAD_TSi44 :
   IKEV2_PAYLOAD_TSr45, sa)) == -1)
return (-1);

return (len);
2086}


2089ssize_t
2090ikev2_add_certreq(struct ibuf *e, struct ikev2_payload **pld, ssize_t len,
  struct ibuf *certreq, uint8_t type)
2092{
struct ikev2_cert	*cert;

if (type == IKEV2_CERT_NONE0)
return (len);

if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_CERTREQ38) == -1)
return (-1);

/* CERTREQ payload */
if ((*pld = ikev2_add_payload(e)) == NULL((void *)0))
return (-1);

if ((cert = ibuf_reserve(e, sizeof(*cert))) == NULL((void *)0))
return (-1);

cert->cert_type = type;
len = sizeof(*cert);

if (certreq != NULL((void *)0) && cert->cert_type == IKEV2_CERT_X509_CERT4) {
if (ikev2_add_buf(e, certreq) == -1)
	return (-1);
len += ibuf_size(certreq);
}

log_debug("%s: type %s length %zd", __func__,
   print_map(type, ikev2_cert_map), len);

return (len);
2121}

2123ssize_t
2124ikev2_add_ipcompnotify(struct iked *env, struct ibuf *e,
  struct ikev2_payload **pld, ssize_t len, struct iked_sa *sa,
  int initiator)
2127{
struct iked_childsa		 csa;
struct iked_ipcomp		*ic;
struct ikev2_notify		*n;
uint8_t				*ptr;
uint16_t			 cpi;
uint32_t			 spi;
uint8_t				 transform;

/* we only support deflate */
transform = IKEV2_IPCOMP_DEFLATE2;
ic = initiator ? &sa->sa_ipcompi : &sa->sa_ipcompr;

if (initiator) {
bzero(&csa, sizeof(csa));
csa.csa_saproto = IKEV2_SAPROTO_IPCOMP204;
csa.csa_ikesa = sa;
csa.csa_local = &sa->sa_peer;
csa.csa_peer = &sa->sa_local;
if (pfkey_sa_init(env, &csa, &spi) == -1)
	return (-1);
ic->ic_cpi_in = spi;
} else {
spi = ic->ic_cpi_in;
/* make sure IPCOMP CPIs are not reused */
ic->ic_transform = 0;
ic->ic_cpi_in = 0;
ic->ic_cpi_out = 0;
}
log_debug("%s: ic_cpi_in 0x%04x", __func__, spi);

/*
* We get spi == 0 if the kernel does not support IPcomp,
* so just return the length of the current payload.
*/
if (spi == 0)
return (len);
cpi = htobe16((uint16_t)spi)(__uint16_t)(__builtin_constant_p((uint16_t)spi) ? (__uint16_t
)(((__uint16_t)((uint16_t)spi) & 0xffU) << 8 | ((__uint16_t
)((uint16_t)spi) & 0xff00U) >> 8) : __swap16md((uint16_t
)spi));
if (*pld)
if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_NOTIFY41) == -1)
	return (-1);
if ((*pld = ikev2_add_payload(e)) == NULL((void *)0))
return (-1);
len = sizeof(*n) + sizeof(cpi) + sizeof(transform);
if ((ptr = ibuf_reserve(e, len)) == NULL((void *)0))
return (-1);
n = (struct ikev2_notify *)ptr;
n->n_protoid = 0;
n->n_spisize = 0;
n->n_type = htobe16(IKEV2_N_IPCOMP_SUPPORTED)(__uint16_t)(__builtin_constant_p(16387) ? (__uint16_t)(((__uint16_t
)(16387) & 0xffU) << 8 | ((__uint16_t)(16387) &
 0xff00U) >> 8) : __swap16md(16387));
ptr += sizeof(*n);
memcpy(ptr, &cpi, sizeof(cpi));
ptr += sizeof(cpi);
memcpy(ptr, &transform, sizeof(transform));

return (len);
2183}

2185ssize_t
2186ikev2_add_notify(struct ibuf *e, struct ikev2_payload **pld, ssize_t len,
  uint16_t notify)
2188{
struct ikev2_notify		*n;

if (*pld)
if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_NOTIFY41) == -1)
	return (-1);
if ((*pld = ikev2_add_payload(e)) == NULL((void *)0))
return (-1);
len = sizeof(*n);
if ((n = ibuf_reserve(e, len)) == NULL((void *)0))
return (-1);
n->n_protoid = 0;
n->n_spisize = 0;
n->n_type = htobe16(notify)(__uint16_t)(__builtin_constant_p(notify) ? (__uint16_t)(((__uint16_t
)(notify) & 0xffU) << 8 | ((__uint16_t)(notify) &
 0xff00U) >> 8) : __swap16md(notify));
log_debug("%s: done", __func__);

return (len);
2205}

2207ssize_t
2208ikev2_add_vendor_id(struct ibuf *e, struct ikev2_payload **pld,
  ssize_t len, struct ibuf *id)
2210{
if (*pld)
if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_VENDOR43) == -1)
	return (-1);
if ((*pld = ikev2_add_payload(e)) == NULL((void *)0))
return (-1);
if (ibuf_add_buf(e, id) == -1)
return (-1);

return (ibuf_size(id));
2220}

2222ssize_t
2223ikev2_add_mobike(struct ibuf *e, struct ikev2_payload **pld, ssize_t len)
2224{
return ikev2_add_notify(e, pld, len, IKEV2_N_MOBIKE_SUPPORTED16396);
2226}

2228ssize_t
2229ikev2_add_fragmentation(struct ibuf *buf, struct ikev2_payload **pld,
  ssize_t len)
2231{
return ikev2_add_notify(buf, pld, len, IKEV2_N_FRAGMENTATION_SUPPORTED16430);
2233}

2235ssize_t
2236ikev2_add_sighashnotify(struct ibuf *e, struct ikev2_payload **pld,
  ssize_t len)
2238{
struct ikev2_notify		*n;
uint8_t				*ptr;
size_t				 i;
uint16_t			 hash, signature_hashes[] = {
IKEV2_SIGHASH_SHA2_2562,
IKEV2_SIGHASH_SHA2_3843,
IKEV2_SIGHASH_SHA2_5124
};

if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_NOTIFY41) == -1)
return (-1);

/* XXX signature_hashes are hardcoded for now */
len = sizeof(*n) + nitems(signature_hashes)(sizeof((signature_hashes)) / sizeof((signature_hashes)[0])) * sizeof(hash);

/* NOTIFY payload */
if ((*pld = ikev2_add_payload(e)) == NULL((void *)0))
return (-1);
if ((ptr = ibuf_reserve(e, len)) == NULL((void *)0))
return (-1);

n = (struct ikev2_notify *)ptr;
n->n_protoid = 0;
n->n_spisize = 0;
n->n_type = htobe16(IKEV2_N_SIGNATURE_HASH_ALGORITHMS)(__uint16_t)(__builtin_constant_p(16431) ? (__uint16_t)(((__uint16_t
)(16431) & 0xffU) << 8 | ((__uint16_t)(16431) &
 0xff00U) >> 8) : __swap16md(16431));
ptr += sizeof(*n);

for (i = 0; i < nitems(signature_hashes)(sizeof((signature_hashes)) / sizeof((signature_hashes)[0])); i++) {
hash = htobe16(signature_hashes[i])(__uint16_t)(__builtin_constant_p(signature_hashes[i]) ? (__uint16_t
)(((__uint16_t)(signature_hashes[i]) & 0xffU) << 8 |
 ((__uint16_t)(signature_hashes[i]) & 0xff00U) >> 8
) : __swap16md(signature_hashes[i]));
memcpy(ptr, &hash, sizeof(hash));
ptr += sizeof(hash);
}

return (len);
2273}

2275ssize_t
2276ikev2_add_transport_mode(struct iked *env, struct ibuf *e,
  struct ikev2_payload **pld, ssize_t len, struct iked_sa *sa)
2278{
return ikev2_add_notify(e, pld, len, IKEV2_N_USE_TRANSPORT_MODE16391);
2280}

2282int
2283ikev2_next_payload(struct ikev2_payload *pld, size_t length,
  uint8_t nextpayload)
2285{
size_t	 pldlength = sizeof(*pld) + length;

if (pldlength > UINT16_MAX0xffff) {
log_debug("%s: payload too long", __func__);
return (-1);
}

log_debug("%s: length %zu nextpayload %s",
   __func__, pldlength, print_map(nextpayload, ikev2_payload_map));

pld->pld_length = htobe16(pldlength)(__uint16_t)(__builtin_constant_p(pldlength) ? (__uint16_t)((
(__uint16_t)(pldlength) & 0xffU) << 8 | ((__uint16_t
)(pldlength) & 0xff00U) >> 8) : __swap16md(pldlength
));
pld->pld_nextpayload = nextpayload;

return (0);
2300}

2302ssize_t
2303ikev2_nat_detection(struct iked *env, struct iked_message *msg,
  void *ptr, size_t len, unsigned int type, int frompeer)
2305{
EVP_MD_CTX		*ctx;
struct ike_header	*hdr;
uint8_t			 md[SHA_DIGEST_LENGTH20];
unsigned int		 mdlen = sizeof(md);
struct iked_sa		*sa = msg->msg_sa;
struct sockaddr_in	*in4;
struct sockaddr_in6	*in6;
ssize_t			 ret = -1;
struct sockaddr_storage	*src, *dst, *ss;
uint64_t		 rspi, ispi;
struct ibuf		*buf;
uint32_t		 rnd;

if (ptr == NULL((void *)0))
return (mdlen);

if (frompeer) {
buf = msg->msg_parent->msg_data;
if ((hdr = ibuf_seek(buf, 0, sizeof(*hdr))) == NULL((void *)0))
	return (-1);
ispi = hdr->ike_ispi;
rspi = hdr->ike_rspi;
src = &msg->msg_peer;
dst = &msg->msg_local;
} else {
ispi = htobe64(sa->sa_hdr.sh_ispi)(__uint64_t)(__builtin_constant_p(sa->sa_hdr.sh_ispi) ? (__uint64_t
)((((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff) << 56
) | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00ULL) <<
| ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff0000ULL)
 << 24 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff000000ULL
) << 8 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00000000ULL
) >> 8 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md(sa->sa_hdr.sh_ispi));
rspi = htobe64(sa->sa_hdr.sh_rspi)(__uint64_t)(__builtin_constant_p(sa->sa_hdr.sh_rspi) ? (__uint64_t
)((((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff) << 56
) | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00ULL) <<
| ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff0000ULL)
 << 24 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff000000ULL
) << 8 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00000000ULL
) >> 8 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00000000000000ULL
) >> 56) : __swap64md(sa->sa_hdr.sh_rspi));
src = &msg->msg_local;
dst = &msg->msg_peer;
}

ctx = EVP_MD_CTX_new();
if (ctx == NULL((void *)0))
return (-1);
EVP_DigestInit_ex(ctx, EVP_sha1(), NULL((void *)0));

switch (type) {
case IKEV2_N_NAT_DETECTION_SOURCE_IP16388:
log_debug("%s: %s source %s %s %s", __func__,
    frompeer ? "peer" : "local",
    print_spi(betoh64(ispi)(__uint64_t)(__builtin_constant_p(ispi) ? (__uint64_t)((((__uint64_t
)(ispi) & 0xff) << 56) | ((__uint64_t)(ispi) & 0xff00ULL
) << 40 | ((__uint64_t)(ispi) & 0xff0000ULL) <<
| ((__uint64_t)(ispi) & 0xff000000ULL) << 8 | (
(__uint64_t)(ispi) & 0xff00000000ULL) >> 8 | ((__uint64_t
)(ispi) & 0xff0000000000ULL) >> 24 | ((__uint64_t)(
ispi) & 0xff000000000000ULL) >> 40 | ((__uint64_t)(
ispi) & 0xff00000000000000ULL) >> 56) : __swap64md(
ispi)), 8),
    print_spi(betoh64(rspi)(__uint64_t)(__builtin_constant_p(rspi) ? (__uint64_t)((((__uint64_t
)(rspi) & 0xff) << 56) | ((__uint64_t)(rspi) & 0xff00ULL
) << 40 | ((__uint64_t)(rspi) & 0xff0000ULL) <<
| ((__uint64_t)(rspi) & 0xff000000ULL) << 8 | (
(__uint64_t)(rspi) & 0xff00000000ULL) >> 8 | ((__uint64_t
)(rspi) & 0xff0000000000ULL) >> 24 | ((__uint64_t)(
rspi) & 0xff000000000000ULL) >> 40 | ((__uint64_t)(
rspi) & 0xff00000000000000ULL) >> 56) : __swap64md(
rspi)), 8),
    print_addr(src));
ss = src;
break;
case IKEV2_N_NAT_DETECTION_DESTINATION_IP16389:
log_debug("%s: %s destination %s %s %s", __func__,
    frompeer ? "peer" : "local",
    print_spi(betoh64(ispi)(__uint64_t)(__builtin_constant_p(ispi) ? (__uint64_t)((((__uint64_t
)(ispi) & 0xff) << 56) | ((__uint64_t)(ispi) & 0xff00ULL
) << 40 | ((__uint64_t)(ispi) & 0xff0000ULL) <<
| ((__uint64_t)(ispi) & 0xff000000ULL) << 8 | (
(__uint64_t)(ispi) & 0xff00000000ULL) >> 8 | ((__uint64_t
)(ispi) & 0xff0000000000ULL) >> 24 | ((__uint64_t)(
ispi) & 0xff000000000000ULL) >> 40 | ((__uint64_t)(
ispi) & 0xff00000000000000ULL) >> 56) : __swap64md(
ispi)), 8),
    print_spi(betoh64(rspi)(__uint64_t)(__builtin_constant_p(rspi) ? (__uint64_t)((((__uint64_t
)(rspi) & 0xff) << 56) | ((__uint64_t)(rspi) & 0xff00ULL
) << 40 | ((__uint64_t)(rspi) & 0xff0000ULL) <<
| ((__uint64_t)(rspi) & 0xff000000ULL) << 8 | (
(__uint64_t)(rspi) & 0xff00000000ULL) >> 8 | ((__uint64_t
)(rspi) & 0xff0000000000ULL) >> 24 | ((__uint64_t)(
rspi) & 0xff000000000000ULL) >> 40 | ((__uint64_t)(
rspi) & 0xff00000000000000ULL) >> 56) : __swap64md(
rspi)), 8),
    print_addr(dst));
ss = dst;
break;
default:
goto done;
}

EVP_DigestUpdate(ctx, &ispi, sizeof(ispi));
EVP_DigestUpdate(ctx, &rspi, sizeof(rspi));

switch (ss->ss_family) {
case AF_INET2:
in4 = (struct sockaddr_in *)ss;
EVP_DigestUpdate(ctx, &in4->sin_addr.s_addr,
    sizeof(in4->sin_addr.s_addr));
EVP_DigestUpdate(ctx, &in4->sin_port,
    sizeof(in4->sin_port));
break;
case AF_INET624:
in6 = (struct sockaddr_in6 *)ss;
EVP_DigestUpdate(ctx, &in6->sin6_addr.s6_addr__u6_addr.__u6_addr8,
    sizeof(in6->sin6_addr.s6_addr__u6_addr.__u6_addr8));
EVP_DigestUpdate(ctx, &in6->sin6_port,
    sizeof(in6->sin6_port));
break;
default:
goto done;
}

if (env->sc_nattmode == NATT_FORCE) {
/* Enforce NAT-T/UDP-encapsulation by distorting the digest */
rnd = arc4random();
EVP_DigestUpdate(ctx, &rnd, sizeof(rnd));
}

EVP_DigestFinal_ex(ctx, md, &mdlen);

if (len < mdlen)
goto done;

memcpy(ptr, md, mdlen);
ret = mdlen;
done:
EVP_MD_CTX_free(ctx);

return (ret);
2402}

2404ssize_t
2405ikev2_add_nat_detection(struct iked *env, struct ibuf *buf,
  struct ikev2_payload **pld, struct iked_message *msg, ssize_t len)
2407{
struct ikev2_notify		*n;
uint8_t			*ptr;

/* *pld is NULL if there is no previous payload */
if (*pld != NULL((void *)0)) {
if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_NOTIFY41) == -1)
	return (-1);
}
/* NAT-T notify payloads */
if ((*pld = ikev2_add_payload(buf)) == NULL((void *)0))
return (-1);
if ((n = ibuf_reserve(buf, sizeof(*n))) == NULL((void *)0))
return (-1);
n->n_type = htobe16(IKEV2_N_NAT_DETECTION_SOURCE_IP)(__uint16_t)(__builtin_constant_p(16388) ? (__uint16_t)(((__uint16_t
)(16388) & 0xffU) << 8 | ((__uint16_t)(16388) &
 0xff00U) >> 8) : __swap16md(16388));
len = ikev2_nat_detection(env, msg, NULL((void *)0), 0, 0, 0);
if ((ptr = ibuf_reserve(buf, len)) == NULL((void *)0))
return (-1);
if ((len = ikev2_nat_detection(env, msg, ptr, len,
   betoh16(n->n_type)(__uint16_t)(__builtin_constant_p(n->n_type) ? (__uint16_t
)(((__uint16_t)(n->n_type) & 0xffU) << 8 | ((__uint16_t
)(n->n_type) & 0xff00U) >> 8) : __swap16md(n->
n_type)), 0)) == -1)
return (-1);
len += sizeof(*n);

if (ikev2_next_payload(*pld, len, IKEV2_PAYLOAD_NOTIFY41) == -1)
return (-1);

if ((*pld = ikev2_add_payload(buf)) == NULL((void *)0))
return (-1);
if ((n = ibuf_reserve(buf, sizeof(*n))) == NULL((void *)0))
return (-1);
n->n_type = htobe16(IKEV2_N_NAT_DETECTION_DESTINATION_IP)(__uint16_t)(__builtin_constant_p(16389) ? (__uint16_t)(((__uint16_t
)(16389) & 0xffU) << 8 | ((__uint16_t)(16389) &
 0xff00U) >> 8) : __swap16md(16389));
len = ikev2_nat_detection(env, msg, NULL((void *)0), 0, 0, 0);
if ((ptr = ibuf_reserve(buf, len)) == NULL((void *)0))
return (-1);
if ((len = ikev2_nat_detection(env, msg, ptr, len,
   betoh16(n->n_type)(__uint16_t)(__builtin_constant_p(n->n_type) ? (__uint16_t
)(((__uint16_t)(n->n_type) & 0xffU) << 8 | ((__uint16_t
)(n->n_type) & 0xff00U) >> 8) : __swap16md(n->
n_type)), 0)) == -1)
return (-1);
len += sizeof(*n);
return (len);
2446}

2448ssize_t
2449ikev2_add_cp(struct iked *env, struct iked_sa *sa, int type, struct ibuf *buf)
2450{
struct iked_policy	*pol = sa->sa_policy;
struct ikev2_cp		*cp;
struct ikev2_cfg	*cfg;
struct iked_cfg		*ikecfg;
unsigned int		 i;
uint32_t		 mask4;
size_t			 len;
struct sockaddr_in	*in4;
struct sockaddr_in6	*in6;
uint8_t			 prefixlen;
int			 sent_addr4 = 0, sent_addr6 = 0;
int			 have_mask4 = 0, sent_mask4 = 0;

if ((cp = ibuf_reserve(buf, sizeof(*cp))) == NULL((void *)0))
return (-1);
len = sizeof(*cp);

switch (type) {
case IKEV2_CP_REQUEST1:
case IKEV2_CP_REPLY2:
cp->cp_type = type;
break;
default:
/* Not yet supported */
return (-1);
}

for (i = 0; i < pol->pol_ncfg; i++) {
ikecfg = &pol->pol_cfg[i];
if (ikecfg->cfg_action != cp->cp_type)
	continue;
/* only return one address in case of multiple pools */
if (type == IKEV2_CP_REPLY2) {
	switch (ikecfg->cfg_type) {
	case IKEV2_CFG_INTERNAL_IP4_ADDRESS1:
		if (sent_addr4)
			continue;
		break;
	case IKEV2_CFG_INTERNAL_IP6_ADDRESS8:
		if (sent_addr6)
			continue;
		break;
	}
}

if ((cfg = ibuf_reserve(buf, sizeof(*cfg))) == NULL((void *)0))
	return (-1);

cfg->cfg_type = htobe16(ikecfg->cfg_type)(__uint16_t)(__builtin_constant_p(ikecfg->cfg_type) ? (__uint16_t
)(((__uint16_t)(ikecfg->cfg_type) & 0xffU) << 8 |
 ((__uint16_t)(ikecfg->cfg_type) & 0xff00U) >> 8
) : __swap16md(ikecfg->cfg_type));
len += sizeof(*cfg);

switch (ikecfg->cfg_type) {
case IKEV2_CFG_INTERNAL_IP4_ADDRESS1:
case IKEV2_CFG_INTERNAL_IP4_NETMASK2:
case IKEV2_CFG_INTERNAL_IP4_DNS3:
case IKEV2_CFG_INTERNAL_IP4_NBNS4:
case IKEV2_CFG_INTERNAL_IP4_DHCP6:
case IKEV2_CFG_INTERNAL_IP4_SERVER23456:
	/* 4 bytes IPv4 address */
	in4 = ((ikecfg->cfg_type ==
	    IKEV2_CFG_INTERNAL_IP4_ADDRESS1) &&
	    sa->sa_addrpool &&
	    sa->sa_addrpool->addr_af == AF_INET2) ?
	    (struct sockaddr_in *)&sa->sa_addrpool->addr :
	    (struct sockaddr_in *)&ikecfg->cfg.address.addr;
	/* don't include unspecified address in request */
	if (type == IKEV2_CP_REQUEST1 &&
	    !in4->sin_addr.s_addr)
		break;
	cfg->cfg_length = htobe16(4)(__uint16_t)(__builtin_constant_p(4) ? (__uint16_t)(((__uint16_t
)(4) & 0xffU) << 8 | ((__uint16_t)(4) & 0xff00U
) >> 8) : __swap16md(4));
	if (ibuf_add(buf, &in4->sin_addr.s_addr, 4) == -1)
		return (-1);
	len += 4;
	if (ikecfg->cfg_type == IKEV2_CFG_INTERNAL_IP4_ADDRESS1) {
		sent_addr4 = 1;
		if (sa->sa_addrpool &&
		    sa->sa_addrpool->addr_af == AF_INET2 &&
		    sa->sa_addrpool->addr_mask != 0)
			have_mask4 = 1;
	}
	if (ikecfg->cfg_type == IKEV2_CFG_INTERNAL_IP4_NETMASK2)
		sent_mask4 = 1;
	break;
case IKEV2_CFG_INTERNAL_IP4_SUBNET13:
	/* 4 bytes IPv4 address + 4 bytes IPv4 mask + */
	in4 = (struct sockaddr_in *)&ikecfg->cfg.address.addr;
	mask4 = prefixlen2mask(ikecfg->cfg.address.addr_mask);
	cfg->cfg_length = htobe16(8)(__uint16_t)(__builtin_constant_p(8) ? (__uint16_t)(((__uint16_t
)(8) & 0xffU) << 8 | ((__uint16_t)(8) & 0xff00U
) >> 8) : __swap16md(8));
	if (ibuf_add(buf, &in4->sin_addr.s_addr, 4) == -1)
		return (-1);
	if (ibuf_add(buf, &mask4, 4) == -1)
		return (-1);
	len += 8;
	break;
case IKEV2_CFG_INTERNAL_IP6_DNS10:
case IKEV2_CFG_INTERNAL_IP6_NBNS11:
case IKEV2_CFG_INTERNAL_IP6_DHCP12:
case IKEV2_CFG_INTERNAL_IP6_SERVER23457:
	/* 16 bytes IPv6 address */
	in6 = (struct sockaddr_in6 *)&ikecfg->cfg.address.addr;
	cfg->cfg_length = htobe16(16)(__uint16_t)(__builtin_constant_p(16) ? (__uint16_t)(((__uint16_t
)(16) & 0xffU) << 8 | ((__uint16_t)(16) & 0xff00U
) >> 8) : __swap16md(16));
	if (ibuf_add(buf, &in6->sin6_addr.s6_addr__u6_addr.__u6_addr8, 16) == -1)
		return (-1);
	len += 16;
	break;
case IKEV2_CFG_INTERNAL_IP6_ADDRESS8:
case IKEV2_CFG_INTERNAL_IP6_SUBNET15:
	/* 16 bytes IPv6 address + 1 byte prefix length */
	in6 = ((ikecfg->cfg_type ==
	    IKEV2_CFG_INTERNAL_IP6_ADDRESS8) &&
	    sa->sa_addrpool6 &&
	    sa->sa_addrpool6->addr_af == AF_INET624) ?
	    (struct sockaddr_in6 *)&sa->sa_addrpool6->addr :
	    (struct sockaddr_in6 *)&ikecfg->cfg.address.addr;
	/* don't include unspecified address in request */
	if (type == IKEV2_CP_REQUEST1 &&
	   IN6_IS_ADDR_UNSPECIFIED(&in6->sin6_addr)((*(const u_int32_t *)(const void *)(&(&in6->sin6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&in6->sin6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&in6->sin6_addr)->__u6_addr.__u6_addr8[8]
) == 0) && (*(const u_int32_t *)(const void *)(&(
&in6->sin6_addr)->__u6_addr.__u6_addr8[12]) == 0)))
		break;
	cfg->cfg_length = htobe16(17)(__uint16_t)(__builtin_constant_p(17) ? (__uint16_t)(((__uint16_t
)(17) & 0xffU) << 8 | ((__uint16_t)(17) & 0xff00U
) >> 8) : __swap16md(17));
	if (ibuf_add(buf, &in6->sin6_addr.s6_addr__u6_addr.__u6_addr8, 16) == -1)
		return (-1);
	if (ikecfg->cfg.address.addr_net)
		prefixlen = ikecfg->cfg.address.addr_mask;
	else
		prefixlen = 128;
	if (ibuf_add(buf, &prefixlen, 1) == -1)
		return (-1);
	len += 16 + 1;
	if (ikecfg->cfg_type == IKEV2_CFG_INTERNAL_IP6_ADDRESS8)
		sent_addr6 = 1;
	break;
case IKEV2_CFG_APPLICATION_VERSION7:
	/* Reply with an empty string (non-NUL terminated) */
	cfg->cfg_length = 0;
	break;
}
}

/* derive netmask from pool */
if (type == IKEV2_CP_REPLY2 && have_mask4 && !sent_mask4) {
if ((cfg = ibuf_reserve(buf, sizeof(*cfg))) == NULL((void *)0))
	return (-1);
cfg->cfg_type = htobe16(IKEV2_CFG_INTERNAL_IP4_NETMASK)(__uint16_t)(__builtin_constant_p(2) ? (__uint16_t)(((__uint16_t
)(2) & 0xffU) << 8 | ((__uint16_t)(2) & 0xff00U
) >> 8) : __swap16md(2));
len += sizeof(*cfg);
mask4 = prefixlen2mask(sa->sa_addrpool->addr_mask);
cfg->cfg_length = htobe16(4)(__uint16_t)(__builtin_constant_p(4) ? (__uint16_t)(((__uint16_t
)(4) & 0xffU) << 8 | ((__uint16_t)(4) & 0xff00U
) >> 8) : __swap16md(4));
if (ibuf_add(buf, &mask4, 4) == -1)
	return (-1);
len += 4;
}

return (len);
2603}

2605ssize_t
2606ikev2_init_add_cp(struct iked *env, struct iked_sa *sa, struct ibuf *buf)
2607{
return (ikev2_add_cp(env, sa, IKEV2_CP_REQUEST1, buf));
2609}

2611ssize_t
2612ikev2_resp_add_cp(struct iked *env, struct iked_sa *sa, struct ibuf *buf)
2613{
int			 ret;

switch (sa->sa_cp) {
case IKEV2_CP_REQUEST1:
ret = ikev2_add_cp(env, sa, IKEV2_CP_REPLY2, buf);
break;
case IKEV2_CP_REPLY2:
case IKEV2_CP_SET3:
case IKEV2_CP_ACK4:
default:
/* Not yet supported */
ret = -1;
}
return (ret);
2628}

2630ssize_t
2631ikev2_add_proposals(struct iked *env, struct iked_sa *sa, struct ibuf *buf,
  struct iked_proposals *proposals, uint8_t protoid, int initiator,
  int sendikespi, int skipdh)
2634{
struct ikev2_sa_proposal	*sap = NULL((void *)0);
struct iked_transform		*xform;
struct iked_proposal		*prop;
struct iked_childsa		 csa;
ssize_t				 length = 0, saplength, xflen;
uint64_t			 spi64;
uint32_t			 spi32, spi = 0;
unsigned int			 i, xfi, nxforms;
int				 prop_skipdh;

TAILQ_FOREACH(prop, proposals, prop_entry)for((prop) = ((proposals)->tqh_first); (prop) != ((void *)
0); (prop) = ((prop)->prop_entry.tqe_next)) {
if ((protoid && prop->prop_protoid != protoid) ||
    (!protoid && prop->prop_protoid == IKEV2_SAPROTO_IKE1))
	continue;

prop_skipdh = skipdh;

if (protoid != IKEV2_SAPROTO_IKE1 && initiator) {
	if (spi == 0) {
		bzero(&csa, sizeof(csa));
		csa.csa_ikesa = sa;
		csa.csa_saproto = prop->prop_protoid;
		csa.csa_local = &sa->sa_peer;
		csa.csa_peer = &sa->sa_local;

		if (pfkey_sa_init(env, &csa, &spi) == -1)
			return (-1);
	}

	prop->prop_localspi.spi = spi;
	prop->prop_localspi.spi_size = 4;
	prop->prop_localspi.spi_protoid = prop->prop_protoid;
}

if ((sap = ibuf_reserve(buf, sizeof(*sap))) == NULL((void *)0)) {
	log_debug("%s: failed to add proposal", __func__);
	return (-1);
}

if (sendikespi) {
	/* Special case for IKE SA rekeying */
	prop->prop_localspi.spi = initiator ?
	    sa->sa_hdr.sh_ispi : sa->sa_hdr.sh_rspi;
	prop->prop_localspi.spi_size = 8;
	prop->prop_localspi.spi_protoid = IKEV2_SAPROTO_IKE1;
}

/*
 * A single DH transform of type NONE is equivalent with
 * not sending a DH transform at all.
 * Prefer the latter for downwards compatibility.
 */
if (protoid != IKEV2_SAPROTO_IKE1) {
	for (i = 0; i < prop->prop_nxforms; i++) {
		xform = prop->prop_xforms + i;
		if (xform->xform_type == IKEV2_XFORMTYPE_DH4 &&
		    xform->xform_id != IKEV2_XFORMDH_NONE0)
			break;
	}
	if (i == prop->prop_nxforms)
		prop_skipdh = 1;
}

/*
 * RFC 7296: 1.2. The Initial Exchanges
 * IKE_AUTH messages do not contain KE/N payloads, thus
 * SA payloads cannot contain groups.
 */
if (prop_skipdh) {
	nxforms = 0;
	for (i = 0; i < prop->prop_nxforms; i++) {
		xform = prop->prop_xforms + i;
		if (xform->xform_type == IKEV2_XFORMTYPE_DH4)
			continue;
		nxforms++;
	}
} else
	nxforms = prop->prop_nxforms;

sap->sap_more = IKEV1_PAYLOAD_PROPOSAL2;
sap->sap_proposalnr = prop->prop_id;
sap->sap_protoid = prop->prop_protoid;
sap->sap_spisize = prop->prop_localspi.spi_size;
sap->sap_transforms = nxforms;
saplength = sizeof(*sap);

switch (prop->prop_localspi.spi_size) {
case 4:
	spi32 = htobe32(prop->prop_localspi.spi)(__uint32_t)(__builtin_constant_p(prop->prop_localspi.spi)
 ? (__uint32_t)(((__uint32_t)(prop->prop_localspi.spi) &
 0xff) << 24 | ((__uint32_t)(prop->prop_localspi.spi
) & 0xff00) << 8 | ((__uint32_t)(prop->prop_localspi
.spi) & 0xff0000) >> 8 | ((__uint32_t)(prop->prop_localspi
.spi) & 0xff000000) >> 24) : __swap32md(prop->prop_localspi
.spi));
	if (ibuf_add(buf, &spi32, sizeof(spi32)) != 0)
		return (-1);
	saplength += 4;
	break;
case 8:
	spi64 = htobe64(prop->prop_localspi.spi)(__uint64_t)(__builtin_constant_p(prop->prop_localspi.spi)
 ? (__uint64_t)((((__uint64_t)(prop->prop_localspi.spi) &
 0xff) << 56) | ((__uint64_t)(prop->prop_localspi.spi
) & 0xff00ULL) << 40 | ((__uint64_t)(prop->prop_localspi
.spi) & 0xff0000ULL) << 24 | ((__uint64_t)(prop->
prop_localspi.spi) & 0xff000000ULL) << 8 | ((__uint64_t
)(prop->prop_localspi.spi) & 0xff00000000ULL) >>
| ((__uint64_t)(prop->prop_localspi.spi) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(prop->prop_localspi.spi) &
 0xff000000000000ULL) >> 40 | ((__uint64_t)(prop->prop_localspi
.spi) & 0xff00000000000000ULL) >> 56) : __swap64md(
prop->prop_localspi.spi));
	if (ibuf_add(buf, &spi64, sizeof(spi64)) != 0)
		return (-1);
	saplength += 8;
	break;
default:
	break;
}

for (i = 0, xfi = 0; i < prop->prop_nxforms; i++) {
	xform = prop->prop_xforms + i;

	if (prop_skipdh && xform->xform_type == IKEV2_XFORMTYPE_DH4)
		continue;

	if ((xflen = ikev2_add_transform(buf,
	    xfi == nxforms - 1 ?
	    IKEV2_XFORM_LAST0 : IKEV2_XFORM_MORE3,
	    xform->xform_type, xform->xform_id,
	    xform->xform_length)) == -1)
		return (-1);

	xfi++;
	saplength += xflen;
}

sap->sap_length = htobe16(saplength)(__uint16_t)(__builtin_constant_p(saplength) ? (__uint16_t)((
(__uint16_t)(saplength) & 0xffU) << 8 | ((__uint16_t
)(saplength) & 0xff00U) >> 8) : __swap16md(saplength
));
length += saplength;
}
if (sap != NULL((void *)0))
sap->sap_more = IKEV1_PAYLOAD_NONE0;

log_debug("%s: length %zd", __func__, length);

return (length);
2764}

2766ssize_t
2767ikev2_add_transform(struct ibuf *buf,
  uint8_t more, uint8_t type, uint16_t id, uint16_t length)
2769{
struct ikev2_transform	*xfrm;
struct ikev2_attribute	*attr;

if ((xfrm = ibuf_reserve(buf, sizeof(*xfrm))) == NULL((void *)0)) {
log_debug("%s: failed to add transform", __func__);
return (-1);
}
xfrm->xfrm_more = more;
xfrm->xfrm_type = type;
xfrm->xfrm_id = htobe16(id)(__uint16_t)(__builtin_constant_p(id) ? (__uint16_t)(((__uint16_t
)(id) & 0xffU) << 8 | ((__uint16_t)(id) & 0xff00U
) >> 8) : __swap16md(id));

if (length) {
xfrm->xfrm_length = htobe16(sizeof(*xfrm) + sizeof(*attr))(__uint16_t)(__builtin_constant_p(sizeof(*xfrm) + sizeof(*attr
)) ? (__uint16_t)(((__uint16_t)(sizeof(*xfrm) + sizeof(*attr)
) & 0xffU) << 8 | ((__uint16_t)(sizeof(*xfrm) + sizeof
(*attr)) & 0xff00U) >> 8) : __swap16md(sizeof(*xfrm
) + sizeof(*attr)));

if ((attr = ibuf_reserve(buf, sizeof(*attr))) == NULL((void *)0)) {
	log_debug("%s: failed to add attribute", __func__);
	return (-1);
}
attr->attr_type = htobe16(IKEV2_ATTRAF_TV |(__uint16_t)(__builtin_constant_p(0x8000 | 14) ? (__uint16_t)
(((__uint16_t)(0x8000 | 14) & 0xffU) << 8 | ((__uint16_t
)(0x8000 | 14) & 0xff00U) >> 8) : __swap16md(0x8000
 | 14))
    IKEV2_ATTRTYPE_KEY_LENGTH)(__uint16_t)(__builtin_constant_p(0x8000 | 14) ? (__uint16_t)
(((__uint16_t)(0x8000 | 14) & 0xffU) << 8 | ((__uint16_t
)(0x8000 | 14) & 0xff00U) >> 8) : __swap16md(0x8000
 | 14));
attr->attr_length = htobe16(length)(__uint16_t)(__builtin_constant_p(length) ? (__uint16_t)(((__uint16_t
)(length) & 0xffU) << 8 | ((__uint16_t)(length) &
 0xff00U) >> 8) : __swap16md(length));
} else
xfrm->xfrm_length = htobe16(sizeof(*xfrm))(__uint16_t)(__builtin_constant_p(sizeof(*xfrm)) ? (__uint16_t
)(((__uint16_t)(sizeof(*xfrm)) & 0xffU) << 8 | ((__uint16_t
)(sizeof(*xfrm)) & 0xff00U) >> 8) : __swap16md(sizeof
(*xfrm)));

return (betoh16(xfrm->xfrm_length)(__uint16_t)(__builtin_constant_p(xfrm->xfrm_length) ? (__uint16_t
)(((__uint16_t)(xfrm->xfrm_length) & 0xffU) << 8
 | ((__uint16_t)(xfrm->xfrm_length) & 0xff00U) >>
 8) : __swap16md(xfrm->xfrm_length)));
2795}

2797int
2798ikev2_add_data(struct ibuf *buf, void *data, size_t length)
2799{
void	*msgbuf;

if ((msgbuf = ibuf_reserve(buf, length)) == NULL((void *)0)) {
log_debug("%s: failed", __func__);
return (-1);
}
memcpy(msgbuf, data, length);

return (0);
2809}

2811int
2812ikev2_add_buf(struct ibuf *buf, struct ibuf *data)
2813{
void	*msgbuf;

if ((msgbuf = ibuf_reserve(buf, ibuf_size(data))) == NULL((void *)0)) {
log_debug("%s: failed", __func__);
return (-1);
}
memcpy(msgbuf, ibuf_data(data), ibuf_size(data));

return (0);
2823}

2825int
2826ikev2_resp_informational(struct iked *env, struct iked_sa *sa,
  struct iked_message *msg)
2828{
struct ikev2_notify		*n;
struct ikev2_payload		*pld = NULL((void *)0);
struct ibuf			*buf = NULL((void *)0);
ssize_t				 len = 0;
int				 ret = -1;
uint8_t				 firstpayload = IKEV2_PAYLOAD_NONE0;

if (!sa_stateok(sa, IKEV2_STATE_AUTH_REQUEST5) ||
   msg->msg_responded || msg->msg_error)
goto done;

if ((buf = ibuf_static()) == NULL((void *)0))
goto done;

if ((len = ikev2_handle_delete(env, msg, buf, &pld,
   &firstpayload)) == -1)
goto done;

/*
* Include NAT_DETECTION notification on UPDATE_SA_ADDRESSES or if
* the peer did include them, too (RFC 4555, 3.8).
*/
if (sa->sa_mobike &&
   (msg->msg_update_sa_addresses || msg->msg_natt_rcvd)) {
/* NAT-T notify payloads */
len = ikev2_add_nat_detection(env, buf, &pld, msg, len);
if (len == -1)
	goto done;
firstpayload = IKEV2_PAYLOAD_NOTIFY41;
}
/* Reflect COOKIE2 */
if (msg->msg_cookie2) {
/* *pld is NULL if there is no previous payload */
if (pld != NULL((void *)0)) {
	if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NOTIFY41) == -1)
		goto done;
}
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
	goto done;
if ((n = ibuf_reserve(buf, sizeof(*n))) == NULL((void *)0))
	goto done;
n->n_protoid = IKEV2_SAPROTO_IKE1;
n->n_spisize = 0;
n->n_type = htobe16(IKEV2_N_COOKIE2)(__uint16_t)(__builtin_constant_p(16401) ? (__uint16_t)(((__uint16_t
)(16401) & 0xffU) << 8 | ((__uint16_t)(16401) &
 0xff00U) >> 8) : __swap16md(16401));
if (ikev2_add_buf(buf, msg->msg_cookie2) == -1)
	goto done;
len = sizeof(*n) + ibuf_size(msg->msg_cookie2);
log_debug("%s: added cookie2", __func__);
if (firstpayload == IKEV2_PAYLOAD_NONE0)
	firstpayload = IKEV2_PAYLOAD_NOTIFY41;
}
/* add terminator, if there is already a payload */
if (firstpayload != IKEV2_PAYLOAD_NONE0)
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
	goto done;
ret = ikev2_msg_send_encrypt(env, sa, &buf,
   IKEV2_EXCHANGE_INFORMATIONAL37, firstpayload, 1);
if (ret != -1)
msg->msg_responded = 1;
if (msg->msg_flags & IKED_MSG_FLAGS_AUTHENTICATION_FAILED0x0020) {
log_debug("%s: AUTHENTICATION_FAILED, closing SA",
    __func__);
ikev2_log_cert_info(SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    sa->sa_hdr.sh_initiator ? &sa->sa_rcert : &sa->sa_icert);
ikev2_ike_sa_setreason(sa,
    "authentication failed notification from peer");
sa_state(env, sa, IKEV2_STATE_CLOSED11);
}
done:
ibuf_free(buf);
return (ret);
2900}

2902void
2903ikev2_resp_recv(struct iked *env, struct iked_message *msg,
  struct ike_header *hdr)
2905{
struct iked_sa		*sa;

switch (hdr->ike_exchange) {
case IKEV2_EXCHANGE_IKE_SA_INIT34:
if (msg->msg_sa != NULL((void *)0)) {
	log_debug("%s: SA already exists", __func__);
	return;
}
if ((msg->msg_sa = sa_new(env,
    betoh64(hdr->ike_ispi)(__uint64_t)(__builtin_constant_p(hdr->ike_ispi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_ispi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_ispi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_ispi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_ispi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_ispi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_ispi)), betoh64(hdr->ike_rspi)(__uint64_t)(__builtin_constant_p(hdr->ike_rspi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_rspi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_rspi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_rspi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_rspi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_rspi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_rspi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_rspi)),
    0, msg->msg_policy)) == NULL((void *)0)) {
	log_debug("%s: failed to get new SA", __func__);
	return;
}
/* Setup exchange timeout. */
timer_set(env, &msg->msg_sa->sa_timer,
    ikev2_init_ike_sa_timeout, msg->msg_sa);
timer_add(env, &msg->msg_sa->sa_timer,
    IKED_IKE_SA_EXCHANGE_TIMEOUT300);
break;
case IKEV2_EXCHANGE_IKE_AUTH35:
if (ikev2_msg_valid_ike_sa(env, hdr, msg) == -1)
	return;
if (sa_stateok(msg->msg_sa, IKEV2_STATE_VALID7)) {
	log_debug("%s: already authenticated", __func__);
	return;
}
break;
case IKEV2_EXCHANGE_CREATE_CHILD_SA36:
case IKEV2_EXCHANGE_INFORMATIONAL37:
if (ikev2_msg_valid_ike_sa(env, hdr, msg) == -1)
	return;
break;
default:
log_debug("%s: unsupported exchange: %s", __func__,
    print_map(hdr->ike_exchange, ikev2_exchange_map));
return;
}

if (ikev2_pld_parse(env, hdr, msg, msg->msg_offset) != 0) {
log_info("%s: failed to parse message",
    SPI_SA(msg->msg_sa, __func__)ikev2_ikesa_info((&(msg->msg_sa)->sa_hdr)->sh_ispi
, ((__func__))));
return;
}

if (!ikev2_msg_frompeer(msg))
return;

if (ikev2_handle_notifies(env, msg) != 0)
return;

if ((sa = msg->msg_sa) == NULL((void *)0))
return;

if (sa->sa_fragments.frag_count != 0)
return;

msg->msg_valid = 1;

if (msg->msg_natt && sa->sa_natt == 0) {
log_debug("%s: NAT-T message received, updated SA", __func__);
sa->sa_natt = 1;
}

switch (hdr->ike_exchange) {
case IKEV2_EXCHANGE_IKE_SA_INIT34:
if (ikev2_sa_responder(env, sa, NULL((void *)0), msg) != 0) {
	log_info("%s: failed to negotiate IKE SA",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	if (msg->msg_error == 0)
		msg->msg_error = IKEV2_N_NO_PROPOSAL_CHOSEN14;
	ikev2_send_init_error(env, msg);
	ikev2_ike_sa_setreason(sa, "no proposal chosen");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	return;
}
if (ikev2_resp_ike_sa_init(env, msg) != 0) {
	log_debug("%s: failed to send init response", __func__);
	ikev2_ike_sa_setreason(sa, "SA_INIT response failed");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	return;
}
break;
case IKEV2_EXCHANGE_IKE_AUTH35:
if (!sa_stateok(sa, IKEV2_STATE_SA_INIT2)) {
	log_debug("%s: state mismatch", __func__);
	ikev2_ike_sa_setreason(sa, "state mismatch IKE_AUTH");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	return;
}

/* Handle EAP authentication */
if (msg->msg_eap.eam_found) {
	if (ikev2_resp_ike_eap(env, sa, msg)) {
		log_info("%s: failed eap response",
		    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
		ikev2_ike_sa_setreason(sa, "EAP failed");
		sa_state(env, sa, IKEV2_STATE_CLOSED11);
		return;
	}
	return;
}

if (ikev2_ike_auth_recv(env, sa, msg) != 0) {
	log_debug("%s: failed to send auth response", __func__);
	ikev2_send_error(env, sa, msg, hdr->ike_exchange);
	ikev2_ike_sa_setreason(sa, "IKE_AUTH failed");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	return;
}
break;
case IKEV2_EXCHANGE_CREATE_CHILD_SA36:
if (ikev2_resp_create_child_sa(env, msg) != 0) {
	if (msg->msg_error == 0)
		msg->msg_error = IKEV2_N_NO_PROPOSAL_CHOSEN14;
	ikev2_send_error(env, sa, msg, hdr->ike_exchange);
}
break;
case IKEV2_EXCHANGE_INFORMATIONAL37:
if (msg->msg_update_sa_addresses)
	ikev2_update_sa_addresses(env, sa);
(void)ikev2_resp_informational(env, sa, msg);
break;
default:
break;
}
3032}

3034ssize_t
3035ikev2_handle_delete(struct iked *env, struct iked_message *msg,
  struct ibuf *resp, struct ikev2_payload **pld, uint8_t *firstpayload)
3037{
struct iked_childsa	**peersas = NULL((void *)0);
struct iked_sa		*sa = msg->msg_sa;
struct ikev2_delete	*localdel;
FILE			*spif;
char			*spibuf = NULL((void *)0);
uint64_t		*localspi = NULL((void *)0);
uint64_t		 spi64, spi = 0;
uint32_t		 spi32;
uint8_t			*buf;
size_t			 found = 0;
int			 ret = -1;
size_t			 i, sz, cnt, len, dummy;

if (!msg->msg_del_protoid)
return (0);

if ((spif = open_memstream(&spibuf, &dummy)) == NULL((void *)0)) {
log_warn("%s", __func__);
return (0);
}

sz = msg->msg_del_spisize;

switch (sz) {
case 4:
case 8:
break;
case 0:
if (msg->msg_del_protoid != IKEV2_SAPROTO_IKE1) {
	log_debug("%s: invalid SPI size", __func__);
	goto done;
}
ikev2_ikesa_recv_delete(env, sa);
return (0);
default:
log_info("%s: error: invalid SPI size", __func__);
goto done;
}

cnt = msg->msg_del_cnt;
len = ibuf_length(msg->msg_del_buf);

if ((len / sz) != cnt) {
log_debug("%s: invalid payload length %zu/%zu != %zu",
    __func__, len, sz, cnt);
return (-1);
}

if (((peersas = calloc(cnt, sizeof(struct iked_childsa *))) == NULL((void *)0) ||
    (localspi = calloc(cnt, sizeof(uint64_t))) == NULL((void *)0))) {
log_warn("%s", __func__);
goto done;
}

buf = ibuf_data(msg->msg_del_buf);
for (i = 0; i < cnt; i++) {
switch (sz) {
case 4:
	memcpy(&spi32, buf + (i * sz), sizeof(spi32));
	spi = betoh32(spi32)(__uint32_t)(__builtin_constant_p(spi32) ? (__uint32_t)(((__uint32_t
)(spi32) & 0xff) << 24 | ((__uint32_t)(spi32) &
 0xff00) << 8 | ((__uint32_t)(spi32) & 0xff0000) >>
| ((__uint32_t)(spi32) & 0xff000000) >> 24) : __swap32md
(spi32));
	break;
case 8:
	memcpy(&spi64, buf + (i * sz), sizeof(spi64));
	spi = betoh64(spi64)(__uint64_t)(__builtin_constant_p(spi64) ? (__uint64_t)((((__uint64_t
)(spi64) & 0xff) << 56) | ((__uint64_t)(spi64) &
 0xff00ULL) << 40 | ((__uint64_t)(spi64) & 0xff0000ULL
) << 24 | ((__uint64_t)(spi64) & 0xff000000ULL) <<
| ((__uint64_t)(spi64) & 0xff00000000ULL) >> 8 |
 ((__uint64_t)(spi64) & 0xff0000000000ULL) >> 24 | (
(__uint64_t)(spi64) & 0xff000000000000ULL) >> 40 | (
(__uint64_t)(spi64) & 0xff00000000000000ULL) >> 56)
 : __swap64md(spi64));
	break;
}

log_debug("%s: spi %s", __func__, print_spi(spi, sz));

if (peersas == NULL((void *)0) || sa == NULL((void *)0))
	continue;

if ((peersas[i] = childsa_lookup(sa, spi,
    msg->msg_del_protoid)) == NULL((void *)0)) {
	log_warnx("%s: CHILD SA doesn't exist for spi %s",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
	    print_spi(spi, sz));
	continue;
}

if (ikev2_childsa_delete(env, sa, msg->msg_del_protoid, spi,
    &localspi[i], 0) != -1) {
	found++;
	/* append SPI to log buffer */
	if (ftello(spif) > 0)
		fputs(", ", spif);
	fputs(print_spi(spi, sz), spif);
}

/*
 * Flows are left in the require mode so that it would be
 * possible to quickly negotiate a new Child SA
 */
}

if (resp == NULL((void *)0)) {
ret = 0;
goto done;
}

/* Response to the INFORMATIONAL with Delete payload */
if (found) {
if ((*pld = ikev2_add_payload(resp)) == NULL((void *)0))
	goto done;
*firstpayload = IKEV2_PAYLOAD_DELETE42;

if ((localdel = ibuf_reserve(resp, sizeof(*localdel))) == NULL((void *)0))
	goto done;

localdel->del_protoid = msg->msg_del_protoid;
localdel->del_spisize = sz;
localdel->del_nspi = htobe16(found)(__uint16_t)(__builtin_constant_p(found) ? (__uint16_t)(((__uint16_t
)(found) & 0xffU) << 8 | ((__uint16_t)(found) &
 0xff00U) >> 8) : __swap16md(found));
ret = sizeof(*localdel);

for (i = 0; i < cnt; i++) {
	if (localspi[i] == 0)	/* happens if found < cnt */
		continue;
	switch (sz) {
	case 4:
		spi32 = htobe32(localspi[i])(__uint32_t)(__builtin_constant_p(localspi[i]) ? (__uint32_t)
(((__uint32_t)(localspi[i]) & 0xff) << 24 | ((__uint32_t
)(localspi[i]) & 0xff00) << 8 | ((__uint32_t)(localspi
[i]) & 0xff0000) >> 8 | ((__uint32_t)(localspi[i]) &
 0xff000000) >> 24) : __swap32md(localspi[i]));
		if (ibuf_add(resp, &spi32, sizeof(spi32)) != 0)
			goto done;
		ret += sizeof(spi32);
		break;
	case 8:
		spi64 = htobe64(localspi[i])(__uint64_t)(__builtin_constant_p(localspi[i]) ? (__uint64_t)
((((__uint64_t)(localspi[i]) & 0xff) << 56) | ((__uint64_t
)(localspi[i]) & 0xff00ULL) << 40 | ((__uint64_t)(localspi
[i]) & 0xff0000ULL) << 24 | ((__uint64_t)(localspi[
i]) & 0xff000000ULL) << 8 | ((__uint64_t)(localspi[
i]) & 0xff00000000ULL) >> 8 | ((__uint64_t)(localspi
[i]) & 0xff0000000000ULL) >> 24 | ((__uint64_t)(localspi
[i]) & 0xff000000000000ULL) >> 40 | ((__uint64_t)(localspi
[i]) & 0xff00000000000000ULL) >> 56) : __swap64md(localspi
[i]));
		if (ibuf_add(resp, &spi64, sizeof(spi64)) != 0)
			goto done;
		ret += sizeof(spi64);
		break;
	}
}
fflush(spif);
if (!ferror(spif)(!__isthreaded ? (((spif)->_flags & 0x0040) != 0) : (ferror
)(spif))) {
	log_info("%sdeleted %zu SPI%s: %s",
	    SPI_SA(sa, NULL)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((((void
 *)0)))), found, found == 1 ? "" : "s",
	    spibuf);
}
} else {
/* XXX should we send an INVALID_SPI notification? */
ret = 0;
}

done:
free(localspi);
free(peersas);
fclose(spif);
free(spibuf);

return (ret);
3188}

3190int
3191ikev2_handle_notifies(struct iked *env, struct iked_message *msg)
3192{
struct iked_ipcomp	*ic;
struct iked_sa		*sa;
struct iked_spi		 rekey;
struct dh_group		*group;
uint16_t		 groupid;
unsigned int		 protoid;

if ((sa = msg->msg_sa) == NULL((void *)0))
return (-1);

if (msg->msg_flags & IKED_MSG_FLAGS_CHILD_SA_NOT_FOUND0x0008)
sa->sa_stateflags &= ~IKED_REQ_CHILDSA0x0080;

if ((msg->msg_flags & IKED_MSG_FLAGS_FRAGMENTATION0x0001) && env->sc_fragsc_static.st_frag) {
log_debug("%s: fragmentation enabled", __func__);
sa->sa_frag = 1;
}

if ((msg->msg_flags & IKED_MSG_FLAGS_MOBIKE0x0002) && env->sc_mobikesc_static.st_mobike) {
log_debug("%s: mobike enabled", __func__);
sa->sa_mobike = 1;
/* enforce natt */
if (sa->sa_natt == 0 && sa->sa_udpencap == 0)
	ikev2_enable_natt(env, sa, msg, 0);
}

if ((msg->msg_flags & IKED_MSG_FLAGS_NO_ADDITIONAL_SAS0x0010)
   && sa->sa_stateflags & IKED_REQ_CHILDSA0x0080) {
/* This makes sense for Child SAs only atm */
ikev2_disable_rekeying(env, sa);
sa->sa_stateflags &= ~IKED_REQ_CHILDSA0x0080;
}

if (msg->msg_flags & IKED_MSG_FLAGS_INVALID_KE0x0040) {
groupid = betoh16(msg->msg_group)(__uint16_t)(__builtin_constant_p(msg->msg_group) ? (__uint16_t
)(((__uint16_t)(msg->msg_group) & 0xffU) << 8 | (
(__uint16_t)(msg->msg_group) & 0xff00U) >> 8) : __swap16md
(msg->msg_group));
if (group_getid(groupid) == NULL((void *)0)) {
	log_debug("%s: unable to select DH group %u",
	    __func__, groupid);
	ikev2_ike_sa_setreason(sa,
	    "unable to select DH group");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	msg->msg_sa = NULL((void *)0);
	return (-1);
}
log_debug("%s: responder selected DH group %u", __func__,
    groupid);
switch (msg->msg_exchange) {
case IKEV2_EXCHANGE_IKE_SA_INIT34:
	protoid = IKEV2_SAPROTO_IKE1;
	if (!sa->sa_hdr.sh_initiator) {
		log_debug("%s: not an initiator", __func__);
		ikev2_ike_sa_setreason(sa,
		    "received invalid KE as responder");
		sa_state(env, sa, IKEV2_STATE_CLOSED11);
		msg->msg_sa = NULL((void *)0);
		return (-1);
	}
	if (config_findtransform_ext(&msg->msg_policy->pol_proposals,
	    IKEV2_XFORMTYPE_DH4, groupid, protoid) == NULL((void *)0)) {
		log_debug("%s: DH group %u denied by policy",
		    __func__, groupid);
		ikev2_ike_sa_setreason(sa,
		    "unsupported group in INVALID_KE message");
		sa_state(env, sa, IKEV2_STATE_CLOSED11);
		msg->msg_sa = NULL((void *)0);
		return (-1);
	}
	ikev2_ike_sa_setreason(sa,
	    "reinitiating with new DH group");
	sa_state(env, sa, IKEV2_STATE_CLOSED11);
	msg->msg_sa = NULL((void *)0);
	msg->msg_policy->pol_peerdh = groupid;
	timer_set(env, &env->sc_inittmr, ikev2_init_ike_sa, NULL((void *)0));
	timer_add(env, &env->sc_inittmr, IKED_INITIATOR_INITIAL2);
	return (-1);
case IKEV2_EXCHANGE_CREATE_CHILD_SA36:
	if (!(sa->sa_stateflags & IKED_REQ_CHILDSA0x0080)) {
		log_debug("%s: IKED_REQ_CHILDSA missing",
		    __func__);
		return (-1);
	}
	sa->sa_stateflags &= ~IKED_REQ_CHILDSA0x0080;
	protoid = sa->sa_rekeyspi ?
	    IKEV2_SAPROTO_ESP3 : IKEV2_SAPROTO_IKE1;
	if (config_findtransform_ext(&msg->msg_policy->pol_proposals,
	    IKEV2_XFORMTYPE_DH4, groupid, protoid) == NULL((void *)0)) {
		log_debug("%s: DH group %u denied by policy",
		    __func__, groupid);
		ikev2_ike_sa_setreason(sa,
		    "unsupported group in INVALID_KE message");
		sa_state(env, sa, IKEV2_STATE_CLOSED11);
		msg->msg_sa = NULL((void *)0);
		return (-1);
	}
	if (protoid == IKEV2_SAPROTO_ESP3) {
		/* CHILDSA */
		rekey.spi = sa->sa_rekeyspi;
		rekey.spi_size = 4;
		rekey.spi_protoid = protoid;
		(void)ikev2_send_create_child_sa(env, sa,
		    &rekey, rekey.spi_protoid, groupid);
	} else {
		/* IKESA */
		if ((group = group_get(groupid)) == NULL((void *)0))
			return -1;
		group_free(sa->sa_dhgroupsa_kex.kex_dhgroup);
		sa->sa_dhgroupsa_kex.kex_dhgroup = group;
		timer_set(env, &sa->sa_rekey,
		    ikev2_ike_sa_rekey, sa);
		timer_add(env, &sa->sa_rekey, 0);
	}
	return (-1);
}
}

if (msg->msg_flags & IKED_MSG_FLAGS_IPCOMP_SUPPORTED0x0080) {
/* we only support deflate */
if ((msg->msg_policy->pol_flags & IKED_POLICY_IPCOMP0x20) &&
    (msg->msg_transform == IKEV2_IPCOMP_DEFLATE2)) {
	ic = msg->msg_response ?
	    &sa->sa_ipcompi :
	    &sa->sa_ipcompr;
	ic->ic_transform = msg->msg_transform;
	ic->ic_cpi_out = betoh16(msg->msg_cpi)(__uint16_t)(__builtin_constant_p(msg->msg_cpi) ? (__uint16_t
)(((__uint16_t)(msg->msg_cpi) & 0xffU) << 8 | ((
__uint16_t)(msg->msg_cpi) & 0xff00U) >> 8) : __swap16md
(msg->msg_cpi));
}
}

if (msg->msg_nat_detected & IKED_MSG_NAT_DST_IP0x02) {
/* Send keepalive, since we are behind a NAT-gw */
sa->sa_usekeepalive = 1;
}

/* Signature hash algorithm */
if (msg->msg_flags & IKED_MSG_FLAGS_SIGSHA20x0004)
sa->sa_sigsha2 = 1;

if (msg->msg_flags & IKED_MSG_FLAGS_USE_TRANSPORT0x0100)
sa->sa_use_transport_mode = 1;

if ((msg->msg_flags & IKED_MSG_FLAGS_TEMPORARY_FAILURE0x0200)
   && sa->sa_nexti != NULL((void *)0))
sa->sa_tmpfail = 1;

return (0);
3337}

3339int
3340ikev2_resp_ike_sa_init(struct iked *env, struct iked_message *msg)
3341{
struct iked_message		 resp;
struct ike_header		*hdr;
struct ikev2_payload		*pld;
struct ikev2_keyexchange	*ke;
struct iked_sa			*sa = msg->msg_sa;
struct ibuf			*buf;
struct ibuf			*vendor_id = NULL((void *)0);
struct dh_group			*group;
ssize_t				 len;
int				 ret = -1;

if (sa->sa_hdr.sh_initiator) {
log_debug("%s: called by initiator", __func__);
return (-1);
}
if (msg->msg_nat_detected && sa->sa_udpencap == 0) {
log_debug("%s: detected NAT, enabling UDP encapsulation",
    __func__);
sa->sa_udpencap = 1;
}

if ((buf = ikev2_msg_init(env, &resp,
   &msg->msg_peer, msg->msg_peerlen,
   &msg->msg_local, msg->msg_locallen, 1)) == NULL((void *)0))
goto done;

resp.msg_sa = sa;
resp.msg_fd = msg->msg_fd;
resp.msg_natt = msg->msg_natt;
resp.msg_msgid = 0;

/* IKE header */
if ((hdr = ikev2_add_header(buf, sa, resp.msg_msgid,
   IKEV2_PAYLOAD_SA33, IKEV2_EXCHANGE_IKE_SA_INIT34,
   IKEV2_FLAG_RESPONSE0x20)) == NULL((void *)0))
goto done;

/* SA payload */
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
goto done;
if ((len = ikev2_add_proposals(env, sa, buf, &sa->sa_proposals,
   IKEV2_SAPROTO_IKE1, sa->sa_hdr.sh_initiator, 0, 0)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_KE34) == -1)
goto done;

/* KE payload */
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
goto done;
if ((ke = ibuf_reserve(buf, sizeof(*ke))) == NULL((void *)0))
goto done;
if ((group = sa->sa_dhgroupsa_kex.kex_dhgroup) == NULL((void *)0)) {
log_debug("%s: invalid dh", __func__);
goto done;
}
ke->kex_dhgroup = htobe16(group->id)(__uint16_t)(__builtin_constant_p(group->id) ? (__uint16_t
)(((__uint16_t)(group->id) & 0xffU) << 8 | ((__uint16_t
)(group->id) & 0xff00U) >> 8) : __swap16md(group
->id));
if (ikev2_add_buf(buf, sa->sa_dhrexchangesa_kex.kex_dhrexchange) == -1)
goto done;
len = sizeof(*ke) + ibuf_size(sa->sa_dhrexchangesa_kex.kex_dhrexchange);

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONCE40) == -1)
goto done;

/* NONCE payload */
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
goto done;
if (ikev2_add_buf(buf, sa->sa_rnoncesa_kex.kex_rnonce) == -1)
goto done;
len = ibuf_size(sa->sa_rnoncesa_kex.kex_rnonce);

if (env->sc_vendoridsc_static.st_vendorid != 0) {
vendor_id = ibuf_new(IKED_VENDOR_ID"OpenIKED-", strlen(IKED_VENDOR_ID"OpenIKED-"));
ibuf_add(vendor_id, IKED_VERSION"7.2", strlen(IKED_VERSION"7.2"));
if ((len = ikev2_add_vendor_id(buf, &pld, len, vendor_id))
    == -1)
	goto done;
}

/* Fragmentation Notify*/
if (sa->sa_frag) {
if ((len = ikev2_add_fragmentation(buf, &pld, len))
    == -1)
	goto done;
}

if ((env->sc_nattmode != NATT_DISABLE) &&
   msg->msg_local.ss_family != AF_UNSPEC0) {
if ((len = ikev2_add_nat_detection(env, buf, &pld, &resp, len))
    == -1)
	goto done;
}
if (sa->sa_statevalid & IKED_REQ_CERT0x0001) {
/* CERTREQ payload(s) */
if ((len = ikev2_add_certreq(buf, &pld,
    len, env->sc_certreq, env->sc_certreqtype)) == -1)
	goto done;

if (env->sc_certreqtype != sa->sa_policy->pol_certreqtype &&
    (len = ikev2_add_certreq(buf, &pld,
    len, NULL((void *)0), sa->sa_policy->pol_certreqtype)) == -1)
	goto done;
}

if (sa->sa_sigsha2 &&
   (len = ikev2_add_sighashnotify(buf, &pld, len)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
goto done;

if (ikev2_set_header(hdr, ibuf_size(buf) - sizeof(*hdr)) == -1)
goto done;

(void)ikev2_pld_parse(env, hdr, &resp, 0);

ibuf_free(sa->sa_2ndmsg);
if ((sa->sa_2ndmsg = ibuf_dup(buf)) == NULL((void *)0)) {
log_debug("%s: failed to copy 2nd message", __func__);
goto done;
}

ret = ikev2_msg_send(env, &resp);

done:
ibuf_free(vendor_id);
ikev2_msg_cleanup(env, &resp);

return (ret);
3471}

3473int
3474ikev2_send_auth_failed(struct iked *env, struct iked_sa *sa)
3475{
char				 dstid[IKED_ID_SIZE1024];
struct ikev2_notify		*n;
struct ibuf			*buf = NULL((void *)0);
int				 ret = -1, exchange, response;

if (ikev2_print_id(IKESA_DSTID(sa)((sa)->sa_hdr.sh_initiator ? &(sa)->sa_rid : &(
sa)->sa_iid), dstid, sizeof(dstid)) == -1)
bzero(dstid, sizeof(dstid));
log_info("%s: authentication failed for %s",
   SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), dstid);

/* Log certificate information */
ikev2_log_cert_info(SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
   sa->sa_hdr.sh_initiator ? &sa->sa_rcert : &sa->sa_icert);

/* Notify payload */
if ((buf = ibuf_static()) == NULL((void *)0))
goto done;
if ((n = ibuf_reserve(buf, sizeof(*n))) == NULL((void *)0))
goto done;
n->n_protoid = IKEV2_SAPROTO_IKE1;
n->n_spisize = 0;
n->n_type = htobe16(IKEV2_N_AUTHENTICATION_FAILED)(__uint16_t)(__builtin_constant_p(24) ? (__uint16_t)(((__uint16_t
)(24) & 0xffU) << 8 | ((__uint16_t)(24) & 0xff00U
) >> 8) : __swap16md(24));
if (sa->sa_hdr.sh_initiator) {
exchange = IKEV2_EXCHANGE_INFORMATIONAL37;
response = 0;
} else {
exchange = IKEV2_EXCHANGE_IKE_AUTH35;
response = 1;
}
ret = ikev2_send_ike_e(env, sa, buf, IKEV2_PAYLOAD_NOTIFY41,
   exchange, response);
if (exchange == IKEV2_EXCHANGE_INFORMATIONAL37)
sa->sa_stateflags |= IKED_REQ_INF0x0100;
done:
ibuf_free(buf);

/* cleanup SA after timeout */
sa_state(env, sa, IKEV2_STATE_CLOSING10);
timer_del(env, &sa->sa_timer);
timer_set(env, &sa->sa_timer, ikev2_ike_sa_timeout, sa);
timer_add(env, &sa->sa_timer, IKED_IKE_SA_DELETE_TIMEOUT120);
config_free_fragments(&sa->sa_fragments);
ikev2_ike_sa_setreason(sa, "authentication failed");

return (ret);
3521}

3523ssize_t
3524ikev2_add_error(struct iked *env, struct ibuf *buf, struct iked_message *msg)
3525{
struct ikev2_notify		*n;
struct iked_spi			*rekey;
uint16_t			 group;
uint32_t			 spi32;
uint64_t			 spi64;
size_t				 len;
uint8_t				*ptr;

switch (msg->msg_error) {
case IKEV2_N_CHILD_SA_NOT_FOUND44:
break;
case IKEV2_N_NO_PROPOSAL_CHOSEN14:
ikev2_log_proposal(msg->msg_sa, &msg->msg_proposals);
break;
case IKEV2_N_INVALID_KE_PAYLOAD17:
break;
default:
return (-1);
}
log_info("%s: %s", SPI_SA(msg->msg_sa, __func__)ikev2_ikesa_info((&(msg->msg_sa)->sa_hdr)->sh_ispi
, ((__func__))),
   print_map(msg->msg_error, ikev2_n_map));
len = sizeof(*n);
if ((ptr = ibuf_reserve(buf, len)) == NULL((void *)0))
return (-1);
n = (struct ikev2_notify *)ptr;
n->n_type = htobe16(msg->msg_error)(__uint16_t)(__builtin_constant_p(msg->msg_error) ? (__uint16_t
)(((__uint16_t)(msg->msg_error) & 0xffU) << 8 | (
(__uint16_t)(msg->msg_error) & 0xff00U) >> 8) : __swap16md
(msg->msg_error));
switch (msg->msg_error) {
case IKEV2_N_CHILD_SA_NOT_FOUND44:
rekey = &msg->msg_rekey;
switch (rekey->spi_size) {
case 4:
	spi32 = htobe32(rekey->spi)(__uint32_t)(__builtin_constant_p(rekey->spi) ? (__uint32_t
)(((__uint32_t)(rekey->spi) & 0xff) << 24 | ((__uint32_t
)(rekey->spi) & 0xff00) << 8 | ((__uint32_t)(rekey
->spi) & 0xff0000) >> 8 | ((__uint32_t)(rekey->
spi) & 0xff000000) >> 24) : __swap32md(rekey->spi
));
	if (ibuf_add(buf, &spi32, sizeof(spi32)) != 0)
		return (-1);
	len += sizeof(spi32);
	break;
case 8:
	spi64 = htobe64(rekey->spi)(__uint64_t)(__builtin_constant_p(rekey->spi) ? (__uint64_t
)((((__uint64_t)(rekey->spi) & 0xff) << 56) | ((
__uint64_t)(rekey->spi) & 0xff00ULL) << 40 | ((__uint64_t
)(rekey->spi) & 0xff0000ULL) << 24 | ((__uint64_t
)(rekey->spi) & 0xff000000ULL) << 8 | ((__uint64_t
)(rekey->spi) & 0xff00000000ULL) >> 8 | ((__uint64_t
)(rekey->spi) & 0xff0000000000ULL) >> 24 | ((__uint64_t
)(rekey->spi) & 0xff000000000000ULL) >> 40 | ((__uint64_t
)(rekey->spi) & 0xff00000000000000ULL) >> 56) : __swap64md
(rekey->spi));
	if (ibuf_add(buf, &spi64, sizeof(spi64)) != 0)
		return (-1);
	len += sizeof(spi64);
	break;
default:
	log_debug("%s: invalid SPI size %d", __func__,
	    rekey->spi_size);
	return (-1);
}
n->n_protoid = rekey->spi_protoid;
n->n_spisize = rekey->spi_size;
break;
case IKEV2_N_INVALID_KE_PAYLOAD17:
group = htobe16(msg->msg_dhgroup)(__uint16_t)(__builtin_constant_p(msg->msg_dhgroup) ? (__uint16_t
)(((__uint16_t)(msg->msg_dhgroup) & 0xffU) << 8 |
 ((__uint16_t)(msg->msg_dhgroup) & 0xff00U) >> 8
) : __swap16md(msg->msg_dhgroup));
if (ibuf_add(buf, &group, sizeof(group)) != 0)
	return (-1);
len += sizeof(group);
n->n_protoid = 0;
n->n_spisize = 0;
break;
default:
n->n_protoid = 0;
n->n_spisize = 0;
break;
}
log_debug("%s: done", __func__);

return (len);
3592}

3594int
3595ikev2_record_dstid(struct iked *env, struct iked_sa *sa)
3596{
struct iked_sa *osa;

osa = sa_dstid_lookup(env, sa);
if (osa == sa)
return (0);
if (osa != NULL((void *)0)) {
sa_dstid_remove(env, osa);
if (env->sc_enforcesingleikesasc_static.st_enforcesingleikesa &&
    osa->sa_state < IKEV2_STATE_CLOSING10) {
	log_info("%sreplaced by IKESA %s (identical DSTID)",
	    SPI_SA(osa, NULL)ikev2_ikesa_info((&(osa)->sa_hdr)->sh_ispi, ((((void
 *)0)))),
	    print_spi(sa->sa_hdr.sh_ispi, 8));
	if (osa->sa_state == IKEV2_STATE_ESTABLISHED9)
		ikev2_disable_timer(env, osa);
	ikev2_ike_sa_setreason(osa, "sa replaced");
	ikev2_ikesa_delete(env, osa, 0);
	timer_add(env, &osa->sa_timer,
	    3 * IKED_RETRANSMIT_TIMEOUT2);
}
}
osa = sa_dstid_insert(env, sa);
if (osa != NULL((void *)0)) {
/* XXX how can this fail */
log_info("%s: could not replace old IKESA %s",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    print_spi(osa->sa_hdr.sh_ispi, 8));
return (-1);
}
return (0);
3626}

3628int
3629ikev2_send_error(struct iked *env, struct iked_sa *sa,
  struct iked_message *msg, uint8_t exchange)
3631{
struct ibuf			*buf = NULL((void *)0);
int				 ret = -1;

if (msg->msg_error == 0)
return (0);
if ((buf = ibuf_static()) == NULL((void *)0))
goto done;
if (ikev2_add_error(env, buf, msg) == 0)
goto done;
ret = ikev2_send_ike_e(env, sa, buf, IKEV2_PAYLOAD_NOTIFY41,
   exchange, 1);
done:
ibuf_free(buf);
return (ret);
3646}

3648/*
* Variant of ikev2_send_error() that can be used before encryption
* is enabled. Based on ikev2_resp_ike_sa_init() code.
*/
3652int
3653ikev2_send_init_error(struct iked *env, struct iked_message *msg)
3654{
struct iked_message		 resp;
struct ike_header		*hdr;
struct ikev2_payload		*pld;
struct iked_sa			*sa = msg->msg_sa;
struct ibuf			*buf;
ssize_t				 len = 0;
int				 ret = -1;

if (sa->sa_hdr.sh_initiator) {
log_debug("%s: called by initiator", __func__);
return (-1);
}
if (msg->msg_error == 0)
return (0);

if ((buf = ikev2_msg_init(env, &resp,
   &msg->msg_peer, msg->msg_peerlen,
   &msg->msg_local, msg->msg_locallen, 1)) == NULL((void *)0))
goto done;

resp.msg_sa = sa;
resp.msg_fd = msg->msg_fd;
resp.msg_natt = msg->msg_natt;
resp.msg_msgid = 0;

/* IKE header */
if ((hdr = ikev2_add_header(buf, sa, resp.msg_msgid,
   IKEV2_PAYLOAD_NOTIFY41, IKEV2_EXCHANGE_IKE_SA_INIT34,
   IKEV2_FLAG_RESPONSE0x20)) == NULL((void *)0))
goto done;

/* NOTIFY payload */
if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
goto done;
if ((len = ikev2_add_error(env, buf, msg)) == 0)
goto done;
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
goto done;
if (ikev2_set_header(hdr, ibuf_size(buf) - sizeof(*hdr)) == -1)
goto done;

(void)ikev2_pld_parse(env, hdr, &resp, 0);
ret = ikev2_msg_send(env, &resp);

done:
ikev2_msg_cleanup(env, &resp);

return (ret);
3703}

3705int
3706ikev2_handle_certreq(struct iked* env, struct iked_message *msg)
3707{
struct iked_certreq	*cr;
struct iked_sa		*sa;
uint8_t			 crtype;
uint8_t	more;

if ((sa = msg->msg_sa) == NULL((void *)0))
return (-1);

/* Ignore CERTREQ when policy uses PSK authentication */
if (sa->sa_policy->pol_auth.auth_method == IKEV2_AUTH_SHARED_KEY_MIC2)
return (0);

if (sa->sa_hdr.sh_initiator)
sa->sa_stateinit |= IKED_REQ_CERT0x0001;
else
sa->sa_statevalid |= IKED_REQ_CERT0x0001;

/*
* If we have to send a local certificate but did not receive an
* optional CERTREQ, use our own certreq to find a local certificate.
* We could alternatively extract the CA from the peer certificate
* to find a matching local one.
*/
if (SIMPLEQ_EMPTY(&msg->msg_certreqs)(((&msg->msg_certreqs)->sqh_first) == ((void *)0))) {
if (sa->sa_policy->pol_certreqtype)
	crtype = sa->sa_policy->pol_certreqtype;
else
	crtype = env->sc_certreqtype;
ca_setreq(env, sa, &sa->sa_policy->pol_localid,
    crtype, 0, ibuf_data(env->sc_certreq),
    ibuf_size(env->sc_certreq), PROC_CERT);
} else {
while ((cr = SIMPLEQ_FIRST(&msg->msg_certreqs)((&msg->msg_certreqs)->sqh_first))) {
	if (SIMPLEQ_NEXT(cr, cr_entry)((cr)->cr_entry.sqe_next) != NULL((void *)0))
		more = 1;
	else
		more = 0;

	ca_setreq(env, sa, &sa->sa_policy->pol_localid,
	    cr->cr_type, more, ibuf_data(cr->cr_data),
	    ibuf_size(cr->cr_data),
	    PROC_CERT);

	ibuf_free(cr->cr_data);
	SIMPLEQ_REMOVE_HEAD(&msg->msg_certreqs, cr_entry)do { if (((&msg->msg_certreqs)->sqh_first = (&msg
->msg_certreqs)->sqh_first->cr_entry.sqe_next) == ((
void *)0)) (&msg->msg_certreqs)->sqh_last = &(&
msg->msg_certreqs)->sqh_first; } while (0);
	free(cr);
}
}

return (0);
3758}

3760int
3761ikev2_resp_ike_eap_mschap(struct iked *env, struct iked_sa *sa,
  struct iked_message *msg)
3763{
uint8_t			 successmsg[EAP_MSCHAP_SUCCESS_SZ42];
uint8_t			 ntresponse[EAP_MSCHAP_NTRESPONSE_SZ24];
struct eap_msg		*eap = &msg->msg_eap;
struct iked_user	*usr;
uint8_t			*pass;
char			*name = NULL((void *)0);
size_t			 passlen;
int			 ret;

switch (eap->eam_state) {
case EAP_STATE_IDENTITY(1):
sa->sa_eapid = eap->eam_identity;
return (eap_challenge_request(env, sa, eap->eam_id));
case EAP_STATE_MSCHAPV2_CHALLENGE(2):
if (eap->eam_user) {
	name = eap->eam_user;
} else if (sa->sa_eapid) {
	name = sa->sa_eapid;
}
if (name == NULL((void *)0)) {
	log_info("%s: invalid response name",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
if ((usr = user_lookup(env, name)) == NULL((void *)0)) {
	log_info("%s: unknown user '%s'", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
	    name);
	return (-1);
}

if ((pass = string2unicode(usr->usr_pass, &passlen)) == NULL((void *)0))
	return (-1);

mschap_nt_response(ibuf_data(sa->sa_eap.id_buf),
    eap->eam_challenge, usr->usr_name, strlen(usr->usr_name),
    pass, passlen, ntresponse);

if (memcmp(ntresponse, eap->eam_ntresponse,
    sizeof(ntresponse)) != 0) {
	log_info("%s: '%s' authentication failed",
	   SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), usr->usr_name);
	freezero(pass, passlen);

	/* XXX should we send an EAP failure packet? */
	return (-1);
}

bzero(&successmsg, sizeof(successmsg));

mschap_auth_response(pass, passlen,
    ntresponse, ibuf_data(sa->sa_eap.id_buf),
    eap->eam_challenge, usr->usr_name, strlen(usr->usr_name),
    successmsg);
if ((sa->sa_eapmsk = ibuf_new(NULL((void *)0), MSCHAP_MSK_SZ64)) == NULL((void *)0)) {
	log_info("%s: failed to get MSK", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	freezero(pass, passlen);
	return (-1);
}
mschap_msk(pass, passlen, ntresponse,
    ibuf_data(sa->sa_eapmsk));
freezero(pass, passlen);

log_info("%s: '%s' authenticated", __func__, usr->usr_name);

ret = eap_mschap_challenge(env, sa, eap->eam_id, eap->eam_msrid,
    successmsg, EAP_MSCHAP_SUCCESS_SZ42);
if (ret == 0)
	sa_state(env, sa, IKEV2_STATE_AUTH_SUCCESS6);
break;
case EAP_STATE_MSCHAPV2_SUCCESS(3):
return (eap_mschap_success(env, sa, eap->eam_id));
case EAP_STATE_SUCCESS(4):
if (!sa_stateok(sa, IKEV2_STATE_AUTH_SUCCESS6))
	return (-1);
return (eap_success(env, sa, msg->msg_eap.eam_id));
default:
log_info("%s: eap ignored.", __func__);
break;
}
return 0;
3844}

3846int
3847ikev2_resp_ike_eap(struct iked *env, struct iked_sa *sa,
  struct iked_message *msg)
3849{
if (!sa_stateok(sa, IKEV2_STATE_EAP3))
return (-1);

switch (sa->sa_policy->pol_auth.auth_eap) {
case EAP_TYPE_MSCHAP_V226:
return ikev2_resp_ike_eap_mschap(env, sa, msg);
}
return -1;
3858}

3860int
3861ikev2_resp_ike_auth(struct iked *env, struct iked_sa *sa)
3862{
struct ikev2_payload		*pld;
struct ikev2_cert		*cert;
struct ikev2_auth		*auth;
struct iked_id			*id, *certid;
struct ibuf			*e = NULL((void *)0);
uint8_t				 firstpayload;
int				 ret = -1;
ssize_t				 len;
int				 i;

if (sa == NULL((void *)0))
return (-1);

if (sa->sa_state == IKEV2_STATE_EAP3)
return (eap_identity_request(env, sa));

if (!sa_stateok(sa, IKEV2_STATE_VALID7))
return (0);	/* ignore */

if (ikev2_cp_setaddr(env, sa, AF_INET2) < 0 ||
   ikev2_cp_setaddr(env, sa, AF_INET624) < 0)
return (-1);

if (ikev2_childsa_negotiate(env, sa, &sa->sa_kex, &sa->sa_proposals,
   sa->sa_hdr.sh_initiator, 0) < 0)
return (-1);

/* New encrypted message buffer */
if ((e = ibuf_static()) == NULL((void *)0))
goto done;

if (!sa->sa_localauth.id_type) {
/* Downgrade the state */
sa_state(env, sa, IKEV2_STATE_AUTH_SUCCESS6);
}

if (sa->sa_hdr.sh_initiator) {
id = &sa->sa_iid;
certid = &sa->sa_icert;
} else {
id = &sa->sa_rid;
certid = &sa->sa_rcert;
}

if (sa->sa_state != IKEV2_STATE_EAP_VALID8) {
/* ID payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;
firstpayload = IKEV2_PAYLOAD_IDr36;
if (ibuf_add_buf(e, id->id_buf) != 0)
	goto done;
len = ibuf_size(id->id_buf);

/* CERT payload */
if ((sa->sa_statevalid & IKED_REQ_CERT0x0001) &&
    (certid->id_type != IKEV2_CERT_NONE0)) {
	if (ikev2_next_payload(pld, len,
	    IKEV2_PAYLOAD_CERT37) == -1)
		goto done;

	if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
		goto done;
	if ((cert = ibuf_reserve(e, sizeof(*cert))) == NULL((void *)0))
		goto done;
	cert->cert_type = certid->id_type;
	if (ibuf_add_buf(e, certid->id_buf) != 0)
		goto done;
	len = ibuf_size(certid->id_buf) + sizeof(*cert);

	for (i = 0; i < IKED_SCERT_MAX3; i++) {
		if (sa->sa_scert[i].id_type == IKEV2_CERT_NONE0)
			break;
		if (ikev2_next_payload(pld, len,
		    IKEV2_PAYLOAD_CERT37) == -1)
			goto done;
		if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
			goto done;
		if ((cert = ibuf_reserve(e,
		    sizeof(*cert))) == NULL((void *)0))
			goto done;
		cert->cert_type = sa->sa_scert[i].id_type;
		if (ibuf_add_buf(e, sa->sa_scert[i].id_buf) !=
		    0)
			goto done;
		len = ibuf_size(sa->sa_scert[i].id_buf)
		    + sizeof(*cert);
	}
}

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_AUTH39) == -1)
	goto done;
} else
firstpayload = IKEV2_PAYLOAD_AUTH39;

/* AUTH payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
if ((auth = ibuf_reserve(e, sizeof(*auth))) == NULL((void *)0))
goto done;
auth->auth_method = sa->sa_localauth.id_type;
if (ibuf_add_buf(e, sa->sa_localauth.id_buf) != 0)
goto done;
len = ibuf_size(sa->sa_localauth.id_buf) + sizeof(*auth);

/* CP payload */
if (sa->sa_cp) {
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_CP47) == -1)
	goto done;
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;
if ((len = ikev2_resp_add_cp(env, sa, e)) == -1)
	goto done;
}

if (sa->sa_ipcompr.ic_transform &&
   (len = ikev2_add_ipcompnotify(env, e, &pld, len, sa, 0)) == -1)
goto done;
if (sa->sa_used_transport_mode &&
   (len = ikev2_add_transport_mode(env, e, &pld, len, sa)) == -1)
goto done;

/* MOBIKE */
if (sa->sa_mobike &&
   (len = ikev2_add_mobike(e, &pld, len)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_SA33) == -1)
goto done;

/* SA payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
if ((len = ikev2_add_proposals(env, sa, e, &sa->sa_proposals, 0,
   sa->sa_hdr.sh_initiator, 0, 1)) == -1)
goto done;

if ((len = ikev2_add_ts(e, &pld, len, sa, 0)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
goto done;

ret = ikev2_msg_send_encrypt(env, sa, &e,
   IKEV2_EXCHANGE_IKE_AUTH35, firstpayload, 1);
if (ret == 0)
ret = ikev2_childsa_enable(env, sa);
if (ret == 0) {
sa_state(env, sa, IKEV2_STATE_ESTABLISHED9);
/* Delete exchange timeout. */
timer_del(env, &sa->sa_timer);
ikev2_enable_timer(env, sa);
ikev2_log_established(sa);
ikev2_record_dstid(env, sa);
}

done:
if (ret)
ikev2_childsa_delete(env, sa, 0, 0, NULL((void *)0), 1);
ibuf_free(e);
return (ret);
4023}

4025int
4026ikev2_send_ike_e(struct iked *env, struct iked_sa *sa, struct ibuf *buf,
  uint8_t firstpayload, uint8_t exchange, int response)
4028{
struct ikev2_payload		*pld;
struct ibuf			*e = NULL((void *)0);
int				 ret = -1;

/* New encrypted message buffer */
if ((e = ibuf_static()) == NULL((void *)0))
goto done;

if (buf) {
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;

if (ibuf_add_buf(e, buf) != 0)
	goto done;

if (ikev2_next_payload(pld, ibuf_size(buf),
    IKEV2_PAYLOAD_NONE0) == -1)
	goto done;
}

ret = ikev2_msg_send_encrypt(env, sa, &e, exchange, firstpayload,
   response);

done:
ibuf_free(e);

return (ret);
4056}

4058int
4059ikev2_set_sa_proposal(struct iked_sa *sa, struct iked_policy *pol,
  unsigned int proto)
4061{
struct iked_proposal		*prop, *copy;
struct iked_transform		*xform;
unsigned int			 i;

/* create copy of the policy proposals */
config_free_proposals(&sa->sa_proposals, proto);
TAILQ_FOREACH(prop, &pol->pol_proposals, prop_entry)for((prop) = ((&pol->pol_proposals)->tqh_first); (prop
) != ((void *)0); (prop) = ((prop)->prop_entry.tqe_next)) {
if (proto != 0 && prop->prop_protoid != proto)
	continue;
if ((copy = config_add_proposal(&sa->sa_proposals,
    prop->prop_id, prop->prop_protoid)) == NULL((void *)0))
	return (-1);
for (i = 0; i < prop->prop_nxforms; i++) {
	xform = &prop->prop_xforms[i];
	if (config_add_transform(copy, xform->xform_type,
	    xform->xform_id, xform->xform_length,
	    xform->xform_keylength) != 0)
		return (-1);
}
}
return (0);
4083}

4085int
4086ikev2_send_create_child_sa(struct iked *env, struct iked_sa *sa,
  struct iked_spi *rekey, uint8_t protoid, uint16_t proposed_group)
4088{
struct iked_policy		*pol = sa->sa_policy;
struct iked_childsa		*csa = NULL((void *)0), *csb = NULL((void *)0);
struct iked_transform		*xform;
struct ikev2_notify		*n;
struct ikev2_payload		*pld = NULL((void *)0);
struct ikev2_keyexchange	*ke;
struct dh_group			*group;
struct ibuf			*e = NULL((void *)0), *nonce = NULL((void *)0);
uint8_t				*ptr;
uint8_t				 firstpayload;
uint32_t			 spi;
ssize_t				 len = 0;
int				 initiator, ret = -1;

if (rekey)
log_debug("%s: rekeying %s spi %s", __func__,
    print_map(rekey->spi_protoid, ikev2_saproto_map),
    print_spi(rekey->spi, rekey->spi_size));
else
log_debug("%s: creating new CHILD SAs", __func__);

/* XXX cannot initiate multiple concurrent CREATE_CHILD_SA exchanges */
if (sa->sa_stateflags & (IKED_REQ_CHILDSA0x0080|IKED_REQ_INF0x0100)) {
log_debug("%s: another exchange already active",
    __func__);
return (-1);
}

ibuf_free(sa->sa_simult);
sa->sa_simult = NULL((void *)0);
sa->sa_rekeyspi = 0;	/* clear rekey spi */
initiator = sa->sa_hdr.sh_initiator ? 1 : 0;

if (rekey &&
   ((csa = childsa_lookup(sa, rekey->spi,
   rekey->spi_protoid)) == NULL((void *)0) ||
   (csb = csa->csa_peersa) == NULL((void *)0))) {
log_debug("%s: CHILD SA %s wasn't found", __func__,
    print_spi(rekey->spi, rekey->spi_size));
goto done;
}

/* Generate new nonce */
if ((nonce = ibuf_random(IKED_NONCE_SIZE32)) == NULL((void *)0))
goto done;

/* Update initiator nonce */
ibuf_free(sa->sa_inoncesa_kex.kex_inonce);
sa->sa_inoncesa_kex.kex_inonce = nonce;

if ((e = ibuf_static()) == NULL((void *)0))
goto done;

if ((pol->pol_flags & IKED_POLICY_IPCOMP0x20) &&
   (len = ikev2_add_ipcompnotify(env, e, &pld, 0, sa, 1)) == -1)
goto done;
if ((pol->pol_flags & IKED_POLICY_TRANSPORT0x40) &&
   (len = ikev2_add_transport_mode(env, e, &pld, len, sa)) == -1)
goto done;

if (pld) {
firstpayload = IKEV2_PAYLOAD_NOTIFY41;
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_SA33) == -1)
	goto done;
} else
firstpayload = IKEV2_PAYLOAD_SA33;

/* SA payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;

/*
* We need to reset the sa_proposal. Otherwise it would be
* left over from the IKE_AUTH exchange and would not contain
* any DH groups (e.g. for ESP child SAs).
*/
if (ikev2_set_sa_proposal(sa, pol, protoid) < 0) {
log_debug("%s: ikev2_set_sa_proposal failed", __func__);
goto done;
}

if ((len = ikev2_add_proposals(env, sa, e, &sa->sa_proposals,
   protoid, 1, 0, 0)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONCE40) == -1)
goto done;

/* NONCE payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
if (ikev2_add_buf(e, nonce) == -1)
goto done;
len = ibuf_size(nonce);

if ((xform = config_findtransform(&pol->pol_proposals, IKEV2_XFORMTYPE_DH4,
   protoid)) && xform->xform_id != IKEV2_XFORMDH_NONE0) {
log_debug("%s: enable PFS", __func__);
ikev2_sa_cleanup_dh(sa);
if (proposed_group) {
	if ((sa->sa_dhgroupsa_kex.kex_dhgroup =
	    group_get(proposed_group)) == NULL((void *)0)) {
		log_debug("%s: failed to get group", __func__);
		goto done;
	}
}
if (ikev2_sa_initiator_dh(sa, NULL((void *)0), protoid, NULL((void *)0)) < 0) {
	log_debug("%s: failed to setup DH", __func__);
	goto done;
}
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_KE34) == -1)
	goto done;

/* KE payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;
if ((ke = ibuf_reserve(e, sizeof(*ke))) == NULL((void *)0))
	goto done;
if ((group = sa->sa_dhgroupsa_kex.kex_dhgroup) == NULL((void *)0)) {
	log_debug("%s: invalid dh", __func__);
	goto done;
}
ke->kex_dhgroup = htobe16(group->id)(__uint16_t)(__builtin_constant_p(group->id) ? (__uint16_t
)(((__uint16_t)(group->id) & 0xffU) << 8 | ((__uint16_t
)(group->id) & 0xff00U) >> 8) : __swap16md(group
->id));
if (ikev2_add_buf(e, sa->sa_dhiexchangesa_kex.kex_dhiexchange) == -1)
	goto done;
len = sizeof(*ke) + ibuf_size(sa->sa_dhiexchangesa_kex.kex_dhiexchange);
}

if ((len = ikev2_add_ts(e, &pld, len, sa, !initiator)) == -1)
goto done;

if (rekey) {
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NOTIFY41) == -1)
	goto done;

/* REKEY_SA notification */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;
if ((n = ibuf_reserve(e, sizeof(*n))) == NULL((void *)0))
	goto done;
n->n_type = htobe16(IKEV2_N_REKEY_SA)(__uint16_t)(__builtin_constant_p(16393) ? (__uint16_t)(((__uint16_t
)(16393) & 0xffU) << 8 | ((__uint16_t)(16393) &
 0xff00U) >> 8) : __swap16md(16393));
n->n_protoid = rekey->spi_protoid;
n->n_spisize = rekey->spi_size;
if ((ptr = ibuf_reserve(e, rekey->spi_size)) == NULL((void *)0))
	goto done;
len = rekey->spi_size;
spi = htobe32((uint32_t)csa->csa_peerspi)(__uint32_t)(__builtin_constant_p((uint32_t)csa->csa_peerspi
) ? (__uint32_t)(((__uint32_t)((uint32_t)csa->csa_peerspi)
 & 0xff) << 24 | ((__uint32_t)((uint32_t)csa->csa_peerspi
) & 0xff00) << 8 | ((__uint32_t)((uint32_t)csa->
csa_peerspi) & 0xff0000) >> 8 | ((__uint32_t)((uint32_t
)csa->csa_peerspi) & 0xff000000) >> 24) : __swap32md
((uint32_t)csa->csa_peerspi));
memcpy(ptr, &spi, rekey->spi_size);
len += sizeof(*n);
}

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
goto done;

ret = ikev2_msg_send_encrypt(env, sa, &e,
   IKEV2_EXCHANGE_CREATE_CHILD_SA36, firstpayload, 0);
if (ret == 0) {
if (rekey) {
	csa->csa_rekey = 1;
	csb->csa_rekey = 1;
	/*
	 * Remember the peer spi of the rekeyed
	 * SA for ikev2_init_create_child_sa().
	 */
	sa->sa_rekeyspi = csa->csa_peerspi;
}
sa->sa_stateflags |= IKED_REQ_CHILDSA0x0080;
}

4258done:
ibuf_free(e);
return (ret);
4261}

4263void
4264ikev2_ike_sa_rekey(struct iked *env, void *arg)
4265{
struct iked_sa			*sa = arg;
struct iked_sa			*nsa = NULL((void *)0);
struct ikev2_payload		*pld = NULL((void *)0);
struct ikev2_keyexchange	*ke;
struct dh_group			*group;
struct ibuf			*e = NULL((void *)0), *nonce = NULL((void *)0);
ssize_t				 len = 0;
int				 ret = -1;

log_debug("%s: IKE SA %p ispi %s rspi %s", __func__, sa,
   print_spi(sa->sa_hdr.sh_ispi, 8),
   print_spi(sa->sa_hdr.sh_rspi, 8));

if (sa->sa_nexti) {
log_debug("%s: already rekeying", __func__);
goto done;
}

if (sa->sa_stateflags & (IKED_REQ_CHILDSA0x0080|IKED_REQ_INF0x0100)) {
/*
 * We cannot initiate multiple concurrent CREATE_CHILD_SA
 * exchanges, so retry again fast.
 */
log_info("%s: busy, delaying rekey", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
ikev2_ike_sa_rekey_schedule_fast(env, sa);
return;
}

/* We need to make sure the rekeying finishes in time */
timer_set(env, &sa->sa_rekey, ikev2_ike_sa_rekey_timeout, sa);
timer_add(env, &sa->sa_rekey, IKED_IKE_SA_REKEY_TIMEOUT120);

if ((nsa = sa_new(env, 0, 0, 1, sa->sa_policy)) == NULL((void *)0)) {
log_debug("%s: failed to get new SA", __func__);
goto done;
}

if (ikev2_sa_initiator(env, nsa, sa, NULL((void *)0))) {
log_debug("%s: failed to setup DH", __func__);
goto done;
}
sa_state(env, nsa, IKEV2_STATE_AUTH_SUCCESS6);
nonce = nsa->sa_inoncesa_kex.kex_inonce;

if ((e = ibuf_static()) == NULL((void *)0))
goto done;

/* SA payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;

/* just reuse the old IKE SA proposals */
if ((len = ikev2_add_proposals(env, nsa, e, &sa->sa_proposals,
   IKEV2_SAPROTO_IKE1, 1, 1, 0)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONCE40) == -1)
goto done;

/* NONCE payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
if (ikev2_add_buf(e, nonce) == -1)
goto done;
len = ibuf_size(nonce);

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_KE34) == -1)
goto done;

/* KE payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
if ((ke = ibuf_reserve(e, sizeof(*ke))) == NULL((void *)0))
goto done;
if ((group = nsa->sa_dhgroupsa_kex.kex_dhgroup) == NULL((void *)0)) {
log_debug("%s: invalid dh", __func__);
goto done;
}
ke->kex_dhgroup = htobe16(group->id)(__uint16_t)(__builtin_constant_p(group->id) ? (__uint16_t
)(((__uint16_t)(group->id) & 0xffU) << 8 | ((__uint16_t
)(group->id) & 0xff00U) >> 8) : __swap16md(group
->id));
if (ikev2_add_buf(e, nsa->sa_dhiexchangesa_kex.kex_dhiexchange) == -1)
goto done;
len = sizeof(*ke) + ibuf_size(nsa->sa_dhiexchangesa_kex.kex_dhiexchange);

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
goto done;

ret = ikev2_msg_send_encrypt(env, sa, &e,
   IKEV2_EXCHANGE_CREATE_CHILD_SA36, IKEV2_PAYLOAD_SA33, 0);
if (ret == 0) {
sa->sa_stateflags |= IKED_REQ_CHILDSA0x0080;
sa->sa_nexti = nsa;
nsa->sa_previ = sa;
sa->sa_tmpfail = 0;
nsa = NULL((void *)0);
}
4361done:
if (nsa) {
ikev2_ike_sa_setreason(nsa, "failed to send CREATE_CHILD_SA");
sa_free(env, nsa);
}
ibuf_free(e);

if (ret == 0)
log_debug("%s: create child SA sent", __func__);
else
log_debug("%s: could not send create child SA", __func__);
/* XXX should we try again in case of ret != 0 ? */
4373}

4375int
4376ikev2_nonce_cmp(struct ibuf *a, struct ibuf *b)
4377{
size_t				alen, blen, len;
int				ret;

alen = ibuf_size(a);
blen = ibuf_size(b);
len = MINIMUM(alen, blen)(((alen)<(blen))?(alen):(blen));
ret = memcmp(ibuf_data(a), ibuf_data(b), len);
if (ret == 0)
ret = (alen < blen ? -1 : 1);
return (ret);
4388}

4390int
4391ikev2_init_create_child_sa(struct iked *env, struct iked_message *msg)
4392{
struct iked_childsa		*csa = NULL((void *)0);
struct iked_proposal		*prop;
struct iked_sa			*sa = msg->msg_sa;
struct iked_sa			*nsa, *dsa;
struct iked_spi			*spi;
struct ikev2_delete		*del;
struct ibuf			*buf = NULL((void *)0);
struct ibuf			*ni, *nr;
uint32_t			 spi32;
int				 pfs = 0, ret = -1;

if (!ikev2_msg_frompeer(msg) ||
   (sa->sa_stateflags & (IKED_REQ_CHILDSA0x0080|IKED_REQ_INF0x0100)) == 0)
return (0);

if (sa->sa_nexti != NULL((void *)0) && sa->sa_tmpfail) {
sa->sa_stateflags &= ~IKED_REQ_CHILDSA0x0080;
ikev2_ike_sa_setreason(sa->sa_nexti, "tmpfail");
sa_free(env, sa->sa_nexti);
sa->sa_nexti = NULL((void *)0);
timer_set(env, &sa->sa_rekey, ikev2_ike_sa_rekey, sa);
ikev2_ike_sa_rekey_schedule_fast(env, sa);
log_info("%s: IKESA rekey delayed", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (0);
}

if (msg->msg_prop == NULL((void *)0) ||
   TAILQ_EMPTY(&msg->msg_proposals)(((&msg->msg_proposals)->tqh_first) == ((void *)0))) {
log_info("%s: no proposal specified", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (-1);
}

if (proposals_negotiate(&sa->sa_proposals, &sa->sa_proposals,
   &msg->msg_proposals, 1, -1) != 0) {
log_info("%s: no proposal chosen", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
ikestat_inc(env, ikes_sa_proposals_negotiate_failures)do { env->sc_stats.ikes_sa_proposals_negotiate_failures +=
 (1); } while(0);
return (-1);
}

TAILQ_FOREACH(prop, &sa->sa_proposals, prop_entry)for((prop) = ((&sa->sa_proposals)->tqh_first); (prop
) != ((void *)0); (prop) = ((prop)->prop_entry.tqe_next)) {
if (prop->prop_protoid == msg->msg_prop->prop_protoid)
	break;
}
if (prop == NULL((void *)0)) {
log_info("%s: failed to find %s proposals", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    print_map(msg->msg_prop->prop_protoid, ikev2_saproto_map));
return (-1);
}

/* IKE SA rekeying */
if (prop->prop_protoid == IKEV2_SAPROTO_IKE1) {
if (sa->sa_nexti == NULL((void *)0)) {
	log_info("%s: missing IKE SA for rekeying",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
/* Update the responder SPI */
/* XXX sa_new() is just a lookup, so nsa == sa->sa_nexti */
spi = &msg->msg_prop->prop_peerspi;
if ((nsa = sa_new(env, sa->sa_nexti->sa_hdr.sh_ispi,
    spi->spi, 1, NULL((void *)0))) == NULL((void *)0) || nsa != sa->sa_nexti) {
	log_info("%s: invalid rekey SA", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	if (nsa) {
		ikev2_ike_sa_setreason(nsa,
		    "invalid SA for rekey");
		sa_free(env, nsa);
	}
	ikev2_ike_sa_setreason(sa->sa_nexti, "invalid SA nexti");
	sa_free(env, sa->sa_nexti);
	sa->sa_nexti = NULL((void *)0);	/* reset by sa_free */
	return (-1);
}
if (ikev2_sa_initiator(env, nsa, sa, msg) == -1) {
	log_info("%s: failed to get IKE keys",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
sa->sa_stateflags &= ~IKED_REQ_CHILDSA0x0080;
if (sa->sa_nextr) {
	/*
	 * Resolve simultaneous IKE SA rekeying by
	 * deleting the SA with the lowest NONCE.
	 */
	log_info("%s: resolving simultaneous IKE SA rekeying",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	/* ni: minimum nonce of sa_nexti */
	if (ikev2_nonce_cmp(sa->sa_nexti->sa_inoncesa_kex.kex_inonce,
	    sa->sa_nexti->sa_rnoncesa_kex.kex_rnonce) < 0)
		ni = sa->sa_nexti->sa_inoncesa_kex.kex_inonce;
	else
		ni = sa->sa_nexti->sa_rnoncesa_kex.kex_rnonce;
	/* nr: minimum nonce of sa_nextr */
	if (ikev2_nonce_cmp(sa->sa_nextr->sa_inoncesa_kex.kex_inonce,
	    sa->sa_nextr->sa_rnoncesa_kex.kex_rnonce) < 0)
		nr = sa->sa_nextr->sa_inoncesa_kex.kex_inonce;
	else
		nr = sa->sa_nextr->sa_rnoncesa_kex.kex_rnonce;
	/* delete SA with minumum nonce */
	if (ikev2_nonce_cmp(ni, nr) < 0) {
		dsa = sa->sa_nexti;
		nsa = sa->sa_nextr;
	} else {
		dsa = sa->sa_nextr;
		nsa = sa->sa_nexti;
	}
	/* unlink sa_nextr */
	sa->sa_nextr->sa_prevr = NULL((void *)0);
	sa->sa_nextr = NULL((void *)0);
	/* Setup address, socket and NAT information */
	sa_address(dsa, &dsa->sa_peer,
	    (struct sockaddr *)&sa->sa_peer.addr);
	sa_address(dsa, &dsa->sa_local,
	    (struct sockaddr *)&sa->sa_local.addr);
	dsa->sa_fd = sa->sa_fd;
	dsa->sa_natt = sa->sa_natt;
	dsa->sa_udpencap = sa->sa_udpencap;
	ikev2_ike_sa_setreason(dsa,
	    "resolving simultaneous rekeying");
	ikev2_ikesa_delete(env, dsa, dsa->sa_hdr.sh_initiator);
}
/* unlink sa_nexti */
sa->sa_nexti->sa_previ = NULL((void *)0);
sa->sa_nexti = NULL((void *)0);
return (ikev2_ikesa_enable(env, sa, nsa));
}

/* Child SA rekeying */
if (sa->sa_rekeyspi &&
   (csa = childsa_lookup(sa, sa->sa_rekeyspi, prop->prop_protoid))
   != NULL((void *)0)) {
log_info("%s: rekeying CHILD SA old %s spi %s",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    print_spi(csa->csa_spi.spi, csa->csa_spi.spi_size),
    print_spi(prop->prop_peerspi.spi,
    prop->prop_peerspi.spi_size));
}

/* check KE payload for PFS */
if (ibuf_length(msg->msg_ke)) {
log_debug("%s: using PFS", __func__);
if (ikev2_sa_initiator_dh(sa, msg, prop->prop_protoid, NULL((void *)0)) < 0) {
	log_info("%s: failed to setup DH",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (ret);
}
if (sa->sa_dhpeersa_kex.kex_dhpeer == NULL((void *)0)) {
	log_info("%s: no peer DH", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (ret);
}
pfs = 1;
/* XXX check group against policy ? */
/* XXX should proposals_negotiate do this? */
}

/* Update responder's nonce */
if (!ibuf_length(msg->msg_nonce)) {
log_info("%s: responder didn't send nonce",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (-1);
}
ibuf_free(sa->sa_rnoncesa_kex.kex_rnonce);
sa->sa_rnoncesa_kex.kex_rnonce = msg->msg_nonce;
msg->msg_nonce = NULL((void *)0);

if (csa && (nr = sa->sa_simult) != NULL((void *)0)) {
log_info("%s: resolving simultaneous CHILD SA rekeying",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
/* set ni to minimum nonce for exchange initiated by us */
if (ikev2_nonce_cmp(sa->sa_inoncesa_kex.kex_inonce, sa->sa_rnoncesa_kex.kex_rnonce) < 0)
	ni = sa->sa_inoncesa_kex.kex_inonce;
else
	ni = sa->sa_rnoncesa_kex.kex_rnonce;
/*
 * If the exchange initated by us has smaller nonce,
 * then we have to delete our SAs.
 */
if (ikev2_nonce_cmp(ni, nr) < 0) {
	ret = ikev2_childsa_delete_proposed(env, sa,
	    &sa->sa_proposals);
	goto done;
}
}

if (ikev2_childsa_negotiate(env, sa, &sa->sa_kex, &sa->sa_proposals, 1,
   pfs)) {
log_info("%s: failed to get CHILD SAs", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (-1);
}

if (csa) {
/* Child SA rekeying */

if ((buf = ibuf_static()) == NULL((void *)0))
	goto done;

if ((del = ibuf_reserve(buf, sizeof(*del))) == NULL((void *)0))
	goto done;

del->del_protoid = prop->prop_protoid;
del->del_spisize = sizeof(spi32);
del->del_nspi = htobe16(1)(__uint16_t)(__builtin_constant_p(1) ? (__uint16_t)(((__uint16_t
)(1) & 0xffU) << 8 | ((__uint16_t)(1) & 0xff00U
) >> 8) : __swap16md(1));

spi32 = htobe32(csa->csa_spi.spi)(__uint32_t)(__builtin_constant_p(csa->csa_spi.spi) ? (__uint32_t
)(((__uint32_t)(csa->csa_spi.spi) & 0xff) << 24 |
 ((__uint32_t)(csa->csa_spi.spi) & 0xff00) << 8 |
 ((__uint32_t)(csa->csa_spi.spi) & 0xff0000) >> 8
 | ((__uint32_t)(csa->csa_spi.spi) & 0xff000000) >>
 24) : __swap32md(csa->csa_spi.spi));
if (ibuf_add(buf, &spi32, sizeof(spi32)))
	goto done;

if (ikev2_send_ike_e(env, sa, buf, IKEV2_PAYLOAD_DELETE42,
    IKEV2_EXCHANGE_INFORMATIONAL37, 0))
	goto done;

sa->sa_stateflags |= IKED_REQ_INF0x0100;
}

ret = ikev2_childsa_enable(env, sa);

4608done:
sa->sa_stateflags &= ~IKED_REQ_CHILDSA0x0080;

if (ret)
ikev2_childsa_delete(env, sa, 0, 0, NULL((void *)0), 1);
else if (csa) {
/* delete the rekeyed SA pair */
ikev2_childsa_delete(env, sa, csa->csa_saproto,
    csa->csa_peerspi, NULL((void *)0), 0);
}
ibuf_free(buf);
return (ret);
4620}

4622int
4623ikev2_ikesa_enable(struct iked *env, struct iked_sa *sa, struct iked_sa *nsa)
4624{
struct iked_childsa		*csa, *csatmp, *ipcomp;
struct iked_flow		*flow, *flowtmp;
struct iked_proposal		*prop, *proptmp;
int				i;

log_debug("%s: IKE SA %p ispi %s rspi %s replaced"
   " by SA %p ispi %s rspi %s ",
   __func__, sa,
   print_spi(sa->sa_hdr.sh_ispi, 8),
   print_spi(sa->sa_hdr.sh_rspi, 8),
   nsa,
   print_spi(nsa->sa_hdr.sh_ispi, 8),
   print_spi(nsa->sa_hdr.sh_rspi, 8));

/* Transfer socket and NAT information */
nsa->sa_fd = sa->sa_fd;
nsa->sa_natt = sa->sa_natt;
nsa->sa_udpencap = sa->sa_udpencap;
nsa->sa_usekeepalive = sa->sa_usekeepalive;
nsa->sa_mobike = sa->sa_mobike;
nsa->sa_frag = sa->sa_frag;

/* Transfer old addresses */
memcpy(&nsa->sa_local, &sa->sa_local, sizeof(nsa->sa_local));
memcpy(&nsa->sa_peer, &sa->sa_peer, sizeof(nsa->sa_peer));
memcpy(&nsa->sa_peer_loaded, &sa->sa_peer_loaded,
   sizeof(nsa->sa_peer_loaded));

/* Transfer all Child SAs and flows from the old IKE SA */
TAILQ_FOREACH_SAFE(flow, &sa->sa_flows, flow_entry, flowtmp)for ((flow) = ((&sa->sa_flows)->tqh_first); (flow) !=
 ((void *)0) && ((flowtmp) = ((flow)->flow_entry.tqe_next
), 1); (flow) = (flowtmp)) {
TAILQ_REMOVE(&sa->sa_flows, flow, flow_entry)do { if (((flow)->flow_entry.tqe_next) != ((void *)0)) (flow
)->flow_entry.tqe_next->flow_entry.tqe_prev = (flow)->
flow_entry.tqe_prev; else (&sa->sa_flows)->tqh_last
 = (flow)->flow_entry.tqe_prev; *(flow)->flow_entry.tqe_prev
 = (flow)->flow_entry.tqe_next; ; ; } while (0);
TAILQ_INSERT_TAIL(&nsa->sa_flows, flow,do { (flow)->flow_entry.tqe_next = ((void *)0); (flow)->
flow_entry.tqe_prev = (&nsa->sa_flows)->tqh_last; *
(&nsa->sa_flows)->tqh_last = (flow); (&nsa->
sa_flows)->tqh_last = &(flow)->flow_entry.tqe_next;
 } while (0)
    flow_entry)do { (flow)->flow_entry.tqe_next = ((void *)0); (flow)->
flow_entry.tqe_prev = (&nsa->sa_flows)->tqh_last; *
(&nsa->sa_flows)->tqh_last = (flow); (&nsa->
sa_flows)->tqh_last = &(flow)->flow_entry.tqe_next;
 } while (0);
flow->flow_ikesa = nsa;
flow->flow_local = &nsa->sa_local;
flow->flow_peer = &nsa->sa_peer;
}
TAILQ_FOREACH_SAFE(csa, &sa->sa_childsas, csa_entry, csatmp)for ((csa) = ((&sa->sa_childsas)->tqh_first); (csa)
 != ((void *)0) && ((csatmp) = ((csa)->csa_entry.tqe_next
), 1); (csa) = (csatmp)) {
TAILQ_REMOVE(&sa->sa_childsas, csa, csa_entry)do { if (((csa)->csa_entry.tqe_next) != ((void *)0)) (csa)
->csa_entry.tqe_next->csa_entry.tqe_prev = (csa)->csa_entry
.tqe_prev; else (&sa->sa_childsas)->tqh_last = (csa
)->csa_entry.tqe_prev; *(csa)->csa_entry.tqe_prev = (csa
)->csa_entry.tqe_next; ; ; } while (0);
TAILQ_INSERT_TAIL(&nsa->sa_childsas, csa,do { (csa)->csa_entry.tqe_next = ((void *)0); (csa)->csa_entry
.tqe_prev = (&nsa->sa_childsas)->tqh_last; *(&nsa
->sa_childsas)->tqh_last = (csa); (&nsa->sa_childsas
)->tqh_last = &(csa)->csa_entry.tqe_next; } while (
0)
    csa_entry)do { (csa)->csa_entry.tqe_next = ((void *)0); (csa)->csa_entry
.tqe_prev = (&nsa->sa_childsas)->tqh_last; *(&nsa
->sa_childsas)->tqh_last = (csa); (&nsa->sa_childsas
)->tqh_last = &(csa)->csa_entry.tqe_next; } while (
0);
csa->csa_ikesa = nsa;
if (csa->csa_dir == IPSP_DIRECTION_IN0x1) {
	csa->csa_local = &nsa->sa_peer;
	csa->csa_peer = &nsa->sa_local;
} else {
	csa->csa_local = &nsa->sa_local;
	csa->csa_peer = &nsa->sa_peer;
}
if ((ipcomp = csa->csa_bundled) != NULL((void *)0)) {
	ipcomp->csa_ikesa = nsa;
	ipcomp->csa_local = csa->csa_local;
	ipcomp->csa_peer = csa->csa_peer;
}
}
/* Transfer all non-IKE proposals */
TAILQ_FOREACH_SAFE(prop, &sa->sa_proposals, prop_entry, proptmp)for ((prop) = ((&sa->sa_proposals)->tqh_first); (prop
) != ((void *)0) && ((proptmp) = ((prop)->prop_entry
.tqe_next), 1); (prop) = (proptmp)) {
if (prop->prop_protoid == IKEV2_SAPROTO_IKE1)
	continue;
TAILQ_REMOVE(&sa->sa_proposals, prop, prop_entry)do { if (((prop)->prop_entry.tqe_next) != ((void *)0)) (prop
)->prop_entry.tqe_next->prop_entry.tqe_prev = (prop)->
prop_entry.tqe_prev; else (&sa->sa_proposals)->tqh_last
 = (prop)->prop_entry.tqe_prev; *(prop)->prop_entry.tqe_prev
 = (prop)->prop_entry.tqe_next; ; ; } while (0);
TAILQ_INSERT_TAIL(&nsa->sa_proposals, prop,do { (prop)->prop_entry.tqe_next = ((void *)0); (prop)->
prop_entry.tqe_prev = (&nsa->sa_proposals)->tqh_last
; *(&nsa->sa_proposals)->tqh_last = (prop); (&nsa
->sa_proposals)->tqh_last = &(prop)->prop_entry.
tqe_next; } while (0)
    prop_entry)do { (prop)->prop_entry.tqe_next = ((void *)0); (prop)->
prop_entry.tqe_prev = (&nsa->sa_proposals)->tqh_last
; *(&nsa->sa_proposals)->tqh_last = (prop); (&nsa
->sa_proposals)->tqh_last = &(prop)->prop_entry.
tqe_next; } while (0);
}

/* Preserve ID information */
ibuf_free(nsa->sa_iid.id_buf);
ibuf_free(nsa->sa_rid.id_buf);
ibuf_free(nsa->sa_icert.id_buf);
ibuf_free(nsa->sa_rcert.id_buf);
if (sa->sa_hdr.sh_initiator == nsa->sa_hdr.sh_initiator) {
nsa->sa_iid = sa->sa_iid;
nsa->sa_rid = sa->sa_rid;
nsa->sa_icert = sa->sa_icert;
nsa->sa_rcert = sa->sa_rcert;
} else {
/* initiator and responder role swapped */
nsa->sa_iid = sa->sa_rid;
nsa->sa_rid = sa->sa_iid;
nsa->sa_icert = sa->sa_rcert;
nsa->sa_rcert = sa->sa_icert;
}
for (i = 0; i < IKED_SCERT_MAX3; i++)
nsa->sa_scert[i] = sa->sa_scert[i];
/* duplicate the actual buffer */
nsa->sa_iid.id_buf = ibuf_dup(nsa->sa_iid.id_buf);
nsa->sa_rid.id_buf = ibuf_dup(nsa->sa_rid.id_buf);
nsa->sa_icert.id_buf = ibuf_dup(nsa->sa_icert.id_buf);
nsa->sa_rcert.id_buf = ibuf_dup(nsa->sa_rcert.id_buf);
for (i = 0; i < IKED_SCERT_MAX3; i++)
nsa->sa_scert[i].id_buf = ibuf_dup(nsa->sa_scert[i].id_buf);

/* Transfer sa_addrpool address */
if (sa->sa_addrpool) {
RB_REMOVE(iked_addrpool, &env->sc_addrpool, sa)iked_addrpool_RB_REMOVE(&env->sc_addrpool, sa);
nsa->sa_addrpool = sa->sa_addrpool;
sa->sa_addrpool = NULL((void *)0);
RB_INSERT(iked_addrpool, &env->sc_addrpool, nsa)iked_addrpool_RB_INSERT(&env->sc_addrpool, nsa);
}
if (sa->sa_addrpool6) {
RB_REMOVE(iked_addrpool6, &env->sc_addrpool6, sa)iked_addrpool6_RB_REMOVE(&env->sc_addrpool6, sa);
nsa->sa_addrpool6 = sa->sa_addrpool6;
sa->sa_addrpool6 = NULL((void *)0);
RB_INSERT(iked_addrpool6, &env->sc_addrpool6, nsa)iked_addrpool6_RB_INSERT(&env->sc_addrpool6, nsa);
}
nsa->sa_cp = sa->sa_cp;
nsa->sa_cp_addr = sa->sa_cp_addr;
sa->sa_cp_addr = NULL((void *)0);
nsa->sa_cp_addr6 = sa->sa_cp_addr6;
sa->sa_cp_addr6 = NULL((void *)0);
nsa->sa_cp_dns = sa->sa_cp_dns;
sa->sa_cp_dns = NULL((void *)0);
/* Transfer other attributes */
if (sa->sa_dstid_entry_valid) {
sa_dstid_remove(env, sa);
sa_dstid_insert(env, nsa);
}
if (sa->sa_tag) {
nsa->sa_tag = sa->sa_tag;
sa->sa_tag = NULL((void *)0);
}
if (sa->sa_eapid) {
nsa->sa_eapid = sa->sa_eapid;
sa->sa_eapid = NULL((void *)0);
}
log_info("%srekeyed as new IKESA %s (enc %s%s%s group %s prf %s)",
   SPI_SA(sa, NULL)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((((void
 *)0)))), print_spi(nsa->sa_hdr.sh_ispi, 8),
   print_xf(nsa->sa_encr->encr_id, cipher_keylength(nsa->sa_encr) -
   nsa->sa_encr->encr_saltlength, ikeencxfs),
   nsa->sa_encr->encr_authid ? "" : " auth ",
   nsa->sa_encr->encr_authid ? "" : print_xf(nsa->sa_integr->hash_id,
   hash_keylength(nsa->sa_integr), authxfs),
   print_xf(nsa->sa_dhgroupsa_kex.kex_dhgroup->id, 0, groupxfs),
   print_xf(nsa->sa_prf->hash_id, hash_keylength(sa->sa_prf), prfxfs));
sa_state(env, nsa, IKEV2_STATE_ESTABLISHED9);
ikev2_enable_timer(env, nsa);

ikestat_inc(env, ikes_sa_rekeyed)do { env->sc_stats.ikes_sa_rekeyed += (1); } while(0);

nsa->sa_stateflags = nsa->sa_statevalid; /* XXX */

/* unregister DPD keep alive timer & rekey first */
if (sa->sa_state == IKEV2_STATE_ESTABLISHED9)
ikev2_disable_timer(env, sa);

ikev2_ike_sa_setreason(sa, "SA rekeyed");
ikev2_ikesa_delete(env, sa, nsa->sa_hdr.sh_initiator);
return (0);
4772}

4774void
4775ikev2_ikesa_delete(struct iked *env, struct iked_sa *sa, int initiator)
4776{
struct ibuf			*buf = NULL((void *)0);
struct ikev2_delete		*del;

if (initiator) {
/* XXX: Can not have simultaneous INFORMATIONAL exchanges */
if (sa->sa_stateflags & IKED_REQ_INF0x0100)
	goto done;
/* Send PAYLOAD_DELETE */
if ((buf = ibuf_static()) == NULL((void *)0))
	goto done;
if ((del = ibuf_reserve(buf, sizeof(*del))) == NULL((void *)0))
	goto done;
del->del_protoid = IKEV2_SAPROTO_IKE1;
del->del_spisize = 0;
del->del_nspi = 0;
if (ikev2_send_ike_e(env, sa, buf, IKEV2_PAYLOAD_DELETE42,
    IKEV2_EXCHANGE_INFORMATIONAL37, 0) == -1)
	goto done;
sa->sa_stateflags |= IKED_REQ_INF0x0100;
log_info("%s: sent delete, closing SA", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
4797done:
ibuf_free(buf);
sa_state(env, sa, IKEV2_STATE_CLOSED11);
} else {
sa_state(env, sa, IKEV2_STATE_CLOSING10);
}

/* Remove IKE-SA after timeout, e.g. if we don't get a delete */
timer_set(env, &sa->sa_timer, ikev2_ike_sa_timeout, sa);
timer_add(env, &sa->sa_timer, IKED_IKE_SA_DELETE_TIMEOUT120);
ikev2_ike_sa_setreason(sa, "deleting SA");
4808}

4810void
4811ikev2_ikesa_recv_delete(struct iked *env, struct iked_sa *sa)
4812{
log_info("%s: received delete", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
if (sa->sa_nexti) {
/*
 * We initiated rekeying, but since sa_nexti is still set
 * we have to assume that the the peer did not receive our
 * rekey message. So remove the initiated SA and -- if
 * sa_nextr is set -- keep the responder SA instead.
 */
if (sa->sa_nextr) {
	log_debug("%s: resolving simultaneous IKE SA rekeying",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	ikev2_ikesa_enable(env, sa, sa->sa_nextr);
	/* unlink sa_nextr */
	sa->sa_nextr->sa_prevr = NULL((void *)0);
	sa->sa_nextr = NULL((void *)0);
}
ikev2_ike_sa_setreason(sa->sa_nexti,
    "received delete (simultaneous rekeying)");
sa_free(env, sa->sa_nexti);
sa->sa_nexti = NULL((void *)0);	/* reset by sa_free */
}
ikev2_ike_sa_setreason(sa, "received delete");
if (env->sc_stickyaddresssc_static.st_stickyaddress) {
/* delay deletion if client reconnects soon */
sa_state(env, sa, IKEV2_STATE_CLOSING10);
timer_del(env, &sa->sa_timer);
timer_set(env, &sa->sa_timer, ikev2_ike_sa_timeout, sa);
timer_add(env, &sa->sa_timer, 3 * IKED_RETRANSMIT_TIMEOUT2);
} else {
sa_state(env, sa, IKEV2_STATE_CLOSED11);
}
4844}

4846int
4847ikev2_resp_create_child_sa(struct iked *env, struct iked_message *msg)
4848{
struct iked_childsa		*csa = NULL((void *)0);
struct iked_proposal		*prop;
struct iked_proposals		 proposals;
struct iked_kex			*kex, *kextmp = NULL((void *)0);
struct iked_sa			*nsa = NULL((void *)0), *sa = msg->msg_sa;
struct iked_spi			*spi, *rekey = &msg->msg_rekey;
struct iked_transform		*xform;
struct ikev2_keyexchange	*ke;
struct ikev2_payload		*pld = NULL((void *)0);
struct ibuf			*e = NULL((void *)0), *nonce = NULL((void *)0);
uint8_t				 firstpayload;
ssize_t				 len = 0;
int				 initiator, protoid, rekeying = 1;
int				 ret = -1;
int				 pfs = 0;

initiator = sa->sa_hdr.sh_initiator ? 1 : 0;

if (!ikev2_msg_frompeer(msg) || msg->msg_prop == NULL((void *)0))
return (0);

TAILQ_INIT(&proposals)do { (&proposals)->tqh_first = ((void *)0); (&proposals
)->tqh_last = &(&proposals)->tqh_first; } while
 (0);

if ((protoid = rekey->spi_protoid) == 0) {
/*
 * If REKEY_SA notification is not present, then it's either
 * IKE SA rekeying or the client wants to create additional
 * CHILD SAs
 */
if (msg->msg_prop->prop_protoid == IKEV2_SAPROTO_IKE1) {
	protoid = rekey->spi_protoid = IKEV2_SAPROTO_IKE1;
	if (sa->sa_hdr.sh_initiator)
		rekey->spi = sa->sa_hdr.sh_rspi;
	else
		rekey->spi = sa->sa_hdr.sh_ispi;
	rekey->spi_size = 8;
} else {
	protoid = msg->msg_prop->prop_protoid;
	rekeying = 0;
}
}

if (rekeying)
log_debug("%s: rekey %s spi %s", __func__,
    print_map(rekey->spi_protoid, ikev2_saproto_map),
    print_spi(rekey->spi, rekey->spi_size));
else
log_debug("%s: creating new %s SA", __func__,
    print_map(protoid, ikev2_saproto_map));

if (protoid == IKEV2_SAPROTO_IKE1) {
if ((sa->sa_stateflags & IKED_REQ_CHILDSA0x0080)
    && !(sa->sa_nexti)) {
	log_debug("%s: Ignore IKE SA rekey: waiting for Child "
	    "SA response.", __func__);
	/* Ignore, don't send error */
	msg->msg_valid = 0;
	return (0);
}

/* IKE SA rekeying */
spi = &msg->msg_prop->prop_peerspi;

if ((nsa = sa_new(env, spi->spi, 0, 0,
    msg->msg_policy)) == NULL((void *)0)) {
	log_debug("%s: failed to get new SA", __func__);
	return (ret);
}

if (ikev2_sa_responder(env, nsa, sa, msg)) {
	log_debug("%s: failed to get IKE SA keys", __func__);
	return (ret);
}

sa_state(env, nsa, IKEV2_STATE_AUTH_SUCCESS6);

nonce = nsa->sa_rnoncesa_kex.kex_rnonce;
kex = &nsa->sa_kex;
} else {
/* Child SA creating/rekeying */

if ((kex = kextmp = calloc(1, sizeof(*kextmp))) == NULL((void *)0)) {
	log_debug("%s: calloc kex", __func__);
	goto fail;
}

if (proposals_negotiate(&proposals,
    &sa->sa_policy->pol_proposals, &msg->msg_proposals,
    1, msg->msg_dhgroup) != 0) {
	log_info("%s: no proposal chosen", __func__);
	msg->msg_error = IKEV2_N_NO_PROPOSAL_CHOSEN14;
	ikestat_inc(env, ikes_sa_proposals_negotiate_failures)do { env->sc_stats.ikes_sa_proposals_negotiate_failures +=
 (1); } while(0);
	goto fail;
}

/* Check KE payload for PFS, ignore if DH transform is NONE */
if (((xform = config_findtransform(&proposals,
    IKEV2_XFORMTYPE_DH4, protoid)) != NULL((void *)0)) &&
    xform->xform_id != IKEV2_XFORMDH_NONE0 &&
    ibuf_length(msg->msg_ke)) {
	log_debug("%s: using PFS", __func__);
	if (ikev2_sa_responder_dh(kex, &proposals,
	    msg, protoid) < 0) {
		log_debug("%s: failed to setup DH", __func__);
		goto fail;
	}
	pfs = 1;
	/* XXX check group against policy ? */
}

/* Update peer SPI */
TAILQ_FOREACH(prop, &proposals, prop_entry)for((prop) = ((&proposals)->tqh_first); (prop) != ((void
 *)0); (prop) = ((prop)->prop_entry.tqe_next)) {
	if (prop->prop_protoid == protoid)
		break;
}
if (prop == NULL((void *)0)) {
	log_debug("%s: failed to find %s proposals", __func__,
	    print_map(protoid, ikev2_saproto_map));
	goto fail;
} else
	prop->prop_peerspi = msg->msg_prop->prop_peerspi;

/* Set rekeying flags on Child SAs */
if (rekeying) {
	if ((csa = childsa_lookup(sa, rekey->spi,
	    rekey->spi_protoid)) == NULL((void *)0)) {
		log_info("%s: CHILD SA %s wasn't found",
		    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
		    print_spi(rekey->spi, rekey->spi_size));
		msg->msg_error = IKEV2_N_CHILD_SA_NOT_FOUND44;
		goto fail;
	}
	if (!csa->csa_loaded || !csa->csa_peersa ||
	    !csa->csa_peersa->csa_loaded) {
		log_info("%s: CHILD SA %s is not loaded"
		    " or no peer SA", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
		    print_spi(rekey->spi, rekey->spi_size));
		msg->msg_error = IKEV2_N_CHILD_SA_NOT_FOUND44;
		goto fail;
	}
	csa->csa_rekey = 1;
	csa->csa_peersa->csa_rekey = 1;
}

/* Update initiator's nonce */
if (!ibuf_length(msg->msg_nonce)) {
	log_debug("%s: initiator didn't send nonce", __func__);
	goto fail;
}
ibuf_free(kex->kex_inonce);
kex->kex_inonce = msg->msg_nonce;
msg->msg_nonce = NULL((void *)0);

/* Generate new responder's nonce */
if ((nonce = ibuf_random(IKED_NONCE_SIZE32)) == NULL((void *)0))
	goto fail;

/* Update responder's nonce */
ibuf_free(kex->kex_rnonce);
kex->kex_rnonce = nonce;

if (ikev2_childsa_negotiate(env, sa, kex, &proposals, 0, pfs)) {
	log_debug("%s: failed to get CHILD SAs", __func__);
	goto fail;
}

if (rekeying && (sa->sa_stateflags & IKED_REQ_CHILDSA0x0080) &&
    csa && (sa->sa_rekeyspi == csa->csa_peerspi)) {
	log_info("%s: simultaneous rekeying for CHILD SA %s/%s",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
	    print_spi(rekey->spi, rekey->spi_size),
	    print_spi(sa->sa_rekeyspi, rekey->spi_size));
	ibuf_free(sa->sa_simult);
	if (ikev2_nonce_cmp(kex->kex_inonce, nonce) < 0)
		sa->sa_simult = ibuf_dup(kex->kex_inonce);
	else
		sa->sa_simult = ibuf_dup(nonce);
}
}

if ((e = ibuf_static()) == NULL((void *)0))
goto done;

if (!nsa && sa->sa_ipcompr.ic_transform &&
   (len = ikev2_add_ipcompnotify(env, e, &pld, 0, sa, 0)) == -1)
goto done;
if (!nsa && sa->sa_used_transport_mode &&
   (len = ikev2_add_transport_mode(env, e, &pld, len, sa)) == -1)
goto done;

if (pld) {
firstpayload = IKEV2_PAYLOAD_NOTIFY41;
if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_SA33) == -1)
	goto done;
} else
firstpayload = IKEV2_PAYLOAD_SA33;

/* SA payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;

if ((len = ikev2_add_proposals(env, nsa ? nsa : sa, e,
   nsa ? &nsa->sa_proposals : &proposals,
   protoid, 0, nsa ? 1 : 0, 0)) == -1)
goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONCE40) == -1)
goto done;

/* NONCE payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;
if (ikev2_add_buf(e, nonce) == -1)
goto done;
len = ibuf_size(nonce);

if (protoid == IKEV2_SAPROTO_IKE1 || pfs) {

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_KE34) == -1)
	goto done;

/* KE payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
	goto done;
if ((ke = ibuf_reserve(e, sizeof(*ke))) == NULL((void *)0))
	goto done;
if (kex->kex_dhgroup == NULL((void *)0)) {
	log_debug("%s: invalid dh", __func__);
	goto done;
}
ke->kex_dhgroup = htobe16(kex->kex_dhgroup->id)(__uint16_t)(__builtin_constant_p(kex->kex_dhgroup->id)
 ? (__uint16_t)(((__uint16_t)(kex->kex_dhgroup->id) &
 0xffU) << 8 | ((__uint16_t)(kex->kex_dhgroup->id
) & 0xff00U) >> 8) : __swap16md(kex->kex_dhgroup
->id));
if (ikev2_add_buf(e, kex->kex_dhrexchange) == -1)
	goto done;
len = sizeof(*ke) + ibuf_size(kex->kex_dhrexchange);
}

if (protoid != IKEV2_SAPROTO_IKE1)
if ((len = ikev2_add_ts(e, &pld, len, sa, initiator)) == -1)
	goto done;

if (ikev2_next_payload(pld, len, IKEV2_PAYLOAD_NONE0) == -1)
goto done;

if ((ret = ikev2_msg_send_encrypt(env, sa, &e,
   IKEV2_EXCHANGE_CREATE_CHILD_SA36, firstpayload, 1)) == -1)
goto done;

if (protoid == IKEV2_SAPROTO_IKE1) {
/*
 * If we also have initiated rekeying for this IKE SA, then
 * sa_nexti is already set. In this case don't enable the new SA
 * immediately, but record it in sa_nextr, until the exchange
 * for sa_nexti completes in ikev2_init_create_child_sa() and
 * the 'winner' can be selected by comparing nonces.
 */
if (sa->sa_nexti) {
	log_info("%s: simultaneous IKE SA rekeying",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	sa->sa_nextr = nsa;
	nsa->sa_prevr = sa;	/* backpointer */
	ret = 0;
} else
	ret = ikev2_ikesa_enable(env, sa, nsa);
} else
ret = ikev2_childsa_enable(env, sa);

done:
if (ret && protoid != IKEV2_SAPROTO_IKE1)
ikev2_childsa_delete(env, sa, 0, 0, NULL((void *)0), 1);
ibuf_free(e);
config_free_proposals(&proposals, 0);
config_free_kex(kextmp);
return (ret);

fail:
config_free_proposals(&proposals, 0);
config_free_kex(kextmp);
return (-1);
5127}

5129void
5130ikev2_ike_sa_setreason(struct iked_sa *sa, char *reason)
5131{
/* allow update only if reason is reset to NULL */
if (reason == NULL((void *)0) || sa->sa_reason == NULL((void *)0))
sa->sa_reason = reason;
5135}

5137void
5138ikev2_ike_sa_timeout(struct iked *env, void *arg)
5139{
struct iked_sa			*sa = arg;

log_debug("%s: closing SA", __func__);
ikev2_ike_sa_setreason(sa, "timeout");
sa_free(env, sa);
5145}

5147void
5148ikev2_ike_sa_rekey_timeout(struct iked *env, void *arg)
5149{
struct iked_sa			*sa = arg;

log_debug("%s: closing SA", __func__);
ikev2_ike_sa_setreason(sa, "rekey timeout");
sa_free(env, sa);
5155}

5157void
5158ikev2_ike_sa_rekey_schedule(struct iked *env, struct iked_sa *sa)
5159{
timer_add(env, &sa->sa_rekey, (sa->sa_policy->pol_rekey * 850 +
   arc4random_uniform(100)) / 1000);
5162}

5164/* rekey delayed, so re-try after short delay (1% of configured) */
5165void
5166ikev2_ike_sa_rekey_schedule_fast(struct iked *env, struct iked_sa *sa)
5167{
int timeout = sa->sa_policy->pol_rekey / 100; /* 1% */

if (timeout > 60)
timeout = 60;	/* max */
else if (timeout < 4)
timeout = 4;	/* min */
timer_add(env, &sa->sa_rekey, timeout);
5175}

5177void
5178ikev2_ike_sa_alive(struct iked *env, void *arg)
5179{
struct iked_sa			*sa = arg;
struct iked_childsa		*csa = NULL((void *)0);
uint64_t			 last_used, diff;
int				 foundin = 0, foundout = 0;
int				 ikeidle = 0;

if (env->sc_alive_timeoutsc_static.st_alive_timeout == 0)
return;

/* check for incoming traffic on any child SA */
TAILQ_FOREACH(csa, &sa->sa_childsas, csa_entry)for((csa) = ((&sa->sa_childsas)->tqh_first); (csa) !=
 ((void *)0); (csa) = ((csa)->csa_entry.tqe_next)) {
if (!csa->csa_loaded)
	continue;
if (pfkey_sa_last_used(env, csa, &last_used) != 0)
	continue;
diff = (uint32_t)(gettime() - last_used);
log_debug("%s: %s CHILD SA spi %s last used %llu second(s) ago",
    __func__,
    csa->csa_dir == IPSP_DIRECTION_IN0x1 ? "incoming" : "outgoing",
    print_spi(csa->csa_spi.spi, csa->csa_spi.spi_size), diff);
if (diff < env->sc_alive_timeoutsc_static.st_alive_timeout) {
	if (csa->csa_dir == IPSP_DIRECTION_IN0x1) {
		foundin = 1;
		break;
	} else {
		foundout = 1;
	}
}
}

diff = (uint32_t)(gettime() - sa->sa_last_recvd);
if (diff >= IKED_IKE_SA_LAST_RECVD_TIMEOUT300) {
ikeidle = 1;
log_debug("%s: IKE SA %p ispi %s rspi %s last received %llu"
    " second(s) ago", __func__, sa,
    print_spi(sa->sa_hdr.sh_ispi, 8),
    print_spi(sa->sa_hdr.sh_rspi, 8), diff);
}

/*
* send probe if any outgoing SA has been used, but no incoming
* SA, or if we haven't received an IKE message. but only if we
* are not already waiting for an answer.
*/
if (((!foundin && foundout) || ikeidle) &&
   (sa->sa_stateflags & (IKED_REQ_CHILDSA0x0080|IKED_REQ_INF0x0100)) == 0) {
log_debug("%s: sending alive check", __func__);
ikev2_send_ike_e(env, sa, NULL((void *)0), IKEV2_PAYLOAD_NONE0,
    IKEV2_EXCHANGE_INFORMATIONAL37, 0);
sa->sa_stateflags |= IKED_REQ_INF0x0100;
ikestat_inc(env, ikes_dpd_sent)do { env->sc_stats.ikes_dpd_sent += (1); } while(0);
}

/* re-register */
timer_add(env, &sa->sa_timer, env->sc_alive_timeoutsc_static.st_alive_timeout);
5235}

5237void
5238ikev2_ike_sa_keepalive(struct iked *env, void *arg)
5239{
struct iked_sa			*sa = arg;
uint8_t				 marker = 0xff;

if (sendtofrom(sa->sa_fd, &marker, sizeof(marker), 0,
   (struct sockaddr *)&sa->sa_peer.addr, sa->sa_peer.addr.ss_len,
   (struct sockaddr *)&sa->sa_local.addr, sa->sa_local.addr.ss_len)
   == -1)
log_warn("%s: sendtofrom: peer %s local %s", __func__,
    print_addr(&sa->sa_peer.addr),
    print_addr(&sa->sa_local.addr));
else
log_debug("%s: peer %s local %s", __func__,
    print_addr(&sa->sa_peer.addr),
    print_addr(&sa->sa_local.addr));
ikestat_inc(env, ikes_keepalive_sent)do { env->sc_stats.ikes_keepalive_sent += (1); } while(0);
timer_add(env, &sa->sa_keepalive, IKED_IKE_SA_KEEPALIVE_TIMEOUT20);
5256}

5258int
5259ikev2_send_informational(struct iked *env, struct iked_message *msg)
5260{
struct iked_message		 resp;
struct ike_header		*hdr;
struct ikev2_payload		*pld;
struct ikev2_notify		*n;
struct iked_sa			*sa = msg->msg_sa, sah;
struct ibuf			*buf, *e = NULL((void *)0);
int				 ret = -1;

if (msg->msg_error == 0)
return (0);

if ((buf = ikev2_msg_init(env, &resp,
   &msg->msg_peer, msg->msg_peerlen,
   &msg->msg_local, msg->msg_locallen, 0)) == NULL((void *)0))
goto done;

/* New encrypted message buffer */
if ((e = ibuf_static()) == NULL((void *)0))
goto done;

/* NOTIFY payload */
if ((pld = ikev2_add_payload(e)) == NULL((void *)0))
goto done;

if ((n = ibuf_reserve(e, sizeof(*n))) == NULL((void *)0))
goto done;
n->n_protoid = IKEV2_SAPROTO_IKE1;	/* XXX ESP etc. */
n->n_spisize = 0;
n->n_type = htobe16(msg->msg_error)(__uint16_t)(__builtin_constant_p(msg->msg_error) ? (__uint16_t
)(((__uint16_t)(msg->msg_error) & 0xffU) << 8 | (
(__uint16_t)(msg->msg_error) & 0xff00U) >> 8) : __swap16md
(msg->msg_error));

switch (msg->msg_error) {
case IKEV2_N_INVALID_IKE_SPI4:
break;
case IKEV2_N_NO_PROPOSAL_CHOSEN14:
ikev2_log_proposal(msg->msg_sa, &msg->msg_proposals);
break;
default:
log_warnx("%s: unsupported notification %s", SPI_SA(sa,ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
)))
    __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), print_map(msg->msg_error, ikev2_n_map));
goto done;
}
log_info("%s: %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
   print_map(msg->msg_error, ikev2_n_map));

if (ikev2_next_payload(pld, sizeof(*n), IKEV2_PAYLOAD_NONE0) == -1)
goto done;

if (sa != NULL((void *)0) && msg->msg_e) {
resp.msg_msgid = ikev2_msg_id(env, sa);

/* IKE header */
if ((hdr = ikev2_add_header(buf, sa, resp.msg_msgid,
    IKEV2_PAYLOAD_SK46, IKEV2_EXCHANGE_INFORMATIONAL37,
    0)) == NULL((void *)0))
	goto done;

if ((pld = ikev2_add_payload(buf)) == NULL((void *)0))
	goto done;

/* Encrypt message and add as an E payload */
if ((e = ikev2_msg_encrypt(env, sa, e, buf)) == NULL((void *)0)) {
	log_debug("%s: encryption failed", __func__);
	goto done;
}
if (ibuf_add_buf(buf, e) != 0)
	goto done;
if (ikev2_next_payload(pld, ibuf_size(e),
    IKEV2_PAYLOAD_NOTIFY41) == -1)
	goto done;

if (ikev2_set_header(hdr, ibuf_size(buf) - sizeof(*hdr)) == -1)
	goto done;

/* Add integrity checksum (HMAC) */
if (ikev2_msg_integr(env, sa, buf) != 0) {
	log_debug("%s: integrity checksum failed", __func__);
	goto done;
}
} else {
if ((hdr = ibuf_seek(msg->msg_data, 0, sizeof(*hdr))) == NULL((void *)0))
	goto done;

bzero(&sah, sizeof(sah));
sah.sa_hdr.sh_rspi = betoh64(hdr->ike_rspi)(__uint64_t)(__builtin_constant_p(hdr->ike_rspi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_rspi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_rspi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_rspi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_rspi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_rspi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_rspi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_rspi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_rspi));
sah.sa_hdr.sh_ispi = betoh64(hdr->ike_ispi)(__uint64_t)(__builtin_constant_p(hdr->ike_ispi) ? (__uint64_t
)((((__uint64_t)(hdr->ike_ispi) & 0xff) << 56) |
 ((__uint64_t)(hdr->ike_ispi) & 0xff00ULL) << 40
 | ((__uint64_t)(hdr->ike_ispi) & 0xff0000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff000000ULL) <<
| ((__uint64_t)(hdr->ike_ispi) & 0xff00000000ULL) >>
| ((__uint64_t)(hdr->ike_ispi) & 0xff0000000000ULL)
 >> 24 | ((__uint64_t)(hdr->ike_ispi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(hdr->ike_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md(hdr->ike_ispi));
sah.sa_hdr.sh_initiator =
    hdr->ike_flags & IKEV2_FLAG_INITIATOR0x08 ? 0 : 1;

resp.msg_msgid = ikev2_msg_id(env, &sah);

/* IKE header */
if ((hdr = ikev2_add_header(buf, &sah, resp.msg_msgid,
    IKEV2_PAYLOAD_NOTIFY41, IKEV2_EXCHANGE_INFORMATIONAL37,
    0)) == NULL((void *)0))
	goto done;
if (ibuf_add_buf(buf, e) != 0)
	goto done;
if (ikev2_set_header(hdr, ibuf_size(buf) - sizeof(*hdr)) == -1)
	goto done;
}

resp.msg_data = buf;
resp.msg_fd = msg->msg_fd;
TAILQ_INIT(&resp.msg_proposals)do { (&resp.msg_proposals)->tqh_first = ((void *)0); (
&resp.msg_proposals)->tqh_last = &(&resp.msg_proposals
)->tqh_first; } while (0);

ret = ikev2_msg_send(env, &resp);

done:
ibuf_free(e);
ikev2_msg_cleanup(env, &resp);

return (ret);
5373}

5375ssize_t
5376ikev2_psk(struct iked_sa *sa, uint8_t *data, size_t length,
  uint8_t **pskptr)
5378{
uint8_t		*psk;
size_t		 psklen = -1;

if (hash_setkey(sa->sa_prf, data, length) == NULL((void *)0))
return (-1);

if ((psk = calloc(1, hash_keylength(sa->sa_prf))) == NULL((void *)0))
return (-1);

hash_init(sa->sa_prf);
hash_update(sa->sa_prf, IKEV2_KEYPAD"Key Pad for IKEv2", strlen(IKEV2_KEYPAD"Key Pad for IKEv2"));
hash_final(sa->sa_prf, psk, &psklen);

*pskptr = psk;
return (psklen);
5394}

5396int
5397ikev2_sa_initiator_dh(struct iked_sa *sa, struct iked_message *msg,
  unsigned int proto, struct iked_sa *osa)
5399{
struct iked_policy	*pol = sa->sa_policy;
struct iked_transform	*xform;
struct iked_proposals	*proposals;

proposals = osa ? &osa->sa_proposals : &pol->pol_proposals;

if (sa->sa_dhgroupsa_kex.kex_dhgroup == NULL((void *)0)) {
if ((xform = config_findtransform(proposals,
    IKEV2_XFORMTYPE_DH4, proto)) == NULL((void *)0)) {
	log_debug("%s: did not find dh transform", __func__);
	return (-1);
}
if ((sa->sa_dhgroupsa_kex.kex_dhgroup =
    group_get(xform->xform_id)) == NULL((void *)0)) {
	log_debug("%s: invalid dh %d", __func__,
	    xform->xform_id);
	return (-1);
}
}

if (!ibuf_length(sa->sa_dhiexchangesa_kex.kex_dhiexchange)) {
if (dh_create_exchange(sa->sa_dhgroupsa_kex.kex_dhgroup,
    &sa->sa_dhiexchangesa_kex.kex_dhiexchange, NULL((void *)0)) == -1) {
	log_debug("%s: failed to get dh exchange", __func__);
	return (-1);
}
}

/* Initial message */
if (msg == NULL((void *)0))
return (0);

if (!ibuf_length(sa->sa_dhrexchangesa_kex.kex_dhrexchange)) {
if (!ibuf_length(msg->msg_ke)) {
	log_debug("%s: invalid peer dh exchange", __func__);
	return (-1);
}
sa->sa_dhrexchangesa_kex.kex_dhrexchange = msg->msg_ke;
msg->msg_ke = NULL((void *)0);
}

/* Set a pointer to the peer exchange */
sa->sa_dhpeersa_kex.kex_dhpeer = sa->sa_dhrexchangesa_kex.kex_dhrexchange;
return (0);
5444}

5446int
5447ikev2_sa_negotiate_common(struct iked *env, struct iked_sa *sa,
  struct iked_message *msg, int groupid)
5449{
struct iked_transform	*xform;

/* XXX we need a better way to get this */
if (proposals_negotiate(&sa->sa_proposals,
   &msg->msg_policy->pol_proposals, &msg->msg_proposals, 0, groupid) != 0) {
log_info("%s: proposals_negotiate", __func__);
ikestat_inc(env, ikes_sa_proposals_negotiate_failures)do { env->sc_stats.ikes_sa_proposals_negotiate_failures +=
 (1); } while(0);
return (-1);
}
if (sa_stateok(sa, IKEV2_STATE_SA_INIT2))
sa_stateflags(sa, IKED_REQ_SA0x0020);

if (sa->sa_encr == NULL((void *)0)) {
if ((xform = config_findtransform(&sa->sa_proposals,
    IKEV2_XFORMTYPE_ENCR1, 0)) == NULL((void *)0)) {
	log_info("%s: did not find encr transform",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
if ((sa->sa_encr = cipher_new(xform->xform_type,
    xform->xform_id, xform->xform_length)) == NULL((void *)0)) {
	log_info("%s: failed to get encr",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
}

/* For AEAD ciphers integrity is implicit */
if (sa->sa_encr->encr_authid && sa->sa_integr == NULL((void *)0)) {
if ((sa->sa_integr = hash_new(IKEV2_XFORMTYPE_INTEGR3,
    sa->sa_encr->encr_authid)) == NULL((void *)0)) {
	log_info("%s: failed to get AEAD integr",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
}

if (sa->sa_prf == NULL((void *)0)) {
if ((xform = config_findtransform(&sa->sa_proposals,
    IKEV2_XFORMTYPE_PRF2, 0)) == NULL((void *)0)) {
	log_info("%s: did not find prf transform",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
if ((sa->sa_prf =
    hash_new(xform->xform_type, xform->xform_id)) == NULL((void *)0)) {
	log_info("%s: failed to get prf", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
}

if (sa->sa_integr == NULL((void *)0)) {
if ((xform = config_findtransform(&sa->sa_proposals,
    IKEV2_XFORMTYPE_INTEGR3, 0)) == NULL((void *)0)) {
	log_info("%s: did not find integr transform",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
if ((sa->sa_integr =
    hash_new(xform->xform_type, xform->xform_id)) == NULL((void *)0)) {
	log_info("%s: failed to get integr",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
}

return (0);
5517}

5519int
5520ikev2_sa_initiator(struct iked *env, struct iked_sa *sa,
  struct iked_sa *osa, struct iked_message *msg)
5522{
if (ikev2_sa_initiator_dh(sa, msg, 0, osa) < 0)
return (-1);

if (!ibuf_length(sa->sa_inoncesa_kex.kex_inonce)) {
if ((sa->sa_inoncesa_kex.kex_inonce = ibuf_random(IKED_NONCE_SIZE32)) == NULL((void *)0)) {
	log_info("%s: failed to get local nonce",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
}

/* Initial message */
if (msg == NULL((void *)0))
return (0);

if (!ibuf_length(sa->sa_rnoncesa_kex.kex_rnonce)) {
if (!ibuf_length(msg->msg_nonce)) {
	log_info("%s: invalid peer nonce",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return (-1);
}
sa->sa_rnoncesa_kex.kex_rnonce = msg->msg_nonce;
msg->msg_nonce = NULL((void *)0);
}

if (ikev2_sa_negotiate_common(env, sa, msg, -1) != 0)
return (-1);

ibuf_free(sa->sa_2ndmsg);
if ((sa->sa_2ndmsg = ibuf_dup(msg->msg_data)) == NULL((void *)0)) {
log_info("%s: failed to copy 2nd message",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (-1);
}

return (ikev2_sa_keys(env, sa, osa ? osa->sa_key_d : NULL((void *)0)));
5559}

5561int
5562ikev2_sa_responder_dh(struct iked_kex *kex, struct iked_proposals *proposals,
  struct iked_message *msg, unsigned int proto)
5564{
struct iked_transform	*xform;

if (kex->kex_dhgroup == NULL((void *)0)) {
if ((xform = config_findtransform(proposals,
    IKEV2_XFORMTYPE_DH4, proto)) == NULL((void *)0)) {
	log_info("%s: did not find dh transform",
	    SPI_SA(msg->msg_sa, __func__)ikev2_ikesa_info((&(msg->msg_sa)->sa_hdr)->sh_ispi
, ((__func__))));
	return (-1);
}
if ((kex->kex_dhgroup =
    group_get(xform->xform_id)) == NULL((void *)0)) {
	log_debug("%s: invalid dh %d",
	    SPI_SA(msg->msg_sa, __func__)ikev2_ikesa_info((&(msg->msg_sa)->sa_hdr)->sh_ispi
, ((__func__))), xform->xform_id);
	return (-1);
}
}

/* Look for dhgroup mismatch during an IKE SA negotiation */
if (msg->msg_dhgroup != kex->kex_dhgroup->id) {
log_info("%s: want dh %s, KE has %s",
    SPI_SA(msg->msg_sa, __func__)ikev2_ikesa_info((&(msg->msg_sa)->sa_hdr)->sh_ispi
, ((__func__))),
    print_map(kex->kex_dhgroup->id, ikev2_xformdh_map),
    print_map(msg->msg_dhgroup, ikev2_xformdh_map));
msg->msg_error = IKEV2_N_INVALID_KE_PAYLOAD17;
msg->msg_dhgroup = kex->kex_dhgroup->id;
return (-1);
}

if (!ibuf_length(kex->kex_dhiexchange)) {
kex->kex_dhiexchange = msg->msg_ke;
msg->msg_ke = NULL((void *)0);
}

if (!ibuf_length(kex->kex_dhrexchange)) {
if (dh_create_exchange(kex->kex_dhgroup,
    &kex->kex_dhrexchange, kex->kex_dhiexchange) == -1) {
	log_info("%s: failed to get dh exchange",
	    SPI_SA(msg->msg_sa, __func__)ikev2_ikesa_info((&(msg->msg_sa)->sa_hdr)->sh_ispi
, ((__func__))));
	return (-1);
}
}

/* Set a pointer to the peer exchange */
kex->kex_dhpeer = kex->kex_dhiexchange;
return (0);
5610}

5612int
5613ikev2_sa_responder(struct iked *env, struct iked_sa *sa, struct iked_sa *osa,
  struct iked_message *msg)
5615{
struct iked_policy	*old;

/* re-lookup policy based on 'msg' (unless IKESA is rekeyed) */
if (osa == NULL((void *)0)) {
old = sa->sa_policy;
sa->sa_policy = NULL((void *)0);
if (policy_lookup(env, msg, &msg->msg_proposals,
    NULL((void *)0), 0) != 0 || msg->msg_policy == NULL((void *)0)) {
	sa->sa_policy = old;
	log_info("%s: no proposal chosen", __func__);
	msg->msg_error = IKEV2_N_NO_PROPOSAL_CHOSEN14;
	return (-1);
}
/* move sa to new policy */
sa->sa_policy = msg->msg_policy;
TAILQ_REMOVE(&old->pol_sapeers, sa, sa_peer_entry)do { if (((sa)->sa_peer_entry.tqe_next) != ((void *)0)) (sa
)->sa_peer_entry.tqe_next->sa_peer_entry.tqe_prev = (sa
)->sa_peer_entry.tqe_prev; else (&old->pol_sapeers)
->tqh_last = (sa)->sa_peer_entry.tqe_prev; *(sa)->sa_peer_entry
.tqe_prev = (sa)->sa_peer_entry.tqe_next; ; ; } while (0);
TAILQ_INSERT_TAIL(&sa->sa_policy->pol_sapeers,do { (sa)->sa_peer_entry.tqe_next = ((void *)0); (sa)->
sa_peer_entry.tqe_prev = (&sa->sa_policy->pol_sapeers
)->tqh_last; *(&sa->sa_policy->pol_sapeers)->
tqh_last = (sa); (&sa->sa_policy->pol_sapeers)->
tqh_last = &(sa)->sa_peer_entry.tqe_next; } while (0)
    sa, sa_peer_entry)do { (sa)->sa_peer_entry.tqe_next = ((void *)0); (sa)->
sa_peer_entry.tqe_prev = (&sa->sa_policy->pol_sapeers
)->tqh_last; *(&sa->sa_policy->pol_sapeers)->
tqh_last = (sa); (&sa->sa_policy->pol_sapeers)->
tqh_last = &(sa)->sa_peer_entry.tqe_next; } while (0);
policy_unref(env, old);
policy_ref(env, sa->sa_policy);
}

sa_state(env, sa, IKEV2_STATE_SA_INIT2);

ibuf_free(sa->sa_1stmsg);
if ((sa->sa_1stmsg = ibuf_dup(msg->msg_data)) == NULL((void *)0)) {
log_debug("%s: failed to copy 1st message", __func__);
return (-1);
}

if (sa->sa_rnoncesa_kex.kex_rnonce == NULL((void *)0) &&
   (sa->sa_rnoncesa_kex.kex_rnonce = ibuf_random(IKED_NONCE_SIZE32)) == NULL((void *)0)) {
log_debug("%s: failed to get local nonce", __func__);
return (-1);
}

if (!ibuf_length(sa->sa_inoncesa_kex.kex_inonce) &&
   (ibuf_length(msg->msg_nonce) < IKED_NONCE_MIN16)) {
log_debug("%s: failed to get peer nonce", __func__);
return (-1);
}
sa->sa_inoncesa_kex.kex_inonce = msg->msg_nonce;
msg->msg_nonce = NULL((void *)0);

if (ikev2_sa_negotiate_common(env, sa, msg, msg->msg_dhgroup) != 0)
return (-1);

if (ikev2_sa_responder_dh(&sa->sa_kex, &sa->sa_proposals, msg, 0) < 0)
return (-1);

return (ikev2_sa_keys(env, sa, osa ? osa->sa_key_d : NULL((void *)0)));
5667}

5669int
5670ikev2_sa_keys(struct iked *env, struct iked_sa *sa, struct ibuf *key)
5671{
struct iked_hash	*prf, *integr;
struct iked_cipher	*encr;
struct dh_group		*group;
struct ibuf		*ninr, *dhsecret, *skeyseed, *s, *t;
size_t			 nonceminlen, ilen, rlen, tmplen;
uint64_t		 ispi, rspi;
int			 ret = -1;
int			 isaead = 0;

ninr = dhsecret = skeyseed = s = t = NULL((void *)0);

if ((encr = sa->sa_encr) == NULL((void *)0) ||
   (prf = sa->sa_prf) == NULL((void *)0) ||
   (integr = sa->sa_integr) == NULL((void *)0) ||
   (group = sa->sa_dhgroupsa_kex.kex_dhgroup) == NULL((void *)0)) {
log_info("%s: failed to get key input data",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (-1);
}

/* For AEADs no auth keys are required (see RFC 5282) */
isaead = !!integr->hash_isaead;

if (prf->hash_fixedkey)
nonceminlen = prf->hash_fixedkey;
else
nonceminlen = IKED_NONCE_MIN16;

/* Nonces need a minimal size and should have an even length */
if (ibuf_length(sa->sa_inoncesa_kex.kex_inonce) < nonceminlen ||
   (ibuf_length(sa->sa_inoncesa_kex.kex_inonce) % 2) != 0 ||
   ibuf_length(sa->sa_rnoncesa_kex.kex_rnonce) < nonceminlen ||
   (ibuf_length(sa->sa_rnoncesa_kex.kex_rnonce) % 2) != 0) {
log_info("%s: invalid nonces", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (-1);
}

if (prf->hash_fixedkey) {
/* Half of the key bits must come from Ni, and half from Nr */
ilen = prf->hash_fixedkey / 2;
rlen = prf->hash_fixedkey / 2;
} else {
/* Most PRF functions accept a variable-length key */
ilen = ibuf_length(sa->sa_inoncesa_kex.kex_inonce);
rlen = ibuf_length(sa->sa_rnoncesa_kex.kex_rnonce);
}

/*
*  Depending on whether we're generating new keying material
*  or rekeying existing SA the algorithm is different. If the
*  "key" argument is not specified a concatenation of nonces
*  (Ni | Nr) is used as a PRF key, otherwise a "key" buffer
*  is used and PRF is performed on the concatenation of DH
*  exchange result and nonces (g^ir | Ni | Nr).  See sections
*  2.14 and 2.18 of RFC7296 for more information.
*/

/*
*  Generate g^ir
*/
if (dh_create_shared(group, &dhsecret, sa->sa_dhpeersa_kex.kex_dhpeer) == -1) {
log_info("%s: failed to get dh secret"
    " group %d secret %zu exchange %zu",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    group->id, ibuf_length(dhsecret),
    ibuf_length(sa->sa_dhpeersa_kex.kex_dhpeer));
goto done;
}

log_debug("%s: DHSECRET with %zu bytes", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
   ibuf_size(dhsecret));
print_hexbuf(dhsecret);

if (!key) {
/*
 * Set PRF key to generate SKEYSEED = prf(Ni | Nr, g^ir)
 */
if ((ninr = ibuf_new(ibuf_data(sa->sa_inoncesa_kex.kex_inonce), ilen)) == NULL((void *)0) ||
    ibuf_add(ninr, ibuf_data(sa->sa_rnoncesa_kex.kex_rnonce), rlen) != 0) {
	log_info("%s: failed to get nonce key buffer",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	goto done;
}
key = ninr;
} else {
/*
 * Set PRF key to generate SKEYSEED = prf(key, g^ir | Ni | Nr)
 */
if (ibuf_add(dhsecret, ibuf_data(sa->sa_inoncesa_kex.kex_inonce), ilen) != 0 ||
    ibuf_add(dhsecret, ibuf_data(sa->sa_rnoncesa_kex.kex_rnonce), rlen) != 0) {
	log_info("%s: failed to get nonce key buffer",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	goto done;
}
}

if ((hash_setkey(prf, ibuf_data(key), ibuf_size(key))) == NULL((void *)0)) {
log_info("%s: failed to set prf key", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
goto done;
}

if ((skeyseed = ibuf_new(NULL((void *)0), hash_keylength(prf))) == NULL((void *)0)) {
log_info("%s: failed to get SKEYSEED buffer",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
goto done;
}

tmplen = 0;
hash_init(prf);
hash_update(prf, ibuf_data(dhsecret), ibuf_size(dhsecret));
hash_final(prf, ibuf_data(skeyseed), &tmplen);

log_debug("%s: SKEYSEED with %zu bytes", __func__, tmplen);
print_hex(ibuf_data(skeyseed), 0, tmplen);

if (ibuf_setsize(skeyseed, tmplen) == -1) {
log_info("%s: failed to set keymaterial length",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
goto done;
}

/*
* Now generate the key material
*
* S = Ni | Nr | SPIi | SPIr
*/

/* S = Ni | Nr | SPIi | SPIr */
ilen = ibuf_length(sa->sa_inoncesa_kex.kex_inonce);
rlen = ibuf_length(sa->sa_rnoncesa_kex.kex_rnonce);
ispi = htobe64(sa->sa_hdr.sh_ispi)(__uint64_t)(__builtin_constant_p(sa->sa_hdr.sh_ispi) ? (__uint64_t
)((((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff) << 56
) | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00ULL) <<
| ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff0000ULL)
 << 24 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff000000ULL
) << 8 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00000000ULL
) >> 8 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(sa->sa_hdr.sh_ispi) & 0xff00000000000000ULL
) >> 56) : __swap64md(sa->sa_hdr.sh_ispi));
rspi = htobe64(sa->sa_hdr.sh_rspi)(__uint64_t)(__builtin_constant_p(sa->sa_hdr.sh_rspi) ? (__uint64_t
)((((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff) << 56
) | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00ULL) <<
| ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff0000ULL)
 << 24 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff000000ULL
) << 8 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00000000ULL
) >> 8 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff0000000000ULL
) >> 24 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff000000000000ULL
) >> 40 | ((__uint64_t)(sa->sa_hdr.sh_rspi) & 0xff00000000000000ULL
) >> 56) : __swap64md(sa->sa_hdr.sh_rspi));

if ((s = ibuf_new(ibuf_data(sa->sa_inoncesa_kex.kex_inonce), ilen)) == NULL((void *)0) ||
   ibuf_add(s, ibuf_data(sa->sa_rnoncesa_kex.kex_rnonce), rlen) != 0 ||
   ibuf_add(s, &ispi, sizeof(ispi)) != 0 ||
   ibuf_add(s, &rspi, sizeof(rspi)) != 0) {
log_info("%s: failed to set S buffer",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
goto done;
}

log_debug("%s: S with %zu bytes", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), ibuf_size(s));
print_hexbuf(s);

/*
* Get the size of the key material we need and the number
* of rounds we need to run the prf+ function.
*/
ilen = hash_length(prf) +			/* SK_d */
   (isaead ? 0 : hash_keylength(integr)) +	/* SK_ai */
   (isaead ? 0 : hash_keylength(integr)) +	/* SK_ar */
   cipher_keylength(encr) +			/* SK_ei */
   cipher_keylength(encr) +			/* SK_er */
   hash_keylength(prf) +			/* SK_pi */
   hash_keylength(prf);			/* SK_pr */

if ((t = ikev2_prfplus(prf, skeyseed, s, ilen)) == NULL((void *)0)) {
log_info("%s: failed to get IKE SA key material",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
goto done;
}

/* ibuf_getdata() returns a new buffer from the next read offset */
if ((sa->sa_key_d = ibuf_getdata(t, hash_length(prf))) == NULL((void *)0) ||
   (!isaead &&
   (sa->sa_key_iauth = ibuf_getdata(t, hash_keylength(integr))) ==
   NULL((void *)0)) ||
   (!isaead &&
   (sa->sa_key_rauth = ibuf_getdata(t, hash_keylength(integr))) ==
   NULL((void *)0)) ||
   (sa->sa_key_iencr = ibuf_getdata(t, cipher_keylength(encr))) ==
   NULL((void *)0) ||
   (sa->sa_key_rencr = ibuf_getdata(t, cipher_keylength(encr))) ==
   NULL((void *)0) ||
   (sa->sa_key_iprf = ibuf_getdata(t, hash_length(prf))) == NULL((void *)0) ||
   (sa->sa_key_rprf = ibuf_getdata(t, hash_length(prf))) == NULL((void *)0)) {
log_debug("%s: failed to get SA keys", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
goto done;
}

log_debug("%s: SK_d with %zu bytes", __func__, ibuf_size(sa->sa_key_d));
print_hexbuf(sa->sa_key_d);
if (!isaead) {
log_debug("%s: SK_ai with %zu bytes", __func__,
    ibuf_size(sa->sa_key_iauth));
print_hexbuf(sa->sa_key_iauth);
log_debug("%s: SK_ar with %zu bytes", __func__,
    ibuf_size(sa->sa_key_rauth));
print_hexbuf(sa->sa_key_rauth);
}
log_debug("%s: SK_ei with %zu bytes", __func__,
   ibuf_size(sa->sa_key_iencr));
print_hexbuf(sa->sa_key_iencr);
log_debug("%s: SK_er with %zu bytes", __func__,
   ibuf_size(sa->sa_key_rencr));
print_hexbuf(sa->sa_key_rencr);
log_debug("%s: SK_pi with %zu bytes", __func__,
   ibuf_size(sa->sa_key_iprf));
print_hexbuf(sa->sa_key_iprf);
log_debug("%s: SK_pr with %zu bytes", __func__,
   ibuf_size(sa->sa_key_rprf));
print_hexbuf(sa->sa_key_rprf);

ret = 0;

done:
ibuf_free(ninr);
ibuf_free(dhsecret);
ibuf_free(skeyseed);
ibuf_free(s);
ibuf_free(t);

return (ret);
5886}

5888void
5889ikev2_sa_cleanup_dh(struct iked_sa *sa)
5890{
ibuf_free(sa->sa_dhiexchangesa_kex.kex_dhiexchange);
ibuf_free(sa->sa_dhrexchangesa_kex.kex_dhrexchange);
group_free(sa->sa_dhgroupsa_kex.kex_dhgroup);
sa->sa_dhiexchangesa_kex.kex_dhiexchange = NULL((void *)0);
sa->sa_dhrexchangesa_kex.kex_dhrexchange = NULL((void *)0);
sa->sa_dhgroupsa_kex.kex_dhgroup = NULL((void *)0);
5897}

5899struct ibuf *
5900ikev2_prfplus(struct iked_hash *prf, struct ibuf *key, struct ibuf *seed,
  size_t keymatlen)
5902{
struct ibuf	*t = NULL((void *)0), *t1 = NULL((void *)0), *t2 = NULL((void *)0);
size_t		 rlen, i, hashlen = 0;
uint8_t		 pad = 0;

/*
* prf+ (K, S) = T1 | T2 | T3 | T4 | ...
*
* T1 = prf (K, S | 0x01)
* T2 = prf (K, T1 | S | 0x02)
* T3 = prf (K, T2 | S | 0x03)
* T4 = prf (K, T3 | S | 0x04)
*/

if ((hash_setkey(prf, ibuf_data(key), ibuf_size(key))) == NULL((void *)0)) {
log_debug("%s: failed to set prf+ key", __func__);
goto fail;
}

if ((t = ibuf_new(NULL((void *)0), 0)) == NULL((void *)0)) {
log_debug("%s: failed to get T buffer", __func__);
goto fail;
}

rlen = roundup(keymatlen, hash_length(prf))((((keymatlen)+((hash_length(prf))-1))/(hash_length(prf)))*(hash_length
(prf))) / hash_length(prf);
if (rlen > 255)
fatalx("ikev2_prfplus: key material too large");

for (i = 0; i < rlen; i++) {
if (t1 != NULL((void *)0)) {
	t2 = ibuf_new(ibuf_data(t1), ibuf_size(t1));
	ibuf_free(t1);
} else
	t2 = ibuf_new(NULL((void *)0), 0);
t1 = ibuf_new(NULL((void *)0), hash_keylength(prf));

ibuf_add_buf(t2, seed);
pad = i + 1;
ibuf_add(t2, &pad, 1);

hash_init(prf);
hash_update(prf, ibuf_data(t2), ibuf_size(t2));
hash_final(prf, ibuf_data(t1), &hashlen);

if (hashlen != hash_length(prf))
	fatalx("ikev2_prfplus: hash length mismatch");

ibuf_free(t2);
ibuf_add_buf(t, t1);

log_debug("%s: T%d with %zu bytes", __func__,
    pad, ibuf_size(t1));
print_hexbuf(t1);
}

log_debug("%s: Tn with %zu bytes", __func__, ibuf_size(t));
print_hexbuf(t);

ibuf_free(t1);

return (t);

fail:
ibuf_free(t1);
ibuf_free(t);

return (NULL((void *)0));
5969}

5971int
5972ikev2_sa_tag(struct iked_sa *sa, struct iked_id *id)
5973{
char	*format, *domain = NULL((void *)0), *idrepl = NULL((void *)0);
char	 idstr[IKED_ID_SIZE1024];
int	 ret = -1;
size_t	 len;

free(sa->sa_tag);
sa->sa_tag = NULL((void *)0);
format = sa->sa_policy->pol_tag;

len = IKED_TAG_SIZE64;
if ((sa->sa_tag = calloc(1, len)) == NULL((void *)0)) {
log_debug("%s: calloc", __func__);
goto fail;
}
if (strlcpy(sa->sa_tag, format, len) >= len) {
log_debug("%s: tag too long", __func__);
goto fail;
}

if (ikev2_print_id(id, idstr, sizeof(idstr)) == -1) {
log_debug("%s: invalid id", __func__);
goto fail;
}

/* ASN.1 DER IDs are too long, use the CN part instead */
if ((id->id_type == IKEV2_ID_ASN1_DN9) &&
   (idrepl = strstr(idstr, "CN=")) != NULL((void *)0)) {
domain = strstr(idrepl, "emailAddress=");
idrepl[strcspn(idrepl, "/")] = '\0';
} else
idrepl = idstr;

if (strstr(format, "$id") != NULL((void *)0)) {
if (expand_string(sa->sa_tag, len, "$id", idrepl) != 0) {
	log_debug("%s: failed to expand tag", __func__);
	goto fail;
}
}

if (strstr(format, "$eapid") != NULL((void *)0) && sa->sa_eapid != NULL((void *)0)) {
if (expand_string(sa->sa_tag, len, "$eapid",
    sa->sa_eapid) != 0) {
	log_debug("%s: failed to expand tag", __func__);
	goto fail;
}
}

if (strstr(format, "$name") != NULL((void *)0)) {
if (expand_string(sa->sa_tag, len, "$name",
    sa->sa_policy->pol_name) != 0) {
	log_debug("%s: failed to expand tag", __func__);
	goto fail;
}
}

if (strstr(format, "$domain") != NULL((void *)0)) {
if (id->id_type == IKEV2_ID_FQDN2)
	domain = strchr(idrepl, '.');
else if (id->id_type == IKEV2_ID_UFQDN3)
	domain = strchr(idrepl, '@');
else if (*idstr == '/' && domain != NULL((void *)0))
	domain = strchr(domain, '@');
else
	domain = NULL((void *)0);
if (domain == NULL((void *)0) || strlen(domain) < 2) {
	log_debug("%s: no valid domain in ID %s",
	    __func__, idstr);
	goto fail;
}
domain++;
if (expand_string(sa->sa_tag, len, "$domain", domain) != 0) {
	log_debug("%s: failed to expand tag", __func__);
	goto fail;
}
}

log_debug("%s: %s (%zu)", __func__, sa->sa_tag, strlen(sa->sa_tag));

ret = 0;
fail:
if (ret != 0) {
free(sa->sa_tag);
sa->sa_tag = NULL((void *)0);
}

return (ret);
6060}

6062int
6063ikev2_childsa_delete_proposed(struct iked *env, struct iked_sa *sa,
  struct iked_proposals *proposals)
6065{
struct ibuf			*buf = NULL((void *)0);
struct iked_proposal		*prop;
struct ikev2_delete		*del;
uint32_t			 spi32;
uint8_t				 protoid = 0;
int				 ret = -1, count;

if (!sa_stateok(sa, IKEV2_STATE_VALID7))
return (-1);

count = 0;
TAILQ_FOREACH(prop, proposals, prop_entry)for((prop) = ((proposals)->tqh_first); (prop) != ((void *)
0); (prop) = ((prop)->prop_entry.tqe_next)) {
if (ikev2_valid_proposal(prop, NULL((void *)0), NULL((void *)0), NULL((void *)0)) != 0)
	continue;
protoid = prop->prop_protoid;
count++;
}
if (count == 0)
return (0);
if ((buf = ibuf_static()) == NULL((void *)0))
return (-1);
if ((del = ibuf_reserve(buf, sizeof(*del))) == NULL((void *)0))
goto done;
/* XXX we assume all have the same protoid */
del->del_protoid = protoid;
del->del_spisize = 4;
del->del_nspi = htobe16(count)(__uint16_t)(__builtin_constant_p(count) ? (__uint16_t)(((__uint16_t
)(count) & 0xffU) << 8 | ((__uint16_t)(count) &
 0xff00U) >> 8) : __swap16md(count));

TAILQ_FOREACH(prop, proposals, prop_entry)for((prop) = ((proposals)->tqh_first); (prop) != ((void *)
0); (prop) = ((prop)->prop_entry.tqe_next)) {
if (ikev2_valid_proposal(prop, NULL((void *)0), NULL((void *)0), NULL((void *)0)) != 0)
	continue;
spi32 = htobe32(prop->prop_localspi.spi)(__uint32_t)(__builtin_constant_p(prop->prop_localspi.spi)
 ? (__uint32_t)(((__uint32_t)(prop->prop_localspi.spi) &
 0xff) << 24 | ((__uint32_t)(prop->prop_localspi.spi
) & 0xff00) << 8 | ((__uint32_t)(prop->prop_localspi
.spi) & 0xff0000) >> 8 | ((__uint32_t)(prop->prop_localspi
.spi) & 0xff000000) >> 24) : __swap32md(prop->prop_localspi
.spi));
if (ibuf_add(buf, &spi32, sizeof(spi32)))
	goto done;
}

if (ikev2_send_ike_e(env, sa, buf, IKEV2_PAYLOAD_DELETE42,
   IKEV2_EXCHANGE_INFORMATIONAL37, 0) == -1)
goto done;
sa->sa_stateflags |= IKED_REQ_INF0x0100;
ret = 0;
done:
ibuf_free(buf);

return (ret);
6111}

6113int
6114ikev2_childsa_negotiate(struct iked *env, struct iked_sa *sa,
  struct iked_kex *kex, struct iked_proposals *proposals, int initiator,
  int pfs)
6117{
struct iked_proposal	*prop;
struct iked_transform	*xform, *encrxf = NULL((void *)0), *integrxf = NULL((void *)0);
struct iked_childsa	*csa = NULL((void *)0), *csb = NULL((void *)0);
struct iked_childsa	*csa2 = NULL((void *)0), *csb2 = NULL((void *)0);
struct iked_flow	*flow, *saflow, *flowa, *flowb;
struct iked_ipcomp	*ic;
struct ibuf		*keymat = NULL((void *)0), *seed = NULL((void *)0), *dhsecret = NULL((void *)0);
struct dh_group		*group = NULL((void *)0);
uint32_t		 spi = 0;
unsigned int		 i;
size_t			 ilen = 0;
int			 esn, skip, ret = -1;

if (!sa_stateok(sa, IKEV2_STATE_VALID7))
return (-1);

if (ikev2_sa_tag(sa, IKESA_DSTID(sa)((sa)->sa_hdr.sh_initiator ? &(sa)->sa_rid : &(
sa)->sa_iid)) == -1)
return (-1);

ic = initiator ? &sa->sa_ipcompi : &sa->sa_ipcompr;
if (ic->ic_transform == 0 || ic->ic_cpi_out == 0 ||
   (initiator && ic->ic_cpi_in == 0))
ic = NULL((void *)0);

/* reset state */
sa->sa_used_transport_mode = 0;

/* We need to determine the key material length first */
TAILQ_FOREACH(prop, proposals, prop_entry)for((prop) = ((proposals)->tqh_first); (prop) != ((void *)
0); (prop) = ((prop)->prop_entry.tqe_next)) {
if (prop->prop_protoid == IKEV2_SAPROTO_IKE1)
	continue;
log_debug("%s: proposal %d", __func__, prop->prop_id);
for (i = 0; i < prop->prop_nxforms; i++) {
	xform = prop->prop_xforms + i;
	xform->xform_keylength =
	    keylength_xf(prop->prop_protoid,
	    xform->xform_type, xform->xform_id);

	switch (xform->xform_type) {
	case IKEV2_XFORMTYPE_ENCR1:
	case IKEV2_XFORMTYPE_INTEGR3:
		if (xform->xform_length)
			xform->xform_keylength =
			    xform->xform_length;
		xform->xform_keylength +=
		    noncelength_xf(xform->xform_type,
		    xform->xform_id);
		ilen += xform->xform_keylength / 8;
		break;
	}
}
}

/* double key material length for inbound/outbound */
ilen *= 2;

log_debug("%s: key material length %zu", __func__, ilen);

if ((seed = ibuf_new(NULL((void *)0), 0)) == NULL((void *)0)) {
log_debug("%s: failed to setup IKE SA key material", __func__);
goto done;
}
if (pfs) {
log_debug("%s: using PFS", __func__);
if (kex->kex_dhpeer == NULL((void *)0) ||
    ibuf_size(kex->kex_dhpeer) == 0 ||
    (group = kex->kex_dhgroup) == NULL((void *)0)) {
	log_debug("%s: no dh group for pfs", __func__);
	goto done;
}
if (dh_create_shared(group, &dhsecret, kex->kex_dhpeer) == -1) {
	log_debug("%s: failed to get dh secret"
	    " group %d secret %zu exchange %zu",
	    __func__, group->id, ibuf_length(dhsecret),
	    ibuf_length(kex->kex_dhpeer));
	goto done;
}
if (ibuf_add_buf(seed, dhsecret) != 0) {
	log_debug("%s: failed to set dh secret", __func__);
	goto done;
}
}
if (ibuf_add_buf(seed, kex->kex_inonce) != 0 ||
   ibuf_add_buf(seed, kex->kex_rnonce) != 0 ||
   (keymat = ikev2_prfplus(sa->sa_prf,
   sa->sa_key_d, seed, ilen)) == NULL((void *)0)) {
log_debug("%s: failed to get IKE SA key material", __func__);
goto done;
}

/* Create the new flows */
TAILQ_FOREACH(prop, proposals, prop_entry)for((prop) = ((proposals)->tqh_first); (prop) != ((void *)
0); (prop) = ((prop)->prop_entry.tqe_next)) {
if (ikev2_valid_proposal(prop, NULL((void *)0), NULL((void *)0), NULL((void *)0)) != 0)
	continue;

RB_FOREACH(flow, iked_flows, &sa->sa_policy->pol_flows)for ((flow) = iked_flows_RB_MINMAX(&sa->sa_policy->
pol_flows, -1); (flow) != ((void *)0); (flow) = iked_flows_RB_NEXT
(flow)) {

	if ((flowa = calloc(1, sizeof(*flowa))) == NULL((void *)0)) {
		log_debug("%s: failed to get flow", __func__);
		goto done;
	}

	memcpy(flowa, flow, sizeof(*flow));
	flowa->flow_dir = IPSP_DIRECTION_OUT0x2;
	flowa->flow_saproto = ic ? IKEV2_SAPROTO_IPCOMP204 :
	    prop->prop_protoid;
	flowa->flow_rdomain = sa->sa_policy->pol_rdomain;
	flowa->flow_local = &sa->sa_local;
	flowa->flow_peer = &sa->sa_peer;
	flowa->flow_ikesa = sa;
	if (ikev2_cp_fixflow(sa, flow, flowa) == -1) {
		flow_free(flowa);
		continue;
	}

	skip = 0;
	TAILQ_FOREACH(saflow, &sa->sa_flows, flow_entry)for((saflow) = ((&sa->sa_flows)->tqh_first); (saflow
) != ((void *)0); (saflow) = ((saflow)->flow_entry.tqe_next
)) {
		if (flow_equal(saflow, flowa)) {
			skip = 1;
			break;
		}
	}
	if (skip) {
		flow_free(flowa);
		continue;
	}

	if ((flowb = calloc(1, sizeof(*flowb))) == NULL((void *)0)) {
		log_debug("%s: failed to get flow", __func__);
		flow_free(flowa);
		goto done;
	}

	memcpy(flowb, flowa, sizeof(*flow));

	flowb->flow_dir = IPSP_DIRECTION_IN0x1;
	memcpy(&flowb->flow_src, &flow->flow_dst,
	    sizeof(flow->flow_dst));
	memcpy(&flowb->flow_dst, &flow->flow_src,
	    sizeof(flow->flow_src));
	if (ikev2_cp_fixflow(sa, flow, flowb) == -1) {
		flow_free(flowa);
		flow_free(flowb);
		continue;
	}

	TAILQ_INSERT_TAIL(&sa->sa_flows, flowa, flow_entry)do { (flowa)->flow_entry.tqe_next = ((void *)0); (flowa)->
flow_entry.tqe_prev = (&sa->sa_flows)->tqh_last; *(
&sa->sa_flows)->tqh_last = (flowa); (&sa->sa_flows
)->tqh_last = &(flowa)->flow_entry.tqe_next; } while
 (0);
	TAILQ_INSERT_TAIL(&sa->sa_flows, flowb, flow_entry)do { (flowb)->flow_entry.tqe_next = ((void *)0); (flowb)->
flow_entry.tqe_prev = (&sa->sa_flows)->tqh_last; *(
&sa->sa_flows)->tqh_last = (flowb); (&sa->sa_flows
)->tqh_last = &(flowb)->flow_entry.tqe_next; } while
 (0);
}
}

/* create the CHILD SAs using the key material */
TAILQ_FOREACH(prop, proposals, prop_entry)for((prop) = ((proposals)->tqh_first); (prop) != ((void *)
0); (prop) = ((prop)->prop_entry.tqe_next)) {
if (ikev2_valid_proposal(prop, &encrxf, &integrxf, &esn) != 0)
	continue;

spi = 0;

if ((csa = calloc(1, sizeof(*csa))) == NULL((void *)0)) {
	log_debug("%s: failed to get CHILD SA", __func__);
	goto done;
}

csa->csa_saproto = prop->prop_protoid;
csa->csa_ikesa = sa;
csa->csa_spi.spi_protoid = prop->prop_protoid;
csa->csa_esn = esn;
csa->csa_transport = sa->sa_use_transport_mode;
sa->sa_used_transport_mode = sa->sa_use_transport_mode;

if (pfs && group)
	csa->csa_pfsgrpid = group->id;

/* Set up responder's SPIs */
if (initiator) {
	csa->csa_dir = IPSP_DIRECTION_OUT0x2;
	csa->csa_local = &sa->sa_local;
	csa->csa_peer = &sa->sa_peer;
	csa->csa_peerspi = prop->prop_localspi.spi;
	csa->csa_spi.spi = prop->prop_peerspi.spi;
	csa->csa_spi.spi_size = prop->prop_peerspi.spi_size;
} else {
	csa->csa_dir = IPSP_DIRECTION_IN0x1;
	csa->csa_local = &sa->sa_peer;
	csa->csa_peer = &sa->sa_local;

	if ((ret = pfkey_sa_init(env, csa,
	    &spi)) != 0)
		goto done;
	csa->csa_allocated = 1;

	csa->csa_peerspi = prop->prop_peerspi.spi;
	csa->csa_spi.spi = prop->prop_localspi.spi = spi;
	csa->csa_spi.spi_size = 4;
}

if (encrxf && (csa->csa_encrkey = ibuf_getdata(keymat,
    encrxf->xform_keylength / 8)) == NULL((void *)0)) {
	log_debug("%s: failed to get CHILD SA encryption key",
	    __func__);
	goto done;
}
if (integrxf && (csa->csa_integrkey = ibuf_getdata(keymat,
    integrxf->xform_keylength / 8)) == NULL((void *)0)) {
	log_debug("%s: failed to get CHILD SA integrity key",
	    __func__);
	goto done;
}
if (encrxf)
	csa->csa_encrid = encrxf->xform_id;
if (integrxf)
	csa->csa_integrid = integrxf->xform_id;

if ((csb = calloc(1, sizeof(*csb))) == NULL((void *)0)) {
	log_debug("%s: failed to get CHILD SA", __func__);
	goto done;
}

memcpy(csb, csa, sizeof(*csb));

/* Set up initiator's SPIs */
csb->csa_spi.spi = csa->csa_peerspi;
csb->csa_peerspi = csa->csa_spi.spi;
csb->csa_allocated = csa->csa_allocated ? 0 : 1;
csb->csa_dir = csa->csa_dir == IPSP_DIRECTION_IN0x1 ?
    IPSP_DIRECTION_OUT0x2 : IPSP_DIRECTION_IN0x1;
csb->csa_local = csa->csa_peer;
csb->csa_peer = csa->csa_local;

if (encrxf && (csb->csa_encrkey = ibuf_getdata(keymat,
    encrxf->xform_keylength / 8)) == NULL((void *)0)) {
	log_debug("%s: failed to get CHILD SA encryption key",
	    __func__);
	goto done;
}
if (integrxf && (csb->csa_integrkey = ibuf_getdata(keymat,
    integrxf->xform_keylength / 8)) == NULL((void *)0)) {
	log_debug("%s: failed to get CHILD SA integrity key",
	    __func__);
	goto done;
}

if (ic && prop->prop_protoid == IKEV2_SAPROTO_ESP3) {
	/* add IPCOMP SAs */
	if ((csa2 = calloc(1, sizeof(*csa2))) == NULL((void *)0)) {
		log_debug("%s: failed to get CHILD SA", __func__);
		goto done;
	}
	if ((csb2 = calloc(1, sizeof(*csb2))) == NULL((void *)0)) {
		log_debug("%s: failed to get CHILD SA", __func__);
		goto done;
	}

	csa2->csa_saproto = IKEV2_SAPROTO_IPCOMP204;
	csa2->csa_ikesa = csa->csa_ikesa;
	csa2->csa_dir = csa->csa_dir;
	csa2->csa_local = csa->csa_local;
	csa2->csa_peer = csa->csa_peer;
	if (initiator) {
		csa2->csa_spi.spi = ic->ic_cpi_out;
		csa2->csa_peerspi = ic->ic_cpi_in;
		csa2->csa_allocated = 0;
		/* make sure IPCOMP CPIs are not reused */
		ic->ic_transform = 0;
		ic->ic_cpi_in = ic->ic_cpi_out = 0;
	} else {
		if ((ret = pfkey_sa_init(env, csa2,
		    &spi)) != 0)
			goto done;
		ic->ic_cpi_in = spi;
		csa2->csa_spi.spi = ic->ic_cpi_in;
		csa2->csa_peerspi = ic->ic_cpi_out;
		csa2->csa_allocated = 1;
	}
	csa2->csa_spi.spi_size = 2;

	memcpy(csb2, csa2, sizeof(*csb2));
	csb2->csa_spi.spi = csa2->csa_peerspi;
	csb2->csa_peerspi = csa2->csa_spi.spi;
	csb2->csa_allocated = csa2->csa_allocated ? 0 : 1;
	csb2->csa_dir = csa2->csa_dir == IPSP_DIRECTION_IN0x1 ?
	    IPSP_DIRECTION_OUT0x2 : IPSP_DIRECTION_IN0x1;
	csb2->csa_local = csa2->csa_peer;
	csb2->csa_peer = csa2->csa_local;

	/* link IPComp and ESP SAs, switch ESP to transport */
	csa->csa_transport = 1;
	csa->csa_bundled = csa2;
	csa2->csa_bundled = csa;
	csb->csa_transport = 1;
	csb->csa_bundled = csb2;
	csb2->csa_bundled = csb;
	csa2 = NULL((void *)0);
	csb2 = NULL((void *)0);

	ic = NULL((void *)0);
}

TAILQ_INSERT_TAIL(&sa->sa_childsas, csa, csa_entry)do { (csa)->csa_entry.tqe_next = ((void *)0); (csa)->csa_entry
.tqe_prev = (&sa->sa_childsas)->tqh_last; *(&sa
->sa_childsas)->tqh_last = (csa); (&sa->sa_childsas
)->tqh_last = &(csa)->csa_entry.tqe_next; } while (
0);
TAILQ_INSERT_TAIL(&sa->sa_childsas, csb, csa_entry)do { (csb)->csa_entry.tqe_next = ((void *)0); (csb)->csa_entry
.tqe_prev = (&sa->sa_childsas)->tqh_last; *(&sa
->sa_childsas)->tqh_last = (csb); (&sa->sa_childsas
)->tqh_last = &(csb)->csa_entry.tqe_next; } while (
0);
ikestat_add(env, ikes_csa_created, 2)do { env->sc_stats.ikes_csa_created += (2); } while(0);

csa->csa_peersa = csb;
csb->csa_peersa = csa;
csa = NULL((void *)0);
csb = NULL((void *)0);
}

ret = 0;
done:
sa->sa_use_transport_mode = 0;		/* reset state after use */
ibuf_free(dhsecret);
ibuf_free(keymat);
ibuf_free(seed);
childsa_free(csa);
childsa_free(csb);
childsa_free(csa2);
childsa_free(csb2);

return (ret);
6438}

6440int
6441ikev2_childsa_enable(struct iked *env, struct iked_sa *sa)
6442{
struct iked_childsa	*csa, *ocsa, *ipcomp;
struct iked_flow	*flow, *oflow;
int			 peer_changed, reload;
FILE			*spif, *flowf;
char			*spibuf = NULL((void *)0), *flowbuf = NULL((void *)0);
char			 prenat_mask[10];
uint16_t		 encrid = 0, integrid = 0, groupid = 0;
size_t			 encrlen = 0, integrlen = 0, spisz, flowsz;
int			 esn = 0;
int			 ret = -1;

spif = open_memstream(&spibuf, &spisz);
if (spif == NULL((void *)0)) {
log_warn("%s", __func__);
return (ret);
}
flowf = open_memstream(&flowbuf, &flowsz);
if (flowf == NULL((void *)0)) {
log_warn("%s", __func__);
fclose(spif);
return (ret);
}

TAILQ_FOREACH(csa, &sa->sa_childsas, csa_entry)for((csa) = ((&sa->sa_childsas)->tqh_first); (csa) !=
 ((void *)0); (csa) = ((csa)->csa_entry.tqe_next)) {
if (csa->csa_rekey || csa->csa_loaded)
	continue;

ipcomp = csa->csa_bundled;
if (ipcomp && ipcomp->csa_loaded) {
	log_info("%s: IPCOMP SA for CHILD SA spi %s"
	    " already loaded", __func__,
	    print_spi(csa->csa_spi.spi, csa->csa_spi.spi_size));
	continue;
}

if (pfkey_sa_add(env, csa, NULL((void *)0)) != 0) {
	log_debug("%s: failed to load CHILD SA spi %s",
	    __func__, print_spi(csa->csa_spi.spi,
	    csa->csa_spi.spi_size));
	goto done;
}
if (ipcomp) {
	if (pfkey_sa_add(env, ipcomp, csa) != 0) {
		log_debug("%s: failed to load IPCOMP spi %s",
		    __func__, print_spi(ipcomp->csa_spi.spi,
		    ipcomp->csa_spi.spi_size));
		ipcomp = NULL((void *)0);
	}
}

if ((ocsa = RB_FIND(iked_activesas, &env->sc_activesas, csa)iked_activesas_RB_FIND(&env->sc_activesas, csa))
    != NULL((void *)0)) {
	log_debug("%s: replaced CHILD SA %p with %p spi %s",
	    __func__, ocsa, csa, print_spi(ocsa->csa_spi.spi,
	    ocsa->csa_spi.spi_size));
	ocsa->csa_loaded = 0;
	ocsa->csa_rekey = 1;	/* prevent re-loading */
	RB_REMOVE(iked_activesas, &env->sc_activesas, ocsa)iked_activesas_RB_REMOVE(&env->sc_activesas, ocsa);
}

RB_INSERT(iked_activesas, &env->sc_activesas, csa)iked_activesas_RB_INSERT(&env->sc_activesas, csa);

log_debug("%s: loaded CHILD SA spi %s", __func__,
    print_spi(csa->csa_spi.spi, csa->csa_spi.spi_size));

/* append SPI to log buffer */
if (ftello(spif) > 0)
	fputs(", ", spif);
fputs(print_spi(csa->csa_spi.spi, csa->csa_spi.spi_size), spif);
if (ipcomp)
	fprintf(spif, "(%s)", print_spi(ipcomp->csa_spi.spi,
	    ipcomp->csa_spi.spi_size));
if (!encrid) {
	encrid = csa->csa_encrid;
	encrlen = ibuf_length(csa->csa_encrkey);
	switch (encrid) {
	case IKEV2_XFORMENCR_AES_GCM_1620:
	case IKEV2_XFORMENCR_AES_GCM_1219:
		encrlen -= 4;
		break;
	default:
		if (!csa->csa_integrid)
			break;
		integrid = csa->csa_integrid;
		integrlen = ibuf_length(csa->csa_integrkey);
	}
	groupid = csa->csa_pfsgrpid;
	esn = csa->csa_esn;
}
}

peer_changed = (memcmp(&sa->sa_peer_loaded, &sa->sa_peer,
   sizeof(sa->sa_peer_loaded)) != 0);

if (!(sa->sa_policy->pol_flags & IKED_POLICY_ROUTING0x80)) {
TAILQ_FOREACH(flow, &sa->sa_flows, flow_entry)for((flow) = ((&sa->sa_flows)->tqh_first); (flow) !=
 ((void *)0); (flow) = ((flow)->flow_entry.tqe_next)) {
	/* re-load the flow if the peer for the flow has changed */
	reload = 0;
	if (flow->flow_loaded) {
		if (!peer_changed) {
			log_debug("%s: flow already loaded %p",
			    __func__, flow);
			continue;
		}
		RB_REMOVE(iked_flows, &env->sc_activeflows, flow)iked_flows_RB_REMOVE(&env->sc_activeflows, flow);
		(void)pfkey_flow_delete(env, flow);
		flow->flow_loaded = 0; /* we did RB_REMOVE */
		reload = 1;
	}

	if (pfkey_flow_add(env, flow) != 0) {
		log_debug("%s: failed to load flow", __func__);
		goto done;
	}

	if ((oflow = RB_FIND(iked_flows, &env->sc_activeflows, flow)iked_flows_RB_FIND(&env->sc_activeflows, flow))
	    != NULL((void *)0)) {
		log_debug("%s: replaced old flow %p with %p",
		    __func__, oflow, flow);
		oflow->flow_loaded = 0;
		RB_REMOVE(iked_flows, &env->sc_activeflows, oflow)iked_flows_RB_REMOVE(&env->sc_activeflows, oflow);
	}

	RB_INSERT(iked_flows, &env->sc_activeflows, flow)iked_flows_RB_INSERT(&env->sc_activeflows, flow);

	log_debug("%s: %sloaded flow %p", __func__,
	    reload ? "re" : "", flow);

	/* append flow to log buffer */
	if (flow->flow_dir == IPSP_DIRECTION_OUT0x2 &&
	    flow->flow_prenat.addr_af != 0)
		snprintf(prenat_mask, sizeof(prenat_mask), "%d",
		    flow->flow_prenat.addr_mask);
	else
		prenat_mask[0] = '\0';
	if (flow->flow_dir == IPSP_DIRECTION_OUT0x2) {
		if (ftello(flowf) > 0)
			fputs(", ", flowf);
		fprintf(flowf, "%s-%s/%d%s%s%s%s%s=%s/%d(%u)%s",
		    print_map(flow->flow_saproto, ikev2_saproto_map),
		    print_addr(&flow->flow_src.addr),
		    flow->flow_src.addr_mask,
		    flow->flow_prenat.addr_af != 0 ? "[": "",
		    flow->flow_prenat.addr_af != 0 ?
		    print_addr(&flow->flow_prenat.addr) : "",
		    flow->flow_prenat.addr_af != 0 ? "/" : "",
		    flow->flow_prenat.addr_af != 0 ? prenat_mask : "",
		    flow->flow_prenat.addr_af != 0 ? "]": "",
		    print_addr(&flow->flow_dst.addr),
		    flow->flow_dst.addr_mask,
		    flow->flow_ipproto,
		    reload ? "-R" : "");
	}
}
}

/* remember the current address for ikev2_update_sa_addresses()  */
if (peer_changed) {
memcpy(&sa->sa_peer_loaded, &sa->sa_peer,
    sizeof(sa->sa_peer_loaded));
log_debug("%s: remember SA peer %s", __func__,
    print_addr(&sa->sa_peer_loaded.addr));
}

fflush(spif);
if (ftello(spif) > 0 && !ferror(spif)(!__isthreaded ? (((spif)->_flags & 0x0040) != 0) : (ferror
)(spif))) {
log_info("%s: loaded SPIs: %s (enc %s%s%s%s%s%s)",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), spibuf,
    print_xf(encrid, encrlen, ipsecencxfs),
    integrid ? " auth " : "",
    integrid ? print_xf(integrid, integrlen, authxfs) : "",
    groupid ? " group " : "",
    groupid ? print_xf(groupid, 0, groupxfs) : "",
    esn ? " esn" : "");
}
fflush(flowf);
if (ftello(flowf) > 0 && !ferror(flowf)(!__isthreaded ? (((flowf)->_flags & 0x0040) != 0) : (
ferror)(flowf))) {
log_info("%s: loaded flows: %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), flowbuf);
}

ret = 0;
done:
fclose(spif);
fclose(flowf);
free(spibuf);
free(flowbuf);
return (ret);
6630}

6632int
6633ikev2_childsa_delete(struct iked *env, struct iked_sa *sa, uint8_t saproto,
  uint64_t spi, uint64_t *spiptr, int cleanup)
6635{
struct iked_childsa	*csa, *csatmp = NULL((void *)0), *ipcomp;
uint64_t		 peerspi = 0;
int			 found = 0;

TAILQ_FOREACH_SAFE(csa, &sa->sa_childsas, csa_entry, csatmp)for ((csa) = ((&sa->sa_childsas)->tqh_first); (csa)
 != ((void *)0) && ((csatmp) = ((csa)->csa_entry.tqe_next
), 1); (csa) = (csatmp)) {
if ((saproto && csa->csa_saproto != saproto) ||
    (spi && (csa->csa_spi.spi != spi &&
	     csa->csa_peerspi != spi)) ||
    (cleanup && csa->csa_loaded))
	continue;

if (csa->csa_loaded)
	RB_REMOVE(iked_activesas, &env->sc_activesas, csa)iked_activesas_RB_REMOVE(&env->sc_activesas, csa);

if (pfkey_sa_delete(env, csa) != 0)
	log_info("%s: failed to delete CHILD SA spi %s",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), print_spi(csa->csa_spi.spi,
	    csa->csa_spi.spi_size));
else
	log_debug("%s: deleted CHILD SA spi %s",
	    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), print_spi(csa->csa_spi.spi,
	    csa->csa_spi.spi_size));
found++;

if (spi && csa->csa_spi.spi == spi)
	peerspi = csa->csa_peerspi;

ipcomp = csa->csa_bundled;
if (ipcomp) {
	if (ipcomp->csa_loaded) {
		if (pfkey_sa_delete(env, ipcomp) != 0)
			log_info("%s: failed to delete IPCOMP"
			    " SA spi %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
			    print_spi(ipcomp->csa_spi.spi,
			    ipcomp->csa_spi.spi_size));
		else
			log_debug("%s: deleted IPCOMP SA spi %s",
			    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
			    print_spi(ipcomp->csa_spi.spi,
			    ipcomp->csa_spi.spi_size));
	}
	childsa_free(ipcomp);
}
TAILQ_REMOVE(&sa->sa_childsas, csa, csa_entry)do { if (((csa)->csa_entry.tqe_next) != ((void *)0)) (csa)
->csa_entry.tqe_next->csa_entry.tqe_prev = (csa)->csa_entry
.tqe_prev; else (&sa->sa_childsas)->tqh_last = (csa
)->csa_entry.tqe_prev; *(csa)->csa_entry.tqe_prev = (csa
)->csa_entry.tqe_next; ; ; } while (0);
ikestat_inc(env, ikes_csa_removed)do { env->sc_stats.ikes_csa_removed += (1); } while(0);
childsa_free(csa);
}

if (spiptr)
*spiptr = peerspi;

return (found ? 0 : -1);
6688}

6690int
6691ikev2_valid_proposal(struct iked_proposal *prop,
  struct iked_transform **exf, struct iked_transform **ixf, int *esn)
6693{
struct iked_transform	*xform, *encrxf, *integrxf;
unsigned int		 i, doesn = 0;

switch (prop->prop_protoid) {
case IKEV2_SAPROTO_ESP3:
case IKEV2_SAPROTO_AH2:
break;
default:
return (-1);
}

encrxf = integrxf = NULL((void *)0);
for (i = 0; i < prop->prop_nxforms; i++) {
xform = prop->prop_xforms + i;
if (xform->xform_type == IKEV2_XFORMTYPE_ENCR1)
	encrxf = xform;
else if (xform->xform_type == IKEV2_XFORMTYPE_INTEGR3)
	integrxf = xform;
else if (xform->xform_type == IKEV2_XFORMTYPE_ESN5 &&
    xform->xform_id == IKEV2_XFORMESN_ESN1)
	doesn = 1;
}

if (prop->prop_protoid == IKEV2_SAPROTO_IKE1) {
if (encrxf == NULL((void *)0) || integrxf == NULL((void *)0))
	return (-1);
} else if (prop->prop_protoid == IKEV2_SAPROTO_AH2) {
if (integrxf == NULL((void *)0))
	return (-1);
} else if (prop->prop_protoid == IKEV2_SAPROTO_ESP3) {
if (encrxf == NULL((void *)0))
	return (-1);
}

if (exf)
*exf = encrxf;
if (ixf)
*ixf = integrxf;
if (esn)
*esn = doesn;

return (0);
6736}

6738/* return 0 if processed, -1 if busy */
6739int
6740ikev2_child_sa_acquire(struct iked *env, struct iked_flow *acquire)
6741{
struct iked_flow	*flow;
struct iked_sa		*sa;
struct iked_policy	 pol, *p = NULL((void *)0);

if (env->sc_passive)
return (0);

/* First try to find an active flow with IKE SA */
flow = RB_FIND(iked_flows, &env->sc_activeflows, acquire)iked_flows_RB_FIND(&env->sc_activeflows, acquire);
if (!flow) {
/* Otherwise try to find a matching policy */
bzero(&pol, sizeof(pol));
pol.pol_af = acquire->flow_peer->addr_af;
memcpy(&pol.pol_peer, acquire->flow_peer,
    sizeof(pol.pol_peer));

RB_INIT(&pol.pol_flows)do { (&pol.pol_flows)->rbh_root = ((void *)0); } while
 (0);
RB_INSERT(iked_flows, &pol.pol_flows, acquire)iked_flows_RB_INSERT(&pol.pol_flows, acquire);
pol.pol_nflows = 1;

if ((p = policy_test(env, &pol)) == NULL((void *)0)) {
	log_warnx("%s: flow wasn't found", __func__);
	return (0);
}

log_debug("%s: found matching policy '%s'", __func__,
    p->pol_name);

if (ikev2_init_ike_sa_peer(env, p,
    &p->pol_peer, NULL((void *)0)) != 0)
	log_warnx("%s: failed to initiate a "
	    "IKE_SA_INIT exchange for policy '%s'",
	    __func__, p->pol_name);
} else {
log_debug("%s: found active flow", __func__);

if ((sa = flow->flow_ikesa) == NULL((void *)0)) {
	log_warnx("%s: flow without SA", __func__);
	return (0);
}
if (sa->sa_stateflags & (IKED_REQ_CHILDSA0x0080|IKED_REQ_INF0x0100))
	return (-1);	/* busy, retry later */
if (ikev2_send_create_child_sa(env, sa, NULL((void *)0),
    flow->flow_saproto, 0) != 0)
	log_warnx("%s: failed to initiate a "
	    "CREATE_CHILD_SA exchange", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
}
return (0);
6790}

6792void
6793ikev2_disable_rekeying(struct iked *env, struct iked_sa *sa)
6794{
struct iked_childsa		*csa;

TAILQ_FOREACH(csa, &sa->sa_childsas, csa_entry)for((csa) = ((&sa->sa_childsas)->tqh_first); (csa) !=
 ((void *)0); (csa) = ((csa)->csa_entry.tqe_next)) {
csa->csa_persistent = 1;
csa->csa_rekey = 0;
}

(void)ikev2_childsa_delete(env, sa, 0, 0, NULL((void *)0), 1);
6803}

6805/* return 0 if processed, -1 if busy */
6806int
6807ikev2_child_sa_rekey(struct iked *env, struct iked_spi *rekey)
6808{
struct iked_childsa		*csa, key;
struct iked_sa			*sa;

key.csa_spi = *rekey;
csa = RB_FIND(iked_activesas, &env->sc_activesas, &key)iked_activesas_RB_FIND(&env->sc_activesas, &key);
if (!csa)
return (0);

if (csa->csa_rekey)	/* See if it's already taken care of */
return (0);
if ((sa = csa->csa_ikesa) == NULL((void *)0)) {
log_warnx("%s: SA %s doesn't have a parent SA", __func__,
    print_spi(rekey->spi, rekey->spi_size));
return (0);
}
if (!sa_stateok(sa, IKEV2_STATE_ESTABLISHED9)) {
log_warnx("%s: not established, SPI %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    print_spi(rekey->spi, rekey->spi_size));
return (0);
}
if (sa->sa_stateflags & (IKED_REQ_CHILDSA0x0080|IKED_REQ_INF0x0100)) {
log_info("%s: busy, retrying, SPI %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    print_spi(rekey->spi, rekey->spi_size));
return (-1);	/* busy, retry later */
}
if (sa->sa_tmpfail) {
log_info("%s: peer busy, retrying, SPI %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
    print_spi(rekey->spi, rekey->spi_size));
return (-1);	/* peer is busy, retry later */
}
if (csa->csa_allocated)	/* Peer SPI died first, get the local one */
rekey->spi = csa->csa_peerspi;
if (ikev2_send_create_child_sa(env, sa, rekey, rekey->spi_protoid, 0))
log_warnx("%s: failed to initiate a CREATE_CHILD_SA exchange",
    SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return (0);
6845}

6847/* return 0 if processed, -1 if busy */
6848int
6849ikev2_child_sa_drop(struct iked *env, struct iked_spi *drop)
6850{
struct ibuf			*buf = NULL((void *)0);
struct iked_childsa		*csa, key;
struct iked_sa			*sa;
struct ikev2_delete		*del;
uint32_t			 spi32;

key.csa_spi = *drop;
csa = RB_FIND(iked_activesas, &env->sc_activesas, &key)iked_activesas_RB_FIND(&env->sc_activesas, &key);
if (!csa || csa->csa_rekey)
return (0);

sa = csa->csa_ikesa;
if (sa && (sa->sa_stateflags & (IKED_REQ_CHILDSA0x0080|IKED_REQ_INF0x0100))) {
/* XXXX might loop, should we add a counter? */
log_debug("%s: parent SA busy", __func__);
return (-1);	/* busy, retry later */
}

RB_REMOVE(iked_activesas, &env->sc_activesas, csa)iked_activesas_RB_REMOVE(&env->sc_activesas, csa);
csa->csa_loaded = 0;
csa->csa_rekey = 1;	/* prevent re-loading */
if (sa == NULL((void *)0)) {
log_debug("%s: failed to find a parent SA", __func__);
return (0);
}

if (csa->csa_allocated)
spi32 = htobe32(csa->csa_spi.spi)(__uint32_t)(__builtin_constant_p(csa->csa_spi.spi) ? (__uint32_t
)(((__uint32_t)(csa->csa_spi.spi) & 0xff) << 24 |
 ((__uint32_t)(csa->csa_spi.spi) & 0xff00) << 8 |
 ((__uint32_t)(csa->csa_spi.spi) & 0xff0000) >> 8
 | ((__uint32_t)(csa->csa_spi.spi) & 0xff000000) >>
 24) : __swap32md(csa->csa_spi.spi));
else
spi32 = htobe32(csa->csa_peerspi)(__uint32_t)(__builtin_constant_p(csa->csa_peerspi) ? (__uint32_t
)(((__uint32_t)(csa->csa_peerspi) & 0xff) << 24 |
 ((__uint32_t)(csa->csa_peerspi) & 0xff00) << 8 |
 ((__uint32_t)(csa->csa_peerspi) & 0xff0000) >> 8
 | ((__uint32_t)(csa->csa_peerspi) & 0xff000000) >>
 24) : __swap32md(csa->csa_peerspi));

if (ikev2_childsa_delete(env, sa, csa->csa_saproto,
   csa->csa_peerspi, NULL((void *)0), 0))
log_debug("%s: failed to delete CHILD SA %s", __func__,
    print_spi(csa->csa_peerspi, drop->spi_size));

/* Send PAYLOAD_DELETE */

if ((buf = ibuf_static()) == NULL((void *)0))
return (0);
if ((del = ibuf_reserve(buf, sizeof(*del))) == NULL((void *)0))
goto done;
del->del_protoid = drop->spi_protoid;
del->del_spisize = 4;
del->del_nspi = htobe16(1)(__uint16_t)(__builtin_constant_p(1) ? (__uint16_t)(((__uint16_t
)(1) & 0xffU) << 8 | ((__uint16_t)(1) & 0xff00U
) >> 8) : __swap16md(1));
if (ibuf_add(buf, &spi32, sizeof(spi32)))
goto done;

if (ikev2_send_ike_e(env, sa, buf, IKEV2_PAYLOAD_DELETE42,
   IKEV2_EXCHANGE_INFORMATIONAL37, 0) == -1)
goto done;

sa->sa_stateflags |= IKED_REQ_INF0x0100;

6905done:
ibuf_free(buf);
return (0);
6908}

6910int
6911ikev2_print_static_id(struct iked_static_id *id, char *idstr, size_t idstrlen)
6912{
struct iked_id	idp;
int		ret = -1;

bzero(&idp, sizeof(idp));
if ((idp.id_buf = ibuf_new(id->id_data, id->id_length)) == NULL((void *)0)) {
bzero(idstr, idstrlen);
return (-1);
}
idp.id_type = id->id_type;
idp.id_offset = id->id_offset;
if (ikev2_print_id(&idp, idstr, idstrlen) == -1) {
bzero(idstr, idstrlen);
goto done;
}
ret = 0;
done:
ibuf_free(idp.id_buf);
return (ret);
6931}

6933int
6934ikev2_print_id(struct iked_id *id, char *idstr, size_t idstrlen)
6935{
uint8_t				*ptr;
struct sockaddr_in		 s4 = { 0 };
struct sockaddr_in6		 s6 = { 0 };
char				*str;
ssize_t				 len;
int				 i;
const char			*type;

bzero(idstr, idstrlen);

if (id->id_buf == NULL((void *)0))
return (-1);

len = ibuf_size(id->id_buf);
ptr = ibuf_data(id->id_buf);

if (len <= id->id_offset)
return (-1);

len -= id->id_offset;
ptr += id->id_offset;

type = print_map(id->id_type, ikev2_id_map);

if (strlcpy(idstr, type, idstrlen) >= idstrlen ||
   strlcat(idstr, "/", idstrlen) >= idstrlen)
return (-1);

switch (id->id_type) {
case IKEV2_ID_IPV41:
s4.sin_family = AF_INET2;
s4.sin_len = sizeof(s4);
memcpy(&s4.sin_addr.s_addr, ptr, len);

if (strlcat(idstr, print_addr(&s4), idstrlen) >= idstrlen)
	return (-1);
break;
case IKEV2_ID_FQDN2:
case IKEV2_ID_UFQDN3:
if ((str = get_string(ptr, len)) == NULL((void *)0))
	return (-1);

if (strlcat(idstr, str, idstrlen) >= idstrlen) {
	free(str);
	return (-1);
}
free(str);
break;
case IKEV2_ID_IPV65:
s6.sin6_family = AF_INET624;
s6.sin6_len = sizeof(s6);
memcpy(&s6.sin6_addr, ptr, len);

if (strlcat(idstr, print_addr(&s6), idstrlen) >= idstrlen)
	return (-1);
break;
case IKEV2_ID_ASN1_DN9:
if ((str = ca_asn1_name(ptr, len)) == NULL((void *)0))
	return (-1);
if (strlcat(idstr, str, idstrlen) >= idstrlen) {
	OPENSSL_free(str)CRYPTO_free(str);
	return (-1);
}
OPENSSL_free(str)CRYPTO_free(str);
break;
default:
/* XXX test */
for (i = 0; i < len; i++) {
	char buf[3];
	snprintf(buf, sizeof(buf), "%02x", ptr[i]);
	if (strlcat(idstr, buf, idstrlen) >= idstrlen)
		break;
}
break;
}

return (0);
7013}

7015/*
* If we have an IKEV2_CP_REQUEST for IKEV2_CFG_INTERNAL_IP4_ADDRESS and
* if a network(pool) is configured, then select an address from that pool
* and remember it in the sa_addrpool attribute.
*/
7020int
7021ikev2_cp_setaddr(struct iked *env, struct iked_sa *sa, sa_family_t family)
7022{
struct iked_policy	*pol = sa->sa_policy;
struct iked_cfg		*ikecfg = NULL((void *)0);
const char		*errstr = NULL((void *)0);
int			 ret, pass, passes;
size_t			 i;

switch (family) {
case AF_INET2:
if (sa->sa_addrpool)
	return (0);
break;
case AF_INET624:
if (sa->sa_addrpool6)
	return (0);
break;
default:
return (-1);
}
if (pol->pol_ncfg == 0)
return (0);
/* default if no pool configured */
ret = 0;
/* two passes if client requests from specific pool */
passes = (sa->sa_cp_addr != NULL((void *)0) || sa->sa_cp_addr6 != NULL((void *)0)) ? 2 : 1;
for (pass = 0; pass < passes; pass++) {
/* loop over all address pool configs (addr_net) */
for (i = 0; i < pol->pol_ncfg; i++) {
	ikecfg = &pol->pol_cfg[i];
	if (!ikecfg->cfg.address.addr_net)
		continue;
	if ((family == AF_INET2 && ikecfg->cfg_type ==
	    IKEV2_CFG_INTERNAL_IP4_ADDRESS1) ||
	    (family == AF_INET624 && ikecfg->cfg_type ==
	    IKEV2_CFG_INTERNAL_IP6_ADDRESS8)) {
		if ((ret = ikev2_cp_setaddr_pool(env, sa,
		    ikecfg, &errstr, family)) == 0)
			return (0);
	}
}
if (sa->sa_cp_addr != NULL((void *)0)) {
	free(sa->sa_cp_addr);
	sa->sa_cp_addr = NULL((void *)0);
}
if (sa->sa_cp_addr6 != NULL((void *)0)) {
	free(sa->sa_cp_addr6);
	sa->sa_cp_addr6 = NULL((void *)0);
}
}

if (errstr != NULL((void *)0))
log_warnx("%s: %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))), errstr);
return (ret);
7075}

7077int
7078ikev2_cp_setaddr_pool(struct iked *env, struct iked_sa *sa,
  struct iked_cfg *ikecfg, const char **errstr, sa_family_t family)
7080{
struct sockaddr_in	*in4 = NULL((void *)0), *cfg4 = NULL((void *)0);
1
'cfg4' initialized to a null pointer value→
struct sockaddr_in6	*in6 = NULL((void *)0), *cfg6 = NULL((void *)0);
struct iked_sa		 key;
struct iked_sa		*osa;
char			 idstr[IKED_ID_SIZE1024];
struct iked_addr	 addr;
uint32_t		 mask, host, lower, upper, start, nhost;
int			 requested = 0;

/*
* failure: pool configured, but not requested.
* If we continue, we might end up with flows where 0.0.0.0 is NOT
* replaced with an address from the pool with ikev2_cp_fixaddr().
*/
if (sa->sa_cp != IKEV2_CP_REQUEST1) {
2
←
Assuming field 'sa_cp' is equal to IKEV2_CP_REQUEST→
3
←
Taking false branch→
log_debug("%s: pool configured, but IKEV2_CP_REQUEST missing",
    __func__);
return (-1);
}
bzero(&addr, sizeof(addr));
addr.addr_af = family;

/* check if old IKESA for same DSTID already exists and transfer IPs */
if (env->sc_stickyaddresssc_static.st_stickyaddress &&
4
←
Assuming field 'st_stickyaddress' is 0→
   (osa = sa_dstid_lookup(env, sa)) != NULL((void *)0) &&
   ((family == AF_INET2 && osa->sa_addrpool) ||
   (family == AF_INET624 && osa->sa_addrpool6))) {
/* we have to transfer both, even if we just need one */
if (osa->sa_addrpool) {
	if (RB_REMOVE(iked_addrpool, &env->sc_addrpool, osa)iked_addrpool_RB_REMOVE(&env->sc_addrpool, osa)
	    != osa) {
		log_info("%s: addrpool error",
		    SPI_SA(osa, __func__)ikev2_ikesa_info((&(osa)->sa_hdr)->sh_ispi, ((__func__
))));
		return (-1);
	}
}
if (osa->sa_addrpool6) {
	if (RB_REMOVE(iked_addrpool6, &env->sc_addrpool6, osa)iked_addrpool6_RB_REMOVE(&env->sc_addrpool6, osa)
	    != osa) {
		log_info("%s: addrpool6 error",
		    SPI_SA(osa, __func__)ikev2_ikesa_info((&(osa)->sa_hdr)->sh_ispi, ((__func__
))));
		return (-1);
	}
}
sa_dstid_remove(env, osa);
sa->sa_addrpool = osa->sa_addrpool;
osa->sa_addrpool = NULL((void *)0);
sa->sa_addrpool6 = osa->sa_addrpool6;
osa->sa_addrpool6 = NULL((void *)0);
if (osa->sa_state < IKEV2_STATE_CLOSING10) {
	if (osa->sa_state == IKEV2_STATE_ESTABLISHED9)
		ikev2_disable_timer(env, osa);
	ikev2_ike_sa_setreason(osa,
	    "address re-use (identical dstid)");
	ikev2_ikesa_delete(env, osa, 1);
	timer_add(env, &osa->sa_timer,
	    3 * IKED_RETRANSMIT_TIMEOUT2);
}
if (sa->sa_addrpool) {
	RB_INSERT(iked_addrpool, &env->sc_addrpool, sa)iked_addrpool_RB_INSERT(&env->sc_addrpool, sa);
	log_info(
	    "%s: giving up assigned address %s to IKESA %s",
	    SPI_SA(osa, __func__)ikev2_ikesa_info((&(osa)->sa_hdr)->sh_ispi, ((__func__
))),
	    print_addr(&sa->sa_addrpool->addr),
	    print_spi(sa->sa_hdr.sh_ispi, 8));
}
if (sa->sa_addrpool6) {
	RB_INSERT(iked_addrpool6, &env->sc_addrpool6, sa)iked_addrpool6_RB_INSERT(&env->sc_addrpool6, sa);
	log_info(
	    "%s: giving up assigned v6 address %s to IKESA %s",
	    SPI_SA(osa, __func__)ikev2_ikesa_info((&(osa)->sa_hdr)->sh_ispi, ((__func__
))),
	    print_addr(&sa->sa_addrpool6->addr),
	    print_spi(sa->sa_hdr.sh_ispi, 8));
}
if (family == AF_INET2 && sa->sa_addrpool != NULL((void *)0))
	memcpy(&addr, sa->sa_addrpool, sizeof(addr));
else if (family == AF_INET624 && sa->sa_addrpool6 != NULL((void *)0))
	memcpy(&addr, sa->sa_addrpool6, sizeof(addr));
goto done;
}
switch (addr.addr_af) {
5
←
Control jumps to 'case 24:'  at line 7191→
case AF_INET2:
cfg4 = (struct sockaddr_in *)&ikecfg->cfg.address.addr;
mask = prefixlen2mask(ikecfg->cfg.address.addr_mask);
if (sa->sa_cp_addr != NULL((void *)0)) {
	memcpy(&addr, sa->sa_cp_addr, sizeof(addr));
	key.sa_addrpool = &addr;
	in4 = (struct sockaddr_in *)&addr.addr;
	if ((in4->sin_addr.s_addr & mask) !=
	    (cfg4->sin_addr.s_addr & mask)) {
		*errstr = "requested addr out of range";
		return (-1);
	}
	if (RB_FIND(iked_addrpool, &env->sc_addrpool,iked_addrpool_RB_FIND(&env->sc_addrpool, &key)
	    &key)iked_addrpool_RB_FIND(&env->sc_addrpool, &key)) {
		*errstr = "requested addr in use";
		return (-1);
	}
	sa->sa_addrpool = sa->sa_cp_addr;
	sa->sa_cp_addr = NULL((void *)0);
	RB_INSERT(iked_addrpool, &env->sc_addrpool, sa)iked_addrpool_RB_INSERT(&env->sc_addrpool, sa);
	requested = 1;
	goto done;
}
in4 = (struct sockaddr_in *)&addr.addr;
in4->sin_family = AF_INET2;
in4->sin_len = sizeof(*in4);
lower = ntohl(cfg4->sin_addr.s_addr & ~mask)(__uint32_t)(__builtin_constant_p(cfg4->sin_addr.s_addr &
 ~mask) ? (__uint32_t)(((__uint32_t)(cfg4->sin_addr.s_addr
 & ~mask) & 0xff) << 24 | ((__uint32_t)(cfg4->
sin_addr.s_addr & ~mask) & 0xff00) << 8 | ((__uint32_t
)(cfg4->sin_addr.s_addr & ~mask) & 0xff0000) >>
| ((__uint32_t)(cfg4->sin_addr.s_addr & ~mask) &
 0xff000000) >> 24) : __swap32md(cfg4->sin_addr.s_addr
 & ~mask));
key.sa_addrpool = &addr;
break;
case AF_INET624:
cfg6 = (struct sockaddr_in6 *)&ikecfg->cfg.address.addr;
in6 = (struct sockaddr_in6 *)&addr.addr;
if (sa->sa_cp_addr6 != NULL((void *)0)) {
6
←
Assuming field 'sa_cp_addr6' is equal to NULL→
7
←
Taking false branch→
	/* XXX not yet supported */
}
in6->sin6_family = AF_INET624;
in6->sin6_len = sizeof(*in6);
/* truncate prefixlen to get a 32-bit space */
mask = (ikecfg->cfg.address.addr_mask >= 96)
8
←
Assuming field 'addr_mask' is < 96→
9
←
'?' condition is false→
    ? prefixlen2mask(ikecfg->cfg.address.addr_mask - 96)
    : prefixlen2mask(0);
memcpy(&lower, &cfg6->sin6_addr.s6_addr__u6_addr.__u6_addr8[12], sizeof(uint32_t));
lower = ntohl(lower & ~mask)(__uint32_t)(__builtin_constant_p(lower & ~mask) ? (__uint32_t
)(((__uint32_t)(lower & ~mask) & 0xff) << 24 | (
(__uint32_t)(lower & ~mask) & 0xff00) << 8 | ((
__uint32_t)(lower & ~mask) & 0xff0000) >> 8 | (
(__uint32_t)(lower & ~mask) & 0xff000000) >> 24
) : __swap32md(lower & ~mask));
10
←
'?' condition is false→
key.sa_addrpool6 = &addr;
break;
default:
return (-1);
}

/* Note that start, upper and host are in HOST byte order */
upper = ntohl(~mask)(__uint32_t)(__builtin_constant_p(~mask) ? (__uint32_t)(((__uint32_t
)(~mask) & 0xff) << 24 | ((__uint32_t)(~mask) &
 0xff00) << 8 | ((__uint32_t)(~mask) & 0xff0000) >>
| ((__uint32_t)(~mask) & 0xff000000) >> 24) : __swap32md
(~mask));
11
←
 Execution continues on line 7212→
12
←
'?' condition is false→
/* skip .0 address if possible */
if (lower < upper && lower == 0)
13
←
Assuming 'lower' is >= 'upper'→
lower = 1;
if (upper < lower)
14
←
Assuming 'upper' is >= 'lower'→
15
←
Taking false branch→
upper = lower;
/* Randomly select start from [lower, upper-1] */
start = arc4random_uniform(upper - lower) + lower;

for (host = start;;) {
16
←
Loop condition is true.  Entering loop body→
28
←
Loop condition is true.  Entering loop body→
log_debug("%s: mask %x start %x lower %x host %x upper %x",
    __func__, mask, start, lower, host, upper);
switch (addr.addr_af) {
17
←
Control jumps to 'case 24:'  at line 7229→
29
←
Control jumps to 'case 2:'  at line 7225→
case AF_INET2:
	in4->sin_addr.s_addr =
	    (cfg4->sin_addr.s_addr & mask) | htonl(host)(__uint32_t)(__builtin_constant_p(host) ? (__uint32_t)(((__uint32_t
)(host) & 0xff) << 24 | ((__uint32_t)(host) & 0xff00
) << 8 | ((__uint32_t)(host) & 0xff0000) >> 8
 | ((__uint32_t)(host) & 0xff000000) >> 24) : __swap32md
(host));
30
←
Dereference of null pointer
	break;
case AF_INET624:
	memcpy(in6, cfg6, sizeof(*in6));
	memcpy(&nhost, &cfg6->sin6_addr.s6_addr__u6_addr.__u6_addr8[12],
	    sizeof(uint32_t));
	nhost = (nhost & mask) | htonl(host)(__uint32_t)(__builtin_constant_p(host) ? (__uint32_t)(((__uint32_t
)(host) & 0xff) << 24 | ((__uint32_t)(host) & 0xff00
) << 8 | ((__uint32_t)(host) & 0xff0000) >> 8
 | ((__uint32_t)(host) & 0xff000000) >> 24) : __swap32md
(host));
18
←
'?' condition is false→
	memcpy(&in6->sin6_addr.s6_addr__u6_addr.__u6_addr8[12], &nhost,
	    sizeof(uint32_t));
	break;
default:
	return (-1);
}
if ((addr.addr_af == AF_INET2 &&
19
←
Assuming field 'addr_af' is not equal to AF_INET→
22
←
Taking false branch→
    !RB_FIND(iked_addrpool, &env->sc_addrpool, &key)iked_addrpool_RB_FIND(&env->sc_addrpool, &key)) ||
    (addr.addr_af == AF_INET624 &&
20
←
Assuming field 'addr_af' is equal to AF_INET6→
    !RB_FIND(iked_addrpool6, &env->sc_addrpool6, &key)iked_addrpool6_RB_FIND(&env->sc_addrpool6, &key)))
21
←
Assuming the condition is false→
	break;
/* try next address */
host++;
/* but skip broadcast and network address */
if (host >= upper || host < lower)
23
←
Assuming 'host' is < 'upper'→
24
←
Assuming 'host' is >= 'lower'→
25
←
Taking false branch→
	host = lower;
if (host == start) {
26
←
Assuming 'host' is not equal to 'start'→
27
←
Taking false branch→
	*errstr = "address pool exhausted";
	return (-1);		/* exhausted */
}
}

addr.addr_mask = ikecfg->cfg.address.addr_mask;
switch (addr.addr_af) {
case AF_INET2:
if (!key.sa_addrpool)
	return (-1);			/* cannot happen? */
if ((sa->sa_addrpool = calloc(1, sizeof(addr))) == NULL((void *)0))
	return (-1);
memcpy(sa->sa_addrpool, &addr, sizeof(addr));
RB_INSERT(iked_addrpool, &env->sc_addrpool, sa)iked_addrpool_RB_INSERT(&env->sc_addrpool, sa);
break;
case AF_INET624:
if (!key.sa_addrpool6)
	return (-1);			/* cannot happen? */
if ((sa->sa_addrpool6 = calloc(1, sizeof(addr))) == NULL((void *)0))
	return (-1);
memcpy(sa->sa_addrpool6, &addr, sizeof(addr));
RB_INSERT(iked_addrpool6, &env->sc_addrpool6, sa)iked_addrpool6_RB_INSERT(&env->sc_addrpool6, sa);
break;
default:
return (-1);
}
done:
if (ikev2_print_id(IKESA_DSTID(sa)((sa)->sa_hdr.sh_initiator ? &(sa)->sa_rid : &(
sa)->sa_iid), idstr, sizeof(idstr)) == -1)
bzero(idstr, sizeof(idstr));
log_info("%sassigned address %s to %s%s", SPI_SA(sa, NULL)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((((void
 *)0)))),
   print_addr(&addr.addr),
   idstr, requested ? " (requested by peer)" : "");
return (0);
7284}

7286int
7287ikev2_cp_request_configured(struct iked_sa *sa)
7288{
struct iked_policy	*pol = sa->sa_policy;
struct iked_cfg		*ikecfg;
unsigned int		 i;

for (i = 0; i < pol->pol_ncfg; i++) {
ikecfg = &pol->pol_cfg[i];
if (ikecfg->cfg_action == IKEV2_CP_REQUEST1) {
	log_debug("%s: yes", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
	return 1;
}
}
log_debug("%s: no", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))));
return 0;
7302}

7304/*
* if 'addr' is 'UNSPECIFIED' replace it with sa_addrpool from
* the ip-pool or the sa_cp_addr received from peer and store the
* result in 'patched'.
*/
7309int
7310ikev2_cp_fixaddr(struct iked_sa *sa, struct iked_addr *addr,
  struct iked_addr *patched)
7312{
struct sockaddr_in	*in4;
struct sockaddr_in6	*in6;
struct iked_addr	*naddr;

if (addr->addr_net)
return (-2);
if (sa->sa_cp == 0)
return (-1);
switch (addr->addr_af) {
case AF_INET2:
in4 = (struct sockaddr_in *)&addr->addr;
if (in4->sin_addr.s_addr)
	return (-2);
naddr = (sa->sa_cp == IKEV2_CP_REQUEST1) ?
    sa->sa_addrpool : sa->sa_cp_addr;
if (naddr == NULL((void *)0))
	return (-1);
memcpy(patched, naddr, sizeof(*patched));
patched->addr_net = 0;
patched->addr_mask = 32;
break;
case AF_INET624:
in6 = (struct sockaddr_in6 *)&addr->addr;
if (!IN6_IS_ADDR_UNSPECIFIED(&in6->sin6_addr)((*(const u_int32_t *)(const void *)(&(&in6->sin6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&in6->sin6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&in6->sin6_addr)->__u6_addr.__u6_addr8[8]
) == 0) && (*(const u_int32_t *)(const void *)(&(
&in6->sin6_addr)->__u6_addr.__u6_addr8[12]) == 0)))
	return (-2);
naddr = (sa->sa_cp == IKEV2_CP_REQUEST1) ?
    sa->sa_addrpool6 : sa->sa_cp_addr6;
if (naddr == NULL((void *)0))
	return (-1);
memcpy(patched, naddr, sizeof(*patched));
patched->addr_net = 0;
patched->addr_mask = 128;
break;
}
return (0);
7348}

7350/* replace unspecified address in flow with requested address */
7351int
7352ikev2_cp_fixflow(struct iked_sa *sa, struct iked_flow *flow,
  struct iked_flow *patched)
7354{
switch (sa->sa_cp) {
case IKEV2_CP_REQUEST1:
if (patched->flow_dir == IPSP_DIRECTION_IN0x1)
	return (ikev2_cp_fixaddr(sa, &flow->flow_dst,
	    &patched->flow_src));
else
	return (ikev2_cp_fixaddr(sa, &flow->flow_dst,
	    &patched->flow_dst));
case IKEV2_CP_REPLY2:
if (patched->flow_dir == IPSP_DIRECTION_IN0x1)
	return (ikev2_cp_fixaddr(sa, &flow->flow_src,
	    &patched->flow_dst));
else
	return (ikev2_cp_fixaddr(sa, &flow->flow_src,
	    &patched->flow_src));
default:
return (0);
}
7373}

7375int
7376ikev2_update_sa_addresses(struct iked *env, struct iked_sa *sa)
7377{
struct iked_childsa		*csa, *ipcomp;
struct iked_flow		*flow, *oflow;
struct iked_message		*msg;
struct iked_msg_retransmit	*mr;

if (!sa_stateok(sa, IKEV2_STATE_ESTABLISHED9))
return -1;

log_info("%s: old %s new %s", SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))),
   print_addr(&sa->sa_peer_loaded.addr),
   print_addr(&sa->sa_peer.addr));

TAILQ_FOREACH(csa, &sa->sa_childsas, csa_entry)for((csa) = ((&sa->sa_childsas)->tqh_first); (csa) !=
 ((void *)0); (csa) = ((csa)->csa_entry.tqe_next)) {
if (!csa->csa_loaded)
	continue;
if (pfkey_sa_update_addresses(env, csa) != 0)
	log_debug("%s: failed to update sa", __func__);
if ((ipcomp = csa->csa_bundled) != NULL((void *)0) &&
    ipcomp->csa_loaded)
	if (pfkey_sa_update_addresses(env, ipcomp)
	    != 0)
		log_debug("%s: failed to update sa", __func__);
}

/* delete and re-add flows */
TAILQ_FOREACH(flow, &sa->sa_flows, flow_entry)for((flow) = ((&sa->sa_flows)->tqh_first); (flow) !=
 ((void *)0); (flow) = ((flow)->flow_entry.tqe_next)) {
if (flow->flow_loaded) {
	RB_REMOVE(iked_flows, &env->sc_activeflows, flow)iked_flows_RB_REMOVE(&env->sc_activeflows, flow);
	(void)pfkey_flow_delete(env, flow);
	flow->flow_loaded = 0;
}
if (pfkey_flow_add(env, flow) != 0)
	log_debug("%s: failed to add flow %p", __func__, flow);
if (!flow->flow_loaded)
	continue;
if ((oflow = RB_FIND(iked_flows, &env->sc_activeflows, flow)iked_flows_RB_FIND(&env->sc_activeflows, flow))
    != NULL((void *)0)) {
	log_debug("%s: replaced old flow %p with %p",
	    __func__, oflow, flow);
	oflow->flow_loaded = 0;
	RB_REMOVE(iked_flows, &env->sc_activeflows, oflow)iked_flows_RB_REMOVE(&env->sc_activeflows, oflow);
}
RB_INSERT(iked_flows, &env->sc_activeflows, flow)iked_flows_RB_INSERT(&env->sc_activeflows, flow);
}

/* update pending requests and responses */
TAILQ_FOREACH(mr, &sa->sa_requests, mrt_entry)for((mr) = ((&sa->sa_requests)->tqh_first); (mr) !=
 ((void *)0); (mr) = ((mr)->mrt_entry.tqe_next)) {
TAILQ_FOREACH(msg, &mr->mrt_frags, msg_entry)for((msg) = ((&mr->mrt_frags)->tqh_first); (msg) !=
 ((void *)0); (msg) = ((msg)->msg_entry.tqe_next)) {
	msg->msg_local = sa->sa_local.addr;
	msg->msg_locallen = sa->sa_local.addr.ss_len;
	msg->msg_peer = sa->sa_peer.addr;
	msg->msg_peerlen = sa->sa_peer.addr.ss_len;
}
}
TAILQ_FOREACH(mr, &sa->sa_responses, mrt_entry)for((mr) = ((&sa->sa_responses)->tqh_first); (mr) !=
 ((void *)0); (mr) = ((mr)->mrt_entry.tqe_next)) {
TAILQ_FOREACH(msg, &mr->mrt_frags, msg_entry)for((msg) = ((&mr->mrt_frags)->tqh_first); (msg) !=
 ((void *)0); (msg) = ((msg)->msg_entry.tqe_next)) {
	msg->msg_local = sa->sa_local.addr;
	msg->msg_locallen = sa->sa_local.addr.ss_len;
	msg->msg_peer = sa->sa_peer.addr;
	msg->msg_peerlen = sa->sa_peer.addr.ss_len;
}
}

/* Update sa_peer_loaded, to match in-kernel information */
memcpy(&sa->sa_peer_loaded, &sa->sa_peer, sizeof(sa->sa_peer_loaded));

return 0;
7445}

7447void
7448ikev2_info_sa(struct iked *env, int dolog, const char *msg, struct iked_sa *sa)
7449{
char		 idstr[IKED_ID_SIZE1024];
char		*buf;
int		 buflen;

if (ikev2_print_id(IKESA_DSTID(sa)((sa)->sa_hdr.sh_initiator ? &(sa)->sa_rid : &(
sa)->sa_iid), idstr, sizeof(idstr)) == -1)
bzero(idstr, sizeof(idstr));

buflen = asprintf(&buf,
   "%s: %p rspi %s ispi %s %s->%s<%s>[%s] %s %c%s%s nexti %p pol %p\n",
   msg, sa,
   print_spi(sa->sa_hdr.sh_rspi, 8),
   print_spi(sa->sa_hdr.sh_ispi, 8),
   print_addr(&sa->sa_local.addr),
   print_addr(&sa->sa_peer.addr),
   idstr,
   sa->sa_addrpool ? print_addr(&sa->sa_addrpool->addr) : "",
   print_map(sa->sa_state, ikev2_state_map),
   sa->sa_hdr.sh_initiator ? 'i' : 'r',
   sa->sa_natt ? " natt" : "",
   sa->sa_udpencap ? " udpecap" : "",
   sa->sa_nexti, sa->sa_policy);

if (buflen == -1 || buf == NULL((void *)0))
return;

if (dolog) {
if (buflen > 1)
	buf[buflen - 1] = '\0';
log_debug("%s", buf);
} else
proc_compose(&env->sc_ps, PROC_CONTROL, IMSG_CTL_SHOW_SA,
    buf, buflen + 1);
free(buf);
7483}

7485void
7486ikev2_info_csa(struct iked *env, int dolog, const char *msg, struct iked_childsa *csa)
7487{
char		*buf;
int		 buflen;

buflen = asprintf(&buf,
   "%s: %p %s %s %s %s -> %s (%s%s%s%s) B=%p P=%p @%p\n", msg, csa,
   print_map(csa->csa_saproto, ikev2_saproto_map),
   print_spi(csa->csa_spi.spi, csa->csa_spi.spi_size),
   csa->csa_dir == IPSP_DIRECTION_IN0x1 ? "in" : "out",
   print_addr(&csa->csa_local->addr),
   print_addr(&csa->csa_peer->addr),
   csa->csa_loaded ? "L" : "",
   csa->csa_rekey ? "R" : "",
   csa->csa_allocated ? "A" : "",
   csa->csa_persistent ? "P" : "",
   csa->csa_bundled,
   csa->csa_peersa,
   csa->csa_ikesa);

if (buflen == -1 || buf == NULL((void *)0))
return;

if (dolog) {
if (buflen > 1)
	buf[buflen - 1] = '\0';
log_debug("%s", buf);
} else
proc_compose(&env->sc_ps, PROC_CONTROL, IMSG_CTL_SHOW_SA,
    buf, buflen + 1);
free(buf);
7517}

7519void
7520ikev2_info_flow(struct iked *env, int dolog, const char *msg, struct iked_flow *flow)
7521{
char		prenat_mask[10];
char		*buf;
int		buflen;

if (flow->flow_prenat.addr_af != 0)
snprintf(prenat_mask, sizeof(prenat_mask), "%d",
    flow->flow_prenat.addr_mask);
else
prenat_mask[0] = '\0';

buflen = asprintf(&buf,
   "%s: %p %s %s %s/%d -> %s/%d %s%s%s%s%s[%u]@%d (%s) @%p\n", msg, flow,
   print_map(flow->flow_saproto, ikev2_saproto_map),
   flow->flow_dir == IPSP_DIRECTION_IN0x1 ? "in" : "out",
   print_addr(&flow->flow_src.addr),
   flow->flow_src.addr_mask,
   print_addr(&flow->flow_dst.addr),
   flow->flow_dst.addr_mask,
   flow->flow_prenat.addr_af != 0 ? "[": "",
   flow->flow_prenat.addr_af != 0 ?
   print_addr(&flow->flow_prenat.addr) : "",
   flow->flow_prenat.addr_af != 0 ? "/" : "",
   flow->flow_prenat.addr_af != 0 ? prenat_mask : "",
   flow->flow_prenat.addr_af != 0 ? "] ": "",
   flow->flow_ipproto,
   flow->flow_rdomain,
   flow->flow_loaded ? "L" : "",
   flow->flow_ikesa);

if (buflen == -1 || buf == NULL((void *)0))
return;

if (dolog) {
if (buflen > 1)
	buf[buflen - 1] = '\0';
log_debug("%s", buf);
} else
proc_compose(&env->sc_ps, PROC_CONTROL, IMSG_CTL_SHOW_SA,
    buf, buflen + 1);
free(buf);
7562}

7564void
7565ikev2_info(struct iked *env, int dolog)
7566{
struct iked_sa			*sa;
struct iked_childsa		*csa, *ipcomp;
struct iked_flow		*flow;

log_debug("%s: called", __func__);

RB_FOREACH(sa, iked_sas, &env->sc_sas)for ((sa) = iked_sas_RB_MINMAX(&env->sc_sas, -1); (sa)
 != ((void *)0); (sa) = iked_sas_RB_NEXT(sa)) {
ikev2_info_sa(env, dolog, "iked_sas", sa);
TAILQ_FOREACH(csa, &sa->sa_childsas, csa_entry)for((csa) = ((&sa->sa_childsas)->tqh_first); (csa) !=
 ((void *)0); (csa) = ((csa)->csa_entry.tqe_next)) {
	ikev2_info_csa(env, dolog, "  sa_childsas", csa);
	if ((ipcomp = csa->csa_bundled) != NULL((void *)0))
		ikev2_info_csa(env, dolog, "             ",
		    ipcomp);
}
TAILQ_FOREACH(flow, &sa->sa_flows, flow_entry)for((flow) = ((&sa->sa_flows)->tqh_first); (flow) !=
 ((void *)0); (flow) = ((flow)->flow_entry.tqe_next)) {
	ikev2_info_flow(env, dolog, "  sa_flows", flow);
}
}
RB_FOREACH(csa, iked_activesas, &env->sc_activesas)for ((csa) = iked_activesas_RB_MINMAX(&env->sc_activesas
, -1); (csa) != ((void *)0); (csa) = iked_activesas_RB_NEXT(csa
)) {
ikev2_info_csa(env, dolog, "iked_activesas", csa);
if ((ipcomp = csa->csa_bundled) != NULL((void *)0))
	ikev2_info_csa(env, dolog, "              ", ipcomp);
}
RB_FOREACH(flow, iked_flows, &env->sc_activeflows)for ((flow) = iked_flows_RB_MINMAX(&env->sc_activeflows
, -1); (flow) != ((void *)0); (flow) = iked_flows_RB_NEXT(flow
)) {
ikev2_info_flow(env, dolog, "iked_flows", flow);
}
RB_FOREACH(sa, iked_dstid_sas, &env->sc_dstid_sas)for ((sa) = iked_dstid_sas_RB_MINMAX(&env->sc_dstid_sas
, -1); (sa) != ((void *)0); (sa) = iked_dstid_sas_RB_NEXT(sa)
) {
ikev2_info_sa(env, dolog, "iked_dstid_sas", sa);
}
if (dolog)
return;
/* Send empty reply to indicate end of information. */
proc_compose(&env->sc_ps, PROC_CONTROL, IMSG_CTL_SHOW_SA, NULL((void *)0), 0);
7600}

7602const char *
7603ikev2_ikesa_info(uint64_t spi, const char *msg)
7604{
static char buf[1024];
const char *spistr;

spistr = print_spi(spi, 8);
if (msg)
snprintf(buf, sizeof(buf), "spi=%s: %s", spistr, msg);
else
snprintf(buf, sizeof(buf), "spi=%s: ", spistr);
return buf;
7614}

7616void
7617ikev2_log_established(struct iked_sa *sa)
7618{
char dstid[IKED_ID_SIZE1024], srcid[IKED_ID_SIZE1024];

if (ikev2_print_id(IKESA_DSTID(sa)((sa)->sa_hdr.sh_initiator ? &(sa)->sa_rid : &(
sa)->sa_iid), dstid, sizeof(dstid)) == -1)
bzero(dstid, sizeof(dstid));
if (ikev2_print_id(IKESA_SRCID(sa)((sa)->sa_hdr.sh_initiator ? &(sa)->sa_iid : &(
sa)->sa_rid), srcid, sizeof(srcid)) == -1)
bzero(srcid, sizeof(srcid));
log_info(
   "%sestablished peer %s[%s] local %s[%s]%s%s%s%s policy '%s'%s"
   " (enc %s%s%s group %s prf %s)", SPI_SA(sa, NULL)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((((void
 *)0)))),
   print_addr(&sa->sa_peer.addr), dstid,
   print_addr(&sa->sa_local.addr), srcid,
   sa->sa_addrpool ? " assigned " : "",
   sa->sa_addrpool ? print_addr(&sa->sa_addrpool->addr) : "",
   sa->sa_addrpool6 ? " assigned " : "",
   sa->sa_addrpool6 ? print_addr(&sa->sa_addrpool6->addr) : "",
   sa->sa_policy ? sa->sa_policy->pol_name : "",
   sa->sa_hdr.sh_initiator ? " as initiator" : " as responder",
   print_xf(sa->sa_encr->encr_id, cipher_keylength(sa->sa_encr) -
   sa->sa_encr->encr_saltlength, ikeencxfs),
   sa->sa_encr->encr_authid ? "" : " auth ",
   sa->sa_encr->encr_authid ? "" : print_xf(sa->sa_integr->hash_id,
   hash_keylength(sa->sa_integr), authxfs),
   print_xf(sa->sa_dhgroupsa_kex.kex_dhgroup->id, 0, groupxfs),
   print_xf(sa->sa_prf->hash_id, hash_keylength(sa->sa_prf), prfxfs));
7643}

7645void
7646ikev2_log_cert_info(const char *msg, struct iked_id *certid)
7647{
X509		*cert = NULL((void *)0);
BIO		*rawcert = NULL((void *)0);

if (certid->id_type != IKEV2_CERT_X509_CERT4 ||
   certid->id_buf == NULL((void *)0))
return;
if ((rawcert = BIO_new_mem_buf(ibuf_data(certid->id_buf),
   ibuf_size(certid->id_buf))) == NULL((void *)0) ||
   (cert = d2i_X509_bio(rawcert, NULL((void *)0))) == NULL((void *)0))
goto out;
ca_cert_info(msg, cert);
7659out:
if (cert)
X509_free(cert);
if (rawcert)
BIO_free(rawcert);
7664}

7666void
7667ikev2_log_proposal(struct iked_sa *sa, struct iked_proposals *proposals)
7668{
struct iked_proposal	*prop;
struct iked_transform	*xform;
unsigned int		 i;
char			 lenstr[20];

TAILQ_FOREACH(prop, proposals, prop_entry)for((prop) = ((proposals)->tqh_first); (prop) != ((void *)
0); (prop) = ((prop)->prop_entry.tqe_next)) {
for (i = 0; i < prop->prop_nxforms; i++) {
	xform = &prop->prop_xforms[i];
	if (xform->xform_keylength)
		snprintf(lenstr, sizeof(lenstr), "-%u",
		    xform->xform_keylength);
	else
		lenstr[0] = '\0';
	log_info("%s: %s #%u %s=%s%s",
	    sa ? SPI_SA(sa, __func__)ikev2_ikesa_info((&(sa)->sa_hdr)->sh_ispi, ((__func__
))) : __func__,
	    print_map(prop->prop_protoid, ikev2_saproto_map),
	    prop->prop_id,
	    print_map(xform->xform_type, ikev2_xformtype_map),
	    xform->xform_map ?
	    print_map(xform->xform_id, xform->xform_map)
	    : "UNKNOWN",
	    lenstr);
}
}
7693}