/usr/src/sbin/isakmpd/sa.c

Bug Summary

File:	src/sbin/isakmpd/sa.c
Warning:	line 820, column 9 Use of memory after it is freed
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 sa.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/sa.c
1/* $OpenBSD: sa.c,v 1.124 2017/12/05 20:31:45 jca Exp $	 */
2/* $EOM: sa.c,v 1.112 2000/12/12 00:22:52 niklas 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) 2003, 2004 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/un.h>

37#include <stdlib.h>
38#include <string.h>
39#include <netdb.h>

41#include <regex.h>
42#include <keynote.h>

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

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

68/*
* 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.
*/
73#define MAX_BUCKET_BITS16 16

75#if 0
76static void     sa_resize(void);
77#endif
78static void     sa_soft_expire(void *);
79static void     sa_hard_expire(void *);

81static int	_net_addrcmp(struct sockaddr *, struct sockaddr *);

83static		LIST_HEAD(sa_list, sa)struct sa_list { struct sa *lh_first; } *sa_tab;

85/* Works both as a maximum index and a mask.  */
86static int      bucket_mask;

88void
89sa_init(void)
90{
int	i;

bucket_mask = (1 << INITIAL_BUCKET_BITS6) - 1;
sa_tab = calloc(bucket_mask + 1, sizeof(struct sa_list));
if (!sa_tab)
log_fatal("sa_init: malloc (%lu) failed",
    (bucket_mask + 1) * (unsigned long)sizeof(struct sa_list));
for (i = 0; i <= bucket_mask; i++)
LIST_INIT(&sa_tab[i])do { ((&sa_tab[i])->lh_first) = ((void *)0); } while (
0);
100}

102#if 0
103/* XXX We don't yet resize.  */
104static void
105sa_resize(void)
106{
int	new_mask = (bucket_mask + 1) * 2 - 1;
int	i;
struct sa_list *new_tab;

new_tab = reallocarray(sa_tab, new_mask + 1, sizeof(struct sa_list));
if (!new_tab)
return;
sa_tab = new_tab;
for (i = bucket_mask + 1; i <= new_mask; i++)
LIST_INIT(&sa_tab[i])do { ((&sa_tab[i])->lh_first) = ((void *)0); } while (
0);
bucket_mask = new_mask;

/* XXX Rehash existing entries.  */
120}
121#endif

123/* Lookup an SA with the help from a user-supplied checking function.  */
124struct sa *
125sa_find(int (*check) (struct sa*, void *), void *arg)
126{
int             i;
struct sa      *sa;

for (i = 0; i <= bucket_mask; i++)
for (sa = LIST_FIRST(&sa_tab[i])((&sa_tab[i])->lh_first); sa; sa = LIST_NEXT(sa, link)((sa)->link.le_next))
	if (check(sa, arg)) {
		LOG_DBG((LOG_SA, 90, "sa_find: return SA %p",log_debug (LOG_SA, 90, "sa_find: return SA %p", sa)
		    sa))log_debug (LOG_SA, 90, "sa_find: return SA %p", sa);
		return sa;
	}
LOG_DBG((LOG_SA, 90, "sa_find: no SA matched query"))log_debug (LOG_SA, 90, "sa_find: no SA matched query");
return 0;
139}

141/* Check if SA is an ISAKMP SA with an initiator cookie equal to ICOOKIE.  */
142static int
143sa_check_icookie(struct sa *sa, void *icookie)
144{
return sa->phase == 1 &&
   memcmp(sa->cookies, icookie, ISAKMP_HDR_ICOOKIE_LEN8) == 0;
147}

149/* Lookup an ISAKMP SA out of just the initiator cookie.  */
150struct sa *
151sa_lookup_from_icookie(u_int8_t *cookie)
152{
return sa_find(sa_check_icookie, cookie);
154}

156struct name_phase_arg {
char           *name;
u_int8_t        phase;
159};

161/* Check if SA has the name and phase given by V_ARG.  */
162static int
163sa_check_name_phase(struct sa *sa, void *v_arg)
164{
struct name_phase_arg *arg = v_arg;

return sa->name && strcasecmp(sa->name, arg->name) == 0 &&
   sa->phase == arg->phase && !(sa->flags & SA_FLAG_REPLACED0x08);
169}

171/* Lookup an SA by name, case-independent, and phase.  */
172struct sa *
173sa_lookup_by_name(char *name, int phase)
174{
struct name_phase_arg arg;

arg.name = name;
arg.phase = phase;
return sa_find(sa_check_name_phase, &arg);
180}

182struct addr_arg {
struct sockaddr *addr;
socklen_t       len;
int             phase;
int             flags;
187};

189/*
* This function has been removed from libc and put here as this
* file is the only user for it.
*/
193static int
194_net_addrcmp(struct sockaddr *sa1, struct sockaddr *sa2)
195{

if (sa1->sa_len != sa2->sa_len)
return (sa1->sa_len < sa2->sa_len) ? -1 : 1;
if (sa1->sa_family != sa2->sa_family)
return (sa1->sa_family < sa2->sa_family) ? -1 : 1;

switch(sa1->sa_family) {
case AF_INET2:
return (memcmp(&((struct sockaddr_in *)sa1)->sin_addr,
    &((struct sockaddr_in *)sa2)->sin_addr,
    sizeof(struct in_addr)));
case AF_INET624:
if (((struct sockaddr_in6 *)sa1)->sin6_scope_id !=
    ((struct sockaddr_in6 *)sa2)->sin6_scope_id)
	return (((struct sockaddr_in6 *)sa1)->sin6_scope_id < 
	    ((struct sockaddr_in6 *)sa2)->sin6_scope_id)
	    ? -1 : 1;
return memcmp(&((struct sockaddr_in6 *)sa1)->sin6_addr,
    &((struct sockaddr_in6 *)sa2)->sin6_addr,
    sizeof(struct in6_addr));
case AF_LOCAL1:
return (strcmp(((struct sockaddr_un *)sa1)->sun_path,
    ((struct sockaddr_un *)sa2)->sun_path));
default:
return -1;
}
222}

224/*
* Check if SA is ready and has a peer with an address equal the one given
* by V_ADDR.  Furthermore if we are searching for a specific phase, check
* that too.
*/
229static int
230sa_check_peer(struct sa *sa, void *v_addr)
231{
struct addr_arg *addr = v_addr;
struct sockaddr *dst;

if (!sa->transport || (sa->flags & SA_FLAG_READY0x01) == 0 ||
   (addr->phase && addr->phase != sa->phase))
return 0;

sa->transport->vtbl->get_dst(sa->transport, &dst);
if (_net_addrcmp(dst, addr->addr) != 0)
return 0;

/* same family, length and address, check port if inet/inet6 */
switch (dst->sa_family) {
case AF_INET2:
return ((struct sockaddr_in *)dst)->sin_port == ((struct sockaddr_in *)addr->addr)->sin_port;
case AF_INET624:
return ((struct sockaddr_in6 *)dst)->sin6_port == ((struct sockaddr_in6 *)addr->addr)->sin6_port;
}

return 1;
252}

254struct dst_isakmpspi_arg {
struct sockaddr *dst;
u_int8_t       *spi;	/* must be ISAKMP_SPI_SIZE octets */
257};

259/*
* Check if SA matches what we are asking for through V_ARG.  It has to
* be a finished phase 1 (ISAKMP) SA.
*/
263static int
264isakmp_sa_check(struct sa *sa, void *v_arg)
265{
struct dst_isakmpspi_arg *arg = v_arg;
struct sockaddr		*dst, *src;

if (sa->phase != 1 || !(sa->flags & SA_FLAG_READY0x01))
return 0;

/* verify address is either src or dst for this sa */
sa->transport->vtbl->get_dst(sa->transport, &dst);
sa->transport->vtbl->get_src(sa->transport, &src);
if (memcmp(src, arg->dst, SA_LEN(src)((src)->sa_len)) &&
   memcmp(dst, arg->dst, SA_LEN(dst)((dst)->sa_len)))
return 0;

/* match icookie+rcookie against spi */
if (memcmp(sa->cookies, arg->spi, ISAKMP_HDR_COOKIES_LEN(8 + 8)) == 0)
return 1;

return 0;
284}

286/*
* Find an ISAKMP SA with a "name" of DST & SPI.
*/
289struct sa *
290sa_lookup_isakmp_sa(struct sockaddr *dst, u_int8_t *spi)
291{
struct dst_isakmpspi_arg arg;

arg.dst = dst;
arg.spi = spi;

return sa_find(isakmp_sa_check, &arg);
298}

300/* Lookup a ready SA by the peer's address.  */
301struct sa *
302sa_lookup_by_peer(struct sockaddr *dst, socklen_t dstlen, int phase)
303{
struct addr_arg arg;

arg.addr = dst;
arg.len = dstlen;
arg.phase = phase;

return sa_find(sa_check_peer, &arg);
311}

313/* Lookup a ready ISAKMP SA given its peer address.  */
314struct sa *
315sa_isakmp_lookup_by_peer(struct sockaddr *dst, socklen_t dstlen)
316{
struct addr_arg arg;

arg.addr = dst;
arg.len = dstlen;
arg.phase = 1;

return sa_find(sa_check_peer, &arg);
324}

326int
327sa_enter(struct sa *sa)
328{
u_int16_t       bucket = 0;
int             i;
u_int8_t       *cp;

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

for (i = 0; i < ISAKMP_HDR_COOKIES_LEN(8 + 8); i += 2) {
cp = sa->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 = sa->message_id + i;
/* Doing it this way avoids alignment problems.  */
bucket ^= cp[0] | cp[1] << 8;
}
bucket &= bucket_mask;
LIST_INSERT_HEAD(&sa_tab[bucket], sa, link)do { if (((sa)->link.le_next = (&sa_tab[bucket])->lh_first
) != ((void *)0)) (&sa_tab[bucket])->lh_first->link
.le_prev = &(sa)->link.le_next; (&sa_tab[bucket])->
lh_first = (sa); (sa)->link.le_prev = &(&sa_tab[bucket
])->lh_first; } while (0);
sa_reference(sa);
LOG_DBG((LOG_SA, 70, "sa_enter: SA %p added to SA list", sa))log_debug (LOG_SA, 70, "sa_enter: SA %p added to SA list", sa
);
return 1;
350}

352/*
* Lookup the SA given by the header fields MSG.  PHASE2 is false when
* looking for phase 1 SAa and true otherwise.
*/
356struct sa *
357sa_lookup_by_header(u_int8_t *msg, int phase2)
358{
return sa_lookup(msg + ISAKMP_HDR_COOKIES_OFF0,
   phase2 ? msg + ISAKMP_HDR_MESSAGE_ID_OFF20 : 0);
361}

363/*
* Lookup the SA given by the COOKIES and possibly the MESSAGE_ID unless
* a null pointer, meaning we are looking for phase 1 SAs.
*/
367struct sa *
368sa_lookup(u_int8_t *cookies, u_int8_t *message_id)
369{
u_int16_t       bucket = 0;
int             i;
struct sa      *sa;
u_int8_t       *cp;

/*
* We use the cookies to get bits to use as an index into sa_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 = cookies + i;
/* Doing it this way avoids alignment problems.  */
bucket ^= cp[0] | cp[1] << 8;
}
if (message_id)
for (i = 0; i < ISAKMP_HDR_MESSAGE_ID_LEN4; i += 2) {
	cp = message_id + i;
	/* Doing it this way avoids alignment problems.  */
	bucket ^= cp[0] | cp[1] << 8;
}
bucket &= bucket_mask;
for (sa = LIST_FIRST(&sa_tab[bucket])((&sa_tab[bucket])->lh_first);
   sa && (memcmp(cookies, sa->cookies, ISAKMP_HDR_COOKIES_LEN(8 + 8)) != 0 ||
   (message_id && memcmp(message_id, sa->message_id,
   ISAKMP_HDR_MESSAGE_ID_LEN4) != 0) ||
   (!message_id && !zero_test(sa->message_id, ISAKMP_HDR_MESSAGE_ID_LEN4)));
   sa = LIST_NEXT(sa, link)((sa)->link.le_next))
;

return sa;
403}

405/* Create an SA.  */
406int
407sa_create(struct exchange *exchange, struct transport *t)
408{
struct sa      *sa;

/*
* We want the SA zeroed for sa_free to be able to find out what fields
* have been filled-in.
*/
sa = calloc(1, sizeof *sa);
if (!sa) {
log_error("sa_create: calloc (1, %lu) failed",
    (unsigned long)sizeof *sa);
return -1;
}
sa->transport = t;
if (t)
transport_reference(t);
sa->phase = exchange->phase;
memcpy(sa->cookies, exchange->cookies, ISAKMP_HDR_COOKIES_LEN(8 + 8));
memcpy(sa->message_id, exchange->message_id,
   ISAKMP_HDR_MESSAGE_ID_LEN4);
sa->doi = exchange->doi;
sa->policy_id = -1;

if (sa->doi->sa_size) {
/*
 * Allocate the DOI-specific structure and initialize it to
 * zeroes.
 */
sa->data = calloc(1, sa->doi->sa_size);
if (!sa->data) {
	log_error("sa_create: calloc (1, %lu) failed",
	    (unsigned long)sa->doi->sa_size);
	free(sa);
	return -1;
}
}
TAILQ_INIT(&sa->protos)do { (&sa->protos)->tqh_first = ((void *)0); (&
sa->protos)->tqh_last = &(&sa->protos)->tqh_first
; } while (0);

sa_enter(sa);
TAILQ_INSERT_TAIL(&exchange->sa_list, sa, next)do { (sa)->next.tqe_next = ((void *)0); (sa)->next.tqe_prev
 = (&exchange->sa_list)->tqh_last; *(&exchange->
sa_list)->tqh_last = (sa); (&exchange->sa_list)->
tqh_last = &(sa)->next.tqe_next; } while (0);
sa_reference(sa);

LOG_DBG((LOG_SA, 60,log_debug (LOG_SA, 60, "sa_create: sa %p phase %d added to exchange %p (%s)"
, sa, sa->phase, exchange, exchange->name ? exchange->
name : "<unnamed>")
   "sa_create: sa %p phase %d added to exchange %p (%s)", sa,log_debug (LOG_SA, 60, "sa_create: sa %p phase %d added to exchange %p (%s)"
, sa, sa->phase, exchange, exchange->name ? exchange->
name : "<unnamed>")
   sa->phase, exchange,log_debug (LOG_SA, 60, "sa_create: sa %p phase %d added to exchange %p (%s)"
, sa, sa->phase, exchange, exchange->name ? exchange->
name : "<unnamed>")
   exchange->name ? exchange->name : "<unnamed>"))log_debug (LOG_SA, 60, "sa_create: sa %p phase %d added to exchange %p (%s)"
, sa, sa->phase, exchange, exchange->name ? exchange->
name : "<unnamed>");
return 0;
455}

457/*
* Dump the internal state of SA to the report channel, with HEADER
* prepended to each line.
*/
461void
462sa_dump(int cls, int level, char *header, struct sa *sa)
463{
struct proto   *proto;
char            spi_header[80];
int             i;

LOG_DBG((cls, level, "%s: %p %s phase %d doi %d flags 0x%x", header,log_debug (cls, level, "%s: %p %s phase %d doi %d flags 0x%x"
, header, sa, sa->name ? sa->name : "<unnamed>", sa
->phase, sa->doi->id, sa->flags)
   sa, sa->name ? sa->name : "<unnamed>", sa->phase, sa->doi->id,log_debug (cls, level, "%s: %p %s phase %d doi %d flags 0x%x"
, header, sa, sa->name ? sa->name : "<unnamed>", sa
->phase, sa->doi->id, sa->flags)
   sa->flags))log_debug (cls, level, "%s: %p %s phase %d doi %d flags 0x%x"
, header, sa, sa->name ? sa->name : "<unnamed>", sa
->phase, sa->doi->id, sa->flags);
LOG_DBG((cls, level, "%s: icookie %08x%08x rcookie %08x%08x", header,log_debug (cls, level, "%s: icookie %08x%08x rcookie %08x%08x"
, header, decode_32(sa->cookies), decode_32(sa->cookies
 + 4), decode_32(sa->cookies + 8), decode_32(sa->cookies
 + 12))
   decode_32(sa->cookies), decode_32(sa->cookies + 4),log_debug (cls, level, "%s: icookie %08x%08x rcookie %08x%08x"
, header, decode_32(sa->cookies), decode_32(sa->cookies
 + 4), decode_32(sa->cookies + 8), decode_32(sa->cookies
 + 12))
   decode_32(sa->cookies + 8), decode_32(sa->cookies + 12)))log_debug (cls, level, "%s: icookie %08x%08x rcookie %08x%08x"
, header, decode_32(sa->cookies), decode_32(sa->cookies
 + 4), decode_32(sa->cookies + 8), decode_32(sa->cookies
 + 12));
LOG_DBG((cls, level, "%s: msgid %08x refcnt %d", header,log_debug (cls, level, "%s: msgid %08x refcnt %d", header, decode_32
(sa->message_id), sa->refcnt)
   decode_32(sa->message_id), sa->refcnt))log_debug (cls, level, "%s: msgid %08x refcnt %d", header, decode_32
(sa->message_id), sa->refcnt);
LOG_DBG((cls, level, "%s: life secs %llu kb %llu", header, sa->seconds,log_debug (cls, level, "%s: life secs %llu kb %llu", header, sa
->seconds, sa->kilobytes)
   sa->kilobytes))log_debug (cls, level, "%s: life secs %llu kb %llu", header, sa
->seconds, sa->kilobytes);
for (proto = TAILQ_FIRST(&sa->protos)((&sa->protos)->tqh_first); proto;
   proto = TAILQ_NEXT(proto, link)((proto)->link.tqe_next)) {
LOG_DBG((cls, level, "%s: suite %d proto %d", header,log_debug (cls, level, "%s: suite %d proto %d", header, proto
->no, proto->proto)
    proto->no, proto->proto))log_debug (cls, level, "%s: suite %d proto %d", header, proto
->no, proto->proto);
LOG_DBG((cls, level,log_debug (cls, level, "%s: spi_sz[0] %d spi[0] %p spi_sz[1] %d spi[1] %p"
, header, proto->spi_sz[0], proto->spi[0], proto->spi_sz
[1], proto->spi[1])
    "%s: spi_sz[0] %d spi[0] %p spi_sz[1] %d spi[1] %p",log_debug (cls, level, "%s: spi_sz[0] %d spi[0] %p spi_sz[1] %d spi[1] %p"
, header, proto->spi_sz[0], proto->spi[0], proto->spi_sz
[1], proto->spi[1])
    header, proto->spi_sz[0], proto->spi[0], proto->spi_sz[1],log_debug (cls, level, "%s: spi_sz[0] %d spi[0] %p spi_sz[1] %d spi[1] %p"
, header, proto->spi_sz[0], proto->spi[0], proto->spi_sz
[1], proto->spi[1])
    proto->spi[1]))log_debug (cls, level, "%s: spi_sz[0] %d spi[0] %p spi_sz[1] %d spi[1] %p"
, header, proto->spi_sz[0], proto->spi[0], proto->spi_sz
[1], proto->spi[1]);
LOG_DBG((cls, level, "%s: %s, %s", header,log_debug (cls, level, "%s: %s, %s", header, !sa->doi ? "<nodoi>"
 : sa->doi->decode_ids("initiator id: %s, responder id: %s"
, sa->id_i, sa->id_i_len, sa->id_r, sa->id_r_len,
 0), !sa->transport ? "<no transport>" : sa->transport
->vtbl->decode_ids(sa->transport))
    !sa->doi ? "<nodoi>" :log_debug (cls, level, "%s: %s, %s", header, !sa->doi ? "<nodoi>"
 : sa->doi->decode_ids("initiator id: %s, responder id: %s"
, sa->id_i, sa->id_i_len, sa->id_r, sa->id_r_len,
 0), !sa->transport ? "<no transport>" : sa->transport
->vtbl->decode_ids(sa->transport))
    sa->doi->decode_ids("initiator id: %s, responder id: %s",log_debug (cls, level, "%s: %s, %s", header, !sa->doi ? "<nodoi>"
 : sa->doi->decode_ids("initiator id: %s, responder id: %s"
, sa->id_i, sa->id_i_len, sa->id_r, sa->id_r_len,
 0), !sa->transport ? "<no transport>" : sa->transport
->vtbl->decode_ids(sa->transport))
    sa->id_i, sa->id_i_len,log_debug (cls, level, "%s: %s, %s", header, !sa->doi ? "<nodoi>"
 : sa->doi->decode_ids("initiator id: %s, responder id: %s"
, sa->id_i, sa->id_i_len, sa->id_r, sa->id_r_len,
 0), !sa->transport ? "<no transport>" : sa->transport
->vtbl->decode_ids(sa->transport))
    sa->id_r, sa->id_r_len, 0),log_debug (cls, level, "%s: %s, %s", header, !sa->doi ? "<nodoi>"
 : sa->doi->decode_ids("initiator id: %s, responder id: %s"
, sa->id_i, sa->id_i_len, sa->id_r, sa->id_r_len,
 0), !sa->transport ? "<no transport>" : sa->transport
->vtbl->decode_ids(sa->transport))
    !sa->transport ? "<no transport>" :log_debug (cls, level, "%s: %s, %s", header, !sa->doi ? "<nodoi>"
 : sa->doi->decode_ids("initiator id: %s, responder id: %s"
, sa->id_i, sa->id_i_len, sa->id_r, sa->id_r_len,
 0), !sa->transport ? "<no transport>" : sa->transport
->vtbl->decode_ids(sa->transport))
    sa->transport->vtbl->decode_ids(sa->transport)))log_debug (cls, level, "%s: %s, %s", header, !sa->doi ? "<nodoi>"
 : sa->doi->decode_ids("initiator id: %s, responder id: %s"
, sa->id_i, sa->id_i_len, sa->id_r, sa->id_r_len,
 0), !sa->transport ? "<no transport>" : sa->transport
->vtbl->decode_ids(sa->transport));
for (i = 0; i < 2; i++)
	if (proto->spi[i]) {
		snprintf(spi_header, sizeof spi_header,
		    "%s: spi[%d]", header, i);
		LOG_DBG_BUF((cls, level, spi_header,log_debug_buf (cls, level, spi_header, proto->spi[i], proto
->spi_sz[i])
		    proto->spi[i], proto->spi_sz[i]))log_debug_buf (cls, level, spi_header, proto->spi[i], proto
->spi_sz[i]);
	}
}
501}

503/*
* Display the SA's two SPI values.
*/
506static void
507report_spi(FILE *fd, const u_int8_t *buf, size_t sz, int spi)
508{
509#define SBUFSZ(2 * 32 + 9) (2 * 32 + 9)
char	s[SBUFSZ(2 * 32 + 9)];
size_t	i, j;

for (i = j = 0; i < sz;) {
snprintf(s + j, sizeof s - j, "%02x", buf[i++]);
j += strlen(s + j);
if (i % 4 == 0) {
	if (i % 32 == 0) {
		s[j] = '\0';
		fprintf(fd, "%s", s);
		j = 0;
	} else
		s[j++] = ' ';
}
}

if (j) {
s[j] = '\0';
fprintf(fd, "SPI %d: %s\n", spi, s);
}
530}

532/*
* Display the transform names to file.
* Structure is taken from pf_key_v2.c, pf_key_v2_set_spi.
* Transform names are taken from /usr/src/sys/crypto/xform.c.
*/
537static void
538report_proto(FILE *fd, struct proto *proto)
539{
struct ipsec_proto *iproto;
int	keylen, hashlen;

switch (proto->proto) {
case IPSEC_PROTO_IPSEC_ESP3:
keylen = ipsec_esp_enckeylength(proto);
hashlen = ipsec_esp_authkeylength(proto);
fprintf(fd, "Transform: IPsec ESP\n");
fprintf(fd, "Encryption key length: %d\n", keylen);
fprintf(fd, "Authentication key length: %d\n", hashlen);

fprintf(fd, "Encryption algorithm: ");
switch (proto->id) {
case IPSEC_ESP_3DES3:
	fprintf(fd, "3DES\n");
	break;

case IPSEC_ESP_AES12:
	fprintf(fd, "AES (CBC)\n");
	break;

case IPSEC_ESP_AES_CTR13:
	fprintf(fd, "AES (CTR)\n");
	break;

case IPSEC_ESP_AES_GCM_1620:
	fprintf(fd, "AES (GCM)\n");
	break;

case IPSEC_ESP_AES_GMAC23:
	fprintf(fd, "AES (GMAC)\n");
	break;

case IPSEC_ESP_CAST6:
	fprintf(fd, "Cast-128\n");
	break;

case IPSEC_ESP_BLOWFISH7:
	fprintf(fd, "Blowfish\n");
	break;

default:
	fprintf(fd, "unknown (%d)\n", proto->id);
}

fprintf(fd, "Authentication algorithm: ");

if (!proto->data) {
	fprintf(fd, "none\n");
	break;
}
iproto = proto->data;

switch (iproto->auth) {
case IPSEC_AUTH_HMAC_MD51:
	fprintf(fd, "HMAC-MD5\n");
	break;

case IPSEC_AUTH_HMAC_SHA2:
	fprintf(fd, "HMAC-SHA1\n");
	break;

case IPSEC_AUTH_HMAC_RIPEMD8:
	fprintf(fd, "HMAC-RIPEMD-160\n");
	break;

case IPSEC_AUTH_HMAC_SHA2_2565:
	fprintf(fd, "HMAC-SHA2-256\n");
	break;

case IPSEC_AUTH_HMAC_SHA2_3846:
	fprintf(fd, "HMAC-SHA2-384\n");
	break;

case IPSEC_AUTH_HMAC_SHA2_5127:
	fprintf(fd, "HMAC-SHA2-512\n");
	break;

case IPSEC_AUTH_DES_MAC3:
case IPSEC_AUTH_KPDK4:
	/* XXX We should be supporting KPDK */
	fprintf(fd, "unknown (%d)", iproto->auth);
	break;

default:
	fprintf(fd, "none\n");
}
break;

case IPSEC_PROTO_IPSEC_AH2:
hashlen = ipsec_ah_keylength(proto);
fprintf(fd, "Transform: IPsec AH\n");
fprintf(fd, "Encryption not used.\n");
fprintf(fd, "Authentication key length: %d\n", hashlen);

fprintf(fd, "Authentication algorithm: ");
switch (proto->id) {
case IPSEC_AH_MD52:
	fprintf(fd, "HMAC-MD5\n");
	break;

case IPSEC_AH_SHA3:
	fprintf(fd, "HMAC-SHA1\n");
	break;

case IPSEC_AH_RIPEMD8:
	fprintf(fd, "HMAC-RIPEMD-160\n");
	break;

case IPSEC_AH_SHA2_2565:
	fprintf(fd, "HMAC-SHA2-256\n");
	break;

case IPSEC_AH_SHA2_3846:
	fprintf(fd, "HMAC-SHA2-384\n");
	break;

case IPSEC_AH_SHA2_5127:
	fprintf(fd, "HMAC-SHA2-512\n");
	break;

default:
	fprintf(fd, "unknown (%d)", proto->id);
}
break;

default:
fprintf(fd, "report_proto: invalid proto %d\n", proto->proto);
}
669}

671/*
* Display SA lifetimes.
*/
674static void
675report_lifetimes(FILE *fd, struct sa *sa)
676{
long timeout;

if (sa->seconds)
fprintf(fd, "Lifetime: %llu seconds\n", sa->seconds);

if (sa->soft_death) {
timeout = get_timeout(&sa->soft_death->expiration);
if (timeout < 0)
	fprintf(fd, "<no soft timeout>\n");
else
	fprintf(fd, "Soft timeout in %ld seconds\n", timeout);
}

if (sa->death) {
timeout = get_timeout(&sa->death->expiration);
if (timeout < 0)
	fprintf(fd, "No hard timeout>\n");
else
	fprintf(fd, "Hard timeout in %ld seconds\n", timeout);
}

if (sa->kilobytes)
fprintf(fd, "Lifetime: %llu kilobytes\n", sa->kilobytes);
700}

702/*
* Print phase 1 specific information.
*/
705static void
706report_phase1(FILE *fd, struct sa *sa)
707{
/* Cookies. */
fprintf(fd, "icookie %08x%08x rcookie %08x%08x\n",
   decode_32(sa->cookies), decode_32(sa->cookies + 4),
   decode_32(sa->cookies + 8), decode_32(sa->cookies + 12));
712}

714/*
* Print phase 2 specific information.
*/
717static void
718report_phase2(FILE *fd, struct sa *sa)
719{
struct proto	*proto;
int		 i;

/* Transform information. */
for (proto = TAILQ_FIRST(&sa->protos)((&sa->protos)->tqh_first); proto;
   proto = TAILQ_NEXT(proto, link)((proto)->link.tqe_next)) {

/* SPI values. */
for (i = 0; i < 2; i++)
	if (proto->spi[i])
		report_spi(fd, proto->spi[i],
		    proto->spi_sz[i], i);
	else
		fprintf(fd, "SPI %d not defined.\n", i);

/* Proto values. */
report_proto(fd, proto);
}
738}

740/* Report all the SAs to the report channel.  */
741void
742sa_report(void)
743{
struct sa      *sa;
int             i;

for (i = 0; i <= bucket_mask; i++)
for (sa = LIST_FIRST(&sa_tab[i])((&sa_tab[i])->lh_first); sa; sa = LIST_NEXT(sa, link)((sa)->link.le_next))
	sa_dump(LOG_REPORT-2, 0, "sa_report", sa);
750}

752/*
* Print an SA's connection details to file SA_FILE.
*/
755static void
756sa_dump_all(FILE *fd, struct sa *sa)
757{
/* SA name and phase. */
fprintf(fd, "SA name: %s", sa->name ? sa->name : "<unnamed>");
fprintf(fd, " (Phase %d%s)\n", sa->phase, sa->phase == 1 ?
   (sa->initiator ? "/Initiator" : "/Responder") : "");

/* Source and destination IPs. */
fprintf(fd, "%s", sa->transport == NULL((void *)0) ? "<no transport>" :
   sa->transport->vtbl->decode_ids(sa->transport));
fprintf(fd, "\n");

/* Lifetimes */
report_lifetimes(fd, sa);

fprintf(fd, "Flags 0x%08x\n", sa->flags);

if (sa->phase == 1)
report_phase1(fd, sa);
else if (sa->phase == 2)
report_phase2(fd, sa);
else {
/* Should not happen, but... */
fprintf(fd, "<unknown phase>\n");
}

/* SA separator. */
fprintf(fd, "\n");
784}

786/* Report info of all SAs to file 'fd'.  */
787void
788sa_report_all(FILE *fd)
789{
struct sa      *sa;
int             i;

for (i = 0; i <= bucket_mask; i++)
for (sa = LIST_FIRST(&sa_tab[i])((&sa_tab[i])->lh_first); sa; sa = LIST_NEXT(sa, link)((sa)->link.le_next))
	sa_dump_all(fd, sa);
796}

798/* Free the protocol structure pointed to by PROTO.  */
799void
800proto_free(struct proto *proto)
801{
struct proto_attr *pa;
struct sa      *sa = proto->sa;
int             i;

for (i = 0; i < 2; i++)
1
Loop condition is true.  Entering loop body→
4
←
Loop condition is true.  Entering loop body→
7
←
Loop condition is false. Execution continues on line 812→
if (proto->spi[i]) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
5
←
Assuming the condition is false→
6
←
Taking false branch→
	if (sa->doi->delete_spi)
		sa->doi->delete_spi(sa, proto, i);
	free(proto->spi[i]);
}
TAILQ_REMOVE(&sa->protos, proto, link)do { if (((proto)->link.tqe_next) != ((void *)0)) (proto)->
link.tqe_next->link.tqe_prev = (proto)->link.tqe_prev; else
 (&sa->protos)->tqh_last = (proto)->link.tqe_prev
; *(proto)->link.tqe_prev = (proto)->link.tqe_next; ; ;
 } while (0);
8
←
Assuming field 'tqe_next' is equal to null→
9
←
Taking false branch→
10
←
Loop condition is false.  Exiting loop→
if (proto->data) {
11
←
Assuming field 'data' is null→
12
←
Taking false branch→
if (sa->doi && sa->doi->free_proto_data)
	sa->doi->free_proto_data(proto->data);
free(proto->data);
}
if (proto->xf_cnt)
13
←
Assuming field 'xf_cnt' is not equal to 0→
14
←
Taking true branch→
while ((pa = TAILQ_FIRST(&proto->xfs)((&proto->xfs)->tqh_first)) != NULL((void *)0)) {
15
←
Assuming the condition is true→
16
←
Loop condition is true.  Entering loop body→
21
←
Loop condition is true.  Entering loop body→
	free(pa->attrs);
22
←
Use of memory after it is freed
	TAILQ_REMOVE(&proto->xfs, pa, next)do { if (((pa)->next.tqe_next) != ((void *)0)) (pa)->next
.tqe_next->next.tqe_prev = (pa)->next.tqe_prev; else (&
proto->xfs)->tqh_last = (pa)->next.tqe_prev; *(pa)->
next.tqe_prev = (pa)->next.tqe_next; ; ; } while (0);
17
←
Assuming field 'tqe_next' is equal to null→
18
←
Taking false branch→
19
←
Loop condition is false.  Exiting loop→
	free(pa);
20
←
Memory is released→
}

LOG_DBG((LOG_SA, 90, "proto_free: freeing %p", proto))log_debug (LOG_SA, 90, "proto_free: freeing %p", proto);
free(proto);
827}

829/* Release all resources this SA is using.  */
830void
831sa_free(struct sa *sa)
832{
if (sa->death) {
timer_remove_event(sa->death);
sa->death = 0;
sa->refcnt--;
}
if (sa->soft_death) {
timer_remove_event(sa->soft_death);
sa->soft_death = 0;
sa->refcnt--;
}
if (sa->dpd_event) {
timer_remove_event(sa->dpd_event);
sa->dpd_event = 0;
}
sa_remove(sa);
848}

850/* Remove the SA from the hash table of live SAs.  */
851void
852sa_remove(struct sa *sa)
853{
LIST_REMOVE(sa, link)do { if ((sa)->link.le_next != ((void *)0)) (sa)->link.
le_next->link.le_prev = (sa)->link.le_prev; *(sa)->link
.le_prev = (sa)->link.le_next; ; ; } while (0);
LOG_DBG((LOG_SA, 70, "sa_remove: SA %p removed from SA list", sa))log_debug (LOG_SA, 70, "sa_remove: SA %p removed from SA list"
, sa);
sa_release(sa);
857}

859/* Raise the reference count of SA.  */
860void
861sa_reference(struct sa *sa)
862{
sa->refcnt++;
LOG_DBG((LOG_SA, 80, "sa_reference: SA %p now has %d references",log_debug (LOG_SA, 80, "sa_reference: SA %p now has %d references"
, sa, sa->refcnt)
   sa, sa->refcnt))log_debug (LOG_SA, 80, "sa_reference: SA %p now has %d references"
, sa, sa->refcnt);
866}

868/* Release a reference to SA.  */
869void
870sa_release(struct sa *sa)
871{
struct cert_handler *handler;
struct proto   *proto;

LOG_DBG((LOG_SA, 80, "sa_release: SA %p had %d references",log_debug (LOG_SA, 80, "sa_release: SA %p had %d references",
 sa, sa->refcnt)
   sa, sa->refcnt))log_debug (LOG_SA, 80, "sa_release: SA %p had %d references",
 sa, sa->refcnt);

if (--sa->refcnt)
return;

LOG_DBG((LOG_SA, 60, "sa_release: freeing SA %p", sa))log_debug (LOG_SA, 60, "sa_release: freeing SA %p", sa);

while ((proto = TAILQ_FIRST(&sa->protos)((&sa->protos)->tqh_first)) != 0)
proto_free(proto);
if (sa->data) {
if (sa->doi && sa->doi->free_sa_data)
	sa->doi->free_sa_data(sa->data);
free(sa->data);
}
free(sa->id_i);
free(sa->id_r);
if (sa->recv_cert) {
handler = cert_get(sa->recv_certtype);
if (handler)
	handler->cert_free(sa->recv_cert);
}
if (sa->sent_cert) {
handler = cert_get(sa->sent_certtype);
if (handler)
	handler->cert_free(sa->sent_cert);
}
if (sa->recv_key)
key_free(sa->recv_keytype, ISAKMP_KEYTYPE_PUBLIC0,
    sa->recv_key);
free(sa->keynote_key);	/* This is just a string */
if (sa->policy_id != -1)
kn_close(sa->policy_id);
free(sa->name);
free(sa->keystate);
if (sa->nat_t_keepalive)
timer_remove_event(sa->nat_t_keepalive);
if (sa->dpd_event)
timer_remove_event(sa->dpd_event);
if (sa->transport)
transport_release(sa->transport);
free(sa->tag);
free(sa);
918}

920/*
* Rehash the ISAKMP SA this MSG is negotiating with the responder cookie
* filled in.
*/
924void
925sa_isakmp_upgrade(struct message *msg)
926{
struct sa      *sa = TAILQ_FIRST(&msg->exchange->sa_list)((&msg->exchange->sa_list)->tqh_first);

sa_remove(sa);
GET_ISAKMP_HDR_RCOOKIE(msg->iov[0].iov_base,field_get_raw (isakmp_hdr_fld + 1, msg->iov[0].iov_base, sa
->cookies + 8)
   sa->cookies + ISAKMP_HDR_ICOOKIE_LEN)field_get_raw (isakmp_hdr_fld + 1, msg->iov[0].iov_base, sa
->cookies + 8);

/*
* We don't install a transport in the initiator case as we don't know
* what local address will be chosen.  Do it now instead.
*/
sa->transport = msg->transport;
transport_reference(sa->transport);
sa_enter(sa);
940}

942#define ATTRS_SIZE(17 + 1) (IKE_ATTR_BLOCK_SIZE17 + 1)	/* XXX Should be dynamic.  */

944struct attr_validation_state {
u_int8_t       *attrp[ATTRS_SIZE(17 + 1)];
u_int8_t        checked[ATTRS_SIZE(17 + 1)];
u_int16_t	len[ATTRS_SIZE(17 + 1)];
int             phase;	/* IKE (1) or IPSEC (2) attrs? */
int             mode;	/* 0 = 'load', 1 = check */
950};

952/* Validate an attribute. Return 0 on match.  */
953static int
954sa_validate_xf_attrs(u_int16_t type, u_int8_t *value, u_int16_t len,
  void *arg)
956{
int val0, val1;

struct attr_validation_state *avs =
   (struct attr_validation_state *)arg;

LOG_DBG((LOG_SA, 95, "sa_validate_xf_attrs: phase %d mode %d type %d "log_debug (LOG_SA, 95, "sa_validate_xf_attrs: phase %d mode %d type %d "
 "len %d", avs->phase, avs->mode, type, len)
   "len %d", avs->phase, avs->mode, type, len))log_debug (LOG_SA, 95, "sa_validate_xf_attrs: phase %d mode %d type %d "
 "len %d", avs->phase, avs->mode, type, len);

/* Make sure the phase and type are valid.  */
if (avs->phase == 1) {
if (type < IKE_ATTR_ENCRYPTION_ALGORITHM1 ||
    type > IKE_ATTR_BLOCK_SIZE17)
	return 1;
} else if (avs->phase == 2) {
if (type < IPSEC_ATTR_SA_LIFE_TYPE1 ||
    type > IPSEC_ATTR_ECN_TUNNEL10)
	return 1;
} else
return 1;

if (avs->mode == 0) {	/* Load attrs.  */
avs->attrp[type] = value;
avs->len[type] = len;
return 0;
}
/* Checking for a missing attribute is an immediate failure.  */
if (!avs->attrp[type])
return 1;

/* Match the loaded attribute against this one, mark it as checked.  */
avs->checked[type]++;
switch (len) {
case 2:
val0 = (int)decode_16(value);
break;
case 4:
val0 = (int)decode_32(value);
break;
default:
return 1;
}
switch (avs->len[type]) {
case 2:
val1 = (int)decode_16(avs->attrp[type]);
break;
case 4:
val1 = (int)decode_32(avs->attrp[type]);
break;
default:
return 1;
}
/* Return 0 when the values are equal. */
return (val0 != val1);
1010}

1012/*
* This function is used to validate the returned proposal (protection suite)
* we get from the responder against a proposal we sent. Only run as initiator.
* We return 0 if a match is found (in any transform of this proposal), 1
* otherwise. Also see note in sa_add_transform() below.
*/
1018static int
1019sa_validate_proto_xf(struct proto *match, struct payload *xf, int phase)
1020{
struct attr_validation_state *avs;
struct proto_attr *pa;
int             found = 0;
size_t          i;
u_int8_t        xf_id;

if (!match->xf_cnt)
return 0;

if (match->proto != GET_ISAKMP_PROP_PROTO(xf->context->p)field_get_num (isakmp_prop_fld + 1, xf->context->p)) {
LOG_DBG((LOG_SA, 70, "sa_validate_proto_xf: proto %p (#%d) "log_debug (LOG_SA, 70, "sa_validate_proto_xf: proto %p (#%d) "
 "protocol mismatch", match, match->no)
    "protocol mismatch", match, match->no))log_debug (LOG_SA, 70, "sa_validate_proto_xf: proto %p (#%d) "
 "protocol mismatch", match, match->no);
return 1;
}
avs = calloc(1, sizeof *avs);
if (!avs) {
log_error("sa_validate_proto_xf: calloc (1, %lu)",
    (unsigned long)sizeof *avs);
return 1;
}
avs->phase = phase;

/* Load the "proposal candidate" attribute set.  */
(void)attribute_map(xf->p + ISAKMP_TRANSFORM_SA_ATTRS_OFF8,
   GET_ISAKMP_GEN_LENGTH(xf->p)field_get_num (isakmp_gen_fld + 2, xf->p) - ISAKMP_TRANSFORM_SA_ATTRS_OFF8,
   sa_validate_xf_attrs, avs);
xf_id = GET_ISAKMP_TRANSFORM_ID(xf->p)field_get_num (isakmp_transform_fld + 1, xf->p);

/* Check against the transforms we suggested.  */
avs->mode++;
for (pa = TAILQ_FIRST(&match->xfs)((&match->xfs)->tqh_first); pa && !found;
   pa = TAILQ_NEXT(pa, next)((pa)->next.tqe_next)) {
if (xf_id != GET_ISAKMP_TRANSFORM_ID(pa->attrs)field_get_num (isakmp_transform_fld + 1, pa->attrs))
	continue;

bzero(avs->checked, sizeof avs->checked);
if (attribute_map(pa->attrs + ISAKMP_TRANSFORM_SA_ATTRS_OFF8,
    pa->len - ISAKMP_TRANSFORM_SA_ATTRS_OFF8,
    sa_validate_xf_attrs, avs) == 0)
	found++;

LOG_DBG((LOG_SA, 80, "sa_validate_proto_xf: attr_map "log_debug (LOG_SA, 80, "sa_validate_proto_xf: attr_map " "xf %p proto %p pa %p found %d"
, xf, match, pa, found)
    "xf %p proto %p pa %p found %d", xf, match, pa, found))log_debug (LOG_SA, 80, "sa_validate_proto_xf: attr_map " "xf %p proto %p pa %p found %d"
, xf, match, pa, found);

if (!found)
	continue;

/*
 * Require all attributes present and checked.  XXX perhaps
 * not?
 */
for (i = 0; i < sizeof avs->checked; i++)
	if (avs->attrp[i] && !avs->checked[i])
		found = 0;

LOG_DBG((LOG_SA, 80, "sa_validate_proto_xf: req_attr "log_debug (LOG_SA, 80, "sa_validate_proto_xf: req_attr " "xf %p proto %p pa %p found %d"
, xf, match, pa, found)
    "xf %p proto %p pa %p found %d", xf, match, pa, found))log_debug (LOG_SA, 80, "sa_validate_proto_xf: req_attr " "xf %p proto %p pa %p found %d"
, xf, match, pa, found);
}
free(avs);
return found ? 0 : 1;
1081}

1083/*
* Register the chosen transform XF into SA.  As a side effect set PROTOP
* to point at the corresponding proto structure.  INITIATOR is true if we
* are the initiator.
*/
1088int
1089sa_add_transform(struct sa *sa, struct payload *xf, int initiator,
  struct proto **protop)
1091{
struct proto   *proto;
struct payload *prop = xf->context;

*protop = 0;
if (!initiator) {
proto = calloc(1, sizeof *proto);
if (!proto)
	log_error("sa_add_transform: calloc (1, %lu) failed",
	    (unsigned long)sizeof *proto);
} else {
/*
 * RFC 2408, section 4.2 states the responder SHOULD use the
 * proposal number from the initiator (i.e us), in it's
 * selected proposal to make this lookup easier. Most vendors
 * follow this. One noted exception is the CiscoPIX (and
 * perhaps other Cisco products).
 *
 * We start by matching on the proposal number, as before.
 */
for (proto = TAILQ_FIRST(&sa->protos)((&sa->protos)->tqh_first);
    proto && proto->no != GET_ISAKMP_PROP_NO(prop->p)field_get_num (isakmp_prop_fld + 0, prop->p);
    proto = TAILQ_NEXT(proto, link)((proto)->link.tqe_next))
	;
/*
 * If we did not find a match, search through all proposals
 * and xforms.
 */
if (!proto || sa_validate_proto_xf(proto, xf, sa->phase) != 0)
	for (proto = TAILQ_FIRST(&sa->protos)((&sa->protos)->tqh_first);
	    proto && sa_validate_proto_xf(proto, xf, sa->phase) != 0;
	    proto = TAILQ_NEXT(proto, link)((proto)->link.tqe_next))
		;
}
if (!proto)
return -1;
*protop = proto;

/* Allocate DOI-specific part.  */
if (!initiator) {
proto->data = calloc(1, sa->doi->proto_size);
if (!proto->data) {
	log_error("sa_add_transform: calloc (1, %lu) failed",
	    (unsigned long)sa->doi->proto_size);
	goto cleanup;
}
}
proto->no = GET_ISAKMP_PROP_NO(prop->p)field_get_num (isakmp_prop_fld + 0, prop->p);
proto->proto = GET_ISAKMP_PROP_PROTO(prop->p)field_get_num (isakmp_prop_fld + 1, prop->p);
proto->spi_sz[0] = GET_ISAKMP_PROP_SPI_SZ(prop->p)field_get_num (isakmp_prop_fld + 2, prop->p);
if (proto->spi_sz[0]) {
proto->spi[0] = malloc(proto->spi_sz[0]);
if (!proto->spi[0])
	goto cleanup;
memcpy(proto->spi[0], prop->p + ISAKMP_PROP_SPI_OFF8,
    proto->spi_sz[0]);
}
proto->chosen = xf;
proto->sa = sa;
proto->id = GET_ISAKMP_TRANSFORM_ID(xf->p)field_get_num (isakmp_transform_fld + 1, xf->p);
if (!initiator)
TAILQ_INSERT_TAIL(&sa->protos, proto, link)do { (proto)->link.tqe_next = ((void *)0); (proto)->link
.tqe_prev = (&sa->protos)->tqh_last; *(&sa->
protos)->tqh_last = (proto); (&sa->protos)->tqh_last
 = &(proto)->link.tqe_next; } while (0);

/* Let the DOI get at proto for initializing its own data.  */
if (sa->doi->proto_init)
sa->doi->proto_init(proto, 0);

LOG_DBG((LOG_SA, 80,log_debug (LOG_SA, 80, "sa_add_transform: " "proto %p no %d proto %d chosen %p sa %p id %d"
, proto, proto->no, proto->proto, proto->chosen, proto
->sa, proto->id)
   "sa_add_transform: "log_debug (LOG_SA, 80, "sa_add_transform: " "proto %p no %d proto %d chosen %p sa %p id %d"
, proto, proto->no, proto->proto, proto->chosen, proto
->sa, proto->id)
   "proto %p no %d proto %d chosen %p sa %p id %d",log_debug (LOG_SA, 80, "sa_add_transform: " "proto %p no %d proto %d chosen %p sa %p id %d"
, proto, proto->no, proto->proto, proto->chosen, proto
->sa, proto->id)
   proto, proto->no, proto->proto, proto->chosen, proto->sa,log_debug (LOG_SA, 80, "sa_add_transform: " "proto %p no %d proto %d chosen %p sa %p id %d"
, proto, proto->no, proto->proto, proto->chosen, proto
->sa, proto->id)
   proto->id))log_debug (LOG_SA, 80, "sa_add_transform: " "proto %p no %d proto %d chosen %p sa %p id %d"
, proto, proto->no, proto->proto, proto->chosen, proto
->sa, proto->id);

return 0;

1166cleanup:
if (!initiator) {
free(proto->data);
free(proto);
}
*protop = 0;
return -1;
1173}

1175/* Delete an SA.  Tell the peer if NOTIFY is set.  */
1176void
1177sa_delete(struct sa *sa, int notify)
1178{
if (notify)
message_send_delete(sa);
sa_free(sa);
1182}


1185/* Teardown all SAs.  */
1186void
1187sa_teardown_all(void)
1188{
int             i;
struct sa      *sa, *next = 0;

LOG_DBG((LOG_SA, 70, "sa_teardown_all:"))log_debug (LOG_SA, 70, "sa_teardown_all:");
/* Get Phase 2 SAs.  */
for (i = 0; i <= bucket_mask; i++)
for (sa = LIST_FIRST(&sa_tab[i])((&sa_tab[i])->lh_first); sa; sa = next) {
	next = LIST_NEXT(sa, link)((sa)->link.le_next);
	if (sa->phase == 2) {
		/*
		 * Teardown the phase 2 SAs by name, similar
		 * to ui_teardown.
		 */
		LOG_DBG((LOG_SA, 70,log_debug (LOG_SA, 70, "sa_teardown_all: tearing down SA %s",
 sa->name ? sa->name : "<unnamed>")
		    "sa_teardown_all: tearing down SA %s",log_debug (LOG_SA, 70, "sa_teardown_all: tearing down SA %s",
 sa->name ? sa->name : "<unnamed>")
		    sa->name ? sa->name : "<unnamed>"))log_debug (LOG_SA, 70, "sa_teardown_all: tearing down SA %s",
 sa->name ? sa->name : "<unnamed>");
		if (sa->name)
			connection_teardown(sa->name);
		sa_delete(sa, 1);
	}
}
1210}

1212/*
* This function will get called when we are closing in on the death time of SA
*/
1215static void
1216sa_soft_expire(void *v_sa)
1217{
struct sa      *sa = v_sa;

sa->soft_death = 0;
sa_release(sa);

if ((sa->flags & (SA_FLAG_STAYALIVE0x02 | SA_FLAG_REPLACED0x08)) ==
   SA_FLAG_STAYALIVE0x02)
exchange_establish(sa->name, 0, 0, 1);
else
/*
 * Start to watch the use of this SA, so a renegotiation can
 * happen as soon as it is shown to be alive.
 */
sa->flags |= SA_FLAG_FADING0x10;
1232}

1234/* SA has passed its best before date.  */
1235static void
1236sa_hard_expire(void *v_sa)
1237{
struct sa      *sa = v_sa;

sa->death = 0;
sa_release(sa);

if ((sa->flags & (SA_FLAG_STAYALIVE0x02 | SA_FLAG_REPLACED0x08)) ==
   SA_FLAG_STAYALIVE0x02)
exchange_establish(sa->name, 0, 0, 1);

sa_delete(sa, 1);
1248}

1250void
1251sa_reinit(void)
1252{
struct sa      *sa;
char           *tag;
int             i;

/* For now; only do this if we have the proper tag configured.  */
tag = conf_get_str("General", "Renegotiate-on-HUP");
if (!tag)
return;

LOG_DBG((LOG_SA, 30, "sa_reinit: renegotiating active connections"))log_debug (LOG_SA, 30, "sa_reinit: renegotiating active connections"
);

/*
* Get phase 2 SAs. Soft expire those without active exchanges.  Do
* not touch a phase 2 SA where the soft expiration is not set, ie.
* the SA is not yet established.
*/
for (i = 0; i <= bucket_mask; i++)
for (sa = LIST_FIRST(&sa_tab[i])((&sa_tab[i])->lh_first); sa; sa = LIST_NEXT(sa, link)((sa)->link.le_next))
	if (sa->phase == 2)
		if (exchange_lookup_by_name(sa->name,
		    sa->phase) == 0 && sa->soft_death) {
			timer_remove_event(sa->soft_death);
			sa_soft_expire(sa);
		}
1277}

1279/*
* Get an SA attribute's flag value out of textual description.
*/
1282int
1283sa_flag(char *attr)
1284{
static struct sa_flag_map {
char           *name;
int             flag;
} sa_flag_map[] = {
{
	"active-only", SA_FLAG_ACTIVE_ONLY0x20
},

/*
 * Below this point are flags that are internal to the
 * implementation.
 */
{
	"__ondemand", SA_FLAG_ONDEMAND0x04
},
{
	"ikecfg", SA_FLAG_IKECFG0x40
},
};
size_t	i;

for (i = 0; i < sizeof sa_flag_map / sizeof sa_flag_map[0]; i++)
if (strcasecmp(attr, sa_flag_map[i].name) == 0)
	return sa_flag_map[i].flag;
log_print("sa_flag: attribute \"%s\" unknown", attr);
return 0;
1311}

1313/* Mark SA as replaced.  */
1314void
1315sa_mark_replaced(struct sa *sa)
1316{
LOG_DBG((LOG_SA, 60, "sa_mark_replaced: SA %p (%s) marked as replaced",log_debug (LOG_SA, 60, "sa_mark_replaced: SA %p (%s) marked as replaced"
, sa, sa->name ? sa->name : "unnamed")
   sa, sa->name ? sa->name : "unnamed"))log_debug (LOG_SA, 60, "sa_mark_replaced: SA %p (%s) marked as replaced"
, sa, sa->name ? sa->name : "unnamed");
if (sa->dpd_event) {
timer_remove_event(sa->dpd_event);
sa->dpd_event = 0;
}
sa->flags |= SA_FLAG_REPLACED0x08;
1324}

1326/* Replace SA */
1327void
1328sa_replace(struct sa *sa, struct sa *new_sa)
1329{
LOG_DBG((LOG_SA, 60, "sa_replace: SA %p (%s) is replaced by SA %p (%s)",log_debug (LOG_SA, 60, "sa_replace: SA %p (%s) is replaced by SA %p (%s)"
, sa, sa->name ? sa->name : "unnamed", new_sa, new_sa->
name ? new_sa->name : "unnamed")
   sa, sa->name ? sa->name : "unnamed",log_debug (LOG_SA, 60, "sa_replace: SA %p (%s) is replaced by SA %p (%s)"
, sa, sa->name ? sa->name : "unnamed", new_sa, new_sa->
name ? new_sa->name : "unnamed")
   new_sa, new_sa->name ? new_sa->name : "unnamed"))log_debug (LOG_SA, 60, "sa_replace: SA %p (%s) is replaced by SA %p (%s)"
, sa, sa->name ? sa->name : "unnamed", new_sa, new_sa->
name ? new_sa->name : "unnamed");
sa_mark_replaced(sa);
if (new_sa->flags & SA_FLAG_REPLACED0x08) {
/* enable the dpd */
if ((new_sa->flags & SA_FLAG_DPD0x80) == SA_FLAG_DPD0x80)
	dpd_start(new_sa);
new_sa->flags &= ~SA_FLAG_REPLACED0x08;
}
1340}

1342/*
* Setup expiration timers for SA.  This is used for ISAKMP SAs, but also
* possible to use for application SAs if the application does not deal
* with expirations itself.  An example is the Linux FreeS/WAN KLIPS IPsec
* stack.
*/
1348int
1349sa_setup_expirations(struct sa *sa)
1350{
struct timespec expiration;
u_int64_t       seconds = sa->seconds;

/*
* Set the soft timeout to a random percentage between 85 & 95 of
* the negotiated lifetime to break strictly synchronized
* renegotiations.  This works better when the randomization is on the
* order of processing plus network-roundtrip times, or larger.
* I.e. it depends on configuration and negotiated lifetimes.
* It is not good to do the decrease on the hard timeout, because then
* we may drop our SA before our peer.
* XXX Better scheme to come?
*/
if (!sa->soft_death) {
clock_gettime(CLOCK_MONOTONIC3, &expiration);
/*
 * XXX This should probably be configuration controlled
 * somehow.
 */
seconds = sa->seconds * (850 + arc4random_uniform(100)) / 1000;
LOG_DBG((LOG_TIMER, 95,log_debug (LOG_TIMER, 95, "sa_setup_expirations: SA %p soft timeout in %llu seconds"
, sa, seconds)
    "sa_setup_expirations: SA %p soft timeout in %llu seconds",log_debug (LOG_TIMER, 95, "sa_setup_expirations: SA %p soft timeout in %llu seconds"
, sa, seconds)
    sa, seconds))log_debug (LOG_TIMER, 95, "sa_setup_expirations: SA %p soft timeout in %llu seconds"
, sa, seconds);
expiration.tv_sec += seconds;
sa->soft_death = timer_add_event("sa_soft_expire",
    sa_soft_expire, sa, &expiration);
if (!sa->soft_death) {
	/* If we don't give up we might start leaking...  */
	sa_delete(sa, 1);
	return -1;
}
sa_reference(sa);
}
if (!sa->death) {
clock_gettime(CLOCK_MONOTONIC3, &expiration);
LOG_DBG((LOG_TIMER, 95,log_debug (LOG_TIMER, 95, "sa_setup_expirations: SA %p hard timeout in %llu seconds"
, sa, sa->seconds)
    "sa_setup_expirations: SA %p hard timeout in %llu seconds",log_debug (LOG_TIMER, 95, "sa_setup_expirations: SA %p hard timeout in %llu seconds"
, sa, sa->seconds)
    sa, sa->seconds))log_debug (LOG_TIMER, 95, "sa_setup_expirations: SA %p hard timeout in %llu seconds"
, sa, sa->seconds);
expiration.tv_sec += sa->seconds;
sa->death = timer_add_event("sa_hard_expire", sa_hard_expire,
    sa, &expiration);
if (!sa->death) {
	/* If we don't give up we might start leaking...  */
	sa_delete(sa, 1);
	return -1;
}
sa_reference(sa);
}
return 0;
1400}