/usr/src/sbin/isakmpd/exchange.c

Bug Summary

File:	src/sbin/isakmpd/exchange.c
Warning:	line 1832, column 15 Potential leak of memory pointed to by 'name'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name exchange.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fno-rounding-math -mconstructor-aliases -munwind-tables -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/isakmpd/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/sbin/isakmpd -I . -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/isakmpd/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -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/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/sbin/isakmpd/exchange.c
1/* $OpenBSD: exchange.c,v 1.142 2018/01/15 09:54:48 mpi Exp $	 */
2/* $EOM: exchange.c,v 1.143 2000/12/04 00:02:25 angelos Exp $	 */

4/*
* Copyright (c) 1998, 1999, 2000, 2001 Niklas Hallqvist.  All rights reserved.
* Copyright (c) 1999, 2001 Angelos D. Keromytis.  All rights reserved.
* Copyright (c) 1999, 2000, 2002 Håkan Olsson.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

30/*
* This code was written under funding by Ericsson Radio Systems.
*/

34#include <sys/types.h>
35#include <sys/socket.h>
36#include <netinet/in.h>
37#include <arpa/inet.h>
38#include <stdlib.h>
39#include <string.h>
40#include <regex.h>
41#include <keynote.h>

43#include "cert.h"
44#include "conf.h"
45#include "connection.h"
46#include "constants.h"
47#include "cookie.h"
48#include "crypto.h"
49#include "doi.h"
50#include "exchange.h"
51#include "ipsec_num.h"
52#include "isakmp.h"
53#include "isakmp_cfg.h"
54#include "libcrypto.h"
55#include "log.h"
56#include "message.h"
57#include "timer.h"
58#include "transport.h"
59#include "ipsec.h"
60#include "sa.h"
61#include "ui.h"
62#include "util.h"
63#include "key.h"
64#include "dpd.h"

66/* Initial number of bits from the cookies used as hash.  */
67#define INITIAL_BUCKET_BITS6 6

69/*
* Don't try to use more bits than this as a hash.
* We only XOR 16 bits so going above that means changing the code below
* too.
*/
74#define MAX_BUCKET_BITS16 16

76static void     exchange_dump(char *, struct exchange *);
77static void     exchange_free_aux(void *);
78static struct exchange *exchange_lookup_active(char *, int);

80static
81LIST_HEAD(exchange_list, exchange)struct exchange_list { struct exchange *lh_first; } *exchange_tab;

83/* Works both as a maximum index and a mask.  */
84static int      bucket_mask;

86/*
* Validation scripts used to test messages for correct content of
* payloads depending on the exchange type.
*/
90int16_t script_base[] = {
ISAKMP_PAYLOAD_SA1,	/* Initiator -> responder.  */
ISAKMP_PAYLOAD_NONCE10,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_SA1,	/* Responder -> initiator.  */
ISAKMP_PAYLOAD_NONCE10,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_KEY_EXCH4,	/* Initiator -> responder.  */
ISAKMP_PAYLOAD_ID5,
EXCHANGE_SCRIPT_AUTH-1,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_KEY_EXCH4,	/* Responder -> initiator.  */
ISAKMP_PAYLOAD_ID5,
EXCHANGE_SCRIPT_AUTH-1,
EXCHANGE_SCRIPT_END-4
105};

107int16_t script_identity_protection[] = {
ISAKMP_PAYLOAD_SA1,	/* Initiator -> responder.  */
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_SA1,	/* Responder -> initiator.  */
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_KEY_EXCH4,	/* Initiator -> responder.  */
ISAKMP_PAYLOAD_NONCE10,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_KEY_EXCH4,	/* Responder -> initiator.  */
ISAKMP_PAYLOAD_NONCE10,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_ID5,	/* Initiator -> responder.  */
EXCHANGE_SCRIPT_AUTH-1,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_ID5,	/* Responder -> initiator.  */
EXCHANGE_SCRIPT_AUTH-1,
EXCHANGE_SCRIPT_END-4
124};

126int16_t script_authentication_only[] = {
ISAKMP_PAYLOAD_SA1,	/* Initiator -> responder.  */
ISAKMP_PAYLOAD_NONCE10,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_SA1,	/* Responder -> initiator.  */
ISAKMP_PAYLOAD_NONCE10,
ISAKMP_PAYLOAD_ID5,
EXCHANGE_SCRIPT_AUTH-1,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_ID5,	/* Initiator -> responder.  */
EXCHANGE_SCRIPT_AUTH-1,
EXCHANGE_SCRIPT_END-4
138};

140int16_t script_aggressive[] = {
ISAKMP_PAYLOAD_SA1,	/* Initiator -> responder.  */
ISAKMP_PAYLOAD_KEY_EXCH4,
ISAKMP_PAYLOAD_NONCE10,
ISAKMP_PAYLOAD_ID5,
EXCHANGE_SCRIPT_SWITCH-3,
ISAKMP_PAYLOAD_SA1,	/* Responder -> initiator.  */
ISAKMP_PAYLOAD_KEY_EXCH4,
ISAKMP_PAYLOAD_NONCE10,
ISAKMP_PAYLOAD_ID5,
EXCHANGE_SCRIPT_AUTH-1,
EXCHANGE_SCRIPT_SWITCH-3,
EXCHANGE_SCRIPT_AUTH-1,	/* Initiator -> responder.  */
EXCHANGE_SCRIPT_END-4
154};

156int16_t script_informational[] = {
EXCHANGE_SCRIPT_INFO-2,	/* Initiator -> responder.  */
EXCHANGE_SCRIPT_END-4
159};

161/*
* Check what exchange SA is negotiated with and return a suitable validation
* script.
*/
165int16_t *
166exchange_script(struct exchange *exchange)
167{
switch (exchange->type) {
case ISAKMP_EXCH_BASE1:
return script_base;
case ISAKMP_EXCH_ID_PROT2:
return script_identity_protection;
case ISAKMP_EXCH_AUTH_ONLY3:
return script_authentication_only;
case ISAKMP_EXCH_AGGRESSIVE4:
return script_aggressive;
case ISAKMP_EXCH_INFO5:
return script_informational;
case ISAKMP_EXCH_TRANSACTION6:
return script_transaction;
default:
if (exchange->type >= ISAKMP_EXCH_DOI_MIN32)
	return exchange->doi->exchange_script(exchange->type);
}
return 0;
186}

188/*
* Validate the message MSG's contents wrt what payloads the exchange type
* requires at this point in the dialogue.  Return -1 if the validation fails,
* 0 if it succeeds and the script is not finished and 1 if it's ready.
*/
193static int
194exchange_validate(struct message *msg)
195{
struct exchange *exchange = msg->exchange;
int16_t		*pc = exchange->exch_pc;

while (*pc != EXCHANGE_SCRIPT_END-4 && *pc != EXCHANGE_SCRIPT_SWITCH-3) {
LOG_DBG((LOG_EXCHANGE, 90,log_debug (LOG_EXCHANGE, 90, "exchange_validate: checking for required %s"
, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) : constant_name
(exchange_script_cst, *pc))
    "exchange_validate: checking for required %s",log_debug (LOG_EXCHANGE, 90, "exchange_validate: checking for required %s"
, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) : constant_name
(exchange_script_cst, *pc))
    *pc >= ISAKMP_PAYLOAD_NONElog_debug (LOG_EXCHANGE, 90, "exchange_validate: checking for required %s"
, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) : constant_name
(exchange_script_cst, *pc))
    ? constant_name(isakmp_payload_cst, *pc)log_debug (LOG_EXCHANGE, 90, "exchange_validate: checking for required %s"
, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) : constant_name
(exchange_script_cst, *pc))
    : constant_name(exchange_script_cst, *pc)))log_debug (LOG_EXCHANGE, 90, "exchange_validate: checking for required %s"
, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) : constant_name
(exchange_script_cst, *pc));

/* Check for existence of the required payloads.  */
if ((*pc > 0 && !payload_first(msg, *pc)) ||
    (*pc == EXCHANGE_SCRIPT_AUTH-1 &&
    !payload_first(msg, ISAKMP_PAYLOAD_HASH8) &&
    !payload_first(msg, ISAKMP_PAYLOAD_SIG9)) ||
    (*pc == EXCHANGE_SCRIPT_INFO-2 &&
    ((!payload_first(msg, ISAKMP_PAYLOAD_NOTIFY11) &&
    !payload_first(msg, ISAKMP_PAYLOAD_DELETE12)) ||
    (payload_first(msg, ISAKMP_PAYLOAD_DELETE12) &&
    !payload_first(msg, ISAKMP_PAYLOAD_HASH8))))) {
	/* Missing payload.  */
	LOG_DBG((LOG_MESSAGE, 70,log_debug (LOG_MESSAGE, 70, "exchange_validate: msg %p requires missing %s"
, msg, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) :
 constant_name(exchange_script_cst, *pc))
	    "exchange_validate: msg %p requires missing %s",log_debug (LOG_MESSAGE, 70, "exchange_validate: msg %p requires missing %s"
, msg, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) :
 constant_name(exchange_script_cst, *pc))
	    msg, *pc >= ISAKMP_PAYLOAD_NONElog_debug (LOG_MESSAGE, 70, "exchange_validate: msg %p requires missing %s"
, msg, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) :
 constant_name(exchange_script_cst, *pc))
	    ? constant_name(isakmp_payload_cst, *pc)log_debug (LOG_MESSAGE, 70, "exchange_validate: msg %p requires missing %s"
, msg, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) :
 constant_name(exchange_script_cst, *pc))
	    : constant_name(exchange_script_cst, *pc)))log_debug (LOG_MESSAGE, 70, "exchange_validate: msg %p requires missing %s"
, msg, *pc >= 0 ? constant_name(isakmp_payload_cst, *pc) :
 constant_name(exchange_script_cst, *pc));
	return -1;
}
pc++;
}
if (*pc == EXCHANGE_SCRIPT_END-4)
/* Cleanup.  */
return 1;

return 0;
231}

233/* Feed unhandled payloads to the DOI for handling. Help for exchange_run(). */
234static void
235exchange_handle_leftover_payloads(struct message *msg)
236{
struct exchange *exchange = msg->exchange;
struct doi	*doi = exchange->doi;
struct payload	*p;
int	i;

for (i = ISAKMP_PAYLOAD_SA1; i < ISAKMP_PAYLOAD_MAX255; i++) {
if (i == ISAKMP_PAYLOAD_PROPOSAL2 ||
    i == ISAKMP_PAYLOAD_TRANSFORM3)
	continue;
TAILQ_FOREACH(p, &msg->payload[i], link)for((p) = ((&msg->payload[i])->tqh_first); (p) != (
(void*)0); (p) = ((p)->link.tqe_next)) {
	if (p->flags & PL_MARK1)
		continue;
	if (!doi->handle_leftover_payload ||
	    doi->handle_leftover_payload(msg, i, p))
		LOG_DBG((LOG_EXCHANGE, 10,log_debug (LOG_EXCHANGE, 10, "exchange_handle_leftover_payloads: "
 "unexpected payload %s", constant_name(isakmp_payload_cst, i
))
		    "exchange_handle_leftover_payloads: "log_debug (LOG_EXCHANGE, 10, "exchange_handle_leftover_payloads: "
 "unexpected payload %s", constant_name(isakmp_payload_cst, i
))
		    "unexpected payload %s",log_debug (LOG_EXCHANGE, 10, "exchange_handle_leftover_payloads: "
 "unexpected payload %s", constant_name(isakmp_payload_cst, i
))
		    constant_name(isakmp_payload_cst, i)))log_debug (LOG_EXCHANGE, 10, "exchange_handle_leftover_payloads: "
 "unexpected payload %s", constant_name(isakmp_payload_cst, i
));
}
}
257}

259/*
* Run the exchange script from a point given by the "program counter"
* upto either the script's end or a transmittal of a message.  If we are
* at the point of a reception of a message, that message should be handed
* in here in the MSG argument.  Otherwise we are the initiator and should
* expect MSG to be a half-cooked message without payloads.
*/
266void
267exchange_run(struct message *msg)
268{
struct exchange *exchange = msg->exchange;
struct doi	*doi = exchange->doi;
int             (*handler)(struct message *) = exchange->initiator ?
	    doi->initiator : doi->responder;
int              done = 0;

while (!done) {
/*
 * It's our turn if we're either the initiator on an even step,
 * or the responder on an odd step of the dialogue.
 */
if (exchange->initiator ^ (exchange->step % 2)) {
	done = 1;
	if (exchange->step)
		msg = message_alloc_reply(msg);
	message_setup_header(msg, exchange->type, 0,
	    exchange->message_id);
	if (handler(msg)) {
		/*
		 * This can happen when transient starvation
		 * of memory occurs.
		 * XXX The peer's retransmit ought to
		 * kick-start this exchange again.  If he's
		 * stopped retransmitting he's likely dropped
		 * the SA at his side so we need to do that
		 * too, i.e.  implement automatic SA teardown
		 * after a certain amount of inactivity.
		 */
		log_print("exchange_run: doi->%s (%p) failed",
		    exchange->initiator ? "initiator" :
		    "responder", msg);
		message_free(msg);
		return;
	}
	switch (exchange_validate(msg)) {
	case 1:
		/*
		 * The last message of a multi-message
		 * exchange should not be retransmitted other
		 * than "on-demand", i.e. if we see
		 * retransmits of the last message of the peer
		 * later.
		 */
		msg->flags |= MSG_LAST0x01;
		if (exchange->step > 0) {
			if (exchange->last_sent)
				message_free(exchange->last_sent);
			exchange->last_sent = msg;
		}
		/*
		 * After we physically have sent our last
		 * message we need to do SA-specific
		 * finalization, like telling our application
		 * the SA is ready to be used, or issuing a
		 * CONNECTED notify if we set the COMMIT bit.
		 */
		message_register_post_send(msg,
		    exchange_finalize);

		/* FALLTHROUGH */

	case 0:
		/*
		 * Don't retransmit responses for
		 * unauthenticated messages.
		 */
		if ((exchange->type == ISAKMP_EXCH_ID_PROT2 ||
		    exchange->type == ISAKMP_EXCH_AGGRESSIVE4) &&
		    exchange->phase == 1 && exchange->step == 1)
			msg->flags |= MSG_DONTRETRANSMIT0x40;

		/* XXX error handling.  */
		message_send(msg);
		break;

	default:
		log_print("exchange_run: exchange_validate "
		    "failed, DOI error");
		exchange_free(exchange);
		message_free(msg);
		return;
	}
} else {
	done = exchange_validate(msg);
	switch (done) {
	case 0:
	case 1:
		/* Feed the message to the DOI.  */
		if (handler(msg)) {
			/*
			 * Trust the peer to retransmit.
			 * XXX We have to implement SA aging
			 * with automatic teardown.
			 */
			message_free(msg);
			return;
		}
		/*
		 * Go over the yet unhandled payloads and feed
		 * them to DOI for handling.
		 */
		exchange_handle_leftover_payloads(msg);

		/*
		 * We have advanced the state.  If we have
		 * been processing an incoming message, record
		 * that message as the one to do duplication
		 * tests against.
		 */
		if (exchange->last_received)
			message_free(exchange->last_received);
		exchange->last_received = msg;
		if (exchange->flags & EXCHANGE_FLAG_ENCRYPT0x0004)
			crypto_update_iv(exchange->keystate);

		if (done) {
			exchange_finalize(msg);
			return;
		}
		break;

	case -1:
		log_print("exchange_run: exchange_validate "
		    "failed");
		/*
		 * XXX Is this the best error notification
		 * type?
		 */
		message_drop(msg,
		    ISAKMP_NOTIFY_PAYLOAD_MALFORMED16, 0, 1, 1);
		return;
	}
}

LOG_DBG((LOG_EXCHANGE, 40,log_debug (LOG_EXCHANGE, 40, "exchange_run: exchange %p finished step %d, advancing..."
, exchange, exchange->step)
    "exchange_run: exchange %p finished step %d, advancing...",log_debug (LOG_EXCHANGE, 40, "exchange_run: exchange %p finished step %d, advancing..."
, exchange, exchange->step)
    exchange, exchange->step))log_debug (LOG_EXCHANGE, 40, "exchange_run: exchange %p finished step %d, advancing..."
, exchange, exchange->step);
exchange->step++;
while (*exchange->exch_pc != EXCHANGE_SCRIPT_SWITCH-3 &&
    *exchange->exch_pc != EXCHANGE_SCRIPT_END-4)
	exchange->exch_pc++;
exchange->exch_pc++;
}
412}

414void
415exchange_init(void)
416{
int	i;

bucket_mask = (1 << INITIAL_BUCKET_BITS6) - 1;
exchange_tab = calloc(bucket_mask + 1, sizeof(struct exchange_list));
if (!exchange_tab)
log_fatal("exchange_init: out of memory");
for (i = 0; i <= bucket_mask; i++)
LIST_INIT(&exchange_tab[i])do { ((&exchange_tab[i])->lh_first) = ((void*)0); } while
 (0);
425}

427/* Lookup a phase 1 exchange out of just the initiator cookie.  */
428struct exchange *
429exchange_lookup_from_icookie(u_int8_t *cookie)
430{
struct exchange *exchange;
int	i;

for (i = 0; i <= bucket_mask; i++)
for (exchange = LIST_FIRST(&exchange_tab[i])((&exchange_tab[i])->lh_first); exchange;
    exchange = LIST_NEXT(exchange, link)((exchange)->link.le_next))
	if (memcmp(exchange->cookies, cookie,
	    ISAKMP_HDR_ICOOKIE_LEN8) == 0 &&
	    exchange->phase == 1)
		return exchange;
return 0;
442}

444/* Lookup an exchange out of the name and phase.  */
445struct exchange *
446exchange_lookup_by_name(char *name, int phase)
447{
struct exchange *exchange;
int	i;

/* If we search for nothing, we will find nothing.  */
if (!name)
return 0;

for (i = 0; i <= bucket_mask; i++)
for (exchange = LIST_FIRST(&exchange_tab[i])((&exchange_tab[i])->lh_first); exchange;
    exchange = LIST_NEXT(exchange, link)((exchange)->link.le_next)) {
	LOG_DBG((LOG_EXCHANGE, 90,log_debug (LOG_EXCHANGE, 90, "exchange_lookup_by_name: %s == %s && %d == %d?"
, name, exchange->name ? exchange->name : "<unnamed>"
, phase, exchange->phase)
	    "exchange_lookup_by_name: %s == %s && %d == %d?",log_debug (LOG_EXCHANGE, 90, "exchange_lookup_by_name: %s == %s && %d == %d?"
, name, exchange->name ? exchange->name : "<unnamed>"
, phase, exchange->phase)
	    name, exchange->name ? exchange->name :log_debug (LOG_EXCHANGE, 90, "exchange_lookup_by_name: %s == %s && %d == %d?"
, name, exchange->name ? exchange->name : "<unnamed>"
, phase, exchange->phase)
	    "<unnamed>", phase, exchange->phase))log_debug (LOG_EXCHANGE, 90, "exchange_lookup_by_name: %s == %s && %d == %d?"
, name, exchange->name ? exchange->name : "<unnamed>"
, phase, exchange->phase);

	/*
	 * Match by name, but don't select finished exchanges,
	 * i.e where MSG_LAST are set in last_sent msg.
	 */
	if (exchange->name &&
	    strcasecmp(exchange->name, name) == 0 &&
	    exchange->phase == phase &&
	    (!exchange->last_sent ||
		(exchange->last_sent->flags & MSG_LAST0x01) == 0))
		return exchange;
}
return 0;
475}

477/* Lookup an exchange out of the name, phase and step > 1.  */
478static struct exchange *
479exchange_lookup_active(char *name, int phase)
480{
struct exchange *exchange;
int	i;

/* XXX Almost identical to exchange_lookup_by_name.  */

if (!name)
return 0;

for (i = 0; i <= bucket_mask; i++)
for (exchange = LIST_FIRST(&exchange_tab[i])((&exchange_tab[i])->lh_first); exchange;
    exchange = LIST_NEXT(exchange, link)((exchange)->link.le_next)) {
	LOG_DBG((LOG_EXCHANGE, 90,log_debug (LOG_EXCHANGE, 90, "exchange_lookup_active: %s == %s && %d == %d?"
, name, exchange->name ? exchange->name : "<unnamed>"
, phase, exchange->phase)
	    "exchange_lookup_active: %s == %s && %d == %d?",log_debug (LOG_EXCHANGE, 90, "exchange_lookup_active: %s == %s && %d == %d?"
, name, exchange->name ? exchange->name : "<unnamed>"
, phase, exchange->phase)
	    name, exchange->name ? exchange->name :log_debug (LOG_EXCHANGE, 90, "exchange_lookup_active: %s == %s && %d == %d?"
, name, exchange->name ? exchange->name : "<unnamed>"
, phase, exchange->phase)
	    "<unnamed>", phase, exchange->phase))log_debug (LOG_EXCHANGE, 90, "exchange_lookup_active: %s == %s && %d == %d?"
, name, exchange->name ? exchange->name : "<unnamed>"
, phase, exchange->phase);
	if (exchange->name &&
	    strcasecmp(exchange->name, name) == 0 &&
	    exchange->phase == phase) {
		if (exchange->step > 1)
			return exchange;
		else
			LOG_DBG((LOG_EXCHANGE, 80,log_debug (LOG_EXCHANGE, 80, "exchange_lookup_active: avoided "
 "early (pre-step 1) exchange %p", exchange)
			    "exchange_lookup_active: avoided "log_debug (LOG_EXCHANGE, 80, "exchange_lookup_active: avoided "
 "early (pre-step 1) exchange %p", exchange)
			    "early (pre-step 1) exchange %p",log_debug (LOG_EXCHANGE, 80, "exchange_lookup_active: avoided "
 "early (pre-step 1) exchange %p", exchange)
			    exchange))log_debug (LOG_EXCHANGE, 80, "exchange_lookup_active: avoided "
 "early (pre-step 1) exchange %p", exchange);
	}
}
return 0;
509}

511static void
512exchange_enter(struct exchange *exchange)
513{
u_int16_t	bucket = 0;
u_int8_t       *cp;
int             i;

/* XXX We might resize if we are crossing a certain threshold */

for (i = 0; i < ISAKMP_HDR_COOKIES_LEN(8 + 8); i += 2) {
cp = exchange->cookies + i;
/* Doing it this way avoids alignment problems.  */
bucket ^= cp[0] | cp[1] << 8;
}
for (i = 0; i < ISAKMP_HDR_MESSAGE_ID_LEN4; i += 2) {
cp = exchange->message_id + i;
/* Doing it this way avoids alignment problems.  */
bucket ^= cp[0] | cp[1] << 8;
}
bucket &= bucket_mask;
LIST_INSERT_HEAD(&exchange_tab[bucket], exchange, link)do { if (((exchange)->link.le_next = (&exchange_tab[bucket
])->lh_first) != ((void*)0)) (&exchange_tab[bucket])->
lh_first->link.le_prev = &(exchange)->link.le_next;
 (&exchange_tab[bucket])->lh_first = (exchange); (exchange
)->link.le_prev = &(&exchange_tab[bucket])->lh_first
; } while (0);
exchange->linked = 1;
533}

535/*
* Lookup the exchange given by the header fields MSG.  PHASE2 is false when
* looking for phase 1 exchanges and true otherwise.
*/
539struct exchange *
540exchange_lookup(u_int8_t *msg, int phase2)
541{
struct exchange *exchange;
u_int16_t       bucket = 0;
u_int8_t       *cp;
int             i;

/*
* We use the cookies to get bits to use as an index into exchange_tab,
* as at least one (our cookie) is a good hash, xoring all the bits,
* 16 at a time, and then masking, should do.  Doing it this way means
* we can validate cookies very fast thus delimiting the effects of
* "Denial of service"-attacks using packet flooding.
*/
for (i = 0; i < ISAKMP_HDR_COOKIES_LEN(8 + 8); i += 2) {
cp = msg + ISAKMP_HDR_COOKIES_OFF0 + i;
/* Doing it this way avoids alignment problems.  */
bucket ^= cp[0] | cp[1] << 8;
}
if (phase2)
for (i = 0; i < ISAKMP_HDR_MESSAGE_ID_LEN4; i += 2) {
	cp = msg + ISAKMP_HDR_MESSAGE_ID_OFF20 + i;
	/* Doing it this way avoids alignment problems.  */
	bucket ^= cp[0] | cp[1] << 8;
}
bucket &= bucket_mask;
for (exchange = LIST_FIRST(&exchange_tab[bucket])((&exchange_tab[bucket])->lh_first);
   exchange && (memcmp(msg + ISAKMP_HDR_COOKIES_OFF0,
exchange->cookies, ISAKMP_HDR_COOKIES_LEN(8 + 8)) != 0 ||
(phase2 && memcmp(msg + ISAKMP_HDR_MESSAGE_ID_OFF20,
    exchange->message_id, ISAKMP_HDR_MESSAGE_ID_LEN4) != 0) ||
(!phase2 && !zero_test(msg + ISAKMP_HDR_MESSAGE_ID_OFF20,
    ISAKMP_HDR_MESSAGE_ID_LEN4)));
   exchange = LIST_NEXT(exchange, link)((exchange)->link.le_next))
;

return exchange;
577}

579/*
* Create a phase PHASE exchange where INITIATOR denotes our role.  DOI
* is the domain of interpretation identifier and TYPE tells what exchange
* type to use per either the DOI document or the ISAKMP spec proper.
* NSA tells how many SAs we should pre-allocate, and should be zero
* when we have the responder role.
*/
586static struct exchange *
587exchange_create(int phase, int initiator, int doi, int type)
588{
struct exchange *exchange;
struct timespec	 expiration;
int	delta;

/*
* We want the exchange zeroed for exchange_free to be able to find
* out what fields have been filled-in.
*/
exchange = calloc(1, sizeof *exchange);
if (!exchange) {
log_error("exchange_create: calloc (1, %lu) failed",
    (unsigned long)sizeof *exchange);
return 0;
}
exchange->phase = phase;
exchange->step = 0;
exchange->initiator = initiator;
bzero(exchange->cookies, ISAKMP_HDR_COOKIES_LEN(8 + 8));
bzero(exchange->message_id, ISAKMP_HDR_MESSAGE_ID_LEN4);
exchange->doi = doi_lookup(doi);
exchange->type = type;
exchange->policy_id = -1;
exchange->exch_pc = exchange_script(exchange);
exchange->last_sent = exchange->last_received = 0;
TAILQ_INIT(&exchange->sa_list)do { (&exchange->sa_list)->tqh_first = ((void*)0); (
&exchange->sa_list)->tqh_last = &(&exchange
->sa_list)->tqh_first; } while (0);
TAILQ_INIT(&exchange->aca_list)do { (&exchange->aca_list)->tqh_first = ((void*)0);
 (&exchange->aca_list)->tqh_last = &(&exchange
->aca_list)->tqh_first; } while (0);

/* Allocate the DOI-specific structure and initialize it to zeroes.  */
if (exchange->doi->exchange_size) {
exchange->data = calloc(1, exchange->doi->exchange_size);
if (!exchange->data) {
	log_error("exchange_create: calloc (1, %lu) failed",
	    (unsigned long)exchange->doi->exchange_size);
	exchange_free(exchange);
	return 0;
}
}
clock_gettime(CLOCK_MONOTONIC3, &expiration);
delta = conf_get_num("General", "Exchange-max-time",
   EXCHANGE_MAX_TIME120);
expiration.tv_sec += delta;
exchange->death = timer_add_event("exchange_free_aux",
   exchange_free_aux, exchange, &expiration);
if (!exchange->death) {
/* If we don't give up we might start leaking...  */
exchange_free_aux(exchange);
return 0;
}
return exchange;
638}

640struct exchange_finalization_node {
void	(*first)(struct exchange *, void *, int);
void	*first_arg;
void	(*second)(struct exchange *, void *, int);
void	*second_arg;
645};

647/* Run the finalization functions of ARG.  */
648static void
649exchange_run_finalizations(struct exchange *exchange, void *arg, int fail)
650{
struct exchange_finalization_node *node = arg;

node->first(exchange, node->first_arg, fail);
node->second(exchange, node->second_arg, fail);
free(node);
656}

658/*
* Add a finalization function FINALIZE with argument ARG to the tail
* of the finalization function list of EXCHANGE.
*/
662static void
663exchange_add_finalization(struct exchange *exchange,
  void (*finalize)(struct exchange *, void *, int), void *arg)
665{
struct exchange_finalization_node *node;

if (!finalize)
return;

if (!exchange->finalize) {
exchange->finalize = finalize;
exchange->finalize_arg = arg;
return;
}
node = malloc(sizeof *node);
if (!node) {
log_error("exchange_add_finalization: malloc (%lu) failed",
    (unsigned long)sizeof *node);
free(arg);
return;
}
node->first = exchange->finalize;
node->first_arg = exchange->finalize_arg;
node->second = finalize;
node->second_arg = arg;
exchange->finalize = exchange_run_finalizations;
exchange->finalize_arg = node;
689}

691static void
692exchange_establish_transaction(struct exchange *exchange, void *arg, int fail)
693{
/* Establish a TRANSACTION exchange.  */
struct exchange_finalization_node *node =
   (struct exchange_finalization_node *)arg;
struct sa *isakmp_sa = sa_lookup_by_name((char *) node->second_arg, 1);

if (isakmp_sa && !fail)
exchange_establish_p2(isakmp_sa, ISAKMP_EXCH_TRANSACTION6, 0, 0,
    node->first, node->first_arg);

free(node);
704}

706/* Establish a phase 1 exchange.  */
707int
708exchange_establish_p1(struct transport *t, u_int8_t type, u_int32_t doi,
  char *name, void *args, void (*finalize)(struct exchange *, void *, int),
  void *arg, int stayalive)
711{
struct exchange		*exchange;
struct message		*msg;
struct conf_list	*flags;
struct conf_list_node	*flag;
char	*tag = 0;
char	*str;

if (name) {
/* If no exchange type given, fetch from the configuration.  */
if (type == 0) {
	/*
	 * XXX Similar code can be found in
	 * exchange_setup_p1.  Share?
	 */

	/* Find out our phase 1 mode.  */
	tag = conf_get_str(name, "Configuration");
	if (!tag) {
		/* Use default setting.  */
		tag = CONF_DFLT_TAG_PHASE1_CONFIG"Default-phase-1-configuration";
	}
	/* Figure out the DOI.  XXX Factor out?  */
	str = conf_get_str(tag, "DOI");
	if (!str || strcasecmp(str, "IPSEC") == 0)
		doi = IPSEC_DOI_IPSEC1;
	else if (strcasecmp(str, "ISAKMP") == 0)
		doi = ISAKMP_DOI_ISAKMP0;
	else {
		log_print("exchange_establish_p1: "
		    "DOI \"%s\" unsupported", str);
		return -1;
	}

	/* What exchange type do we want?  */
	str = conf_get_str(tag, "EXCHANGE_TYPE");
	if (!str) {
		log_print("exchange_establish_p1: "
		    "no \"EXCHANGE_TYPE\" tag in [%s] section",
		    tag);
		return -1;
	}
	type = constant_value(isakmp_exch_cst, str);
	if (!type) {
		log_print("exchange_establish_p1: "
		    "unknown exchange type %s", str);
		return -1;
	}
}
}
exchange = exchange_create(1, 1, doi, type);
if (!exchange) {
return -1;
}
if (name) {
exchange->name = strdup(name);
if (!exchange->name) {
	log_error("exchange_establish_p1: "
	    "strdup (\"%s\") failed", name);
	exchange_free(exchange);
	return -1;
}
}
exchange->policy = name ? conf_get_str(name, "Configuration") : 0;
if (!exchange->policy && name)
exchange->policy = CONF_DFLT_TAG_PHASE1_CONFIG"Default-phase-1-configuration";

if (name && (flags = conf_get_list(name, "Flags")) != NULL((void*)0)) {
for (flag = TAILQ_FIRST(&flags->fields)((&flags->fields)->tqh_first); flag;
    flag = TAILQ_NEXT(flag, link)((flag)->link.tqe_next))
	if (strcasecmp(flag->field, "ikecfg") == 0) {
		struct exchange_finalization_node *node;

		node = calloc(1, (unsigned long)sizeof *node);
		if (!node) {
			log_print("exchange_establish_p1: "
			    "calloc (1, %lu) failed",
			    (unsigned long)sizeof(*node));
			exchange_free(exchange);
			return -1;
		}
		/*
		 * Insert this finalization inbetween
		 * the original.
		 */
		node->first = finalize;
		node->first_arg = arg;
		node->second_arg = name;
		exchange_add_finalization(exchange,
		    exchange_establish_transaction,
		    node);
		finalize = 0;
	}
conf_free_list(flags);
}

exchange_add_finalization(exchange, finalize, arg);
cookie_gen(t, exchange, exchange->cookies, ISAKMP_HDR_ICOOKIE_LEN8);
exchange_enter(exchange);
exchange_dump("exchange_establish_p1", exchange);

msg = message_alloc(t, 0, ISAKMP_HDR_SZ28);
if (!msg) {
log_print("exchange_establish_p1: message_alloc () failed");
exchange_free(exchange);
return 0; /* exchange_free() runs finalize */
}
msg->exchange = exchange;

/* Do not create SA for an information or transaction exchange. */
if (exchange->type != ISAKMP_EXCH_INFO5 &&
   exchange->type != ISAKMP_EXCH_TRANSACTION6) {
/*
 * Don't install a transport into this SA as it will be an
 * INADDR_ANY address in the local end, which is not good at
 * all.  Let the reply packet install the transport instead.
 */
sa_create(exchange, 0);
msg->isakmp_sa = TAILQ_FIRST(&exchange->sa_list)((&exchange->sa_list)->tqh_first);
if (!msg->isakmp_sa) {
	message_free(msg);
	exchange_free(exchange);
	return 0; /* exchange_free() runs finalize */
}
sa_reference(msg->isakmp_sa);

if (stayalive)
	msg->isakmp_sa->flags |= SA_FLAG_STAYALIVE0x02;
}
msg->extra = args;

exchange_run(msg);
return 0;
844}

846/* Establish a phase 2 exchange.  XXX With just one SA for now.  */
847int
848exchange_establish_p2(struct sa *isakmp_sa, u_int8_t type, char *name,
  void *args, void (*finalize)(struct exchange *, void *, int), void *arg)
850{
struct exchange *exchange;
struct message	*msg;
u_int32_t        doi = ISAKMP_DOI_ISAKMP0;
u_int32_t        seq = 0;
int              i;
char		*tag, *str;

if (isakmp_sa)
doi = isakmp_sa->doi->id;

if (name) {
/* Find out our phase 2 modes.  */
tag = conf_get_str(name, "Configuration");
if (!tag) {
	log_print("exchange_establish_p2: "
	    "no configuration for peer \"%s\"", name);
	return -1;
}
seq = (u_int32_t)conf_get_num(name, "Acquire-ID", 0);

/* Figure out the DOI.  */
str = conf_get_str(tag, "DOI");
if (!str || strcasecmp(str, "IPSEC") == 0)
	doi = IPSEC_DOI_IPSEC1;
else if (strcasecmp(str, "ISAKMP") == 0)
	doi = ISAKMP_DOI_ISAKMP0;
else {
	log_print("exchange_establish_p2: "
	    "DOI \"%s\" unsupported", str);
	return -1;
}

/* What exchange type do we want?  */
if (!type) {
	str = conf_get_str(tag, "EXCHANGE_TYPE");
	if (!str) {
		log_print("exchange_establish_p2: "
		    "no \"EXCHANGE_TYPE\" tag in [%s] section",
		    tag);
		return -1;
	}
	/* XXX IKE dependent.  */
	type = constant_value(ike_exch_cst, str);
	if (!type) {
		log_print("exchange_establish_p2: unknown "
		    "exchange type %s", str);
		return -1;
	}
}
}
exchange = exchange_create(2, 1, doi, type);
if (!exchange) {
return -1;
}
if (name) {
exchange->name = strdup(name);
if (!exchange->name) {
	log_error("exchange_establish_p2: "
	    "strdup (\"%s\") failed", name);
	exchange_free(exchange);
	return -1;
}
}
exchange->policy = name ? conf_get_str(name, "Configuration") : 0;
exchange->finalize = finalize;
exchange->finalize_arg = arg;
exchange->seq = seq;
memcpy(exchange->cookies, isakmp_sa->cookies, ISAKMP_HDR_COOKIES_LEN(8 + 8));
arc4random_buf(exchange->message_id, ISAKMP_HDR_MESSAGE_ID_LEN4);
exchange->flags |= EXCHANGE_FLAG_ENCRYPT0x0004;
if (isakmp_sa->flags & SA_FLAG_NAT_T_ENABLE0x100)
exchange->flags |= EXCHANGE_FLAG_NAT_T_ENABLE0x0010;
if (isakmp_sa->flags & SA_FLAG_NAT_T_KEEPALIVE0x200)
exchange->flags |= EXCHANGE_FLAG_NAT_T_KEEPALIVE0x0020;
exchange_enter(exchange);
exchange_dump("exchange_establish_p2", exchange);

/*
* Do not create SA's for informational exchanges.
* XXX How to handle new group mode?
*/
if (exchange->type != ISAKMP_EXCH_INFO5 &&
   exchange->type != ISAKMP_EXCH_TRANSACTION6) {
/* XXX Number of SAs should come from the args structure.  */
for (i = 0; i < 1; i++)
	if (sa_create(exchange, isakmp_sa->transport)) {
		exchange_free(exchange);
		return 0; /* exchange_free() runs finalize */
	}
}
msg = message_alloc(isakmp_sa->transport, 0, ISAKMP_HDR_SZ28);
msg->isakmp_sa = isakmp_sa;
sa_reference(isakmp_sa);

msg->extra = args;

/* This needs to be done late or else get_keystate won't work right. */
msg->exchange = exchange;

exchange_run(msg);

return 0;
953}

955/* Out of an incoming phase 1 message, setup an exchange.  */
956struct exchange *
957exchange_setup_p1(struct message *msg, u_int32_t doi)
958{
struct transport	*t = msg->transport;
struct exchange		*exchange;
struct sockaddr		*dst;
struct conf_list	*flags;
struct conf_list_node	*flag;
char		*name = 0, *policy = 0, *str;
u_int32_t        want_doi;
u_int8_t         type;

/* XXX Similar code can be found in exchange_establish_p1.  Share?  */

/*
* Unless this is an informational exchange, look up our policy for
* this peer.
*/
type = GET_ISAKMP_HDR_EXCH_TYPE(msg->iov[0].iov_base)field_get_num (isakmp_hdr_fld + 4, msg->iov[0].iov_base);
if (type != ISAKMP_EXCH_INFO5) {
/*
 * Find out our inbound phase 1 mode.
 */
t->vtbl->get_dst(t, &dst);
if (sockaddr2text(dst, &str, 0) == -1)
	return 0;
name = conf_get_str("Phase 1", str);
free(str);
if (name) {
	/*
	 * If another phase 1 exchange is ongoing don't bother
	 * returning the call. However, we will need to
	 * continue responding if our phase 1 exchange is
	 * still waiting for step 1 (i.e still half-open).
	 */
	exchange = exchange_lookup_active(name, 1);
	if (exchange) {
		LOG_DBG((LOG_EXCHANGE, 40,log_debug (LOG_EXCHANGE, 40, "exchange_establish: %s exchange already "
 "exists as %p", name, exchange)
		    "exchange_establish: %s exchange already "log_debug (LOG_EXCHANGE, 40, "exchange_establish: %s exchange already "
 "exists as %p", name, exchange)
		    "exists as %p", name, exchange))log_debug (LOG_EXCHANGE, 40, "exchange_establish: %s exchange already "
 "exists as %p", name, exchange);
		return 0;
	}
} else {
	name = conf_get_str("Phase 1", "Default");
	if (!name) {
		log_print("exchange_setup_p1: no \"Default\" "
		    "tag in [Phase 1] section");
		return 0;
	}
}

policy = conf_get_str(name, "Configuration");
if (!policy)
	policy = CONF_DFLT_TAG_PHASE1_CONFIG"Default-phase-1-configuration";

/* Figure out the DOI.  */
str = conf_get_str(policy, "DOI");
if (!str || strcasecmp(str, "IPSEC") == 0) {
	want_doi = IPSEC_DOI_IPSEC1;
	str = "IPSEC";
}
else if (strcasecmp(str, "ISAKMP") == 0)
	want_doi = ISAKMP_DOI_ISAKMP0;
else {
	log_print("exchange_setup_p1: "
	    "DOI \"%s\" unsupported", str);
	return 0;
}
if (want_doi != doi) {
	/* XXX Should I tell what DOI I got?  */
	log_print("exchange_setup_p1: expected %s DOI", str);
	return 0;
}
/* What exchange type do we want?  */
str = conf_get_str(policy, "EXCHANGE_TYPE");
if (!str) {
	log_print("exchange_setup_p1: no \"EXCHANGE_TYPE\" "
	    "tag in [%s] section", policy);
	return 0;
}
type = constant_value(isakmp_exch_cst, str);
if (!type) {
	log_print("exchange_setup_p1: "
	    "unknown exchange type %s", str);
	return 0;
}
if (type != GET_ISAKMP_HDR_EXCH_TYPE(msg->iov[0].iov_base)field_get_num (isakmp_hdr_fld + 4, msg->iov[0].iov_base)) {
	log_print("exchange_setup_p1: "
	    "expected exchange type %s got %s", str,
	    constant_name(isakmp_exch_cst,
		GET_ISAKMP_HDR_EXCH_TYPE(msg->iov[0].iov_base)field_get_num (isakmp_hdr_fld + 4, msg->iov[0].iov_base)));
	return 0;
}
}
exchange = exchange_create(1, 0, doi, type);
if (!exchange)
return 0;

exchange->name = name ? strdup(name) : 0;
if (name && !exchange->name) {
log_error("exchange_setup_p1: strdup (\"%s\") failed", name);
exchange_free(exchange);
return 0;
}
exchange->policy = policy;

if (name && (flags = conf_get_list(name, "Flags")) != NULL((void*)0)) {
for (flag = TAILQ_FIRST(&flags->fields)((&flags->fields)->tqh_first); flag;
    flag = TAILQ_NEXT(flag, link)((flag)->link.tqe_next))
	if (strcasecmp(flag->field, "ikecfg") == 0) {
		struct exchange_finalization_node *node;

		node = calloc(1, (unsigned long)sizeof *node);
		if (!node) {
			log_print("exchange_establish_p1: "
			    "calloc (1, %lu) failed",
			    (unsigned long)sizeof(*node));
			exchange_free(exchange);
			return 0;
		}
		/*
		 * Insert this finalization inbetween
		 * the original.
		 */
		node->first = 0;
		node->first_arg = 0;
		node->second_arg = name;
		exchange_add_finalization(exchange,
		    exchange_establish_transaction,
		    node);
	}
conf_free_list(flags);
}

cookie_gen(msg->transport, exchange, exchange->cookies +
   ISAKMP_HDR_ICOOKIE_LEN8, ISAKMP_HDR_RCOOKIE_LEN8);
GET_ISAKMP_HDR_ICOOKIE(msg->iov[0].iov_base, exchange->cookies)field_get_raw (isakmp_hdr_fld + 0, msg->iov[0].iov_base, exchange
->cookies);
exchange_enter(exchange);
exchange_dump("exchange_setup_p1", exchange);
return exchange;
1096}

1098/* Out of an incoming phase 2 message, setup an exchange.  */
1099struct exchange *
1100exchange_setup_p2(struct message *msg, u_int8_t doi)
1101{
struct exchange *exchange;
u_int8_t	*buf = msg->iov[0].iov_base;

exchange = exchange_create(2, 0, doi, GET_ISAKMP_HDR_EXCH_TYPE(buf)field_get_num (isakmp_hdr_fld + 4, buf));
if (!exchange)
return 0;
GET_ISAKMP_HDR_ICOOKIE(buf, exchange->cookies)field_get_raw (isakmp_hdr_fld + 0, buf, exchange->cookies);
GET_ISAKMP_HDR_RCOOKIE(buf,field_get_raw (isakmp_hdr_fld + 1, buf, exchange->cookies +
 8)
   exchange->cookies + ISAKMP_HDR_ICOOKIE_LEN)field_get_raw (isakmp_hdr_fld + 1, buf, exchange->cookies +
 8);
GET_ISAKMP_HDR_MESSAGE_ID(buf, exchange->message_id)field_get_raw (isakmp_hdr_fld + 6, buf, exchange->message_id
);
if (msg->isakmp_sa && (msg->isakmp_sa->flags & SA_FLAG_NAT_T_ENABLE0x100))
exchange->flags |= EXCHANGE_FLAG_NAT_T_ENABLE0x0010;
if (msg->isakmp_sa && (msg->isakmp_sa->flags & SA_FLAG_NAT_T_KEEPALIVE0x200))
exchange->flags |= EXCHANGE_FLAG_NAT_T_KEEPALIVE0x0020;
exchange_enter(exchange);
exchange_dump("exchange_setup_p2", exchange);
return exchange;
1119}

1121/* Dump interesting data about an exchange.  */
1122static void
1123exchange_dump_real(char *header, struct exchange *exchange, int class,
  int level)
1125{
struct sa	*sa;
char             buf[LOG_SIZE200];
/* Don't risk overflowing the final log buffer.  */
size_t           bufsize_max = LOG_SIZE200 - strlen(header) - 32;

LOG_DBG((class, level,log_debug (class, level, "%s: %p %s %s policy %s phase %d doi %d exchange %d step %d"
, header, exchange, exchange->name ? exchange->name : "<unnamed>"
, exchange->policy ? exchange->policy : "<no policy>"
, exchange->initiator ? "initiator" : "responder", exchange
->phase, exchange->doi->id, exchange->type, exchange
->step)
   "%s: %p %s %s policy %s phase %d doi %d exchange %d step %d",log_debug (class, level, "%s: %p %s %s policy %s phase %d doi %d exchange %d step %d"
, header, exchange, exchange->name ? exchange->name : "<unnamed>"
, exchange->policy ? exchange->policy : "<no policy>"
, exchange->initiator ? "initiator" : "responder", exchange
->phase, exchange->doi->id, exchange->type, exchange
->step)
   header, exchange, exchange->name ? exchange->name : "<unnamed>",log_debug (class, level, "%s: %p %s %s policy %s phase %d doi %d exchange %d step %d"
, header, exchange, exchange->name ? exchange->name : "<unnamed>"
, exchange->policy ? exchange->policy : "<no policy>"
, exchange->initiator ? "initiator" : "responder", exchange
->phase, exchange->doi->id, exchange->type, exchange
->step)
   exchange->policy ? exchange->policy : "<no policy>",log_debug (class, level, "%s: %p %s %s policy %s phase %d doi %d exchange %d step %d"
, header, exchange, exchange->name ? exchange->name : "<unnamed>"
, exchange->policy ? exchange->policy : "<no policy>"
, exchange->initiator ? "initiator" : "responder", exchange
->phase, exchange->doi->id, exchange->type, exchange
->step)
   exchange->initiator ? "initiator" : "responder", exchange->phase,log_debug (class, level, "%s: %p %s %s policy %s phase %d doi %d exchange %d step %d"
, header, exchange, exchange->name ? exchange->name : "<unnamed>"
, exchange->policy ? exchange->policy : "<no policy>"
, exchange->initiator ? "initiator" : "responder", exchange
->phase, exchange->doi->id, exchange->type, exchange
->step)
   exchange->doi->id, exchange->type, exchange->step))log_debug (class, level, "%s: %p %s %s policy %s phase %d doi %d exchange %d step %d"
, header, exchange, exchange->name ? exchange->name : "<unnamed>"
, exchange->policy ? exchange->policy : "<no policy>"
, exchange->initiator ? "initiator" : "responder", exchange
->phase, exchange->doi->id, exchange->type, exchange
->step);
LOG_DBG((class, level, "%s: icookie %08x%08x rcookie %08x%08x", header,log_debug (class, level, "%s: icookie %08x%08x rcookie %08x%08x"
, header, decode_32(exchange->cookies), decode_32(exchange
->cookies + 4), decode_32(exchange->cookies + 8), decode_32
(exchange->cookies + 12))
   decode_32(exchange->cookies), decode_32(exchange->cookies + 4),log_debug (class, level, "%s: icookie %08x%08x rcookie %08x%08x"
, header, decode_32(exchange->cookies), decode_32(exchange
->cookies + 4), decode_32(exchange->cookies + 8), decode_32
(exchange->cookies + 12))
   decode_32(exchange->cookies + 8),log_debug (class, level, "%s: icookie %08x%08x rcookie %08x%08x"
, header, decode_32(exchange->cookies), decode_32(exchange
->cookies + 4), decode_32(exchange->cookies + 8), decode_32
(exchange->cookies + 12))
   decode_32(exchange->cookies + 12)))log_debug (class, level, "%s: icookie %08x%08x rcookie %08x%08x"
, header, decode_32(exchange->cookies), decode_32(exchange
->cookies + 4), decode_32(exchange->cookies + 8), decode_32
(exchange->cookies + 12));

/* Include phase 2 SA list for this exchange */
if (exchange->phase == 2) {
snprintf(buf, bufsize_max, "sa_list ");
for (sa = TAILQ_FIRST(&exchange->sa_list)((&exchange->sa_list)->tqh_first);
    sa && strlen(buf) < bufsize_max; sa = TAILQ_NEXT(sa, next)((sa)->next.tqe_next))
	snprintf(buf + strlen(buf), bufsize_max - strlen(buf),
	    "%p ", sa);
if (sa)
	strlcat(buf, "...", bufsize_max);
} else
buf[0] = '\0';

LOG_DBG((class, level, "%s: msgid %08x %s", header,log_debug (class, level, "%s: msgid %08x %s", header, decode_32
(exchange->message_id), buf)
   decode_32(exchange->message_id), buf))log_debug (class, level, "%s: msgid %08x %s", header, decode_32
(exchange->message_id), buf);
1156}

1158static void
1159exchange_dump(char *header, struct exchange *exchange)
1160{
exchange_dump_real(header, exchange, LOG_EXCHANGE, 10);
1162}

1164void
1165exchange_report(void)
1166{
struct exchange	*exchange;
int	i;

for (i = 0; i <= bucket_mask; i++)
for (exchange = LIST_FIRST(&exchange_tab[i])((&exchange_tab[i])->lh_first); exchange;
    exchange = LIST_NEXT(exchange, link)((exchange)->link.le_next))
	exchange_dump_real("exchange_report", exchange,
	    LOG_REPORT-2, 0);
1175}

1177/*
* Release all resources this exchange is using *except* for the "death"
* event.  When removing an exchange from the expiration handler that event
* will be dealt with therein instead.
*/
1182static void
1183exchange_free_aux(void *v_exch)
1184{
struct exchange		*exchange = v_exch;
struct sa		*sa, *next_sa;
struct cert_handler	*handler;

LOG_DBG((LOG_EXCHANGE, 80, "exchange_free_aux: freeing exchange %p",log_debug (LOG_EXCHANGE, 80, "exchange_free_aux: freeing exchange %p"
, exchange)
   exchange))log_debug (LOG_EXCHANGE, 80, "exchange_free_aux: freeing exchange %p"
, exchange);

if (exchange->last_received)
message_free(exchange->last_received);
if (exchange->last_sent)
message_free(exchange->last_sent);
if (exchange->in_transit &&
   exchange->in_transit != exchange->last_sent)
message_free(exchange->in_transit);
free(exchange->nonce_i);
free(exchange->nonce_r);
free(exchange->id_i);
free(exchange->id_r);
free(exchange->keystate);
if (exchange->data) {
if (exchange->doi && exchange->doi->free_exchange_data)
	exchange->doi->free_exchange_data(exchange->data);
free(exchange->data);
}
free(exchange->name);
if (exchange->recv_cert) {
handler = cert_get(exchange->recv_certtype);
if (handler)
	handler->cert_free(exchange->recv_cert);
}
if (exchange->sent_cert) {
handler = cert_get(exchange->sent_certtype);
if (handler)
	handler->cert_free(exchange->sent_cert);
}
if (exchange->recv_key)
key_free(exchange->recv_keytype, ISAKMP_KEYTYPE_PUBLIC0,
    exchange->recv_key);
free(exchange->keynote_key);	/* This is just a string */

if (exchange->policy_id != -1)
kn_close(exchange->policy_id);

exchange_free_aca_list(exchange);
if (exchange->linked) {
LIST_REMOVE(exchange, link)do { if ((exchange)->link.le_next != ((void*)0)) (exchange
)->link.le_next->link.le_prev = (exchange)->link.le_prev
; *(exchange)->link.le_prev = (exchange)->link.le_next;
 ; ; } while (0);
exchange->linked = 0;
}

/* Tell potential finalize routine we never got there.  */
if (exchange->finalize)
exchange->finalize(exchange, exchange->finalize_arg, 1);

/* Remove any SAs that have not been disassociated from us.  */
for (sa = TAILQ_FIRST(&exchange->sa_list)((&exchange->sa_list)->tqh_first); sa; sa = next_sa) {
next_sa = TAILQ_NEXT(sa, next)((sa)->next.tqe_next);
/* One for the reference in exchange->sa_list.  */
sa_release(sa);
/* And two more for the expiration and SA linked list.  */
sa_free(sa);
}

free(exchange);
1248}

1250/* Release all resources this exchange is using.  */
1251void
1252exchange_free(struct exchange *exchange)
1253{
if (exchange->death)
timer_remove_event(exchange->death);
exchange_free_aux(exchange);
1257}

1259/*
* Upgrade the phase 1 exchange and its ISAKMP SA with the rcookie of our
* peer (found in his recently sent message MSG).
*/
1263void
1264exchange_upgrade_p1(struct message *msg)
1265{
struct exchange *exchange = msg->exchange;

LIST_REMOVE(exchange, link)do { if ((exchange)->link.le_next != ((void*)0)) (exchange
)->link.le_next->link.le_prev = (exchange)->link.le_prev
; *(exchange)->link.le_prev = (exchange)->link.le_next;
 ; ; } while (0);
exchange->linked = 0;
GET_ISAKMP_HDR_RCOOKIE(msg->iov[0].iov_base, exchange->cookies +field_get_raw (isakmp_hdr_fld + 1, msg->iov[0].iov_base, exchange
->cookies + 8)
   ISAKMP_HDR_ICOOKIE_LEN)field_get_raw (isakmp_hdr_fld + 1, msg->iov[0].iov_base, exchange
->cookies + 8);
exchange_enter(exchange);
sa_isakmp_upgrade(msg);
1274}

1276static int
1277exchange_check_old_sa(struct sa *sa, void *v_arg)
1278{
struct sa	*new_sa = v_arg;
char		 res1[1024];

if (sa == new_sa || !sa->name || !(sa->flags & SA_FLAG_READY0x01) ||
   (sa->flags & SA_FLAG_REPLACED0x08))
return 0;

if (sa->phase != new_sa->phase || new_sa->name == 0 ||
   strcasecmp(sa->name, new_sa->name))
return 0;

if (sa->initiator)
strlcpy(res1, ipsec_decode_ids("%s %s", sa->id_i, sa->id_i_len,
    sa->id_r, sa->id_r_len, 0), sizeof res1);
else
strlcpy(res1, ipsec_decode_ids("%s %s", sa->id_r, sa->id_r_len,
    sa->id_i, sa->id_i_len, 0), sizeof res1);

LOG_DBG((LOG_EXCHANGE, 30,log_debug (LOG_EXCHANGE, 30, "checking whether new SA replaces existing SA with IDs %s"
, res1)
   "checking whether new SA replaces existing SA with IDs %s", res1))log_debug (LOG_EXCHANGE, 30, "checking whether new SA replaces existing SA with IDs %s"
, res1);

if (new_sa->initiator)
return strcasecmp(res1, ipsec_decode_ids("%s %s", new_sa->id_i,
    new_sa->id_i_len, new_sa->id_r, new_sa->id_r_len, 0)) == 0;
else
return strcasecmp(res1, ipsec_decode_ids("%s %s", new_sa->id_r,
    new_sa->id_r_len, new_sa->id_i, new_sa->id_i_len, 0)) == 0;
1306}

1308void
1309exchange_finalize(struct message *msg)
1310{
struct exchange		*exchange = msg->exchange;
struct sa		*sa, *old_sa;
struct proto		*proto;
struct conf_list	*attrs;
struct conf_list_node	*attr;
struct cert_handler	*handler;
int	 i;
char	*id_doi, *id_trp;

exchange_dump("exchange_finalize", exchange);

/* Copy the ID from phase 1 to exchange or phase 2 SA.  */
if (msg->isakmp_sa) {
if (exchange->id_i && exchange->id_r) {
	ipsec_clone_id(&msg->isakmp_sa->id_i,
	    &msg->isakmp_sa->id_i_len, exchange->id_i,
	    exchange->id_i_len);
	ipsec_clone_id(&msg->isakmp_sa->id_r,
	    &msg->isakmp_sa->id_r_len, exchange->id_r,
	    exchange->id_r_len);
} else if (msg->isakmp_sa->id_i && msg->isakmp_sa->id_r) {
	ipsec_clone_id(&exchange->id_i, &exchange->id_i_len,
	    msg->isakmp_sa->id_i, msg->isakmp_sa->id_i_len);
	ipsec_clone_id(&exchange->id_r, &exchange->id_r_len,
	    msg->isakmp_sa->id_r, msg->isakmp_sa->id_r_len);
}
}
/*
* Walk over all the SAs and noting them as ready.  If we set the
* COMMIT bit, tell the peer each SA is connected.
*
* XXX The decision should really be based on if a SA was installed
* successfully.
*/
for (sa = TAILQ_FIRST(&exchange->sa_list)((&exchange->sa_list)->tqh_first); sa;
   sa = TAILQ_NEXT(sa, next)((sa)->next.tqe_next)) {
/* Move over the name to the SA.  */
sa->name = exchange->name ? strdup(exchange->name) : 0;

if (exchange->flags & EXCHANGE_FLAG_I_COMMITTED0x0001) {
	for (proto = TAILQ_FIRST(&sa->protos)((&sa->protos)->tqh_first); proto;
	    proto = TAILQ_NEXT(proto, link)((proto)->link.tqe_next))
		for (i = 0; i < 2; i++)
			message_send_notification(exchange->last_received,
			    msg->isakmp_sa,
			    ISAKMP_NOTIFY_STATUS_CONNECTED16384,
			    proto, i);
}
/*
 * Locate any old SAs and mark them replaced
 * (SA_FLAG_REPLACED).
 */
sa->initiator = exchange->initiator;
while ((old_sa = sa_find(exchange_check_old_sa, sa)) != 0)
	sa_mark_replaced(old_sa);

/* Setup the SA flags.  */
sa->flags |= SA_FLAG_READY0x01;
if (exchange->name) {
	attrs = conf_get_list(exchange->name, "Flags");
	if (attrs) {
		for (attr = TAILQ_FIRST(&attrs->fields)((&attrs->fields)->tqh_first); attr;
		    attr = TAILQ_NEXT(attr, link)((attr)->link.tqe_next))
			sa->flags |= sa_flag(attr->field);
		conf_free_list(attrs);
	}
	/* 'Connections' should stay alive.  */
	if (connection_exist(exchange->name)) {
		sa->flags |= SA_FLAG_STAYALIVE0x02;

		/*
		 * ISAKMP SA of this connection should also
		 * stay alive.
		 */
		if (exchange->phase == 2 && msg->isakmp_sa)
			msg->isakmp_sa->flags |=
			    SA_FLAG_STAYALIVE0x02;
	}
}
sa->seq = exchange->seq;
sa->exch_type = exchange->type;
}

/*
* If this was an phase 1 SA negotiation, save the keystate in the
* ISAKMP SA structure for future initialization of phase 2 exchanges'
* keystates.  Also save the Phase 1 ID and authentication
* information.
*/
if (exchange->phase == 1 && msg->isakmp_sa) {
msg->isakmp_sa->keystate = exchange->keystate;
exchange->keystate = 0;

msg->isakmp_sa->recv_certtype = exchange->recv_certtype;
msg->isakmp_sa->sent_certtype = exchange->sent_certtype;
msg->isakmp_sa->recv_keytype = exchange->recv_keytype;
msg->isakmp_sa->recv_key = exchange->recv_key;
msg->isakmp_sa->keynote_key = exchange->keynote_key;
/* Reset.  */
exchange->recv_key = 0;
exchange->keynote_key = 0;
msg->isakmp_sa->policy_id = exchange->policy_id;
exchange->policy_id = -1;
msg->isakmp_sa->initiator = exchange->initiator;

if (exchange->recv_certtype && exchange->recv_cert) {
	handler = cert_get(exchange->recv_certtype);
	if (handler)
		msg->isakmp_sa->recv_cert =
		    handler->cert_dup(exchange->recv_cert);
}
if (exchange->sent_certtype) {
	handler = cert_get(exchange->sent_certtype);
	if (handler)
		msg->isakmp_sa->sent_cert =
		    handler->cert_dup(exchange->sent_cert);
}
if (exchange->doi)
	id_doi = exchange->doi->decode_ids(
	    "initiator id %s, responder id %s",
	    exchange->id_i, exchange->id_i_len,
	    exchange->id_r, exchange->id_r_len, 0);
else
	id_doi = "<no doi>";

if (msg->isakmp_sa->transport)
	id_trp =
	    msg->isakmp_sa->transport->vtbl->decode_ids(msg->isakmp_sa->transport);
else
	id_trp = "<no transport>";

if (exchange->flags & EXCHANGE_FLAG_NAT_T_ENABLE0x0010)
	msg->isakmp_sa->flags |= SA_FLAG_NAT_T_ENABLE0x100;
if (exchange->flags & EXCHANGE_FLAG_NAT_T_KEEPALIVE0x0020)
	msg->isakmp_sa->flags |= SA_FLAG_NAT_T_KEEPALIVE0x200;

LOG_DBG((LOG_EXCHANGE, 10,log_debug (LOG_EXCHANGE, 10, "exchange_finalize: phase 1 done: %s, %s"
, id_doi, id_trp)
    "exchange_finalize: phase 1 done: %s, %s", id_doi,log_debug (LOG_EXCHANGE, 10, "exchange_finalize: phase 1 done: %s, %s"
, id_doi, id_trp)
    id_trp))log_debug (LOG_EXCHANGE, 10, "exchange_finalize: phase 1 done: %s, %s"
, id_doi, id_trp);

log_verbose("isakmpd: phase 1 done%s: %s, %s",
	(exchange->initiator == 0) ? " (as responder)" : "",
	id_doi, id_trp);
}
exchange->doi->finalize_exchange(msg);
if (exchange->finalize)
exchange->finalize(exchange, exchange->finalize_arg, 0);
exchange->finalize = 0;

/*
* There is no reason to keep the SAs connected to us anymore, in fact
* it can hurt us if we have short lifetimes on the SAs and we try
* to call exchange_report, where the SA list will be walked and
* references to freed SAs can occur.
*/
while (TAILQ_FIRST(&exchange->sa_list)((&exchange->sa_list)->tqh_first)) {
sa = TAILQ_FIRST(&exchange->sa_list)((&exchange->sa_list)->tqh_first);

if (exchange->id_i && exchange->id_r) {
	ipsec_clone_id(&sa->id_i, &sa->id_i_len,
	    exchange->id_i, exchange->id_i_len);
	ipsec_clone_id(&sa->id_r, &sa->id_r_len,
	    exchange->id_r, exchange->id_r_len);
}
TAILQ_REMOVE(&exchange->sa_list, sa, next)do { if (((sa)->next.tqe_next) != ((void*)0)) (sa)->next
.tqe_next->next.tqe_prev = (sa)->next.tqe_prev; else (&
exchange->sa_list)->tqh_last = (sa)->next.tqe_prev; *
(sa)->next.tqe_prev = (sa)->next.tqe_next; ; ; } while (
0);
sa_release(sa);
}
/*
* Start sending DPD messages after all SAs have been released.
* Otherwise we have a race between exchange_free_aux() and
* dpd_check_event() where both will call sa_free().
*/
if (exchange->phase == 1 && msg->isakmp_sa &&
   (exchange->flags & EXCHANGE_FLAG_DPD_CAP_PEER0x0040))
dpd_start(msg->isakmp_sa);

/* If we have nothing to retransmit we can safely remove ourselves.  */
if (!exchange->last_sent)
exchange_free(exchange);
1490}

1492/* Stash a nonce into the exchange data.  */
1493static int
1494exchange_nonce(struct exchange *exchange, int peer, size_t nonce_sz,
  u_int8_t *buf)
1496{
u_int8_t      **nonce;
size_t         *nonce_len;
int		initiator = exchange->initiator ^ peer;
char            header[32];

if (nonce_sz < 8 || nonce_sz > 256) {
/*
 * RFC2409, ch 5: The length of nonce payload MUST be
 * between 8 and 256 bytes inclusive.
 * XXX I'm assuming the generic payload header is not included.
 */
LOG_DBG((LOG_EXCHANGE, 20,log_debug (LOG_EXCHANGE, 20, "exchange_nonce: invalid nonce length %lu"
, (unsigned long)nonce_sz)
    "exchange_nonce: invalid nonce length %lu",log_debug (LOG_EXCHANGE, 20, "exchange_nonce: invalid nonce length %lu"
, (unsigned long)nonce_sz)
    (unsigned long)nonce_sz))log_debug (LOG_EXCHANGE, 20, "exchange_nonce: invalid nonce length %lu"
, (unsigned long)nonce_sz);
return -1;
}

nonce = initiator ? &exchange->nonce_i : &exchange->nonce_r;
nonce_len =
   initiator ? &exchange->nonce_i_len : &exchange->nonce_r_len;
*nonce_len = nonce_sz;
*nonce = malloc(nonce_sz);
if (!*nonce) {
log_error("exchange_nonce: malloc (%lu) failed",
    (unsigned long)nonce_sz);
return -1;
}
memcpy(*nonce, buf, nonce_sz);
snprintf(header, sizeof header, "exchange_nonce: NONCE_%c",
   initiator ? 'i' : 'r');
LOG_DBG_BUF((LOG_EXCHANGE, 80, header, *nonce, nonce_sz))log_debug_buf (LOG_EXCHANGE, 80, header, *nonce, nonce_sz);
return 0;
1529}

1531/* Generate our NONCE.  */
1532int
1533exchange_gen_nonce(struct message *msg, size_t nonce_sz)
1534{
struct exchange *exchange = msg->exchange;
u_int8_t	*buf;

buf = malloc(ISAKMP_NONCE_SZ4 + nonce_sz);
if (!buf) {
log_error("exchange_gen_nonce: malloc (%lu) failed",
    ISAKMP_NONCE_SZ4 + (unsigned long)nonce_sz);
return -1;
}
arc4random_buf(buf + ISAKMP_NONCE_DATA_OFF4, nonce_sz);
if (message_add_payload(msg, ISAKMP_PAYLOAD_NONCE10, buf,
   ISAKMP_NONCE_SZ4 + nonce_sz, 1)) {
free(buf);
return -1;
}
return exchange_nonce(exchange, 0, nonce_sz,
   buf + ISAKMP_NONCE_DATA_OFF4);
1552}

1554/* Save the peer's NONCE.  */
1555int
1556exchange_save_nonce(struct message *msg)
1557{
struct payload	*noncep;
struct exchange *exchange = msg->exchange;

noncep = payload_first(msg, ISAKMP_PAYLOAD_NONCE10);
noncep->flags |= PL_MARK1;
return exchange_nonce(exchange, 1, GET_ISAKMP_GEN_LENGTH(noncep->p)field_get_num (isakmp_gen_fld + 2, noncep->p) -
   ISAKMP_NONCE_DATA_OFF4, noncep->p + ISAKMP_NONCE_DATA_OFF4);
1565}

1567/* Save the peer's CERT REQuests.  */
1568int
1569exchange_save_certreq(struct message *msg)
1570{
struct payload	*cp;
struct exchange	*exchange = msg->exchange;
struct certreq_aca *aca;

TAILQ_FOREACH(cp, &msg->payload[ISAKMP_PAYLOAD_CERT_REQ], link)for((cp) = ((&msg->payload[7])->tqh_first); (cp) !=
 ((void*)0); (cp) = ((cp)->link.tqe_next)) {
cp->flags |= PL_MARK1;
aca = certreq_decode(GET_ISAKMP_CERTREQ_TYPE(cp->p)field_get_num (isakmp_certreq_fld + 0, cp->p), cp->p +
    ISAKMP_CERTREQ_AUTHORITY_OFF5, GET_ISAKMP_GEN_LENGTH(cp->p)field_get_num (isakmp_gen_fld + 2, cp->p)
    - ISAKMP_CERTREQ_AUTHORITY_OFF5);
if (aca)
	TAILQ_INSERT_TAIL(&exchange->aca_list, aca, link)do { (aca)->link.tqe_next = ((void*)0); (aca)->link.tqe_prev
 = (&exchange->aca_list)->tqh_last; *(&exchange
->aca_list)->tqh_last = (aca); (&exchange->aca_list
)->tqh_last = &(aca)->link.tqe_next; } while (0);
}

return 0;
1585}

1587/* Free the list of pending CERTREQs.  */
1588void
1589exchange_free_aca_list(struct exchange *exchange)
1590{
struct certreq_aca *aca;

for (aca = TAILQ_FIRST(&exchange->aca_list)((&exchange->aca_list)->tqh_first); aca;
   aca = TAILQ_FIRST(&exchange->aca_list)((&exchange->aca_list)->tqh_first)) {
free(aca->raw_ca);
if (aca->data) {
	if (aca->handler)
		aca->handler->free_aca(aca->data);
	free(aca->data);
}
TAILQ_REMOVE(&exchange->aca_list, aca, link)do { if (((aca)->link.tqe_next) != ((void*)0)) (aca)->link
.tqe_next->link.tqe_prev = (aca)->link.tqe_prev; else (
&exchange->aca_list)->tqh_last = (aca)->link.tqe_prev
; *(aca)->link.tqe_prev = (aca)->link.tqe_next; ; ; } while
 (0);
free(aca);
}
1604}

1606/* Add any CERTREQs we should send.  */
1607int
1608exchange_add_certreqs(struct message *msg)
1609{
struct exchange *exchange = msg->exchange;
struct certreq_aca *aca;
u_int8_t *buf;

/*
* Some peers (e.g. Cisco IOS) won't send their cert unless we
* specifically ask beforehand with CERTREQ.  We reflect any
* CERTREQs we receive from the initiator in order to do this.
* This avoids leaking information about which CAs we trust,
* and works in the most common case where both ends trust the
* same CA.
*/
for (aca = TAILQ_FIRST(&exchange->aca_list)((&exchange->aca_list)->tqh_first); aca;
   aca = TAILQ_NEXT(aca, link)((aca)->link.tqe_next)) {

/* But only do this if we have at least one CA */
if (aca->handler != NULL((void*)0) && aca->handler->ca_count() == 0) {
	LOG_DBG((LOG_EXCHANGE, 10,log_debug (LOG_EXCHANGE, 10, "exchange_add_certreqs: no CA, so not "
 "sending a CERTREQ")
	    "exchange_add_certreqs: no CA, so not "log_debug (LOG_EXCHANGE, 10, "exchange_add_certreqs: no CA, so not "
 "sending a CERTREQ")
	    "sending a CERTREQ"))log_debug (LOG_EXCHANGE, 10, "exchange_add_certreqs: no CA, so not "
 "sending a CERTREQ");
	continue;
}

if (aca->raw_ca_len) {
	buf = malloc(ISAKMP_CERTREQ_SZ5 + aca->raw_ca_len);
	if (buf == NULL((void*)0)) {
		log_error("exchange_add_certreqs: "
		    "malloc (%lu) failed",
		    ISAKMP_CERTREQ_SZ5 +
		    (unsigned long)aca->raw_ca_len);
		return -1;
	}

	buf[ISAKMP_CERTREQ_TYPE_OFF4] = aca->id;
	memcpy(buf + ISAKMP_CERTREQ_AUTHORITY_OFF5,
	    aca->raw_ca, aca->raw_ca_len);

	if (message_add_payload(msg, ISAKMP_PAYLOAD_CERT_REQ7,
	    buf, ISAKMP_CERTREQ_SZ5 + aca->raw_ca_len, 1)) {
		free(buf);
		return -1;
	}
}
}

return 0;
1656}

1658/* Obtain certificates from acceptable certification authority.  */
1659int
1660exchange_add_certs(struct message *msg)
1661{
struct exchange *exchange = msg->exchange;
struct certreq_aca *aca;
u_int8_t       *cert = 0, *new_cert = 0;
u_int32_t       certlen;
u_int8_t       *id;
size_t          id_len;

id = exchange->initiator ? exchange->id_r : exchange->id_i;
id_len = exchange->initiator ? exchange->id_r_len : exchange->id_i_len;

/*
* Without IDs we cannot handle this yet. Keep the aca_list around for
* a later step/retry to see if we got the ID by then.
* Note: A 'return -1' breaks X509-auth interop in the responder case
*       with some IPsec clients that send CERTREQs early (such as
*       the SSH Sentinel).
*/
if (!id)
return 0;

for (aca = TAILQ_FIRST(&exchange->aca_list)((&exchange->aca_list)->tqh_first); aca;
   aca = TAILQ_NEXT(aca, link)((aca)->link.tqe_next)) {
/* XXX? If we can not satisfy a CERTREQ we drop the message. */
if (!aca->handler->cert_obtain(id, id_len, aca->data, &cert,
    &certlen)) {
	log_print("exchange_add_certs: could not obtain cert "
	    "for a type %d cert request", aca->id);
	free(cert);
	return -1;
}
new_cert = realloc(cert, ISAKMP_CERT_SZ5 + certlen);
if (!new_cert) {
	log_error("exchange_add_certs: realloc (%p, %d) "
	    "failed", cert, ISAKMP_CERT_SZ5 + certlen);
	free(cert);
	return -1;
}
cert = new_cert;
memmove(cert + ISAKMP_CERT_DATA_OFF5, cert, certlen);
SET_ISAKMP_CERT_ENCODING(cert, aca->id)field_set_num (isakmp_cert_fld + 0, cert, aca->id);
if (message_add_payload(msg, ISAKMP_PAYLOAD_CERT6, cert,
    ISAKMP_CERT_SZ5 + certlen, 1)) {
	free(cert);
	return -1;
}
/*
 * We need to reset cert here, as it is now controlled by
 * message_add_payload() (i.e. we must not free() it), and
 * it is possible for the next iteration of the aca loop
 * to fail early in cert_obtain before it writes to &cert.
 */
cert = NULL((void*)0);
}

/* We dont need the CERT REQs any more, they are answered.  */
exchange_free_aca_list(exchange);

return 0;
1720}

1722static void
1723exchange_establish_finalize(struct exchange *exchange, void *arg, int fail)
1724{
char	*name = arg;

LOG_DBG((LOG_EXCHANGE, 20, "exchange_establish_finalize: "log_debug (LOG_EXCHANGE, 20, "exchange_establish_finalize: " "finalizing exchange %p with arg %p (%s) & fail = %d"
, exchange, arg, name ? name : "<unnamed>", fail)
1
Assuming 'name' is non-null→
2
←
'?' condition is true→
   "finalizing exchange %p with arg %p (%s) & fail = %d",log_debug (LOG_EXCHANGE, 20, "exchange_establish_finalize: " "finalizing exchange %p with arg %p (%s) & fail = %d"
, exchange, arg, name ? name : "<unnamed>", fail)
   exchange, arg, name ? name : "<unnamed>", fail))log_debug (LOG_EXCHANGE, 20, "exchange_establish_finalize: " "finalizing exchange %p with arg %p (%s) & fail = %d"
, exchange, arg, name ? name : "<unnamed>", fail);

if (!fail)
3
←
Assuming 'fail' is 0→
4
←
Taking true branch→
exchange_establish(name, 0, 0, 0);
5
←
Calling 'exchange_establish'→
free(name);
1734}

1736/*
* Establish an exchange named NAME, and record the FINALIZE function
* taking ARG as an argument to be run after the exchange is ready.
*/
1740void
1741exchange_establish(char *name, void (*finalize)(struct exchange *, void *,
  int), void *arg, int stayalive)
1743{
struct transport	*transport;
struct sa		*isakmp_sa;
struct exchange		*exchange;
int	 phase;
char	*trpt, *peer;

phase = conf_get_num(name, "Phase", 0);

if (ui_daemon_passive) {
6
←
Assuming 'ui_daemon_passive' is 0→
7
←
Taking false branch→
LOG_DBG((LOG_EXCHANGE, 40, "exchange_establish:"log_debug (LOG_EXCHANGE, 40, "exchange_establish:" " returning in passive mode for exchange %s phase %d"
, name, phase)
    " returning in passive mode for exchange %s phase %d",log_debug (LOG_EXCHANGE, 40, "exchange_establish:" " returning in passive mode for exchange %s phase %d"
, name, phase)
    name, phase))log_debug (LOG_EXCHANGE, 40, "exchange_establish:" " returning in passive mode for exchange %s phase %d"
, name, phase);
if (finalize)
	finalize(0, arg, 1);
return;
}

/*
* First of all, never try to establish anything if another exchange
* of the same kind is running.
*/
exchange = exchange_lookup_by_name(name, phase);
if (exchange) {
8
←
Assuming 'exchange' is null→
9
←
Taking false branch→
LOG_DBG((LOG_EXCHANGE, 40,log_debug (LOG_EXCHANGE, 40, "exchange_establish: %s exchange already exists as %p"
, name, exchange)
    "exchange_establish: %s exchange already exists as %p",log_debug (LOG_EXCHANGE, 40, "exchange_establish: %s exchange already exists as %p"
, name, exchange)
    name, exchange))log_debug (LOG_EXCHANGE, 40, "exchange_establish: %s exchange already exists as %p"
, name, exchange);
exchange_add_finalization(exchange, finalize, arg);
return;
}
switch (phase) {
10
←
Control jumps to 'case 2:'  at line 1793→
case 1:
trpt = conf_get_str(name, "Transport");
if (!trpt) {
	/* Phase 1 transport defaults to "udp".  */
	trpt = ISAKMP_DEFAULT_TRANSPORT"udp";
}
transport = transport_create(trpt, name);
if (!transport) {
	log_print("exchange_establish: transport \"%s\" for "
	    "peer \"%s\" could not be created", trpt, name);
	if (finalize)
		finalize(0, arg, 1);
	return;
}
if (exchange_establish_p1(transport, 0, 0, name, 0, finalize,
    arg, stayalive) < 0 && finalize)
	finalize(0, arg, 1);
break;

case 2:
peer = conf_get_str(name, "ISAKMP-peer");
if (!peer) {
11
←
Assuming 'peer' is non-null→
12
←
Taking false branch→
	log_print("exchange_establish: No ISAKMP-peer given "
	    "for \"%s\"", name);
	if (finalize)
		finalize(0, arg, 1);
	return;
}
isakmp_sa = sa_lookup_by_name(peer, 1);
if (!isakmp_sa) {
13
←
Assuming 'isakmp_sa' is null→
14
←
Taking true branch→
	/* freed by exchange_establish_finalize() */
	name = strdup(name);
15
←
Memory is allocated→
	if (!name) {
16
←
Assuming 'name' is non-null→
17
←
Taking false branch→
		log_error("exchange_establish: "
		    "strdup (\"%s\") failed", name);
		if (finalize)
			finalize(0, arg, 1);
		return;
	}
	if (conf_get_num(peer, "Phase", 0) != 1) {
18
←
Assuming the condition is false→
19
←
Taking false branch→
		log_print("exchange_establish: "
		    "[%s]:ISAKMP-peer's (%s) phase is not 1",
		    name, peer);
		if (finalize)
			finalize(0, arg, 1);
		free(name);
		return;
	}
	/*
	 * XXX We're losing information here (what the
	 * original finalize routine was. As a result, if an
	 * exchange does not manage to get through, there may
	 * be application-specific information that won't get
	 * cleaned up, since no error signaling will be done.
	 * This is the case with dynamic SAs and PFKEY.
	 */
	exchange_establish(peer, exchange_establish_finalize,
	    name, 0);
	exchange = exchange_lookup_by_name(peer, 1);
20
←
Potential leak of memory pointed to by 'name'
	/*
	 * If the exchange was correctly initialized, add the
	 * original finalization routine; otherwise, call it
	 * directly.
	 */
	if (exchange)
		exchange_add_finalization(exchange, finalize,
		    arg);
	else {
		/* Indicate failure */
		if (finalize)
			finalize(0, arg, 1);
	}
	return;
} else {
	if (exchange_establish_p2(isakmp_sa, 0, name, 0,
	    finalize, arg) < 0 && finalize)
		finalize(0, arg, 1);
}
break;

default:
log_print("exchange_establish: "
    "peer \"%s\" does not have a correct phase (%d)",
    name, phase);
break;
}
1860}