sys/netipsec/key.c

   1 /*      $FreeBSD$       */
   2 /*      $KAME: key.c,v 1.191 2001/06/27 10:46:49 sakane Exp $   */
   3
   4 /*-
   5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the project nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * This code is referd to RFC 2367
  35  */
  36
  37 #include "opt_inet.h"
  38 #include "opt_inet6.h"
  39 #include "opt_ipsec.h"
  40
  41 #include <sys/types.h>
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/kernel.h>
  45 #include <sys/lock.h>
  46 #include <sys/mutex.h>
  47 #include <sys/mbuf.h>
  48 #include <sys/domain.h>
  49 #include <sys/protosw.h>
  50 #include <sys/malloc.h>
  51 #include <sys/socket.h>
  52 #include <sys/socketvar.h>
  53 #include <sys/sysctl.h>
  54 #include <sys/errno.h>
  55 #include <sys/proc.h>
  56 #include <sys/queue.h>
  57 #include <sys/refcount.h>
  58 #include <sys/syslog.h>
  59
  60 #include <net/if.h>
  61 #include <net/if_var.h>
  62 #include <net/route.h>
  63 #include <net/vnet.h>
  64 #include <net/raw_cb.h>
  65
  66 #include <netinet/in.h>
  67 #include <netinet/in_systm.h>
  68 #include <netinet/ip.h>
  69 #include <netinet/in_var.h>
  70
  71 #ifdef INET6
  72 #include <netinet/ip6.h>
  73 #include <netinet6/in6_var.h>
  74 #include <netinet6/ip6_var.h>
  75 #endif /* INET6 */
  76
  77 #if defined(INET) || defined(INET6)
  78 #include <netinet/in_pcb.h>
  79 #endif
  80 #ifdef INET6
  81 #include <netinet6/in6_pcb.h>
  82 #endif /* INET6 */
  83
  84 #include <net/pfkeyv2.h>
  85 #include <netipsec/keydb.h>
  86 #include <netipsec/key.h>
  87 #include <netipsec/keysock.h>
  88 #include <netipsec/key_debug.h>
  89
  90 #include <netipsec/ipsec.h>
  91 #ifdef INET6
  92 #include <netipsec/ipsec6.h>
  93 #endif
  94
  95 #include <netipsec/xform.h>
  96
  97 #include <machine/stdarg.h>
  98
  99 /* randomness */
 100 #include <sys/random.h>
 101
 102 #define FULLMASK        0xff
 103 #define _BITS(bytes)    ((bytes) << 3)
 104
 105 /*
 106  * Note on SA reference counting:
 107  * - SAs that are not in DEAD state will have (total external reference + 1)
 108  *   following value in reference count field.  they cannot be freed and are
 109  *   referenced from SA header.
 110  * - SAs that are in DEAD state will have (total external reference)
 111  *   in reference count field.  they are ready to be freed.  reference from
 112  *   SA header will be removed in key_delsav(), when the reference count
 113  *   field hits 0 (= no external reference other than from SA header.
 114  */
 115
 116 VNET_DEFINE(u_int32_t, key_debug_level) = 0;
 117 static VNET_DEFINE(u_int, key_spi_trycnt) = 1000;
 118 static VNET_DEFINE(u_int32_t, key_spi_minval) = 0x100;
 119 static VNET_DEFINE(u_int32_t, key_spi_maxval) = 0x0fffffff;     /* XXX */
 120 static VNET_DEFINE(u_int32_t, policy_id) = 0;
 121 /*interval to initialize randseed,1(m)*/
 122 static VNET_DEFINE(u_int, key_int_random) = 60;
 123 /* interval to expire acquiring, 30(s)*/
 124 static VNET_DEFINE(u_int, key_larval_lifetime) = 30;
 125 /* counter for blocking SADB_ACQUIRE.*/
 126 static VNET_DEFINE(int, key_blockacq_count) = 10;
 127 /* lifetime for blocking SADB_ACQUIRE.*/
 128 static VNET_DEFINE(int, key_blockacq_lifetime) = 20;
 129 /* preferred old sa rather than new sa.*/
 130 static VNET_DEFINE(int, key_preferred_oldsa) = 1;
 131 #define V_key_spi_trycnt        VNET(key_spi_trycnt)
 132 #define V_key_spi_minval        VNET(key_spi_minval)
 133 #define V_key_spi_maxval        VNET(key_spi_maxval)
 134 #define V_policy_id             VNET(policy_id)
 135 #define V_key_int_random        VNET(key_int_random)
 136 #define V_key_larval_lifetime   VNET(key_larval_lifetime)
 137 #define V_key_blockacq_count    VNET(key_blockacq_count)
 138 #define V_key_blockacq_lifetime VNET(key_blockacq_lifetime)
 139 #define V_key_preferred_oldsa   VNET(key_preferred_oldsa)
 140
 141 static VNET_DEFINE(u_int32_t, acq_seq) = 0;
 142 #define V_acq_seq               VNET(acq_seq)
 143
 144                                                                 /* SPD */
 145 static VNET_DEFINE(LIST_HEAD(_sptree, secpolicy), sptree[IPSEC_DIR_MAX]);
 146 #define V_sptree                VNET(sptree)
 147 static struct mtx sptree_lock;
 148 #define SPTREE_LOCK_INIT() \
 149         mtx_init(&sptree_lock, "sptree", \
 150                 "fast ipsec security policy database", MTX_DEF)
 151 #define SPTREE_LOCK_DESTROY()   mtx_destroy(&sptree_lock)
 152 #define SPTREE_LOCK()           mtx_lock(&sptree_lock)
 153 #define SPTREE_UNLOCK() mtx_unlock(&sptree_lock)
 154 #define SPTREE_LOCK_ASSERT()    mtx_assert(&sptree_lock, MA_OWNED)
 155
 156 static VNET_DEFINE(LIST_HEAD(_sahtree, secashead), sahtree);    /* SAD */
 157 #define V_sahtree               VNET(sahtree)
 158 static struct mtx sahtree_lock;
 159 #define SAHTREE_LOCK_INIT() \
 160         mtx_init(&sahtree_lock, "sahtree", \
 161                 "fast ipsec security association database", MTX_DEF)
 162 #define SAHTREE_LOCK_DESTROY()  mtx_destroy(&sahtree_lock)
 163 #define SAHTREE_LOCK()          mtx_lock(&sahtree_lock)
 164 #define SAHTREE_UNLOCK()        mtx_unlock(&sahtree_lock)
 165 #define SAHTREE_LOCK_ASSERT()   mtx_assert(&sahtree_lock, MA_OWNED)
 166
 167                                                         /* registed list */
 168 static VNET_DEFINE(LIST_HEAD(_regtree, secreg), regtree[SADB_SATYPE_MAX + 1]);
 169 #define V_regtree               VNET(regtree)
 170 static struct mtx regtree_lock;
 171 #define REGTREE_LOCK_INIT() \
 172         mtx_init(&regtree_lock, "regtree", "fast ipsec regtree", MTX_DEF)
 173 #define REGTREE_LOCK_DESTROY()  mtx_destroy(&regtree_lock)
 174 #define REGTREE_LOCK()          mtx_lock(&regtree_lock)
 175 #define REGTREE_UNLOCK()        mtx_unlock(&regtree_lock)
 176 #define REGTREE_LOCK_ASSERT()   mtx_assert(&regtree_lock, MA_OWNED)
 177
 178 static VNET_DEFINE(LIST_HEAD(_acqtree, secacq), acqtree); /* acquiring list */
 179 #define V_acqtree               VNET(acqtree)
 180 static struct mtx acq_lock;
 181 #define ACQ_LOCK_INIT() \
 182         mtx_init(&acq_lock, "acqtree", "fast ipsec acquire list", MTX_DEF)
 183 #define ACQ_LOCK_DESTROY()      mtx_destroy(&acq_lock)
 184 #define ACQ_LOCK()              mtx_lock(&acq_lock)
 185 #define ACQ_UNLOCK()            mtx_unlock(&acq_lock)
 186 #define ACQ_LOCK_ASSERT()       mtx_assert(&acq_lock, MA_OWNED)
 187
 188                                                         /* SP acquiring list */
 189 static VNET_DEFINE(LIST_HEAD(_spacqtree, secspacq), spacqtree);
 190 #define V_spacqtree             VNET(spacqtree)
 191 static struct mtx spacq_lock;
 192 #define SPACQ_LOCK_INIT() \
 193         mtx_init(&spacq_lock, "spacqtree", \
 194                 "fast ipsec security policy acquire list", MTX_DEF)
 195 #define SPACQ_LOCK_DESTROY()    mtx_destroy(&spacq_lock)
 196 #define SPACQ_LOCK()            mtx_lock(&spacq_lock)
 197 #define SPACQ_UNLOCK()          mtx_unlock(&spacq_lock)
 198 #define SPACQ_LOCK_ASSERT()     mtx_assert(&spacq_lock, MA_OWNED)
 199
 200 /* search order for SAs */
 201 static const u_int saorder_state_valid_prefer_old[] = {
 202         SADB_SASTATE_DYING, SADB_SASTATE_MATURE,
 203 };
 204 static const u_int saorder_state_valid_prefer_new[] = {
 205         SADB_SASTATE_MATURE, SADB_SASTATE_DYING,
 206 };
 207 static const u_int saorder_state_alive[] = {
 208         /* except DEAD */
 209         SADB_SASTATE_MATURE, SADB_SASTATE_DYING, SADB_SASTATE_LARVAL
 210 };
 211 static const u_int saorder_state_any[] = {
 212         SADB_SASTATE_MATURE, SADB_SASTATE_DYING,
 213         SADB_SASTATE_LARVAL, SADB_SASTATE_DEAD
 214 };
 215
 216 static const int minsize[] = {
 217         sizeof(struct sadb_msg),        /* SADB_EXT_RESERVED */
 218         sizeof(struct sadb_sa),         /* SADB_EXT_SA */
 219         sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_CURRENT */
 220         sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_HARD */
 221         sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_SOFT */
 222         sizeof(struct sadb_address),    /* SADB_EXT_ADDRESS_SRC */
 223         sizeof(struct sadb_address),    /* SADB_EXT_ADDRESS_DST */
 224         sizeof(struct sadb_address),    /* SADB_EXT_ADDRESS_PROXY */
 225         sizeof(struct sadb_key),        /* SADB_EXT_KEY_AUTH */
 226         sizeof(struct sadb_key),        /* SADB_EXT_KEY_ENCRYPT */
 227         sizeof(struct sadb_ident),      /* SADB_EXT_IDENTITY_SRC */
 228         sizeof(struct sadb_ident),      /* SADB_EXT_IDENTITY_DST */
 229         sizeof(struct sadb_sens),       /* SADB_EXT_SENSITIVITY */
 230         sizeof(struct sadb_prop),       /* SADB_EXT_PROPOSAL */
 231         sizeof(struct sadb_supported),  /* SADB_EXT_SUPPORTED_AUTH */
 232         sizeof(struct sadb_supported),  /* SADB_EXT_SUPPORTED_ENCRYPT */
 233         sizeof(struct sadb_spirange),   /* SADB_EXT_SPIRANGE */
 234         0,                              /* SADB_X_EXT_KMPRIVATE */
 235         sizeof(struct sadb_x_policy),   /* SADB_X_EXT_POLICY */
 236         sizeof(struct sadb_x_sa2),      /* SADB_X_SA2 */
 237         sizeof(struct sadb_x_nat_t_type),/* SADB_X_EXT_NAT_T_TYPE */
 238         sizeof(struct sadb_x_nat_t_port),/* SADB_X_EXT_NAT_T_SPORT */
 239         sizeof(struct sadb_x_nat_t_port),/* SADB_X_EXT_NAT_T_DPORT */
 240         sizeof(struct sadb_address),    /* SADB_X_EXT_NAT_T_OAI */
 241         sizeof(struct sadb_address),    /* SADB_X_EXT_NAT_T_OAR */
 242         sizeof(struct sadb_x_nat_t_frag),/* SADB_X_EXT_NAT_T_FRAG */
 243 };
 244 static const int maxsize[] = {
 245         sizeof(struct sadb_msg),        /* SADB_EXT_RESERVED */
 246         sizeof(struct sadb_sa),         /* SADB_EXT_SA */
 247         sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_CURRENT */
 248         sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_HARD */
 249         sizeof(struct sadb_lifetime),   /* SADB_EXT_LIFETIME_SOFT */
 250         0,                              /* SADB_EXT_ADDRESS_SRC */
 251         0,                              /* SADB_EXT_ADDRESS_DST */
 252         0,                              /* SADB_EXT_ADDRESS_PROXY */
 253         0,                              /* SADB_EXT_KEY_AUTH */
 254         0,                              /* SADB_EXT_KEY_ENCRYPT */
 255         0,                              /* SADB_EXT_IDENTITY_SRC */
 256         0,                              /* SADB_EXT_IDENTITY_DST */
 257         0,                              /* SADB_EXT_SENSITIVITY */
 258         0,                              /* SADB_EXT_PROPOSAL */
 259         0,                              /* SADB_EXT_SUPPORTED_AUTH */
 260         0,                              /* SADB_EXT_SUPPORTED_ENCRYPT */
 261         sizeof(struct sadb_spirange),   /* SADB_EXT_SPIRANGE */
 262         0,                              /* SADB_X_EXT_KMPRIVATE */
 263         0,                              /* SADB_X_EXT_POLICY */
 264         sizeof(struct sadb_x_sa2),      /* SADB_X_SA2 */
 265         sizeof(struct sadb_x_nat_t_type),/* SADB_X_EXT_NAT_T_TYPE */
 266         sizeof(struct sadb_x_nat_t_port),/* SADB_X_EXT_NAT_T_SPORT */
 267         sizeof(struct sadb_x_nat_t_port),/* SADB_X_EXT_NAT_T_DPORT */
 268         0,                              /* SADB_X_EXT_NAT_T_OAI */
 269         0,                              /* SADB_X_EXT_NAT_T_OAR */
 270         sizeof(struct sadb_x_nat_t_frag),/* SADB_X_EXT_NAT_T_FRAG */
 271 };
 272
 273 static VNET_DEFINE(int, ipsec_esp_keymin) = 256;
 274 static VNET_DEFINE(int, ipsec_esp_auth) = 0;
 275 static VNET_DEFINE(int, ipsec_ah_keymin) = 128;
 276
 277 #define V_ipsec_esp_keymin      VNET(ipsec_esp_keymin)
 278 #define V_ipsec_esp_auth        VNET(ipsec_esp_auth)
 279 #define V_ipsec_ah_keymin       VNET(ipsec_ah_keymin)
 280
 281 #ifdef SYSCTL_DECL
 282 SYSCTL_DECL(_net_key);
 283 #endif
 284
 285 SYSCTL_VNET_INT(_net_key, KEYCTL_DEBUG_LEVEL,   debug,
 286         CTLFLAG_RW, &VNET_NAME(key_debug_level),        0,      "");
 287
 288 /* max count of trial for the decision of spi value */
 289 SYSCTL_VNET_INT(_net_key, KEYCTL_SPI_TRY, spi_trycnt,
 290         CTLFLAG_RW, &VNET_NAME(key_spi_trycnt), 0,      "");
 291
 292 /* minimum spi value to allocate automatically. */
 293 SYSCTL_VNET_INT(_net_key, KEYCTL_SPI_MIN_VALUE,
 294         spi_minval,     CTLFLAG_RW, &VNET_NAME(key_spi_minval), 0,      "");
 295
 296 /* maximun spi value to allocate automatically. */
 297 SYSCTL_VNET_INT(_net_key, KEYCTL_SPI_MAX_VALUE,
 298         spi_maxval,     CTLFLAG_RW, &VNET_NAME(key_spi_maxval), 0,      "");
 299
 300 /* interval to initialize randseed */
 301 SYSCTL_VNET_INT(_net_key, KEYCTL_RANDOM_INT,
 302         int_random,     CTLFLAG_RW, &VNET_NAME(key_int_random), 0,      "");
 303
 304 /* lifetime for larval SA */
 305 SYSCTL_VNET_INT(_net_key, KEYCTL_LARVAL_LIFETIME,
 306         larval_lifetime, CTLFLAG_RW, &VNET_NAME(key_larval_lifetime),   0, "");
 307
 308 /* counter for blocking to send SADB_ACQUIRE to IKEd */
 309 SYSCTL_VNET_INT(_net_key, KEYCTL_BLOCKACQ_COUNT,
 310         blockacq_count, CTLFLAG_RW, &VNET_NAME(key_blockacq_count),     0, "");
 311
 312 /* lifetime for blocking to send SADB_ACQUIRE to IKEd */
 313 SYSCTL_VNET_INT(_net_key, KEYCTL_BLOCKACQ_LIFETIME,
 314         blockacq_lifetime, CTLFLAG_RW, &VNET_NAME(key_blockacq_lifetime), 0, "");
 315
 316 /* ESP auth */
 317 SYSCTL_VNET_INT(_net_key, KEYCTL_ESP_AUTH,      esp_auth,
 318         CTLFLAG_RW, &VNET_NAME(ipsec_esp_auth), 0,      "");
 319
 320 /* minimum ESP key length */
 321 SYSCTL_VNET_INT(_net_key, KEYCTL_ESP_KEYMIN,
 322         esp_keymin, CTLFLAG_RW, &VNET_NAME(ipsec_esp_keymin),   0,      "");
 323
 324 /* minimum AH key length */
 325 SYSCTL_VNET_INT(_net_key, KEYCTL_AH_KEYMIN,     ah_keymin,
 326         CTLFLAG_RW, &VNET_NAME(ipsec_ah_keymin),        0,      "");
 327
 328 /* perfered old SA rather than new SA */
 329 SYSCTL_VNET_INT(_net_key, KEYCTL_PREFERED_OLDSA,
 330         preferred_oldsa, CTLFLAG_RW, &VNET_NAME(key_preferred_oldsa),   0, "");
 331
 332 #define __LIST_CHAINED(elm) \
 333         (!((elm)->chain.le_next == NULL && (elm)->chain.le_prev == NULL))
 334 #define LIST_INSERT_TAIL(head, elm, type, field) \
 335 do {\
 336         struct type *curelm = LIST_FIRST(head); \
 337         if (curelm == NULL) {\
 338                 LIST_INSERT_HEAD(head, elm, field); \
 339         } else { \
 340                 while (LIST_NEXT(curelm, field)) \
 341                         curelm = LIST_NEXT(curelm, field);\
 342                 LIST_INSERT_AFTER(curelm, elm, field);\
 343         }\
 344 } while (0)
 345
 346 #define KEY_CHKSASTATE(head, sav, name) \
 347 do { \
 348         if ((head) != (sav)) {                                          \
 349                 ipseclog((LOG_DEBUG, "%s: state mismatched (TREE=%d SA=%d)\n", \
 350                         (name), (head), (sav)));                        \
 351                 continue;                                               \
 352         }                                                               \
 353 } while (0)
 354
 355 #define KEY_CHKSPDIR(head, sp, name) \
 356 do { \
 357         if ((head) != (sp)) {                                           \
 358                 ipseclog((LOG_DEBUG, "%s: direction mismatched (TREE=%d SP=%d), " \
 359                         "anyway continue.\n",                           \
 360                         (name), (head), (sp)));                         \
 361         }                                                               \
 362 } while (0)
 363
 364 MALLOC_DEFINE(M_IPSEC_SA, "secasvar", "ipsec security association");
 365 MALLOC_DEFINE(M_IPSEC_SAH, "sahead", "ipsec sa head");
 366 MALLOC_DEFINE(M_IPSEC_SP, "ipsecpolicy", "ipsec security policy");
 367 MALLOC_DEFINE(M_IPSEC_SR, "ipsecrequest", "ipsec security request");
 368 MALLOC_DEFINE(M_IPSEC_MISC, "ipsec-misc", "ipsec miscellaneous");
 369 MALLOC_DEFINE(M_IPSEC_SAQ, "ipsec-saq", "ipsec sa acquire");
 370 MALLOC_DEFINE(M_IPSEC_SAR, "ipsec-reg", "ipsec sa acquire");
 371
 372 /*
 373  * set parameters into secpolicyindex buffer.
 374  * Must allocate secpolicyindex buffer passed to this function.
 375  */
 376 #define KEY_SETSECSPIDX(_dir, s, d, ps, pd, ulp, idx) \
 377 do { \
 378         bzero((idx), sizeof(struct secpolicyindex));                         \
 379         (idx)->dir = (_dir);                                                 \
 380         (idx)->prefs = (ps);                                                 \
 381         (idx)->prefd = (pd);                                                 \
 382         (idx)->ul_proto = (ulp);                                             \
 383         bcopy((s), &(idx)->src, ((const struct sockaddr *)(s))->sa_len);     \
 384         bcopy((d), &(idx)->dst, ((const struct sockaddr *)(d))->sa_len);     \
 385 } while (0)
 386
 387 /*
 388  * set parameters into secasindex buffer.
 389  * Must allocate secasindex buffer before calling this function.
 390  */
 391 #define KEY_SETSECASIDX(p, m, r, s, d, idx) \
 392 do { \
 393         bzero((idx), sizeof(struct secasindex));                             \
 394         (idx)->proto = (p);                                                  \
 395         (idx)->mode = (m);                                                   \
 396         (idx)->reqid = (r);                                                  \
 397         bcopy((s), &(idx)->src, ((const struct sockaddr *)(s))->sa_len);     \
 398         bcopy((d), &(idx)->dst, ((const struct sockaddr *)(d))->sa_len);     \
 399 } while (0)
 400
 401 /* key statistics */
 402 struct _keystat {
 403         u_long getspi_count; /* the avarage of count to try to get new SPI */
 404 } keystat;
 405
 406 struct sadb_msghdr {
 407         struct sadb_msg *msg;
 408         struct sadb_ext *ext[SADB_EXT_MAX + 1];
 409         int extoff[SADB_EXT_MAX + 1];
 410         int extlen[SADB_EXT_MAX + 1];
 411 };
 412
 413 #ifndef IPSEC_DEBUG2
 414 static struct callout key_timer;
 415 #endif
 416
 417 static struct secasvar *key_allocsa_policy __P((const struct secasindex *));
 418 static void key_freesp_so __P((struct secpolicy **));
 419 static struct secasvar *key_do_allocsa_policy __P((struct secashead *, u_int));
 420 static void key_delsp __P((struct secpolicy *));
 421 static struct secpolicy *key_getsp __P((struct secpolicyindex *));
 422 static void _key_delsp(struct secpolicy *sp);
 423 static struct secpolicy *key_getspbyid __P((u_int32_t));
 424 static u_int32_t key_newreqid __P((void));
 425 static struct mbuf *key_gather_mbuf __P((struct mbuf *,
 426         const struct sadb_msghdr *, int, int, ...));
 427 static int key_spdadd __P((struct socket *, struct mbuf *,
 428         const struct sadb_msghdr *));
 429 static u_int32_t key_getnewspid __P((void));
 430 static int key_spddelete __P((struct socket *, struct mbuf *,
 431         const struct sadb_msghdr *));
 432 static int key_spddelete2 __P((struct socket *, struct mbuf *,
 433         const struct sadb_msghdr *));
 434 static int key_spdget __P((struct socket *, struct mbuf *,
 435         const struct sadb_msghdr *));
 436 static int key_spdflush __P((struct socket *, struct mbuf *,
 437         const struct sadb_msghdr *));
 438 static int key_spddump __P((struct socket *, struct mbuf *,
 439         const struct sadb_msghdr *));
 440 static struct mbuf *key_setdumpsp __P((struct secpolicy *,
 441         u_int8_t, u_int32_t, u_int32_t));
 442 static u_int key_getspreqmsglen __P((struct secpolicy *));
 443 static int key_spdexpire __P((struct secpolicy *));
 444 static struct secashead *key_newsah __P((struct secasindex *));
 445 static void key_delsah __P((struct secashead *));
 446 static struct secasvar *key_newsav __P((struct mbuf *,
 447         const struct sadb_msghdr *, struct secashead *, int *,
 448         const char*, int));
 449 #define KEY_NEWSAV(m, sadb, sah, e)                             \
 450         key_newsav(m, sadb, sah, e, __FILE__, __LINE__)
 451 static void key_delsav __P((struct secasvar *));
 452 static struct secashead *key_getsah __P((struct secasindex *));
 453 static struct secasvar *key_checkspidup __P((struct secasindex *, u_int32_t));
 454 static struct secasvar *key_getsavbyspi __P((struct secashead *, u_int32_t));
 455 static int key_setsaval __P((struct secasvar *, struct mbuf *,
 456         const struct sadb_msghdr *));
 457 static int key_mature __P((struct secasvar *));
 458 static struct mbuf *key_setdumpsa __P((struct secasvar *, u_int8_t,
 459         u_int8_t, u_int32_t, u_int32_t));
 460 static struct mbuf *key_setsadbmsg __P((u_int8_t, u_int16_t, u_int8_t,
 461         u_int32_t, pid_t, u_int16_t));
 462 static struct mbuf *key_setsadbsa __P((struct secasvar *));
 463 static struct mbuf *key_setsadbaddr __P((u_int16_t,
 464         const struct sockaddr *, u_int8_t, u_int16_t));
 465 #ifdef IPSEC_NAT_T
 466 static struct mbuf *key_setsadbxport(u_int16_t, u_int16_t);
 467 static struct mbuf *key_setsadbxtype(u_int16_t);
 468 #endif
 469 static void key_porttosaddr(struct sockaddr *, u_int16_t);
 470 #define KEY_PORTTOSADDR(saddr, port)                            \
 471         key_porttosaddr((struct sockaddr *)(saddr), (port))
 472 static struct mbuf *key_setsadbxsa2 __P((u_int8_t, u_int32_t, u_int32_t));
 473 static struct mbuf *key_setsadbxpolicy __P((u_int16_t, u_int8_t,
 474         u_int32_t));
 475 static struct seckey *key_dup_keymsg(const struct sadb_key *, u_int,
 476                                      struct malloc_type *);
 477 static struct seclifetime *key_dup_lifemsg(const struct sadb_lifetime *src,
 478                                             struct malloc_type *type);
 479 #ifdef INET6
 480 static int key_ismyaddr6 __P((struct sockaddr_in6 *));
 481 #endif
 482
 483 /* flags for key_cmpsaidx() */
 484 #define CMP_HEAD        1       /* protocol, addresses. */
 485 #define CMP_MODE_REQID  2       /* additionally HEAD, reqid, mode. */
 486 #define CMP_REQID       3       /* additionally HEAD, reaid. */
 487 #define CMP_EXACTLY     4       /* all elements. */
 488 static int key_cmpsaidx
 489         __P((const struct secasindex *, const struct secasindex *, int));
 490
 491 static int key_cmpspidx_exactly
 492         __P((struct secpolicyindex *, struct secpolicyindex *));
 493 static int key_cmpspidx_withmask
 494         __P((struct secpolicyindex *, struct secpolicyindex *));
 495 static int key_sockaddrcmp __P((const struct sockaddr *, const struct sockaddr *, int));
 496 static int key_bbcmp __P((const void *, const void *, u_int));
 497 static u_int16_t key_satype2proto __P((u_int8_t));
 498 static u_int8_t key_proto2satype __P((u_int16_t));
 499
 500 static int key_getspi __P((struct socket *, struct mbuf *,
 501         const struct sadb_msghdr *));
 502 static u_int32_t key_do_getnewspi __P((struct sadb_spirange *,
 503                                         struct secasindex *));
 504 static int key_update __P((struct socket *, struct mbuf *,
 505         const struct sadb_msghdr *));
 506 #ifdef IPSEC_DOSEQCHECK
 507 static struct secasvar *key_getsavbyseq __P((struct secashead *, u_int32_t));
 508 #endif
 509 static int key_add __P((struct socket *, struct mbuf *,
 510         const struct sadb_msghdr *));
 511 static int key_setident __P((struct secashead *, struct mbuf *,
 512         const struct sadb_msghdr *));
 513 static struct mbuf *key_getmsgbuf_x1 __P((struct mbuf *,
 514         const struct sadb_msghdr *));
 515 static int key_delete __P((struct socket *, struct mbuf *,
 516         const struct sadb_msghdr *));
 517 static int key_get __P((struct socket *, struct mbuf *,
 518         const struct sadb_msghdr *));
 519
 520 static void key_getcomb_setlifetime __P((struct sadb_comb *));
 521 static struct mbuf *key_getcomb_esp __P((void));
 522 static struct mbuf *key_getcomb_ah __P((void));
 523 static struct mbuf *key_getcomb_ipcomp __P((void));
 524 static struct mbuf *key_getprop __P((const struct secasindex *));
 525
 526 static int key_acquire __P((const struct secasindex *, struct secpolicy *));
 527 static struct secacq *key_newacq __P((const struct secasindex *));
 528 static struct secacq *key_getacq __P((const struct secasindex *));
 529 static struct secacq *key_getacqbyseq __P((u_int32_t));
 530 static struct secspacq *key_newspacq __P((struct secpolicyindex *));
 531 static struct secspacq *key_getspacq __P((struct secpolicyindex *));
 532 static int key_acquire2 __P((struct socket *, struct mbuf *,
 533         const struct sadb_msghdr *));
 534 static int key_register __P((struct socket *, struct mbuf *,
 535         const struct sadb_msghdr *));
 536 static int key_expire __P((struct secasvar *));
 537 static int key_flush __P((struct socket *, struct mbuf *,
 538         const struct sadb_msghdr *));
 539 static int key_dump __P((struct socket *, struct mbuf *,
 540         const struct sadb_msghdr *));
 541 static int key_promisc __P((struct socket *, struct mbuf *,
 542         const struct sadb_msghdr *));
 543 static int key_senderror __P((struct socket *, struct mbuf *, int));
 544 static int key_validate_ext __P((const struct sadb_ext *, int));
 545 static int key_align __P((struct mbuf *, struct sadb_msghdr *));
 546 static struct mbuf *key_setlifetime(struct seclifetime *src,
 547                                      u_int16_t exttype);
 548 static struct mbuf *key_setkey(struct seckey *src, u_int16_t exttype);
 549
 550 #if 0
 551 static const char *key_getfqdn __P((void));
 552 static const char *key_getuserfqdn __P((void));
 553 #endif
 554 static void key_sa_chgstate __P((struct secasvar *, u_int8_t));
 555
 556 static __inline void
 557 sa_initref(struct secasvar *sav)
 558 {
 559
 560         refcount_init(&sav->refcnt, 1);
 561 }
 562 static __inline void
 563 sa_addref(struct secasvar *sav)
 564 {
 565
 566         refcount_acquire(&sav->refcnt);
 567         IPSEC_ASSERT(sav->refcnt != 0, ("SA refcnt overflow"));
 568 }
 569 static __inline int
 570 sa_delref(struct secasvar *sav)
 571 {
 572
 573         IPSEC_ASSERT(sav->refcnt > 0, ("SA refcnt underflow"));
 574         return (refcount_release(&sav->refcnt));
 575 }
 576
 577 #define SP_ADDREF(p) do {                                               \
 578         (p)->refcnt++;                                                  \
 579         IPSEC_ASSERT((p)->refcnt != 0, ("SP refcnt overflow"));         \
 580 } while (0)
 581 #define SP_DELREF(p) do {                                               \
 582         IPSEC_ASSERT((p)->refcnt > 0, ("SP refcnt underflow"));         \
 583         (p)->refcnt--;                                                  \
 584 } while (0)
 585
 586
 587 /*
 588  * Update the refcnt while holding the SPTREE lock.
 589  */
 590 void
 591 key_addref(struct secpolicy *sp)
 592 {
 593         SPTREE_LOCK();
 594         SP_ADDREF(sp);
 595         SPTREE_UNLOCK();
 596 }
 597
 598 /*
 599  * Return 0 when there are known to be no SP's for the specified
 600  * direction.  Otherwise return 1.  This is used by IPsec code
 601  * to optimize performance.
 602  */
 603 int
 604 key_havesp(u_int dir)
 605 {
 606
 607         return (dir == IPSEC_DIR_INBOUND || dir == IPSEC_DIR_OUTBOUND ?
 608                 LIST_FIRST(&V_sptree[dir]) != NULL : 1);
 609 }
 610
 611 /* %%% IPsec policy management */
 612 /*
 613  * allocating a SP for OUTBOUND or INBOUND packet.
 614  * Must call key_freesp() later.
 615  * OUT: NULL:   not found
 616  *      others: found and return the pointer.
 617  */
 618 struct secpolicy *
 619 key_allocsp(struct secpolicyindex *spidx, u_int dir, const char* where, int tag)
 620 {
 621         struct secpolicy *sp;
 622
 623         IPSEC_ASSERT(spidx != NULL, ("null spidx"));
 624         IPSEC_ASSERT(dir == IPSEC_DIR_INBOUND || dir == IPSEC_DIR_OUTBOUND,
 625                 ("invalid direction %u", dir));
 626
 627         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
 628                 printf("DP %s from %s:%u\n", __func__, where, tag));
 629
 630         /* get a SP entry */
 631         KEYDEBUG(KEYDEBUG_IPSEC_DATA,
 632                 printf("*** objects\n");
 633                 kdebug_secpolicyindex(spidx));
 634
 635         SPTREE_LOCK();
 636         LIST_FOREACH(sp, &V_sptree[dir], chain) {
 637                 KEYDEBUG(KEYDEBUG_IPSEC_DATA,
 638                         printf("*** in SPD\n");
 639                         kdebug_secpolicyindex(&sp->spidx));
 640
 641                 if (sp->state == IPSEC_SPSTATE_DEAD)
 642                         continue;
 643                 if (key_cmpspidx_withmask(&sp->spidx, spidx))
 644                         goto found;
 645         }
 646         sp = NULL;
 647 found:
 648         if (sp) {
 649                 /* sanity check */
 650                 KEY_CHKSPDIR(sp->spidx.dir, dir, __func__);
 651
 652                 /* found a SPD entry */
 653                 sp->lastused = time_second;
 654                 SP_ADDREF(sp);
 655         }
 656         SPTREE_UNLOCK();
 657
 658         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
 659                 printf("DP %s return SP:%p (ID=%u) refcnt %u\n", __func__,
 660                         sp, sp ? sp->id : 0, sp ? sp->refcnt : 0));
 661         return sp;
 662 }
 663
 664 /*
 665  * allocating a SP for OUTBOUND or INBOUND packet.
 666  * Must call key_freesp() later.
 667  * OUT: NULL:   not found
 668  *      others: found and return the pointer.
 669  */
 670 struct secpolicy *
 671 key_allocsp2(u_int32_t spi,
 672              union sockaddr_union *dst,
 673              u_int8_t proto,
 674              u_int dir,
 675              const char* where, int tag)
 676 {
 677         struct secpolicy *sp;
 678
 679         IPSEC_ASSERT(dst != NULL, ("null dst"));
 680         IPSEC_ASSERT(dir == IPSEC_DIR_INBOUND || dir == IPSEC_DIR_OUTBOUND,
 681                 ("invalid direction %u", dir));
 682
 683         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
 684                 printf("DP %s from %s:%u\n", __func__, where, tag));
 685
 686         /* get a SP entry */
 687         KEYDEBUG(KEYDEBUG_IPSEC_DATA,
 688                 printf("*** objects\n");
 689                 printf("spi %u proto %u dir %u\n", spi, proto, dir);
 690                 kdebug_sockaddr(&dst->sa));
 691
 692         SPTREE_LOCK();
 693         LIST_FOREACH(sp, &V_sptree[dir], chain) {
 694                 KEYDEBUG(KEYDEBUG_IPSEC_DATA,
 695                         printf("*** in SPD\n");
 696                         kdebug_secpolicyindex(&sp->spidx));
 697
 698                 if (sp->state == IPSEC_SPSTATE_DEAD)
 699                         continue;
 700                 /* compare simple values, then dst address */
 701                 if (sp->spidx.ul_proto != proto)
 702                         continue;
 703                 /* NB: spi's must exist and match */
 704                 if (!sp->req || !sp->req->sav || sp->req->sav->spi != spi)
 705                         continue;
 706                 if (key_sockaddrcmp(&sp->spidx.dst.sa, &dst->sa, 1) == 0)
 707                         goto found;
 708         }
 709         sp = NULL;
 710 found:
 711         if (sp) {
 712                 /* sanity check */
 713                 KEY_CHKSPDIR(sp->spidx.dir, dir, __func__);
 714
 715                 /* found a SPD entry */
 716                 sp->lastused = time_second;
 717                 SP_ADDREF(sp);
 718         }
 719         SPTREE_UNLOCK();
 720
 721         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
 722                 printf("DP %s return SP:%p (ID=%u) refcnt %u\n", __func__,
 723                         sp, sp ? sp->id : 0, sp ? sp->refcnt : 0));
 724         return sp;
 725 }
 726
 727 #if 0
 728 /*
 729  * return a policy that matches this particular inbound packet.
 730  * XXX slow
 731  */
 732 struct secpolicy *
 733 key_gettunnel(const struct sockaddr *osrc,
 734               const struct sockaddr *odst,
 735               const struct sockaddr *isrc,
 736               const struct sockaddr *idst,
 737               const char* where, int tag)
 738 {
 739         struct secpolicy *sp;
 740         const int dir = IPSEC_DIR_INBOUND;
 741         struct ipsecrequest *r1, *r2, *p;
 742         struct secpolicyindex spidx;
 743
 744         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
 745                 printf("DP %s from %s:%u\n", __func__, where, tag));
 746
 747         if (isrc->sa_family != idst->sa_family) {
 748                 ipseclog((LOG_ERR, "%s: protocol family mismatched %d != %d\n.",
 749                         __func__, isrc->sa_family, idst->sa_family));
 750                 sp = NULL;
 751                 goto done;
 752         }
 753
 754         SPTREE_LOCK();
 755         LIST_FOREACH(sp, &V_sptree[dir], chain) {
 756                 if (sp->state == IPSEC_SPSTATE_DEAD)
 757                         continue;
 758
 759                 r1 = r2 = NULL;
 760                 for (p = sp->req; p; p = p->next) {
 761                         if (p->saidx.mode != IPSEC_MODE_TUNNEL)
 762                                 continue;
 763
 764                         r1 = r2;
 765                         r2 = p;
 766
 767                         if (!r1) {
 768                                 /* here we look at address matches only */
 769                                 spidx = sp->spidx;
 770                                 if (isrc->sa_len > sizeof(spidx.src) ||
 771                                     idst->sa_len > sizeof(spidx.dst))
 772                                         continue;
 773                                 bcopy(isrc, &spidx.src, isrc->sa_len);
 774                                 bcopy(idst, &spidx.dst, idst->sa_len);
 775                                 if (!key_cmpspidx_withmask(&sp->spidx, &spidx))
 776                                         continue;
 777                         } else {
 778                                 if (key_sockaddrcmp(&r1->saidx.src.sa, isrc, 0) ||
 779                                     key_sockaddrcmp(&r1->saidx.dst.sa, idst, 0))
 780                                         continue;
 781                         }
 782
 783                         if (key_sockaddrcmp(&r2->saidx.src.sa, osrc, 0) ||
 784                             key_sockaddrcmp(&r2->saidx.dst.sa, odst, 0))
 785                                 continue;
 786
 787                         goto found;
 788                 }
 789         }
 790         sp = NULL;
 791 found:
 792         if (sp) {
 793                 sp->lastused = time_second;
 794                 SP_ADDREF(sp);
 795         }
 796         SPTREE_UNLOCK();
 797 done:
 798         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
 799                 printf("DP %s return SP:%p (ID=%u) refcnt %u\n", __func__,
 800                         sp, sp ? sp->id : 0, sp ? sp->refcnt : 0));
 801         return sp;
 802 }
 803 #endif
 804
 805 /*
 806  * allocating an SA entry for an *OUTBOUND* packet.
 807  * checking each request entries in SP, and acquire an SA if need.
 808  * OUT: 0: there are valid requests.
 809  *      ENOENT: policy may be valid, but SA with REQUIRE is on acquiring.
 810  */
 811 int
 812 key_checkrequest(struct ipsecrequest *isr, const struct secasindex *saidx)
 813 {
 814         u_int level;
 815         int error;
 816         struct secasvar *sav;
 817
 818         IPSEC_ASSERT(isr != NULL, ("null isr"));
 819         IPSEC_ASSERT(saidx != NULL, ("null saidx"));
 820         IPSEC_ASSERT(saidx->mode == IPSEC_MODE_TRANSPORT ||
 821                 saidx->mode == IPSEC_MODE_TUNNEL,
 822                 ("unexpected policy %u", saidx->mode));
 823
 824         /*
 825          * XXX guard against protocol callbacks from the crypto
 826          * thread as they reference ipsecrequest.sav which we
 827          * temporarily null out below.  Need to rethink how we
 828          * handle bundled SA's in the callback thread.
 829          */
 830         IPSECREQUEST_LOCK_ASSERT(isr);
 831
 832         /* get current level */
 833         level = ipsec_get_reqlevel(isr);
 834
 835         /*
 836          * We check new SA in the IPsec request because a different
 837          * SA may be involved each time this request is checked, either
 838          * because new SAs are being configured, or this request is
 839          * associated with an unconnected datagram socket, or this request
 840          * is associated with a system default policy.
 841          *
 842          * key_allocsa_policy should allocate the oldest SA available.
 843          * See key_do_allocsa_policy(), and draft-jenkins-ipsec-rekeying-03.txt.
 844          */
 845         sav = key_allocsa_policy(saidx);
 846         if (sav != isr->sav) {
 847                 /* SA need to be updated. */
 848                 if (!IPSECREQUEST_UPGRADE(isr)) {
 849                         /* Kick everyone off. */
 850                         IPSECREQUEST_UNLOCK(isr);
 851                         IPSECREQUEST_WLOCK(isr);
 852                 }
 853                 if (isr->sav != NULL)
 854                         KEY_FREESAV(&isr->sav);
 855                 isr->sav = sav;
 856                 IPSECREQUEST_DOWNGRADE(isr);
 857         } else if (sav != NULL)
 858                 KEY_FREESAV(&sav);
 859
 860         /* When there is SA. */
 861         if (isr->sav != NULL) {
 862                 if (isr->sav->state != SADB_SASTATE_MATURE &&
 863                     isr->sav->state != SADB_SASTATE_DYING)
 864                         return EINVAL;
 865                 return 0;
 866         }
 867
 868         /* there is no SA */
 869         error = key_acquire(saidx, isr->sp);
 870         if (error != 0) {
 871                 /* XXX What should I do ? */
 872                 ipseclog((LOG_DEBUG, "%s: error %d returned from key_acquire\n",
 873                         __func__, error));
 874                 return error;
 875         }
 876
 877         if (level != IPSEC_LEVEL_REQUIRE) {
 878                 /* XXX sigh, the interface to this routine is botched */
 879                 IPSEC_ASSERT(isr->sav == NULL, ("unexpected SA"));
 880                 return 0;
 881         } else {
 882                 return ENOENT;
 883         }
 884 }
 885
 886 /*
 887  * allocating a SA for policy entry from SAD.
 888  * NOTE: searching SAD of aliving state.
 889  * OUT: NULL:   not found.
 890  *      others: found and return the pointer.
 891  */
 892 static struct secasvar *
 893 key_allocsa_policy(const struct secasindex *saidx)
 894 {
 895 #define N(a)    _ARRAYLEN(a)
 896         struct secashead *sah;
 897         struct secasvar *sav;
 898         u_int stateidx, arraysize;
 899         const u_int *state_valid;
 900
 901         state_valid = NULL;     /* silence gcc */
 902         arraysize = 0;          /* silence gcc */
 903
 904         SAHTREE_LOCK();
 905         LIST_FOREACH(sah, &V_sahtree, chain) {
 906                 if (sah->state == SADB_SASTATE_DEAD)
 907                         continue;
 908                 if (key_cmpsaidx(&sah->saidx, saidx, CMP_MODE_REQID)) {
 909                         if (V_key_preferred_oldsa) {
 910                                 state_valid = saorder_state_valid_prefer_old;
 911                                 arraysize = N(saorder_state_valid_prefer_old);
 912                         } else {
 913                                 state_valid = saorder_state_valid_prefer_new;
 914                                 arraysize = N(saorder_state_valid_prefer_new);
 915                         }
 916                         break;
 917                 }
 918         }
 919         SAHTREE_UNLOCK();
 920         if (sah == NULL)
 921                 return NULL;
 922
 923         /* search valid state */
 924         for (stateidx = 0; stateidx < arraysize; stateidx++) {
 925                 sav = key_do_allocsa_policy(sah, state_valid[stateidx]);
 926                 if (sav != NULL)
 927                         return sav;
 928         }
 929
 930         return NULL;
 931 #undef N
 932 }
 933
 934 /*
 935  * searching SAD with direction, protocol, mode and state.
 936  * called by key_allocsa_policy().
 937  * OUT:
 938  *      NULL    : not found
 939  *      others  : found, pointer to a SA.
 940  */
 941 static struct secasvar *
 942 key_do_allocsa_policy(struct secashead *sah, u_int state)
 943 {
 944         struct secasvar *sav, *nextsav, *candidate, *d;
 945
 946         /* initilize */
 947         candidate = NULL;
 948
 949         SAHTREE_LOCK();
 950         for (sav = LIST_FIRST(&sah->savtree[state]);
 951              sav != NULL;
 952              sav = nextsav) {
 953
 954                 nextsav = LIST_NEXT(sav, chain);
 955
 956                 /* sanity check */
 957                 KEY_CHKSASTATE(sav->state, state, __func__);
 958
 959                 /* initialize */
 960                 if (candidate == NULL) {
 961                         candidate = sav;
 962                         continue;
 963                 }
 964
 965                 /* Which SA is the better ? */
 966
 967                 IPSEC_ASSERT(candidate->lft_c != NULL,
 968                         ("null candidate lifetime"));
 969                 IPSEC_ASSERT(sav->lft_c != NULL, ("null sav lifetime"));
 970
 971                 /* What the best method is to compare ? */
 972                 if (V_key_preferred_oldsa) {
 973                         if (candidate->lft_c->addtime >
 974                                         sav->lft_c->addtime) {
 975                                 candidate = sav;
 976                         }
 977                         continue;
 978                         /*NOTREACHED*/
 979                 }
 980
 981                 /* preferred new sa rather than old sa */
 982                 if (candidate->lft_c->addtime <
 983                                 sav->lft_c->addtime) {
 984                         d = candidate;
 985                         candidate = sav;
 986                 } else
 987                         d = sav;
 988
 989                 /*
 990                  * prepared to delete the SA when there is more
 991                  * suitable candidate and the lifetime of the SA is not
 992                  * permanent.
 993                  */
 994                 if (d->lft_h->addtime != 0) {
 995                         struct mbuf *m, *result;
 996                         u_int8_t satype;
 997
 998                         key_sa_chgstate(d, SADB_SASTATE_DEAD);
 999
1000                         IPSEC_ASSERT(d->refcnt > 0, ("bogus ref count"));
1001
1002                         satype = key_proto2satype(d->sah->saidx.proto);
1003                         if (satype == 0)
1004                                 goto msgfail;
1005
1006                         m = key_setsadbmsg(SADB_DELETE, 0,
1007                             satype, 0, 0, d->refcnt - 1);
1008                         if (!m)
1009                                 goto msgfail;
1010                         result = m;
1011
1012                         /* set sadb_address for saidx's. */
1013                         m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
1014                                 &d->sah->saidx.src.sa,
1015                                 d->sah->saidx.src.sa.sa_len << 3,
1016                                 IPSEC_ULPROTO_ANY);
1017                         if (!m)
1018                                 goto msgfail;
1019                         m_cat(result, m);
1020
1021                         /* set sadb_address for saidx's. */
1022                         m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
1023                                 &d->sah->saidx.dst.sa,
1024                                 d->sah->saidx.dst.sa.sa_len << 3,
1025                                 IPSEC_ULPROTO_ANY);
1026                         if (!m)
1027                                 goto msgfail;
1028                         m_cat(result, m);
1029
1030                         /* create SA extension */
1031                         m = key_setsadbsa(d);
1032                         if (!m)
1033                                 goto msgfail;
1034                         m_cat(result, m);
1035
1036                         if (result->m_len < sizeof(struct sadb_msg)) {
1037                                 result = m_pullup(result,
1038                                                 sizeof(struct sadb_msg));
1039                                 if (result == NULL)
1040                                         goto msgfail;
1041                         }
1042
1043                         result->m_pkthdr.len = 0;
1044                         for (m = result; m; m = m->m_next)
1045                                 result->m_pkthdr.len += m->m_len;
1046                         mtod(result, struct sadb_msg *)->sadb_msg_len =
1047                                 PFKEY_UNIT64(result->m_pkthdr.len);
1048
1049                         if (key_sendup_mbuf(NULL, result,
1050                                         KEY_SENDUP_REGISTERED))
1051                                 goto msgfail;
1052                  msgfail:
1053                         KEY_FREESAV(&d);
1054                 }
1055         }
1056         if (candidate) {
1057                 sa_addref(candidate);
1058                 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
1059                         printf("DP %s cause refcnt++:%d SA:%p\n",
1060                                 __func__, candidate->refcnt, candidate));
1061         }
1062         SAHTREE_UNLOCK();
1063
1064         return candidate;
1065 }
1066
1067 /*
1068  * allocating a usable SA entry for a *INBOUND* packet.
1069  * Must call key_freesav() later.
1070  * OUT: positive:       pointer to a usable sav (i.e. MATURE or DYING state).
1071  *      NULL:           not found, or error occured.
1072  *
1073  * In the comparison, no source address is used--for RFC2401 conformance.
1074  * To quote, from section 4.1:
1075  *      A security association is uniquely identified by a triple consisting
1076  *      of a Security Parameter Index (SPI), an IP Destination Address, and a
1077  *      security protocol (AH or ESP) identifier.
1078  * Note that, however, we do need to keep source address in IPsec SA.
1079  * IKE specification and PF_KEY specification do assume that we
1080  * keep source address in IPsec SA.  We see a tricky situation here.
1081  */
1082 struct secasvar *
1083 key_allocsa(
1084         union sockaddr_union *dst,
1085         u_int proto,
1086         u_int32_t spi,
1087         const char* where, int tag)
1088 {
1089         struct secashead *sah;
1090         struct secasvar *sav;
1091         u_int stateidx, arraysize, state;
1092         const u_int *saorder_state_valid;
1093 #ifdef IPSEC_NAT_T
1094         int natt_chkport;
1095 #endif
1096
1097         IPSEC_ASSERT(dst != NULL, ("null dst address"));
1098
1099         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
1100                 printf("DP %s from %s:%u\n", __func__, where, tag));
1101
1102 #ifdef IPSEC_NAT_T
1103         natt_chkport = (dst->sa.sa_family == AF_INET &&
1104             dst->sa.sa_len == sizeof(struct sockaddr_in) &&
1105             dst->sin.sin_port != 0);
1106 #endif
1107
1108         /*
1109          * searching SAD.
1110          * XXX: to be checked internal IP header somewhere.  Also when
1111          * IPsec tunnel packet is received.  But ESP tunnel mode is
1112          * encrypted so we can't check internal IP header.
1113          */
1114         SAHTREE_LOCK();
1115         if (V_key_preferred_oldsa) {
1116                 saorder_state_valid = saorder_state_valid_prefer_old;
1117                 arraysize = _ARRAYLEN(saorder_state_valid_prefer_old);
1118         } else {
1119                 saorder_state_valid = saorder_state_valid_prefer_new;
1120                 arraysize = _ARRAYLEN(saorder_state_valid_prefer_new);
1121         }
1122         LIST_FOREACH(sah, &V_sahtree, chain) {
1123                 int checkport;
1124
1125                 /* search valid state */
1126                 for (stateidx = 0; stateidx < arraysize; stateidx++) {
1127                         state = saorder_state_valid[stateidx];
1128                         LIST_FOREACH(sav, &sah->savtree[state], chain) {
1129                                 /* sanity check */
1130                                 KEY_CHKSASTATE(sav->state, state, __func__);
1131                                 /* do not return entries w/ unusable state */
1132                                 if (sav->state != SADB_SASTATE_MATURE &&
1133                                     sav->state != SADB_SASTATE_DYING)
1134                                         continue;
1135                                 if (proto != sav->sah->saidx.proto)
1136                                         continue;
1137                                 if (spi != sav->spi)
1138                                         continue;
1139                                 checkport = 0;
1140 #ifdef IPSEC_NAT_T
1141                                 /*
1142                                  * Really only check ports when this is a NAT-T
1143                                  * SA.  Otherwise other lookups providing ports
1144                                  * might suffer.
1145                                  */
1146                                 if (sav->natt_type && natt_chkport)
1147                                         checkport = 1;
1148 #endif
1149 #if 0   /* don't check src */
1150                                 /* check src address */
1151                                 if (key_sockaddrcmp(&src->sa,
1152                                     &sav->sah->saidx.src.sa, checkport) != 0)
1153                                         continue;
1154 #endif
1155                                 /* check dst address */
1156                                 if (key_sockaddrcmp(&dst->sa,
1157                                     &sav->sah->saidx.dst.sa, checkport) != 0)
1158                                         continue;
1159                                 sa_addref(sav);
1160                                 goto done;
1161                         }
1162                 }
1163         }
1164         sav = NULL;
1165 done:
1166         SAHTREE_UNLOCK();
1167
1168         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
1169                 printf("DP %s return SA:%p; refcnt %u\n", __func__,
1170                         sav, sav ? sav->refcnt : 0));
1171         return sav;
1172 }
1173
1174 /*
1175  * Must be called after calling key_allocsp().
1176  * For both the packet without socket and key_freeso().
1177  */
1178 void
1179 _key_freesp(struct secpolicy **spp, const char* where, int tag)
1180 {
1181         struct secpolicy *sp = *spp;
1182
1183         IPSEC_ASSERT(sp != NULL, ("null sp"));
1184
1185         SPTREE_LOCK();
1186         SP_DELREF(sp);
1187
1188         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
1189                 printf("DP %s SP:%p (ID=%u) from %s:%u; refcnt now %u\n",
1190                         __func__, sp, sp->id, where, tag, sp->refcnt));
1191
1192         if (sp->refcnt == 0) {
1193                 *spp = NULL;
1194                 key_delsp(sp);
1195         }
1196         SPTREE_UNLOCK();
1197 }
1198
1199 /*
1200  * Must be called after calling key_allocsp().
1201  * For the packet with socket.
1202  */
1203 void
1204 key_freeso(struct socket *so)
1205 {
1206         IPSEC_ASSERT(so != NULL, ("null so"));
1207
1208         switch (so->so_proto->pr_domain->dom_family) {
1209 #if defined(INET) || defined(INET6)
1210 #ifdef INET
1211         case PF_INET:
1212 #endif
1213 #ifdef INET6
1214         case PF_INET6:
1215 #endif
1216             {
1217                 struct inpcb *pcb = sotoinpcb(so);
1218
1219                 /* Does it have a PCB ? */
1220                 if (pcb == NULL)
1221                         return;
1222                 key_freesp_so(&pcb->inp_sp->sp_in);
1223                 key_freesp_so(&pcb->inp_sp->sp_out);
1224             }
1225                 break;
1226 #endif /* INET || INET6 */
1227         default:
1228                 ipseclog((LOG_DEBUG, "%s: unknown address family=%d.\n",
1229                     __func__, so->so_proto->pr_domain->dom_family));
1230                 return;
1231         }
1232 }
1233
1234 static void
1235 key_freesp_so(struct secpolicy **sp)
1236 {
1237         IPSEC_ASSERT(sp != NULL && *sp != NULL, ("null sp"));
1238
1239         if ((*sp)->policy == IPSEC_POLICY_ENTRUST ||
1240             (*sp)->policy == IPSEC_POLICY_BYPASS)
1241                 return;
1242
1243         IPSEC_ASSERT((*sp)->policy == IPSEC_POLICY_IPSEC,
1244                 ("invalid policy %u", (*sp)->policy));
1245         KEY_FREESP(sp);
1246 }
1247
1248 void
1249 key_addrefsa(struct secasvar *sav, const char* where, int tag)
1250 {
1251
1252         IPSEC_ASSERT(sav != NULL, ("null sav"));
1253         IPSEC_ASSERT(sav->refcnt > 0, ("refcount must exist"));
1254
1255         sa_addref(sav);
1256 }
1257
1258 /*
1259  * Must be called after calling key_allocsa().
1260  * This function is called by key_freesp() to free some SA allocated
1261  * for a policy.
1262  */
1263 void
1264 key_freesav(struct secasvar **psav, const char* where, int tag)
1265 {
1266         struct secasvar *sav = *psav;
1267
1268         IPSEC_ASSERT(sav != NULL, ("null sav"));
1269
1270         if (sa_delref(sav)) {
1271                 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
1272                         printf("DP %s SA:%p (SPI %u) from %s:%u; refcnt now %u\n",
1273                                 __func__, sav, ntohl(sav->spi), where, tag, sav->refcnt));
1274                 *psav = NULL;
1275                 key_delsav(sav);
1276         } else {
1277                 KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
1278                         printf("DP %s SA:%p (SPI %u) from %s:%u; refcnt now %u\n",
1279                                 __func__, sav, ntohl(sav->spi), where, tag, sav->refcnt));
1280         }
1281 }
1282
1283 /* %%% SPD management */
1284 /*
1285  * free security policy entry.
1286  */
1287 static void
1288 key_delsp(struct secpolicy *sp)
1289 {
1290         struct ipsecrequest *isr, *nextisr;
1291
1292         IPSEC_ASSERT(sp != NULL, ("null sp"));
1293         SPTREE_LOCK_ASSERT();
1294
1295         sp->state = IPSEC_SPSTATE_DEAD;
1296
1297         IPSEC_ASSERT(sp->refcnt == 0,
1298                 ("SP with references deleted (refcnt %u)", sp->refcnt));
1299
1300         /* remove from SP index */
1301         if (__LIST_CHAINED(sp))
1302                 LIST_REMOVE(sp, chain);
1303
1304         for (isr = sp->req; isr != NULL; isr = nextisr) {
1305                 if (isr->sav != NULL) {
1306                         KEY_FREESAV(&isr->sav);
1307                         isr->sav = NULL;
1308                 }
1309
1310                 nextisr = isr->next;
1311                 ipsec_delisr(isr);
1312         }
1313         _key_delsp(sp);
1314 }
1315
1316 /*
1317  * search SPD
1318  * OUT: NULL    : not found
1319  *      others  : found, pointer to a SP.
1320  */
1321 static struct secpolicy *
1322 key_getsp(struct secpolicyindex *spidx)
1323 {
1324         struct secpolicy *sp;
1325
1326         IPSEC_ASSERT(spidx != NULL, ("null spidx"));
1327
1328         SPTREE_LOCK();
1329         LIST_FOREACH(sp, &V_sptree[spidx->dir], chain) {
1330                 if (sp->state == IPSEC_SPSTATE_DEAD)
1331                         continue;
1332                 if (key_cmpspidx_exactly(spidx, &sp->spidx)) {
1333                         SP_ADDREF(sp);
1334                         break;
1335                 }
1336         }
1337         SPTREE_UNLOCK();
1338
1339         return sp;
1340 }
1341
1342 /*
1343  * get SP by index.
1344  * OUT: NULL    : not found
1345  *      others  : found, pointer to a SP.
1346  */
1347 static struct secpolicy *
1348 key_getspbyid(u_int32_t id)
1349 {
1350         struct secpolicy *sp;
1351
1352         SPTREE_LOCK();
1353         LIST_FOREACH(sp, &V_sptree[IPSEC_DIR_INBOUND], chain) {
1354                 if (sp->state == IPSEC_SPSTATE_DEAD)
1355                         continue;
1356                 if (sp->id == id) {
1357                         SP_ADDREF(sp);
1358                         goto done;
1359                 }
1360         }
1361
1362         LIST_FOREACH(sp, &V_sptree[IPSEC_DIR_OUTBOUND], chain) {
1363                 if (sp->state == IPSEC_SPSTATE_DEAD)
1364                         continue;
1365                 if (sp->id == id) {
1366                         SP_ADDREF(sp);
1367                         goto done;
1368                 }
1369         }
1370 done:
1371         SPTREE_UNLOCK();
1372
1373         return sp;
1374 }
1375
1376 struct secpolicy *
1377 key_newsp(const char* where, int tag)
1378 {
1379         struct secpolicy *newsp = NULL;
1380
1381         newsp = (struct secpolicy *)
1382                 malloc(sizeof(struct secpolicy), M_IPSEC_SP, M_NOWAIT|M_ZERO);
1383         if (newsp) {
1384                 SECPOLICY_LOCK_INIT(newsp);
1385                 newsp->refcnt = 1;
1386                 newsp->req = NULL;
1387         }
1388
1389         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
1390                 printf("DP %s from %s:%u return SP:%p\n", __func__,
1391                         where, tag, newsp));
1392         return newsp;
1393 }
1394
1395 static void
1396 _key_delsp(struct secpolicy *sp)
1397 {
1398         SECPOLICY_LOCK_DESTROY(sp);
1399         free(sp, M_IPSEC_SP);
1400 }
1401
1402 /*
1403  * create secpolicy structure from sadb_x_policy structure.
1404  * NOTE: `state', `secpolicyindex' in secpolicy structure are not set,
1405  * so must be set properly later.
1406  */
1407 struct secpolicy *
1408 key_msg2sp(xpl0, len, error)
1409         struct sadb_x_policy *xpl0;
1410         size_t len;
1411         int *error;
1412 {
1413         struct secpolicy *newsp;
1414
1415         IPSEC_ASSERT(xpl0 != NULL, ("null xpl0"));
1416         IPSEC_ASSERT(len >= sizeof(*xpl0), ("policy too short: %zu", len));
1417
1418         if (len != PFKEY_EXTLEN(xpl0)) {
1419                 ipseclog((LOG_DEBUG, "%s: Invalid msg length.\n", __func__));
1420                 *error = EINVAL;
1421                 return NULL;
1422         }
1423
1424         if ((newsp = KEY_NEWSP()) == NULL) {
1425                 *error = ENOBUFS;
1426                 return NULL;
1427         }
1428
1429         newsp->spidx.dir = xpl0->sadb_x_policy_dir;
1430         newsp->policy = xpl0->sadb_x_policy_type;
1431
1432         /* check policy */
1433         switch (xpl0->sadb_x_policy_type) {
1434         case IPSEC_POLICY_DISCARD:
1435         case IPSEC_POLICY_NONE:
1436         case IPSEC_POLICY_ENTRUST:
1437         case IPSEC_POLICY_BYPASS:
1438                 newsp->req = NULL;
1439                 break;
1440
1441         case IPSEC_POLICY_IPSEC:
1442             {
1443                 int tlen;
1444                 struct sadb_x_ipsecrequest *xisr;
1445                 struct ipsecrequest **p_isr = &newsp->req;
1446
1447                 /* validity check */
1448                 if (PFKEY_EXTLEN(xpl0) < sizeof(*xpl0)) {
1449                         ipseclog((LOG_DEBUG, "%s: Invalid msg length.\n",
1450                                 __func__));
1451                         KEY_FREESP(&newsp);
1452                         *error = EINVAL;
1453                         return NULL;
1454                 }
1455
1456                 tlen = PFKEY_EXTLEN(xpl0) - sizeof(*xpl0);
1457                 xisr = (struct sadb_x_ipsecrequest *)(xpl0 + 1);
1458
1459                 while (tlen > 0) {
1460                         /* length check */
1461                         if (xisr->sadb_x_ipsecrequest_len < sizeof(*xisr)) {
1462                                 ipseclog((LOG_DEBUG, "%s: invalid ipsecrequest "
1463                                         "length.\n", __func__));
1464                                 KEY_FREESP(&newsp);
1465                                 *error = EINVAL;
1466                                 return NULL;
1467                         }
1468
1469                         /* allocate request buffer */
1470                         /* NB: data structure is zero'd */
1471                         *p_isr = ipsec_newisr();
1472                         if ((*p_isr) == NULL) {
1473                                 ipseclog((LOG_DEBUG,
1474                                     "%s: No more memory.\n", __func__));
1475                                 KEY_FREESP(&newsp);
1476                                 *error = ENOBUFS;
1477                                 return NULL;
1478                         }
1479
1480                         /* set values */
1481                         switch (xisr->sadb_x_ipsecrequest_proto) {
1482                         case IPPROTO_ESP:
1483                         case IPPROTO_AH:
1484                         case IPPROTO_IPCOMP:
1485                                 break;
1486                         default:
1487                                 ipseclog((LOG_DEBUG,
1488                                     "%s: invalid proto type=%u\n", __func__,
1489                                     xisr->sadb_x_ipsecrequest_proto));
1490                                 KEY_FREESP(&newsp);
1491                                 *error = EPROTONOSUPPORT;
1492                                 return NULL;
1493                         }
1494                         (*p_isr)->saidx.proto = xisr->sadb_x_ipsecrequest_proto;
1495
1496                         switch (xisr->sadb_x_ipsecrequest_mode) {
1497                         case IPSEC_MODE_TRANSPORT:
1498                         case IPSEC_MODE_TUNNEL:
1499                                 break;
1500                         case IPSEC_MODE_ANY:
1501                         default:
1502                                 ipseclog((LOG_DEBUG,
1503                                     "%s: invalid mode=%u\n", __func__,
1504                                     xisr->sadb_x_ipsecrequest_mode));
1505                                 KEY_FREESP(&newsp);
1506                                 *error = EINVAL;
1507                                 return NULL;
1508                         }
1509                         (*p_isr)->saidx.mode = xisr->sadb_x_ipsecrequest_mode;
1510
1511                         switch (xisr->sadb_x_ipsecrequest_level) {
1512                         case IPSEC_LEVEL_DEFAULT:
1513                         case IPSEC_LEVEL_USE:
1514                         case IPSEC_LEVEL_REQUIRE:
1515                                 break;
1516                         case IPSEC_LEVEL_UNIQUE:
1517                                 /* validity check */
1518                                 /*
1519                                  * If range violation of reqid, kernel will
1520                                  * update it, don't refuse it.
1521                                  */
1522                                 if (xisr->sadb_x_ipsecrequest_reqid
1523                                                 > IPSEC_MANUAL_REQID_MAX) {
1524                                         ipseclog((LOG_DEBUG,
1525                                             "%s: reqid=%d range "
1526                                             "violation, updated by kernel.\n",
1527                                             __func__,
1528                                             xisr->sadb_x_ipsecrequest_reqid));
1529                                         xisr->sadb_x_ipsecrequest_reqid = 0;
1530                                 }
1531
1532                                 /* allocate new reqid id if reqid is zero. */
1533                                 if (xisr->sadb_x_ipsecrequest_reqid == 0) {
1534                                         u_int32_t reqid;
1535                                         if ((reqid = key_newreqid()) == 0) {
1536                                                 KEY_FREESP(&newsp);
1537                                                 *error = ENOBUFS;
1538                                                 return NULL;
1539                                         }
1540                                         (*p_isr)->saidx.reqid = reqid;
1541                                         xisr->sadb_x_ipsecrequest_reqid = reqid;
1542                                 } else {
1543                                 /* set it for manual keying. */
1544                                         (*p_isr)->saidx.reqid =
1545                                                 xisr->sadb_x_ipsecrequest_reqid;
1546                                 }
1547                                 break;
1548
1549                         default:
1550                                 ipseclog((LOG_DEBUG, "%s: invalid level=%u\n",
1551                                         __func__,
1552                                         xisr->sadb_x_ipsecrequest_level));
1553                                 KEY_FREESP(&newsp);
1554                                 *error = EINVAL;
1555                                 return NULL;
1556                         }
1557                         (*p_isr)->level = xisr->sadb_x_ipsecrequest_level;
1558
1559                         /* set IP addresses if there */
1560                         if (xisr->sadb_x_ipsecrequest_len > sizeof(*xisr)) {
1561                                 struct sockaddr *paddr;
1562
1563                                 paddr = (struct sockaddr *)(xisr + 1);
1564
1565                                 /* validity check */
1566                                 if (paddr->sa_len
1567                                     > sizeof((*p_isr)->saidx.src)) {
1568                                         ipseclog((LOG_DEBUG, "%s: invalid "
1569                                                 "request address length.\n",
1570                                                 __func__));
1571                                         KEY_FREESP(&newsp);
1572                                         *error = EINVAL;
1573                                         return NULL;
1574                                 }
1575                                 bcopy(paddr, &(*p_isr)->saidx.src,
1576                                         paddr->sa_len);
1577
1578                                 paddr = (struct sockaddr *)((caddr_t)paddr
1579                                                         + paddr->sa_len);
1580
1581                                 /* validity check */
1582                                 if (paddr->sa_len
1583                                     > sizeof((*p_isr)->saidx.dst)) {
1584                                         ipseclog((LOG_DEBUG, "%s: invalid "
1585                                                 "request address length.\n",
1586                                                 __func__));
1587                                         KEY_FREESP(&newsp);
1588                                         *error = EINVAL;
1589                                         return NULL;
1590                                 }
1591                                 bcopy(paddr, &(*p_isr)->saidx.dst,
1592                                         paddr->sa_len);
1593                         }
1594
1595                         (*p_isr)->sp = newsp;
1596
1597                         /* initialization for the next. */
1598                         p_isr = &(*p_isr)->next;
1599                         tlen -= xisr->sadb_x_ipsecrequest_len;
1600
1601                         /* validity check */
1602                         if (tlen < 0) {
1603                                 ipseclog((LOG_DEBUG, "%s: becoming tlen < 0.\n",
1604                                         __func__));
1605                                 KEY_FREESP(&newsp);
1606                                 *error = EINVAL;
1607                                 return NULL;
1608                         }
1609
1610                         xisr = (struct sadb_x_ipsecrequest *)((caddr_t)xisr
1611                                          + xisr->sadb_x_ipsecrequest_len);
1612                 }
1613             }
1614                 break;
1615         default:
1616                 ipseclog((LOG_DEBUG, "%s: invalid policy type.\n", __func__));
1617                 KEY_FREESP(&newsp);
1618                 *error = EINVAL;
1619                 return NULL;
1620         }
1621
1622         *error = 0;
1623         return newsp;
1624 }
1625
1626 static u_int32_t
1627 key_newreqid()
1628 {
1629         static u_int32_t auto_reqid = IPSEC_MANUAL_REQID_MAX + 1;
1630
1631         auto_reqid = (auto_reqid == ~0
1632                         ? IPSEC_MANUAL_REQID_MAX + 1 : auto_reqid + 1);
1633
1634         /* XXX should be unique check */
1635
1636         return auto_reqid;
1637 }
1638
1639 /*
1640  * copy secpolicy struct to sadb_x_policy structure indicated.
1641  */
1642 struct mbuf *
1643 key_sp2msg(sp)
1644         struct secpolicy *sp;
1645 {
1646         struct sadb_x_policy *xpl;
1647         int tlen;
1648         caddr_t p;
1649         struct mbuf *m;
1650
1651         IPSEC_ASSERT(sp != NULL, ("null policy"));
1652
1653         tlen = key_getspreqmsglen(sp);
1654
1655         m = m_get2(tlen, M_NOWAIT, MT_DATA, 0);
1656         if (m == NULL)
1657                 return (NULL);
1658         m_align(m, tlen);
1659         m->m_len = tlen;
1660         xpl = mtod(m, struct sadb_x_policy *);
1661         bzero(xpl, tlen);
1662
1663         xpl->sadb_x_policy_len = PFKEY_UNIT64(tlen);
1664         xpl->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
1665         xpl->sadb_x_policy_type = sp->policy;
1666         xpl->sadb_x_policy_dir = sp->spidx.dir;
1667         xpl->sadb_x_policy_id = sp->id;
1668         p = (caddr_t)xpl + sizeof(*xpl);
1669
1670         /* if is the policy for ipsec ? */
1671         if (sp->policy == IPSEC_POLICY_IPSEC) {
1672                 struct sadb_x_ipsecrequest *xisr;
1673                 struct ipsecrequest *isr;
1674
1675                 for (isr = sp->req; isr != NULL; isr = isr->next) {
1676
1677                         xisr = (struct sadb_x_ipsecrequest *)p;
1678
1679                         xisr->sadb_x_ipsecrequest_proto = isr->saidx.proto;
1680                         xisr->sadb_x_ipsecrequest_mode = isr->saidx.mode;
1681                         xisr->sadb_x_ipsecrequest_level = isr->level;
1682                         xisr->sadb_x_ipsecrequest_reqid = isr->saidx.reqid;
1683
1684                         p += sizeof(*xisr);
1685                         bcopy(&isr->saidx.src, p, isr->saidx.src.sa.sa_len);
1686                         p += isr->saidx.src.sa.sa_len;
1687                         bcopy(&isr->saidx.dst, p, isr->saidx.dst.sa.sa_len);
1688                         p += isr->saidx.src.sa.sa_len;
1689
1690                         xisr->sadb_x_ipsecrequest_len =
1691                                 PFKEY_ALIGN8(sizeof(*xisr)
1692                                         + isr->saidx.src.sa.sa_len
1693                                         + isr->saidx.dst.sa.sa_len);
1694                 }
1695         }
1696
1697         return m;
1698 }
1699
1700 /* m will not be freed nor modified */
1701 static struct mbuf *
1702 #ifdef __STDC__
1703 key_gather_mbuf(struct mbuf *m, const struct sadb_msghdr *mhp,
1704         int ndeep, int nitem, ...)
1705 #else
1706 key_gather_mbuf(m, mhp, ndeep, nitem, va_alist)
1707         struct mbuf *m;
1708         const struct sadb_msghdr *mhp;
1709         int ndeep;
1710         int nitem;
1711         va_dcl
1712 #endif
1713 {
1714         va_list ap;
1715         int idx;
1716         int i;
1717         struct mbuf *result = NULL, *n;
1718         int len;
1719
1720         IPSEC_ASSERT(m != NULL, ("null mbuf"));
1721         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
1722
1723         va_start(ap, nitem);
1724         for (i = 0; i < nitem; i++) {
1725                 idx = va_arg(ap, int);
1726                 if (idx < 0 || idx > SADB_EXT_MAX)
1727                         goto fail;
1728                 /* don't attempt to pull empty extension */
1729                 if (idx == SADB_EXT_RESERVED && mhp->msg == NULL)
1730                         continue;
1731                 if (idx != SADB_EXT_RESERVED  &&
1732                     (mhp->ext[idx] == NULL || mhp->extlen[idx] == 0))
1733                         continue;
1734
1735                 if (idx == SADB_EXT_RESERVED) {
1736                         len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
1737
1738                         IPSEC_ASSERT(len <= MHLEN, ("header too big %u", len));
1739
1740                         MGETHDR(n, M_NOWAIT, MT_DATA);
1741                         if (!n)
1742                                 goto fail;
1743                         n->m_len = len;
1744                         n->m_next = NULL;
1745                         m_copydata(m, 0, sizeof(struct sadb_msg),
1746                             mtod(n, caddr_t));
1747                 } else if (i < ndeep) {
1748                         len = mhp->extlen[idx];
1749                         n = m_get2(len, M_NOWAIT, MT_DATA, 0);
1750                         if (n == NULL)
1751                                 goto fail;
1752                         m_align(n, len);
1753                         n->m_len = len;
1754                         m_copydata(m, mhp->extoff[idx], mhp->extlen[idx],
1755                             mtod(n, caddr_t));
1756                 } else {
1757                         n = m_copym(m, mhp->extoff[idx], mhp->extlen[idx],
1758                             M_NOWAIT);
1759                 }
1760                 if (n == NULL)
1761                         goto fail;
1762
1763                 if (result)
1764                         m_cat(result, n);
1765                 else
1766                         result = n;
1767         }
1768         va_end(ap);
1769
1770         if ((result->m_flags & M_PKTHDR) != 0) {
1771                 result->m_pkthdr.len = 0;
1772                 for (n = result; n; n = n->m_next)
1773                         result->m_pkthdr.len += n->m_len;
1774         }
1775
1776         return result;
1777
1778 fail:
1779         m_freem(result);
1780         va_end(ap);
1781         return NULL;
1782 }
1783
1784 /*
1785  * SADB_X_SPDADD, SADB_X_SPDSETIDX or SADB_X_SPDUPDATE processing
1786  * add an entry to SP database, when received
1787  *   <base, address(SD), (lifetime(H),) policy>
1788  * from the user(?).
1789  * Adding to SP database,
1790  * and send
1791  *   <base, address(SD), (lifetime(H),) policy>
1792  * to the socket which was send.
1793  *
1794  * SPDADD set a unique policy entry.
1795  * SPDSETIDX like SPDADD without a part of policy requests.
1796  * SPDUPDATE replace a unique policy entry.
1797  *
1798  * m will always be freed.
1799  */
1800 static int
1801 key_spdadd(so, m, mhp)
1802         struct socket *so;
1803         struct mbuf *m;
1804         const struct sadb_msghdr *mhp;
1805 {
1806         struct sadb_address *src0, *dst0;
1807         struct sadb_x_policy *xpl0, *xpl;
1808         struct sadb_lifetime *lft = NULL;
1809         struct secpolicyindex spidx;
1810         struct secpolicy *newsp;
1811         int error;
1812
1813         IPSEC_ASSERT(so != NULL, ("null socket"));
1814         IPSEC_ASSERT(m != NULL, ("null mbuf"));
1815         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
1816         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
1817
1818         if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
1819             mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
1820             mhp->ext[SADB_X_EXT_POLICY] == NULL) {
1821                 ipseclog((LOG_DEBUG, "key_spdadd: invalid message is passed.\n"));
1822                 return key_senderror(so, m, EINVAL);
1823         }
1824         if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
1825             mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address) ||
1826             mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
1827                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
1828                         __func__));
1829                 return key_senderror(so, m, EINVAL);
1830         }
1831         if (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL) {
1832                 if (mhp->extlen[SADB_EXT_LIFETIME_HARD]
1833                         < sizeof(struct sadb_lifetime)) {
1834                         ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
1835                                 __func__));
1836                         return key_senderror(so, m, EINVAL);
1837                 }
1838                 lft = (struct sadb_lifetime *)mhp->ext[SADB_EXT_LIFETIME_HARD];
1839         }
1840
1841         src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
1842         dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
1843         xpl0 = (struct sadb_x_policy *)mhp->ext[SADB_X_EXT_POLICY];
1844
1845         /*
1846          * Note: do not parse SADB_X_EXT_NAT_T_* here:
1847          * we are processing traffic endpoints.
1848          */
1849
1850         /* make secindex */
1851         /* XXX boundary check against sa_len */
1852         KEY_SETSECSPIDX(xpl0->sadb_x_policy_dir,
1853                         src0 + 1,
1854                         dst0 + 1,
1855                         src0->sadb_address_prefixlen,
1856                         dst0->sadb_address_prefixlen,
1857                         src0->sadb_address_proto,
1858                         &spidx);
1859
1860         /* checking the direciton. */
1861         switch (xpl0->sadb_x_policy_dir) {
1862         case IPSEC_DIR_INBOUND:
1863         case IPSEC_DIR_OUTBOUND:
1864                 break;
1865         default:
1866                 ipseclog((LOG_DEBUG, "%s: Invalid SP direction.\n", __func__));
1867                 mhp->msg->sadb_msg_errno = EINVAL;
1868                 return 0;
1869         }
1870
1871         /* check policy */
1872         /* key_spdadd() accepts DISCARD, NONE and IPSEC. */
1873         if (xpl0->sadb_x_policy_type == IPSEC_POLICY_ENTRUST
1874          || xpl0->sadb_x_policy_type == IPSEC_POLICY_BYPASS) {
1875                 ipseclog((LOG_DEBUG, "%s: Invalid policy type.\n", __func__));
1876                 return key_senderror(so, m, EINVAL);
1877         }
1878
1879         /* policy requests are mandatory when action is ipsec. */
1880         if (mhp->msg->sadb_msg_type != SADB_X_SPDSETIDX
1881          && xpl0->sadb_x_policy_type == IPSEC_POLICY_IPSEC
1882          && mhp->extlen[SADB_X_EXT_POLICY] <= sizeof(*xpl0)) {
1883                 ipseclog((LOG_DEBUG, "%s: some policy requests part required\n",
1884                         __func__));
1885                 return key_senderror(so, m, EINVAL);
1886         }
1887
1888         /*
1889          * checking there is SP already or not.
1890          * SPDUPDATE doesn't depend on whether there is a SP or not.
1891          * If the type is either SPDADD or SPDSETIDX AND a SP is found,
1892          * then error.
1893          */
1894         newsp = key_getsp(&spidx);
1895         if (mhp->msg->sadb_msg_type == SADB_X_SPDUPDATE) {
1896                 if (newsp) {
1897                         SPTREE_LOCK();
1898                         newsp->state = IPSEC_SPSTATE_DEAD;
1899                         SPTREE_UNLOCK();
1900                         KEY_FREESP(&newsp);
1901                 }
1902         } else {
1903                 if (newsp != NULL) {
1904                         KEY_FREESP(&newsp);
1905                         ipseclog((LOG_DEBUG, "%s: a SP entry exists already.\n",
1906                                 __func__));
1907                         return key_senderror(so, m, EEXIST);
1908                 }
1909         }
1910
1911         /* allocation new SP entry */
1912         if ((newsp = key_msg2sp(xpl0, PFKEY_EXTLEN(xpl0), &error)) == NULL) {
1913                 return key_senderror(so, m, error);
1914         }
1915
1916         if ((newsp->id = key_getnewspid()) == 0) {
1917                 _key_delsp(newsp);
1918                 return key_senderror(so, m, ENOBUFS);
1919         }
1920
1921         /* XXX boundary check against sa_len */
1922         KEY_SETSECSPIDX(xpl0->sadb_x_policy_dir,
1923                         src0 + 1,
1924                         dst0 + 1,
1925                         src0->sadb_address_prefixlen,
1926                         dst0->sadb_address_prefixlen,
1927                         src0->sadb_address_proto,
1928                         &newsp->spidx);
1929
1930         /* sanity check on addr pair */
1931         if (((struct sockaddr *)(src0 + 1))->sa_family !=
1932                         ((struct sockaddr *)(dst0+ 1))->sa_family) {
1933                 _key_delsp(newsp);
1934                 return key_senderror(so, m, EINVAL);
1935         }
1936         if (((struct sockaddr *)(src0 + 1))->sa_len !=
1937                         ((struct sockaddr *)(dst0+ 1))->sa_len) {
1938                 _key_delsp(newsp);
1939                 return key_senderror(so, m, EINVAL);
1940         }
1941 #if 1
1942         if (newsp->req && newsp->req->saidx.src.sa.sa_family && newsp->req->saidx.dst.sa.sa_family) {
1943                 if (newsp->req->saidx.src.sa.sa_family != newsp->req->saidx.dst.sa.sa_family) {
1944                         _key_delsp(newsp);
1945                         return key_senderror(so, m, EINVAL);
1946                 }
1947         }
1948 #endif
1949
1950         newsp->created = time_second;
1951         newsp->lastused = newsp->created;
1952         newsp->lifetime = lft ? lft->sadb_lifetime_addtime : 0;
1953         newsp->validtime = lft ? lft->sadb_lifetime_usetime : 0;
1954
1955         newsp->refcnt = 1;      /* do not reclaim until I say I do */
1956         newsp->state = IPSEC_SPSTATE_ALIVE;
1957         LIST_INSERT_TAIL(&V_sptree[newsp->spidx.dir], newsp, secpolicy, chain);
1958
1959         /* delete the entry in spacqtree */
1960         if (mhp->msg->sadb_msg_type == SADB_X_SPDUPDATE) {
1961                 struct secspacq *spacq = key_getspacq(&spidx);
1962                 if (spacq != NULL) {
1963                         /* reset counter in order to deletion by timehandler. */
1964                         spacq->created = time_second;
1965                         spacq->count = 0;
1966                         SPACQ_UNLOCK();
1967                 }
1968         }
1969
1970     {
1971         struct mbuf *n, *mpolicy;
1972         struct sadb_msg *newmsg;
1973         int off;
1974
1975         /*
1976          * Note: do not send SADB_X_EXT_NAT_T_* here:
1977          * we are sending traffic endpoints.
1978          */
1979
1980         /* create new sadb_msg to reply. */
1981         if (lft) {
1982                 n = key_gather_mbuf(m, mhp, 2, 5, SADB_EXT_RESERVED,
1983                     SADB_X_EXT_POLICY, SADB_EXT_LIFETIME_HARD,
1984                     SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
1985         } else {
1986                 n = key_gather_mbuf(m, mhp, 2, 4, SADB_EXT_RESERVED,
1987                     SADB_X_EXT_POLICY,
1988                     SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
1989         }
1990         if (!n)
1991                 return key_senderror(so, m, ENOBUFS);
1992
1993         if (n->m_len < sizeof(*newmsg)) {
1994                 n = m_pullup(n, sizeof(*newmsg));
1995                 if (!n)
1996                         return key_senderror(so, m, ENOBUFS);
1997         }
1998         newmsg = mtod(n, struct sadb_msg *);
1999         newmsg->sadb_msg_errno = 0;
2000         newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
2001
2002         off = 0;
2003         mpolicy = m_pulldown(n, PFKEY_ALIGN8(sizeof(struct sadb_msg)),
2004             sizeof(*xpl), &off);
2005         if (mpolicy == NULL) {
2006                 /* n is already freed */
2007                 return key_senderror(so, m, ENOBUFS);
2008         }
2009         xpl = (struct sadb_x_policy *)(mtod(mpolicy, caddr_t) + off);
2010         if (xpl->sadb_x_policy_exttype != SADB_X_EXT_POLICY) {
2011                 m_freem(n);
2012                 return key_senderror(so, m, EINVAL);
2013         }
2014         xpl->sadb_x_policy_id = newsp->id;
2015
2016         m_freem(m);
2017         return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
2018     }
2019 }
2020
2021 /*
2022  * get new policy id.
2023  * OUT:
2024  *      0:      failure.
2025  *      others: success.
2026  */
2027 static u_int32_t
2028 key_getnewspid()
2029 {
2030         u_int32_t newid = 0;
2031         int count = V_key_spi_trycnt;   /* XXX */
2032         struct secpolicy *sp;
2033
2034         /* when requesting to allocate spi ranged */
2035         while (count--) {
2036                 newid = (V_policy_id = (V_policy_id == ~0 ? 1 : V_policy_id + 1));
2037
2038                 if ((sp = key_getspbyid(newid)) == NULL)
2039                         break;
2040
2041                 KEY_FREESP(&sp);
2042         }
2043
2044         if (count == 0 || newid == 0) {
2045                 ipseclog((LOG_DEBUG, "%s: to allocate policy id is failed.\n",
2046                         __func__));
2047                 return 0;
2048         }
2049
2050         return newid;
2051 }
2052
2053 /*
2054  * SADB_SPDDELETE processing
2055  * receive
2056  *   <base, address(SD), policy(*)>
2057  * from the user(?), and set SADB_SASTATE_DEAD,
2058  * and send,
2059  *   <base, address(SD), policy(*)>
2060  * to the ikmpd.
2061  * policy(*) including direction of policy.
2062  *
2063  * m will always be freed.
2064  */
2065 static int
2066 key_spddelete(so, m, mhp)
2067         struct socket *so;
2068         struct mbuf *m;
2069         const struct sadb_msghdr *mhp;
2070 {
2071         struct sadb_address *src0, *dst0;
2072         struct sadb_x_policy *xpl0;
2073         struct secpolicyindex spidx;
2074         struct secpolicy *sp;
2075
2076         IPSEC_ASSERT(so != NULL, ("null so"));
2077         IPSEC_ASSERT(m != NULL, ("null mbuf"));
2078         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
2079         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
2080
2081         if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
2082             mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
2083             mhp->ext[SADB_X_EXT_POLICY] == NULL) {
2084                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
2085                         __func__));
2086                 return key_senderror(so, m, EINVAL);
2087         }
2088         if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
2089             mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address) ||
2090             mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2091                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
2092                         __func__));
2093                 return key_senderror(so, m, EINVAL);
2094         }
2095
2096         src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
2097         dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
2098         xpl0 = (struct sadb_x_policy *)mhp->ext[SADB_X_EXT_POLICY];
2099
2100         /*
2101          * Note: do not parse SADB_X_EXT_NAT_T_* here:
2102          * we are processing traffic endpoints.
2103          */
2104
2105         /* make secindex */
2106         /* XXX boundary check against sa_len */
2107         KEY_SETSECSPIDX(xpl0->sadb_x_policy_dir,
2108                         src0 + 1,
2109                         dst0 + 1,
2110                         src0->sadb_address_prefixlen,
2111                         dst0->sadb_address_prefixlen,
2112                         src0->sadb_address_proto,
2113                         &spidx);
2114
2115         /* checking the direciton. */
2116         switch (xpl0->sadb_x_policy_dir) {
2117         case IPSEC_DIR_INBOUND:
2118         case IPSEC_DIR_OUTBOUND:
2119                 break;
2120         default:
2121                 ipseclog((LOG_DEBUG, "%s: Invalid SP direction.\n", __func__));
2122                 return key_senderror(so, m, EINVAL);
2123         }
2124
2125         /* Is there SP in SPD ? */
2126         if ((sp = key_getsp(&spidx)) == NULL) {
2127                 ipseclog((LOG_DEBUG, "%s: no SP found.\n", __func__));
2128                 return key_senderror(so, m, EINVAL);
2129         }
2130
2131         /* save policy id to buffer to be returned. */
2132         xpl0->sadb_x_policy_id = sp->id;
2133
2134         SPTREE_LOCK();
2135         sp->state = IPSEC_SPSTATE_DEAD;
2136         SPTREE_UNLOCK();
2137         KEY_FREESP(&sp);
2138
2139     {
2140         struct mbuf *n;
2141         struct sadb_msg *newmsg;
2142
2143         /*
2144          * Note: do not send SADB_X_EXT_NAT_T_* here:
2145          * we are sending traffic endpoints.
2146          */
2147
2148         /* create new sadb_msg to reply. */
2149         n = key_gather_mbuf(m, mhp, 1, 4, SADB_EXT_RESERVED,
2150             SADB_X_EXT_POLICY, SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
2151         if (!n)
2152                 return key_senderror(so, m, ENOBUFS);
2153
2154         newmsg = mtod(n, struct sadb_msg *);
2155         newmsg->sadb_msg_errno = 0;
2156         newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
2157
2158         m_freem(m);
2159         return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
2160     }
2161 }
2162
2163 /*
2164  * SADB_SPDDELETE2 processing
2165  * receive
2166  *   <base, policy(*)>
2167  * from the user(?), and set SADB_SASTATE_DEAD,
2168  * and send,
2169  *   <base, policy(*)>
2170  * to the ikmpd.
2171  * policy(*) including direction of policy.
2172  *
2173  * m will always be freed.
2174  */
2175 static int
2176 key_spddelete2(so, m, mhp)
2177         struct socket *so;
2178         struct mbuf *m;
2179         const struct sadb_msghdr *mhp;
2180 {
2181         u_int32_t id;
2182         struct secpolicy *sp;
2183
2184         IPSEC_ASSERT(so != NULL, ("null socket"));
2185         IPSEC_ASSERT(m != NULL, ("null mbuf"));
2186         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
2187         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
2188
2189         if (mhp->ext[SADB_X_EXT_POLICY] == NULL ||
2190             mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2191                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n", __func__));
2192                 return key_senderror(so, m, EINVAL);
2193         }
2194
2195         id = ((struct sadb_x_policy *)mhp->ext[SADB_X_EXT_POLICY])->sadb_x_policy_id;
2196
2197         /* Is there SP in SPD ? */
2198         if ((sp = key_getspbyid(id)) == NULL) {
2199                 ipseclog((LOG_DEBUG, "%s: no SP found id:%u.\n", __func__, id));
2200                 return key_senderror(so, m, EINVAL);
2201         }
2202
2203         SPTREE_LOCK();
2204         sp->state = IPSEC_SPSTATE_DEAD;
2205         SPTREE_UNLOCK();
2206         KEY_FREESP(&sp);
2207
2208     {
2209         struct mbuf *n, *nn;
2210         struct sadb_msg *newmsg;
2211         int off, len;
2212
2213         /* create new sadb_msg to reply. */
2214         len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
2215
2216         MGETHDR(n, M_NOWAIT, MT_DATA);
2217         if (n && len > MHLEN) {
2218                 MCLGET(n, M_NOWAIT);
2219                 if ((n->m_flags & M_EXT) == 0) {
2220                         m_freem(n);
2221                         n = NULL;
2222                 }
2223         }
2224         if (!n)
2225                 return key_senderror(so, m, ENOBUFS);
2226
2227         n->m_len = len;
2228         n->m_next = NULL;
2229         off = 0;
2230
2231         m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, caddr_t) + off);
2232         off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
2233
2234         IPSEC_ASSERT(off == len, ("length inconsistency (off %u len %u)",
2235                 off, len));
2236
2237         n->m_next = m_copym(m, mhp->extoff[SADB_X_EXT_POLICY],
2238             mhp->extlen[SADB_X_EXT_POLICY], M_NOWAIT);
2239         if (!n->m_next) {
2240                 m_freem(n);
2241                 return key_senderror(so, m, ENOBUFS);
2242         }
2243
2244         n->m_pkthdr.len = 0;
2245         for (nn = n; nn; nn = nn->m_next)
2246                 n->m_pkthdr.len += nn->m_len;
2247
2248         newmsg = mtod(n, struct sadb_msg *);
2249         newmsg->sadb_msg_errno = 0;
2250         newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
2251
2252         m_freem(m);
2253         return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
2254     }
2255 }
2256
2257 /*
2258  * SADB_X_GET processing
2259  * receive
2260  *   <base, policy(*)>
2261  * from the user(?),
2262  * and send,
2263  *   <base, address(SD), policy>
2264  * to the ikmpd.
2265  * policy(*) including direction of policy.
2266  *
2267  * m will always be freed.
2268  */
2269 static int
2270 key_spdget(so, m, mhp)
2271         struct socket *so;
2272         struct mbuf *m;
2273         const struct sadb_msghdr *mhp;
2274 {
2275         u_int32_t id;
2276         struct secpolicy *sp;
2277         struct mbuf *n;
2278
2279         IPSEC_ASSERT(so != NULL, ("null socket"));
2280         IPSEC_ASSERT(m != NULL, ("null mbuf"));
2281         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
2282         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
2283
2284         if (mhp->ext[SADB_X_EXT_POLICY] == NULL ||
2285             mhp->extlen[SADB_X_EXT_POLICY] < sizeof(struct sadb_x_policy)) {
2286                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
2287                         __func__));
2288                 return key_senderror(so, m, EINVAL);
2289         }
2290
2291         id = ((struct sadb_x_policy *)mhp->ext[SADB_X_EXT_POLICY])->sadb_x_policy_id;
2292
2293         /* Is there SP in SPD ? */
2294         if ((sp = key_getspbyid(id)) == NULL) {
2295                 ipseclog((LOG_DEBUG, "%s: no SP found id:%u.\n", __func__, id));
2296                 return key_senderror(so, m, ENOENT);
2297         }
2298
2299         n = key_setdumpsp(sp, SADB_X_SPDGET, 0, mhp->msg->sadb_msg_pid);
2300         KEY_FREESP(&sp);
2301         if (n != NULL) {
2302                 m_freem(m);
2303                 return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
2304         } else
2305                 return key_senderror(so, m, ENOBUFS);
2306 }
2307
2308 /*
2309  * SADB_X_SPDACQUIRE processing.
2310  * Acquire policy and SA(s) for a *OUTBOUND* packet.
2311  * send
2312  *   <base, policy(*)>
2313  * to KMD, and expect to receive
2314  *   <base> with SADB_X_SPDACQUIRE if error occured,
2315  * or
2316  *   <base, policy>
2317  * with SADB_X_SPDUPDATE from KMD by PF_KEY.
2318  * policy(*) is without policy requests.
2319  *
2320  *    0     : succeed
2321  *    others: error number
2322  */
2323 int
2324 key_spdacquire(sp)
2325         struct secpolicy *sp;
2326 {
2327         struct mbuf *result = NULL, *m;
2328         struct secspacq *newspacq;
2329
2330         IPSEC_ASSERT(sp != NULL, ("null secpolicy"));
2331         IPSEC_ASSERT(sp->req == NULL, ("policy exists"));
2332         IPSEC_ASSERT(sp->policy == IPSEC_POLICY_IPSEC,
2333                 ("policy not IPSEC %u", sp->policy));
2334
2335         /* Get an entry to check whether sent message or not. */
2336         newspacq = key_getspacq(&sp->spidx);
2337         if (newspacq != NULL) {
2338                 if (V_key_blockacq_count < newspacq->count) {
2339                         /* reset counter and do send message. */
2340                         newspacq->count = 0;
2341                 } else {
2342                         /* increment counter and do nothing. */
2343                         newspacq->count++;
2344                         return 0;
2345                 }
2346                 SPACQ_UNLOCK();
2347         } else {
2348                 /* make new entry for blocking to send SADB_ACQUIRE. */
2349                 newspacq = key_newspacq(&sp->spidx);
2350                 if (newspacq == NULL)
2351                         return ENOBUFS;
2352         }
2353
2354         /* create new sadb_msg to reply. */
2355         m = key_setsadbmsg(SADB_X_SPDACQUIRE, 0, 0, 0, 0, 0);
2356         if (!m)
2357                 return ENOBUFS;
2358
2359         result = m;
2360
2361         result->m_pkthdr.len = 0;
2362         for (m = result; m; m = m->m_next)
2363                 result->m_pkthdr.len += m->m_len;
2364
2365         mtod(result, struct sadb_msg *)->sadb_msg_len =
2366             PFKEY_UNIT64(result->m_pkthdr.len);
2367
2368         return key_sendup_mbuf(NULL, m, KEY_SENDUP_REGISTERED);
2369 }
2370
2371 /*
2372  * SADB_SPDFLUSH processing
2373  * receive
2374  *   <base>
2375  * from the user, and free all entries in secpctree.
2376  * and send,
2377  *   <base>
2378  * to the user.
2379  * NOTE: what to do is only marking SADB_SASTATE_DEAD.
2380  *
2381  * m will always be freed.
2382  */
2383 static int
2384 key_spdflush(so, m, mhp)
2385         struct socket *so;
2386         struct mbuf *m;
2387         const struct sadb_msghdr *mhp;
2388 {
2389         struct sadb_msg *newmsg;
2390         struct secpolicy *sp;
2391         u_int dir;
2392
2393         IPSEC_ASSERT(so != NULL, ("null socket"));
2394         IPSEC_ASSERT(m != NULL, ("null mbuf"));
2395         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
2396         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
2397
2398         if (m->m_len != PFKEY_ALIGN8(sizeof(struct sadb_msg)))
2399                 return key_senderror(so, m, EINVAL);
2400
2401         for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
2402                 SPTREE_LOCK();
2403                 LIST_FOREACH(sp, &V_sptree[dir], chain)
2404                         sp->state = IPSEC_SPSTATE_DEAD;
2405                 SPTREE_UNLOCK();
2406         }
2407
2408         if (sizeof(struct sadb_msg) > m->m_len + M_TRAILINGSPACE(m)) {
2409                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
2410                 return key_senderror(so, m, ENOBUFS);
2411         }
2412
2413         if (m->m_next)
2414                 m_freem(m->m_next);
2415         m->m_next = NULL;
2416         m->m_pkthdr.len = m->m_len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
2417         newmsg = mtod(m, struct sadb_msg *);
2418         newmsg->sadb_msg_errno = 0;
2419         newmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
2420
2421         return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
2422 }
2423
2424 /*
2425  * SADB_SPDDUMP processing
2426  * receive
2427  *   <base>
2428  * from the user, and dump all SP leaves
2429  * and send,
2430  *   <base> .....
2431  * to the ikmpd.
2432  *
2433  * m will always be freed.
2434  */
2435 static int
2436 key_spddump(so, m, mhp)
2437         struct socket *so;
2438         struct mbuf *m;
2439         const struct sadb_msghdr *mhp;
2440 {
2441         struct secpolicy *sp;
2442         int cnt;
2443         u_int dir;
2444         struct mbuf *n;
2445
2446         IPSEC_ASSERT(so != NULL, ("null socket"));
2447         IPSEC_ASSERT(m != NULL, ("null mbuf"));
2448         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
2449         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
2450
2451         /* search SPD entry and get buffer size. */
2452         cnt = 0;
2453         SPTREE_LOCK();
2454         for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
2455                 LIST_FOREACH(sp, &V_sptree[dir], chain) {
2456                         cnt++;
2457                 }
2458         }
2459
2460         if (cnt == 0) {
2461                 SPTREE_UNLOCK();
2462                 return key_senderror(so, m, ENOENT);
2463         }
2464
2465         for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
2466                 LIST_FOREACH(sp, &V_sptree[dir], chain) {
2467                         --cnt;
2468                         n = key_setdumpsp(sp, SADB_X_SPDDUMP, cnt,
2469                             mhp->msg->sadb_msg_pid);
2470
2471                         if (n)
2472                                 key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
2473                 }
2474         }
2475
2476         SPTREE_UNLOCK();
2477         m_freem(m);
2478         return 0;
2479 }
2480
2481 static struct mbuf *
2482 key_setdumpsp(struct secpolicy *sp, u_int8_t type, u_int32_t seq, u_int32_t pid)
2483 {
2484         struct mbuf *result = NULL, *m;
2485         struct seclifetime lt;
2486
2487         m = key_setsadbmsg(type, 0, SADB_SATYPE_UNSPEC, seq, pid, sp->refcnt);
2488         if (!m)
2489                 goto fail;
2490         result = m;
2491
2492         /*
2493          * Note: do not send SADB_X_EXT_NAT_T_* here:
2494          * we are sending traffic endpoints.
2495          */
2496         m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
2497             &sp->spidx.src.sa, sp->spidx.prefs,
2498             sp->spidx.ul_proto);
2499         if (!m)
2500                 goto fail;
2501         m_cat(result, m);
2502
2503         m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
2504             &sp->spidx.dst.sa, sp->spidx.prefd,
2505             sp->spidx.ul_proto);
2506         if (!m)
2507                 goto fail;
2508         m_cat(result, m);
2509
2510         m = key_sp2msg(sp);
2511         if (!m)
2512                 goto fail;
2513         m_cat(result, m);
2514
2515         if(sp->lifetime){
2516                 lt.addtime=sp->created;
2517                 lt.usetime= sp->lastused;
2518                 m = key_setlifetime(&lt, SADB_EXT_LIFETIME_CURRENT);
2519                 if (!m)
2520                         goto fail;
2521                 m_cat(result, m);
2522
2523                 lt.addtime=sp->lifetime;
2524                 lt.usetime= sp->validtime;
2525                 m = key_setlifetime(&lt, SADB_EXT_LIFETIME_HARD);
2526                 if (!m)
2527                         goto fail;
2528                 m_cat(result, m);
2529         }
2530
2531         if ((result->m_flags & M_PKTHDR) == 0)
2532                 goto fail;
2533
2534         if (result->m_len < sizeof(struct sadb_msg)) {
2535                 result = m_pullup(result, sizeof(struct sadb_msg));
2536                 if (result == NULL)
2537                         goto fail;
2538         }
2539
2540         result->m_pkthdr.len = 0;
2541         for (m = result; m; m = m->m_next)
2542                 result->m_pkthdr.len += m->m_len;
2543
2544         mtod(result, struct sadb_msg *)->sadb_msg_len =
2545             PFKEY_UNIT64(result->m_pkthdr.len);
2546
2547         return result;
2548
2549 fail:
2550         m_freem(result);
2551         return NULL;
2552 }
2553
2554 /*
2555  * get PFKEY message length for security policy and request.
2556  */
2557 static u_int
2558 key_getspreqmsglen(sp)
2559         struct secpolicy *sp;
2560 {
2561         u_int tlen;
2562
2563         tlen = sizeof(struct sadb_x_policy);
2564
2565         /* if is the policy for ipsec ? */
2566         if (sp->policy != IPSEC_POLICY_IPSEC)
2567                 return tlen;
2568
2569         /* get length of ipsec requests */
2570     {
2571         struct ipsecrequest *isr;
2572         int len;
2573
2574         for (isr = sp->req; isr != NULL; isr = isr->next) {
2575                 len = sizeof(struct sadb_x_ipsecrequest)
2576                         + isr->saidx.src.sa.sa_len
2577                         + isr->saidx.dst.sa.sa_len;
2578
2579                 tlen += PFKEY_ALIGN8(len);
2580         }
2581     }
2582
2583         return tlen;
2584 }
2585
2586 /*
2587  * SADB_SPDEXPIRE processing
2588  * send
2589  *   <base, address(SD), lifetime(CH), policy>
2590  * to KMD by PF_KEY.
2591  *
2592  * OUT: 0       : succeed
2593  *      others  : error number
2594  */
2595 static int
2596 key_spdexpire(sp)
2597         struct secpolicy *sp;
2598 {
2599         struct mbuf *result = NULL, *m;
2600         int len;
2601         int error = -1;
2602         struct sadb_lifetime *lt;
2603
2604         /* XXX: Why do we lock ? */
2605
2606         IPSEC_ASSERT(sp != NULL, ("null secpolicy"));
2607
2608         /* set msg header */
2609         m = key_setsadbmsg(SADB_X_SPDEXPIRE, 0, 0, 0, 0, 0);
2610         if (!m) {
2611                 error = ENOBUFS;
2612                 goto fail;
2613         }
2614         result = m;
2615
2616         /* create lifetime extension (current and hard) */
2617         len = PFKEY_ALIGN8(sizeof(*lt)) * 2;
2618         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
2619         if (m == NULL) {
2620                 error = ENOBUFS;
2621                 goto fail;
2622         }
2623         m_align(m, len);
2624         m->m_len = len;
2625         bzero(mtod(m, caddr_t), len);
2626         lt = mtod(m, struct sadb_lifetime *);
2627         lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
2628         lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
2629         lt->sadb_lifetime_allocations = 0;
2630         lt->sadb_lifetime_bytes = 0;
2631         lt->sadb_lifetime_addtime = sp->created;
2632         lt->sadb_lifetime_usetime = sp->lastused;
2633         lt = (struct sadb_lifetime *)(mtod(m, caddr_t) + len / 2);
2634         lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
2635         lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
2636         lt->sadb_lifetime_allocations = 0;
2637         lt->sadb_lifetime_bytes = 0;
2638         lt->sadb_lifetime_addtime = sp->lifetime;
2639         lt->sadb_lifetime_usetime = sp->validtime;
2640         m_cat(result, m);
2641
2642         /*
2643          * Note: do not send SADB_X_EXT_NAT_T_* here:
2644          * we are sending traffic endpoints.
2645          */
2646
2647         /* set sadb_address for source */
2648         m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
2649             &sp->spidx.src.sa,
2650             sp->spidx.prefs, sp->spidx.ul_proto);
2651         if (!m) {
2652                 error = ENOBUFS;
2653                 goto fail;
2654         }
2655         m_cat(result, m);
2656
2657         /* set sadb_address for destination */
2658         m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
2659             &sp->spidx.dst.sa,
2660             sp->spidx.prefd, sp->spidx.ul_proto);
2661         if (!m) {
2662                 error = ENOBUFS;
2663                 goto fail;
2664         }
2665         m_cat(result, m);
2666
2667         /* set secpolicy */
2668         m = key_sp2msg(sp);
2669         if (!m) {
2670                 error = ENOBUFS;
2671                 goto fail;
2672         }
2673         m_cat(result, m);
2674
2675         if ((result->m_flags & M_PKTHDR) == 0) {
2676                 error = EINVAL;
2677                 goto fail;
2678         }
2679
2680         if (result->m_len < sizeof(struct sadb_msg)) {
2681                 result = m_pullup(result, sizeof(struct sadb_msg));
2682                 if (result == NULL) {
2683                         error = ENOBUFS;
2684                         goto fail;
2685                 }
2686         }
2687
2688         result->m_pkthdr.len = 0;
2689         for (m = result; m; m = m->m_next)
2690                 result->m_pkthdr.len += m->m_len;
2691
2692         mtod(result, struct sadb_msg *)->sadb_msg_len =
2693             PFKEY_UNIT64(result->m_pkthdr.len);
2694
2695         return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
2696
2697  fail:
2698         if (result)
2699                 m_freem(result);
2700         return error;
2701 }
2702
2703 /* %%% SAD management */
2704 /*
2705  * allocating a memory for new SA head, and copy from the values of mhp.
2706  * OUT: NULL    : failure due to the lack of memory.
2707  *      others  : pointer to new SA head.
2708  */
2709 static struct secashead *
2710 key_newsah(saidx)
2711         struct secasindex *saidx;
2712 {
2713         struct secashead *newsah;
2714
2715         IPSEC_ASSERT(saidx != NULL, ("null saidx"));
2716
2717         newsah = malloc(sizeof(struct secashead), M_IPSEC_SAH, M_NOWAIT|M_ZERO);
2718         if (newsah != NULL) {
2719                 int i;
2720                 for (i = 0; i < sizeof(newsah->savtree)/sizeof(newsah->savtree[0]); i++)
2721                         LIST_INIT(&newsah->savtree[i]);
2722                 newsah->saidx = *saidx;
2723
2724                 /* add to saidxtree */
2725                 newsah->state = SADB_SASTATE_MATURE;
2726
2727                 SAHTREE_LOCK();
2728                 LIST_INSERT_HEAD(&V_sahtree, newsah, chain);
2729                 SAHTREE_UNLOCK();
2730         }
2731         return(newsah);
2732 }
2733
2734 /*
2735  * delete SA index and all SA registerd.
2736  */
2737 static void
2738 key_delsah(sah)
2739         struct secashead *sah;
2740 {
2741         struct secasvar *sav, *nextsav;
2742         u_int stateidx;
2743         int zombie = 0;
2744
2745         IPSEC_ASSERT(sah != NULL, ("NULL sah"));
2746         SAHTREE_LOCK_ASSERT();
2747
2748         /* searching all SA registerd in the secindex. */
2749         for (stateidx = 0;
2750              stateidx < _ARRAYLEN(saorder_state_any);
2751              stateidx++) {
2752                 u_int state = saorder_state_any[stateidx];
2753                 LIST_FOREACH_SAFE(sav, &sah->savtree[state], chain, nextsav) {
2754                         if (sav->refcnt == 0) {
2755                                 /* sanity check */
2756                                 KEY_CHKSASTATE(state, sav->state, __func__);
2757                                 /*
2758                                  * do NOT call KEY_FREESAV here:
2759                                  * it will only delete the sav if refcnt == 1,
2760                                  * where we already know that refcnt == 0
2761                                  */
2762                                 key_delsav(sav);
2763                         } else {
2764                                 /* give up to delete this sa */
2765                                 zombie++;
2766                         }
2767                 }
2768         }
2769         if (!zombie) {          /* delete only if there are savs */
2770                 /* remove from tree of SA index */
2771                 if (__LIST_CHAINED(sah))
2772                         LIST_REMOVE(sah, chain);
2773                 if (sah->route_cache.sa_route.ro_rt) {
2774                         RTFREE(sah->route_cache.sa_route.ro_rt);
2775                         sah->route_cache.sa_route.ro_rt = (struct rtentry *)NULL;
2776                 }
2777                 free(sah, M_IPSEC_SAH);
2778         }
2779 }
2780
2781 /*
2782  * allocating a new SA with LARVAL state.  key_add() and key_getspi() call,
2783  * and copy the values of mhp into new buffer.
2784  * When SAD message type is GETSPI:
2785  *      to set sequence number from acq_seq++,
2786  *      to set zero to SPI.
2787  *      not to call key_setsava().
2788  * OUT: NULL    : fail
2789  *      others  : pointer to new secasvar.
2790  *
2791  * does not modify mbuf.  does not free mbuf on error.
2792  */
2793 static struct secasvar *
2794 key_newsav(m, mhp, sah, errp, where, tag)
2795         struct mbuf *m;
2796         const struct sadb_msghdr *mhp;
2797         struct secashead *sah;
2798         int *errp;
2799         const char* where;
2800         int tag;
2801 {
2802         struct secasvar *newsav;
2803         const struct sadb_sa *xsa;
2804
2805         IPSEC_ASSERT(m != NULL, ("null mbuf"));
2806         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
2807         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
2808         IPSEC_ASSERT(sah != NULL, ("null secashead"));
2809
2810         newsav = malloc(sizeof(struct secasvar), M_IPSEC_SA, M_NOWAIT|M_ZERO);
2811         if (newsav == NULL) {
2812                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
2813                 *errp = ENOBUFS;
2814                 goto done;
2815         }
2816
2817         switch (mhp->msg->sadb_msg_type) {
2818         case SADB_GETSPI:
2819                 newsav->spi = 0;
2820
2821 #ifdef IPSEC_DOSEQCHECK
2822                 /* sync sequence number */
2823                 if (mhp->msg->sadb_msg_seq == 0)
2824                         newsav->seq =
2825                                 (V_acq_seq = (V_acq_seq == ~0 ? 1 : ++V_acq_seq));
2826                 else
2827 #endif
2828                         newsav->seq = mhp->msg->sadb_msg_seq;
2829                 break;
2830
2831         case SADB_ADD:
2832                 /* sanity check */
2833                 if (mhp->ext[SADB_EXT_SA] == NULL) {
2834                         free(newsav, M_IPSEC_SA);
2835                         newsav = NULL;
2836                         ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
2837                                 __func__));
2838                         *errp = EINVAL;
2839                         goto done;
2840                 }
2841                 xsa = (const struct sadb_sa *)mhp->ext[SADB_EXT_SA];
2842                 newsav->spi = xsa->sadb_sa_spi;
2843                 newsav->seq = mhp->msg->sadb_msg_seq;
2844                 break;
2845         default:
2846                 free(newsav, M_IPSEC_SA);
2847                 newsav = NULL;
2848                 *errp = EINVAL;
2849                 goto done;
2850         }
2851
2852
2853         /* copy sav values */
2854         if (mhp->msg->sadb_msg_type != SADB_GETSPI) {
2855                 *errp = key_setsaval(newsav, m, mhp);
2856                 if (*errp) {
2857                         free(newsav, M_IPSEC_SA);
2858                         newsav = NULL;
2859                         goto done;
2860                 }
2861         }
2862
2863         SECASVAR_LOCK_INIT(newsav);
2864
2865         /* reset created */
2866         newsav->created = time_second;
2867         newsav->pid = mhp->msg->sadb_msg_pid;
2868
2869         /* add to satree */
2870         newsav->sah = sah;
2871         sa_initref(newsav);
2872         newsav->state = SADB_SASTATE_LARVAL;
2873
2874         SAHTREE_LOCK();
2875         LIST_INSERT_TAIL(&sah->savtree[SADB_SASTATE_LARVAL], newsav,
2876                         secasvar, chain);
2877         SAHTREE_UNLOCK();
2878 done:
2879         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
2880                 printf("DP %s from %s:%u return SP:%p\n", __func__,
2881                         where, tag, newsav));
2882
2883         return newsav;
2884 }
2885
2886 /*
2887  * free() SA variable entry.
2888  */
2889 static void
2890 key_cleansav(struct secasvar *sav)
2891 {
2892         /*
2893          * Cleanup xform state.  Note that zeroize'ing causes the
2894          * keys to be cleared; otherwise we must do it ourself.
2895          */
2896         if (sav->tdb_xform != NULL) {
2897                 sav->tdb_xform->xf_zeroize(sav);
2898                 sav->tdb_xform = NULL;
2899         } else {
2900                 KASSERT(sav->iv == NULL, ("iv but no xform"));
2901                 if (sav->key_auth != NULL)
2902                         bzero(sav->key_auth->key_data, _KEYLEN(sav->key_auth));
2903                 if (sav->key_enc != NULL)
2904                         bzero(sav->key_enc->key_data, _KEYLEN(sav->key_enc));
2905         }
2906         if (sav->key_auth != NULL) {
2907                 if (sav->key_auth->key_data != NULL)
2908                         free(sav->key_auth->key_data, M_IPSEC_MISC);
2909                 free(sav->key_auth, M_IPSEC_MISC);
2910                 sav->key_auth = NULL;
2911         }
2912         if (sav->key_enc != NULL) {
2913                 if (sav->key_enc->key_data != NULL)
2914                         free(sav->key_enc->key_data, M_IPSEC_MISC);
2915                 free(sav->key_enc, M_IPSEC_MISC);
2916                 sav->key_enc = NULL;
2917         }
2918         if (sav->sched) {
2919                 bzero(sav->sched, sav->schedlen);
2920                 free(sav->sched, M_IPSEC_MISC);
2921                 sav->sched = NULL;
2922         }
2923         if (sav->replay != NULL) {
2924                 free(sav->replay, M_IPSEC_MISC);
2925                 sav->replay = NULL;
2926         }
2927         if (sav->lft_c != NULL) {
2928                 free(sav->lft_c, M_IPSEC_MISC);
2929                 sav->lft_c = NULL;
2930         }
2931         if (sav->lft_h != NULL) {
2932                 free(sav->lft_h, M_IPSEC_MISC);
2933                 sav->lft_h = NULL;
2934         }
2935         if (sav->lft_s != NULL) {
2936                 free(sav->lft_s, M_IPSEC_MISC);
2937                 sav->lft_s = NULL;
2938         }
2939 }
2940
2941 /*
2942  * free() SA variable entry.
2943  */
2944 static void
2945 key_delsav(sav)
2946         struct secasvar *sav;
2947 {
2948         IPSEC_ASSERT(sav != NULL, ("null sav"));
2949         IPSEC_ASSERT(sav->refcnt == 0, ("reference count %u > 0", sav->refcnt));
2950
2951         /* remove from SA header */
2952         if (__LIST_CHAINED(sav))
2953                 LIST_REMOVE(sav, chain);
2954         key_cleansav(sav);
2955         SECASVAR_LOCK_DESTROY(sav);
2956         free(sav, M_IPSEC_SA);
2957 }
2958
2959 /*
2960  * search SAD.
2961  * OUT:
2962  *      NULL    : not found
2963  *      others  : found, pointer to a SA.
2964  */
2965 static struct secashead *
2966 key_getsah(saidx)
2967         struct secasindex *saidx;
2968 {
2969         struct secashead *sah;
2970
2971         SAHTREE_LOCK();
2972         LIST_FOREACH(sah, &V_sahtree, chain) {
2973                 if (sah->state == SADB_SASTATE_DEAD)
2974                         continue;
2975                 if (key_cmpsaidx(&sah->saidx, saidx, CMP_REQID))
2976                         break;
2977         }
2978         SAHTREE_UNLOCK();
2979
2980         return sah;
2981 }
2982
2983 /*
2984  * check not to be duplicated SPI.
2985  * NOTE: this function is too slow due to searching all SAD.
2986  * OUT:
2987  *      NULL    : not found
2988  *      others  : found, pointer to a SA.
2989  */
2990 static struct secasvar *
2991 key_checkspidup(saidx, spi)
2992         struct secasindex *saidx;
2993         u_int32_t spi;
2994 {
2995         struct secashead *sah;
2996         struct secasvar *sav;
2997
2998         /* check address family */
2999         if (saidx->src.sa.sa_family != saidx->dst.sa.sa_family) {
3000                 ipseclog((LOG_DEBUG, "%s: address family mismatched.\n",
3001                         __func__));
3002                 return NULL;
3003         }
3004
3005         sav = NULL;
3006         /* check all SAD */
3007         SAHTREE_LOCK();
3008         LIST_FOREACH(sah, &V_sahtree, chain) {
3009                 if (!key_ismyaddr((struct sockaddr *)&sah->saidx.dst))
3010                         continue;
3011                 sav = key_getsavbyspi(sah, spi);
3012                 if (sav != NULL)
3013                         break;
3014         }
3015         SAHTREE_UNLOCK();
3016
3017         return sav;
3018 }
3019
3020 /*
3021  * search SAD litmited alive SA, protocol, SPI.
3022  * OUT:
3023  *      NULL    : not found
3024  *      others  : found, pointer to a SA.
3025  */
3026 static struct secasvar *
3027 key_getsavbyspi(sah, spi)
3028         struct secashead *sah;
3029         u_int32_t spi;
3030 {
3031         struct secasvar *sav;
3032         u_int stateidx, state;
3033
3034         sav = NULL;
3035         SAHTREE_LOCK_ASSERT();
3036         /* search all status */
3037         for (stateidx = 0;
3038              stateidx < _ARRAYLEN(saorder_state_alive);
3039              stateidx++) {
3040
3041                 state = saorder_state_alive[stateidx];
3042                 LIST_FOREACH(sav, &sah->savtree[state], chain) {
3043
3044                         /* sanity check */
3045                         if (sav->state != state) {
3046                                 ipseclog((LOG_DEBUG, "%s: "
3047                                     "invalid sav->state (queue: %d SA: %d)\n",
3048                                     __func__, state, sav->state));
3049                                 continue;
3050                         }
3051
3052                         if (sav->spi == spi)
3053                                 return sav;
3054                 }
3055         }
3056
3057         return NULL;
3058 }
3059
3060 /*
3061  * copy SA values from PF_KEY message except *SPI, SEQ, PID, STATE and TYPE*.
3062  * You must update these if need.
3063  * OUT: 0:      success.
3064  *      !0:     failure.
3065  *
3066  * does not modify mbuf.  does not free mbuf on error.
3067  */
3068 static int
3069 key_setsaval(sav, m, mhp)
3070         struct secasvar *sav;
3071         struct mbuf *m;
3072         const struct sadb_msghdr *mhp;
3073 {
3074         int error = 0;
3075
3076         IPSEC_ASSERT(m != NULL, ("null mbuf"));
3077         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
3078         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
3079
3080         /* initialization */
3081         sav->replay = NULL;
3082         sav->key_auth = NULL;
3083         sav->key_enc = NULL;
3084         sav->sched = NULL;
3085         sav->schedlen = 0;
3086         sav->iv = NULL;
3087         sav->lft_c = NULL;
3088         sav->lft_h = NULL;
3089         sav->lft_s = NULL;
3090         sav->tdb_xform = NULL;          /* transform */
3091         sav->tdb_encalgxform = NULL;    /* encoding algorithm */
3092         sav->tdb_authalgxform = NULL;   /* authentication algorithm */
3093         sav->tdb_compalgxform = NULL;   /* compression algorithm */
3094         /*  Initialize even if NAT-T not compiled in: */
3095         sav->natt_type = 0;
3096         sav->natt_esp_frag_len = 0;
3097
3098         /* SA */
3099         if (mhp->ext[SADB_EXT_SA] != NULL) {
3100                 const struct sadb_sa *sa0;
3101
3102                 sa0 = (const struct sadb_sa *)mhp->ext[SADB_EXT_SA];
3103                 if (mhp->extlen[SADB_EXT_SA] < sizeof(*sa0)) {
3104                         error = EINVAL;
3105                         goto fail;
3106                 }
3107
3108                 sav->alg_auth = sa0->sadb_sa_auth;
3109                 sav->alg_enc = sa0->sadb_sa_encrypt;
3110                 sav->flags = sa0->sadb_sa_flags;
3111
3112                 /* replay window */
3113                 if ((sa0->sadb_sa_flags & SADB_X_EXT_OLD) == 0) {
3114                         sav->replay = (struct secreplay *)
3115                                 malloc(sizeof(struct secreplay)+sa0->sadb_sa_replay, M_IPSEC_MISC, M_NOWAIT|M_ZERO);
3116                         if (sav->replay == NULL) {
3117                                 ipseclog((LOG_DEBUG, "%s: No more memory.\n",
3118                                         __func__));
3119                                 error = ENOBUFS;
3120                                 goto fail;
3121                         }
3122                         if (sa0->sadb_sa_replay != 0)
3123                                 sav->replay->bitmap = (caddr_t)(sav->replay+1);
3124                         sav->replay->wsize = sa0->sadb_sa_replay;
3125                 }
3126         }
3127
3128         /* Authentication keys */
3129         if (mhp->ext[SADB_EXT_KEY_AUTH] != NULL) {
3130                 const struct sadb_key *key0;
3131                 int len;
3132
3133                 key0 = (const struct sadb_key *)mhp->ext[SADB_EXT_KEY_AUTH];
3134                 len = mhp->extlen[SADB_EXT_KEY_AUTH];
3135
3136                 error = 0;
3137                 if (len < sizeof(*key0)) {
3138                         error = EINVAL;
3139                         goto fail;
3140                 }
3141                 switch (mhp->msg->sadb_msg_satype) {
3142                 case SADB_SATYPE_AH:
3143                 case SADB_SATYPE_ESP:
3144                 case SADB_X_SATYPE_TCPSIGNATURE:
3145                         if (len == PFKEY_ALIGN8(sizeof(struct sadb_key)) &&
3146                             sav->alg_auth != SADB_X_AALG_NULL)
3147                                 error = EINVAL;
3148                         break;
3149                 case SADB_X_SATYPE_IPCOMP:
3150                 default:
3151                         error = EINVAL;
3152                         break;
3153                 }
3154                 if (error) {
3155                         ipseclog((LOG_DEBUG, "%s: invalid key_auth values.\n",
3156                                 __func__));
3157                         goto fail;
3158                 }
3159
3160                 sav->key_auth = (struct seckey *)key_dup_keymsg(key0, len,
3161                                                                 M_IPSEC_MISC);
3162                 if (sav->key_auth == NULL ) {
3163                         ipseclog((LOG_DEBUG, "%s: No more memory.\n",
3164                                   __func__));
3165                         error = ENOBUFS;
3166                         goto fail;
3167                 }
3168         }
3169
3170         /* Encryption key */
3171         if (mhp->ext[SADB_EXT_KEY_ENCRYPT] != NULL) {
3172                 const struct sadb_key *key0;
3173                 int len;
3174
3175                 key0 = (const struct sadb_key *)mhp->ext[SADB_EXT_KEY_ENCRYPT];
3176                 len = mhp->extlen[SADB_EXT_KEY_ENCRYPT];
3177
3178                 error = 0;
3179                 if (len < sizeof(*key0)) {
3180                         error = EINVAL;
3181                         goto fail;
3182                 }
3183                 switch (mhp->msg->sadb_msg_satype) {
3184                 case SADB_SATYPE_ESP:
3185                         if (len == PFKEY_ALIGN8(sizeof(struct sadb_key)) &&
3186                             sav->alg_enc != SADB_EALG_NULL) {
3187                                 error = EINVAL;
3188                                 break;
3189                         }
3190                         sav->key_enc = (struct seckey *)key_dup_keymsg(key0,
3191                                                                        len,
3192                                                                        M_IPSEC_MISC);
3193                         if (sav->key_enc == NULL) {
3194                                 ipseclog((LOG_DEBUG, "%s: No more memory.\n",
3195                                         __func__));
3196                                 error = ENOBUFS;
3197                                 goto fail;
3198                         }
3199                         break;
3200                 case SADB_X_SATYPE_IPCOMP:
3201                         if (len != PFKEY_ALIGN8(sizeof(struct sadb_key)))
3202                                 error = EINVAL;
3203                         sav->key_enc = NULL;    /*just in case*/
3204                         break;
3205                 case SADB_SATYPE_AH:
3206                 case SADB_X_SATYPE_TCPSIGNATURE:
3207                 default:
3208                         error = EINVAL;
3209                         break;
3210                 }
3211                 if (error) {
3212                         ipseclog((LOG_DEBUG, "%s: invalid key_enc value.\n",
3213                                 __func__));
3214                         goto fail;
3215                 }
3216         }
3217
3218         /* set iv */
3219         sav->ivlen = 0;
3220
3221         switch (mhp->msg->sadb_msg_satype) {
3222         case SADB_SATYPE_AH:
3223                 error = xform_init(sav, XF_AH);
3224                 break;
3225         case SADB_SATYPE_ESP:
3226                 error = xform_init(sav, XF_ESP);
3227                 break;
3228         case SADB_X_SATYPE_IPCOMP:
3229                 error = xform_init(sav, XF_IPCOMP);
3230                 break;
3231         case SADB_X_SATYPE_TCPSIGNATURE:
3232                 error = xform_init(sav, XF_TCPSIGNATURE);
3233                 break;
3234         }
3235         if (error) {
3236                 ipseclog((LOG_DEBUG, "%s: unable to initialize SA type %u.\n",
3237                         __func__, mhp->msg->sadb_msg_satype));
3238                 goto fail;
3239         }
3240
3241         /* reset created */
3242         sav->created = time_second;
3243
3244         /* make lifetime for CURRENT */
3245         sav->lft_c = malloc(sizeof(struct seclifetime), M_IPSEC_MISC, M_NOWAIT);
3246         if (sav->lft_c == NULL) {
3247                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
3248                 error = ENOBUFS;
3249                 goto fail;
3250         }
3251
3252         sav->lft_c->allocations = 0;
3253         sav->lft_c->bytes = 0;
3254         sav->lft_c->addtime = time_second;
3255         sav->lft_c->usetime = 0;
3256
3257         /* lifetimes for HARD and SOFT */
3258     {
3259         const struct sadb_lifetime *lft0;
3260
3261         lft0 = (struct sadb_lifetime *)mhp->ext[SADB_EXT_LIFETIME_HARD];
3262         if (lft0 != NULL) {
3263                 if (mhp->extlen[SADB_EXT_LIFETIME_HARD] < sizeof(*lft0)) {
3264                         error = EINVAL;
3265                         goto fail;
3266                 }
3267                 sav->lft_h = key_dup_lifemsg(lft0, M_IPSEC_MISC);
3268                 if (sav->lft_h == NULL) {
3269                         ipseclog((LOG_DEBUG, "%s: No more memory.\n",__func__));
3270                         error = ENOBUFS;
3271                         goto fail;
3272                 }
3273                 /* to be initialize ? */
3274         }
3275
3276         lft0 = (struct sadb_lifetime *)mhp->ext[SADB_EXT_LIFETIME_SOFT];
3277         if (lft0 != NULL) {
3278                 if (mhp->extlen[SADB_EXT_LIFETIME_SOFT] < sizeof(*lft0)) {
3279                         error = EINVAL;
3280                         goto fail;
3281                 }
3282                 sav->lft_s = key_dup_lifemsg(lft0, M_IPSEC_MISC);
3283                 if (sav->lft_s == NULL) {
3284                         ipseclog((LOG_DEBUG, "%s: No more memory.\n",__func__));
3285                         error = ENOBUFS;
3286                         goto fail;
3287                 }
3288                 /* to be initialize ? */
3289         }
3290     }
3291
3292         return 0;
3293
3294  fail:
3295         /* initialization */
3296         key_cleansav(sav);
3297
3298         return error;
3299 }
3300
3301 /*
3302  * validation with a secasvar entry, and set SADB_SATYPE_MATURE.
3303  * OUT: 0:      valid
3304  *      other:  errno
3305  */
3306 static int
3307 key_mature(struct secasvar *sav)
3308 {
3309         int error;
3310
3311         /* check SPI value */
3312         switch (sav->sah->saidx.proto) {
3313         case IPPROTO_ESP:
3314         case IPPROTO_AH:
3315                 /*
3316                  * RFC 4302, 2.4. Security Parameters Index (SPI), SPI values
3317                  * 1-255 reserved by IANA for future use,
3318                  * 0 for implementation specific, local use.
3319                  */
3320                 if (ntohl(sav->spi) <= 255) {
3321                         ipseclog((LOG_DEBUG, "%s: illegal range of SPI %u.\n",
3322                             __func__, (u_int32_t)ntohl(sav->spi)));
3323                         return EINVAL;
3324                 }
3325                 break;
3326         }
3327
3328         /* check satype */
3329         switch (sav->sah->saidx.proto) {
3330         case IPPROTO_ESP:
3331                 /* check flags */
3332                 if ((sav->flags & (SADB_X_EXT_OLD|SADB_X_EXT_DERIV)) ==
3333                     (SADB_X_EXT_OLD|SADB_X_EXT_DERIV)) {
3334                         ipseclog((LOG_DEBUG, "%s: invalid flag (derived) "
3335                                 "given to old-esp.\n", __func__));
3336                         return EINVAL;
3337                 }
3338                 error = xform_init(sav, XF_ESP);
3339                 break;
3340         case IPPROTO_AH:
3341                 /* check flags */
3342                 if (sav->flags & SADB_X_EXT_DERIV) {
3343                         ipseclog((LOG_DEBUG, "%s: invalid flag (derived) "
3344                                 "given to AH SA.\n", __func__));
3345                         return EINVAL;
3346                 }
3347                 if (sav->alg_enc != SADB_EALG_NONE) {
3348                         ipseclog((LOG_DEBUG, "%s: protocol and algorithm "
3349                                 "mismated.\n", __func__));
3350                         return(EINVAL);
3351                 }
3352                 error = xform_init(sav, XF_AH);
3353                 break;
3354         case IPPROTO_IPCOMP:
3355                 if (sav->alg_auth != SADB_AALG_NONE) {
3356                         ipseclog((LOG_DEBUG, "%s: protocol and algorithm "
3357                                 "mismated.\n", __func__));
3358                         return(EINVAL);
3359                 }
3360                 if ((sav->flags & SADB_X_EXT_RAWCPI) == 0
3361                  && ntohl(sav->spi) >= 0x10000) {
3362                         ipseclog((LOG_DEBUG, "%s: invalid cpi for IPComp.\n",
3363                                 __func__));
3364                         return(EINVAL);
3365                 }
3366                 error = xform_init(sav, XF_IPCOMP);
3367                 break;
3368         case IPPROTO_TCP:
3369                 if (sav->alg_enc != SADB_EALG_NONE) {
3370                         ipseclog((LOG_DEBUG, "%s: protocol and algorithm "
3371                                 "mismated.\n", __func__));
3372                         return(EINVAL);
3373                 }
3374                 error = xform_init(sav, XF_TCPSIGNATURE);
3375                 break;
3376         default:
3377                 ipseclog((LOG_DEBUG, "%s: Invalid satype.\n", __func__));
3378                 error = EPROTONOSUPPORT;
3379                 break;
3380         }
3381         if (error == 0) {
3382                 SAHTREE_LOCK();
3383                 key_sa_chgstate(sav, SADB_SASTATE_MATURE);
3384                 SAHTREE_UNLOCK();
3385         }
3386         return (error);
3387 }
3388
3389 /*
3390  * subroutine for SADB_GET and SADB_DUMP.
3391  */
3392 static struct mbuf *
3393 key_setdumpsa(struct secasvar *sav, u_int8_t type, u_int8_t satype,
3394     u_int32_t seq, u_int32_t pid)
3395 {
3396         struct mbuf *result = NULL, *tres = NULL, *m;
3397         int i;
3398         int dumporder[] = {
3399                 SADB_EXT_SA, SADB_X_EXT_SA2,
3400                 SADB_EXT_LIFETIME_HARD, SADB_EXT_LIFETIME_SOFT,
3401                 SADB_EXT_LIFETIME_CURRENT, SADB_EXT_ADDRESS_SRC,
3402                 SADB_EXT_ADDRESS_DST, SADB_EXT_ADDRESS_PROXY, SADB_EXT_KEY_AUTH,
3403                 SADB_EXT_KEY_ENCRYPT, SADB_EXT_IDENTITY_SRC,
3404                 SADB_EXT_IDENTITY_DST, SADB_EXT_SENSITIVITY,
3405 #ifdef IPSEC_NAT_T
3406                 SADB_X_EXT_NAT_T_TYPE,
3407                 SADB_X_EXT_NAT_T_SPORT, SADB_X_EXT_NAT_T_DPORT,
3408                 SADB_X_EXT_NAT_T_OAI, SADB_X_EXT_NAT_T_OAR,
3409                 SADB_X_EXT_NAT_T_FRAG,
3410 #endif
3411         };
3412
3413         m = key_setsadbmsg(type, 0, satype, seq, pid, sav->refcnt);
3414         if (m == NULL)
3415                 goto fail;
3416         result = m;
3417
3418         for (i = sizeof(dumporder)/sizeof(dumporder[0]) - 1; i >= 0; i--) {
3419                 m = NULL;
3420                 switch (dumporder[i]) {
3421                 case SADB_EXT_SA:
3422                         m = key_setsadbsa(sav);
3423                         if (!m)
3424                                 goto fail;
3425                         break;
3426
3427                 case SADB_X_EXT_SA2:
3428                         m = key_setsadbxsa2(sav->sah->saidx.mode,
3429                                         sav->replay ? sav->replay->count : 0,
3430                                         sav->sah->saidx.reqid);
3431                         if (!m)
3432                                 goto fail;
3433                         break;
3434
3435                 case SADB_EXT_ADDRESS_SRC:
3436                         m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
3437                             &sav->sah->saidx.src.sa,
3438                             FULLMASK, IPSEC_ULPROTO_ANY);
3439                         if (!m)
3440                                 goto fail;
3441                         break;
3442
3443                 case SADB_EXT_ADDRESS_DST:
3444                         m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
3445                             &sav->sah->saidx.dst.sa,
3446                             FULLMASK, IPSEC_ULPROTO_ANY);
3447                         if (!m)
3448                                 goto fail;
3449                         break;
3450
3451                 case SADB_EXT_KEY_AUTH:
3452                         if (!sav->key_auth)
3453                                 continue;
3454                         m = key_setkey(sav->key_auth, SADB_EXT_KEY_AUTH);
3455                         if (!m)
3456                                 goto fail;
3457                         break;
3458
3459                 case SADB_EXT_KEY_ENCRYPT:
3460                         if (!sav->key_enc)
3461                                 continue;
3462                         m = key_setkey(sav->key_enc, SADB_EXT_KEY_ENCRYPT);
3463                         if (!m)
3464                                 goto fail;
3465                         break;
3466
3467                 case SADB_EXT_LIFETIME_CURRENT:
3468                         if (!sav->lft_c)
3469                                 continue;
3470                         m = key_setlifetime(sav->lft_c,
3471                                             SADB_EXT_LIFETIME_CURRENT);
3472                         if (!m)
3473                                 goto fail;
3474                         break;
3475
3476                 case SADB_EXT_LIFETIME_HARD:
3477                         if (!sav->lft_h)
3478                                 continue;
3479                         m = key_setlifetime(sav->lft_h,
3480                                             SADB_EXT_LIFETIME_HARD);
3481                         if (!m)
3482                                 goto fail;
3483                         break;
3484
3485                 case SADB_EXT_LIFETIME_SOFT:
3486                         if (!sav->lft_s)
3487                                 continue;
3488                         m = key_setlifetime(sav->lft_s,
3489                                             SADB_EXT_LIFETIME_SOFT);
3490
3491                         if (!m)
3492                                 goto fail;
3493                         break;
3494
3495 #ifdef IPSEC_NAT_T
3496                 case SADB_X_EXT_NAT_T_TYPE:
3497                         m = key_setsadbxtype(sav->natt_type);
3498                         if (!m)
3499                                 goto fail;
3500                         break;
3501
3502                 case SADB_X_EXT_NAT_T_DPORT:
3503                         m = key_setsadbxport(
3504                             KEY_PORTFROMSADDR(&sav->sah->saidx.dst),
3505                             SADB_X_EXT_NAT_T_DPORT);
3506                         if (!m)
3507                                 goto fail;
3508                         break;
3509
3510                 case SADB_X_EXT_NAT_T_SPORT:
3511                         m = key_setsadbxport(
3512                             KEY_PORTFROMSADDR(&sav->sah->saidx.src),
3513                             SADB_X_EXT_NAT_T_SPORT);
3514                         if (!m)
3515                                 goto fail;
3516                         break;
3517
3518                 case SADB_X_EXT_NAT_T_OAI:
3519                 case SADB_X_EXT_NAT_T_OAR:
3520                 case SADB_X_EXT_NAT_T_FRAG:
3521                         /* We do not (yet) support those. */
3522                         continue;
3523 #endif
3524
3525                 case SADB_EXT_ADDRESS_PROXY:
3526                 case SADB_EXT_IDENTITY_SRC:
3527                 case SADB_EXT_IDENTITY_DST:
3528                         /* XXX: should we brought from SPD ? */
3529                 case SADB_EXT_SENSITIVITY:
3530                 default:
3531                         continue;
3532                 }
3533
3534                 if (!m)
3535                         goto fail;
3536                 if (tres)
3537                         m_cat(m, tres);
3538                 tres = m;
3539
3540         }
3541
3542         m_cat(result, tres);
3543         if (result->m_len < sizeof(struct sadb_msg)) {
3544                 result = m_pullup(result, sizeof(struct sadb_msg));
3545                 if (result == NULL)
3546                         goto fail;
3547         }
3548
3549         result->m_pkthdr.len = 0;
3550         for (m = result; m; m = m->m_next)
3551                 result->m_pkthdr.len += m->m_len;
3552
3553         mtod(result, struct sadb_msg *)->sadb_msg_len =
3554             PFKEY_UNIT64(result->m_pkthdr.len);
3555
3556         return result;
3557
3558 fail:
3559         m_freem(result);
3560         m_freem(tres);
3561         return NULL;
3562 }
3563
3564 /*
3565  * set data into sadb_msg.
3566  */
3567 static struct mbuf *
3568 key_setsadbmsg(u_int8_t type, u_int16_t tlen, u_int8_t satype, u_int32_t seq,
3569     pid_t pid, u_int16_t reserved)
3570 {
3571         struct mbuf *m;
3572         struct sadb_msg *p;
3573         int len;
3574
3575         len = PFKEY_ALIGN8(sizeof(struct sadb_msg));
3576         if (len > MCLBYTES)
3577                 return NULL;
3578         MGETHDR(m, M_NOWAIT, MT_DATA);
3579         if (m && len > MHLEN) {
3580                 MCLGET(m, M_NOWAIT);
3581                 if ((m->m_flags & M_EXT) == 0) {
3582                         m_freem(m);
3583                         m = NULL;
3584                 }
3585         }
3586         if (!m)
3587                 return NULL;
3588         m->m_pkthdr.len = m->m_len = len;
3589         m->m_next = NULL;
3590
3591         p = mtod(m, struct sadb_msg *);
3592
3593         bzero(p, len);
3594         p->sadb_msg_version = PF_KEY_V2;
3595         p->sadb_msg_type = type;
3596         p->sadb_msg_errno = 0;
3597         p->sadb_msg_satype = satype;
3598         p->sadb_msg_len = PFKEY_UNIT64(tlen);
3599         p->sadb_msg_reserved = reserved;
3600         p->sadb_msg_seq = seq;
3601         p->sadb_msg_pid = (u_int32_t)pid;
3602
3603         return m;
3604 }
3605
3606 /*
3607  * copy secasvar data into sadb_address.
3608  */
3609 static struct mbuf *
3610 key_setsadbsa(sav)
3611         struct secasvar *sav;
3612 {
3613         struct mbuf *m;
3614         struct sadb_sa *p;
3615         int len;
3616
3617         len = PFKEY_ALIGN8(sizeof(struct sadb_sa));
3618         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
3619         if (m == NULL)
3620                 return (NULL);
3621         m_align(m, len);
3622         m->m_len = len;
3623         p = mtod(m, struct sadb_sa *);
3624         bzero(p, len);
3625         p->sadb_sa_len = PFKEY_UNIT64(len);
3626         p->sadb_sa_exttype = SADB_EXT_SA;
3627         p->sadb_sa_spi = sav->spi;
3628         p->sadb_sa_replay = (sav->replay != NULL ? sav->replay->wsize : 0);
3629         p->sadb_sa_state = sav->state;
3630         p->sadb_sa_auth = sav->alg_auth;
3631         p->sadb_sa_encrypt = sav->alg_enc;
3632         p->sadb_sa_flags = sav->flags;
3633
3634         return m;
3635 }
3636
3637 /*
3638  * set data into sadb_address.
3639  */
3640 static struct mbuf *
3641 key_setsadbaddr(u_int16_t exttype, const struct sockaddr *saddr, u_int8_t prefixlen, u_int16_t ul_proto)
3642 {
3643         struct mbuf *m;
3644         struct sadb_address *p;
3645         size_t len;
3646
3647         len = PFKEY_ALIGN8(sizeof(struct sadb_address)) +
3648             PFKEY_ALIGN8(saddr->sa_len);
3649         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
3650         if (m == NULL)
3651                 return (NULL);
3652         m_align(m, len);
3653         m->m_len = len;
3654         p = mtod(m, struct sadb_address *);
3655
3656         bzero(p, len);
3657         p->sadb_address_len = PFKEY_UNIT64(len);
3658         p->sadb_address_exttype = exttype;
3659         p->sadb_address_proto = ul_proto;
3660         if (prefixlen == FULLMASK) {
3661                 switch (saddr->sa_family) {
3662                 case AF_INET:
3663                         prefixlen = sizeof(struct in_addr) << 3;
3664                         break;
3665                 case AF_INET6:
3666                         prefixlen = sizeof(struct in6_addr) << 3;
3667                         break;
3668                 default:
3669                         ; /*XXX*/
3670                 }
3671         }
3672         p->sadb_address_prefixlen = prefixlen;
3673         p->sadb_address_reserved = 0;
3674
3675         bcopy(saddr,
3676             mtod(m, caddr_t) + PFKEY_ALIGN8(sizeof(struct sadb_address)),
3677             saddr->sa_len);
3678
3679         return m;
3680 }
3681
3682 /*
3683  * set data into sadb_x_sa2.
3684  */
3685 static struct mbuf *
3686 key_setsadbxsa2(u_int8_t mode, u_int32_t seq, u_int32_t reqid)
3687 {
3688         struct mbuf *m;
3689         struct sadb_x_sa2 *p;
3690         size_t len;
3691
3692         len = PFKEY_ALIGN8(sizeof(struct sadb_x_sa2));
3693         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
3694         if (m == NULL)
3695                 return (NULL);
3696         m_align(m, len);
3697         m->m_len = len;
3698         p = mtod(m, struct sadb_x_sa2 *);
3699
3700         bzero(p, len);
3701         p->sadb_x_sa2_len = PFKEY_UNIT64(len);
3702         p->sadb_x_sa2_exttype = SADB_X_EXT_SA2;
3703         p->sadb_x_sa2_mode = mode;
3704         p->sadb_x_sa2_reserved1 = 0;
3705         p->sadb_x_sa2_reserved2 = 0;
3706         p->sadb_x_sa2_sequence = seq;
3707         p->sadb_x_sa2_reqid = reqid;
3708
3709         return m;
3710 }
3711
3712 #ifdef IPSEC_NAT_T
3713 /*
3714  * Set a type in sadb_x_nat_t_type.
3715  */
3716 static struct mbuf *
3717 key_setsadbxtype(u_int16_t type)
3718 {
3719         struct mbuf *m;
3720         size_t len;
3721         struct sadb_x_nat_t_type *p;
3722
3723         len = PFKEY_ALIGN8(sizeof(struct sadb_x_nat_t_type));
3724
3725         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
3726         if (m == NULL)
3727                 return (NULL);
3728         m_align(m, len);
3729         m->m_len = len;
3730         p = mtod(m, struct sadb_x_nat_t_type *);
3731
3732         bzero(p, len);
3733         p->sadb_x_nat_t_type_len = PFKEY_UNIT64(len);
3734         p->sadb_x_nat_t_type_exttype = SADB_X_EXT_NAT_T_TYPE;
3735         p->sadb_x_nat_t_type_type = type;
3736
3737         return (m);
3738 }
3739 /*
3740  * Set a port in sadb_x_nat_t_port.
3741  * In contrast to default RFC 2367 behaviour, port is in network byte order.
3742  */
3743 static struct mbuf *
3744 key_setsadbxport(u_int16_t port, u_int16_t type)
3745 {
3746         struct mbuf *m;
3747         size_t len;
3748         struct sadb_x_nat_t_port *p;
3749
3750         len = PFKEY_ALIGN8(sizeof(struct sadb_x_nat_t_port));
3751
3752         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
3753         if (m == NULL)
3754                 return (NULL);
3755         m_align(m, len);
3756         m->m_len = len;
3757         p = mtod(m, struct sadb_x_nat_t_port *);
3758
3759         bzero(p, len);
3760         p->sadb_x_nat_t_port_len = PFKEY_UNIT64(len);
3761         p->sadb_x_nat_t_port_exttype = type;
3762         p->sadb_x_nat_t_port_port = port;
3763
3764         return (m);
3765 }
3766
3767 /*
3768  * Get port from sockaddr. Port is in network byte order.
3769  */
3770 u_int16_t
3771 key_portfromsaddr(struct sockaddr *sa)
3772 {
3773
3774         switch (sa->sa_family) {
3775 #ifdef INET
3776         case AF_INET:
3777                 return ((struct sockaddr_in *)sa)->sin_port;
3778 #endif
3779 #ifdef INET6
3780         case AF_INET6:
3781                 return ((struct sockaddr_in6 *)sa)->sin6_port;
3782 #endif
3783         }
3784         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
3785                 printf("DP %s unexpected address family %d\n",
3786                         __func__, sa->sa_family));
3787         return (0);
3788 }
3789 #endif /* IPSEC_NAT_T */
3790
3791 /*
3792  * Set port in struct sockaddr. Port is in network byte order.
3793  */
3794 static void
3795 key_porttosaddr(struct sockaddr *sa, u_int16_t port)
3796 {
3797
3798         switch (sa->sa_family) {
3799 #ifdef INET
3800         case AF_INET:
3801                 ((struct sockaddr_in *)sa)->sin_port = port;
3802                 break;
3803 #endif
3804 #ifdef INET6
3805         case AF_INET6:
3806                 ((struct sockaddr_in6 *)sa)->sin6_port = port;
3807                 break;
3808 #endif
3809         default:
3810                 ipseclog((LOG_DEBUG, "%s: unexpected address family %d.\n",
3811                         __func__, sa->sa_family));
3812                 break;
3813         }
3814 }
3815
3816 /*
3817  * set data into sadb_x_policy
3818  */
3819 static struct mbuf *
3820 key_setsadbxpolicy(u_int16_t type, u_int8_t dir, u_int32_t id)
3821 {
3822         struct mbuf *m;
3823         struct sadb_x_policy *p;
3824         size_t len;
3825
3826         len = PFKEY_ALIGN8(sizeof(struct sadb_x_policy));
3827         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
3828         if (m == NULL)
3829                 return (NULL);
3830         m_align(m, len);
3831         m->m_len = len;
3832         p = mtod(m, struct sadb_x_policy *);
3833
3834         bzero(p, len);
3835         p->sadb_x_policy_len = PFKEY_UNIT64(len);
3836         p->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
3837         p->sadb_x_policy_type = type;
3838         p->sadb_x_policy_dir = dir;
3839         p->sadb_x_policy_id = id;
3840
3841         return m;
3842 }
3843
3844 /* %%% utilities */
3845 /* Take a key message (sadb_key) from the socket and turn it into one
3846  * of the kernel's key structures (seckey).
3847  *
3848  * IN: pointer to the src
3849  * OUT: NULL no more memory
3850  */
3851 struct seckey *
3852 key_dup_keymsg(const struct sadb_key *src, u_int len,
3853                struct malloc_type *type)
3854 {
3855         struct seckey *dst;
3856         dst = (struct seckey *)malloc(sizeof(struct seckey), type, M_NOWAIT);
3857         if (dst != NULL) {
3858                 dst->bits = src->sadb_key_bits;
3859                 dst->key_data = (char *)malloc(len, type, M_NOWAIT);
3860                 if (dst->key_data != NULL) {
3861                         bcopy((const char *)src + sizeof(struct sadb_key),
3862                               dst->key_data, len);
3863                 } else {
3864                         ipseclog((LOG_DEBUG, "%s: No more memory.\n",
3865                                   __func__));
3866                         free(dst, type);
3867                         dst = NULL;
3868                 }
3869         } else {
3870                 ipseclog((LOG_DEBUG, "%s: No more memory.\n",
3871                           __func__));
3872
3873         }
3874         return dst;
3875 }
3876
3877 /* Take a lifetime message (sadb_lifetime) passed in on a socket and
3878  * turn it into one of the kernel's lifetime structures (seclifetime).
3879  *
3880  * IN: pointer to the destination, source and malloc type
3881  * OUT: NULL, no more memory
3882  */
3883
3884 static struct seclifetime *
3885 key_dup_lifemsg(const struct sadb_lifetime *src,
3886                  struct malloc_type *type)
3887 {
3888         struct seclifetime *dst = NULL;
3889
3890         dst = (struct seclifetime *)malloc(sizeof(struct seclifetime),
3891                                            type, M_NOWAIT);
3892         if (dst == NULL) {
3893                 /* XXX counter */
3894                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
3895         } else {
3896                 dst->allocations = src->sadb_lifetime_allocations;
3897                 dst->bytes = src->sadb_lifetime_bytes;
3898                 dst->addtime = src->sadb_lifetime_addtime;
3899                 dst->usetime = src->sadb_lifetime_usetime;
3900         }
3901         return dst;
3902 }
3903
3904 /* compare my own address
3905  * OUT: 1: true, i.e. my address.
3906  *      0: false
3907  */
3908 int
3909 key_ismyaddr(sa)
3910         struct sockaddr *sa;
3911 {
3912 #ifdef INET
3913         struct sockaddr_in *sin;
3914         struct in_ifaddr *ia;
3915 #endif
3916
3917         IPSEC_ASSERT(sa != NULL, ("null sockaddr"));
3918
3919         switch (sa->sa_family) {
3920 #ifdef INET
3921         case AF_INET:
3922                 sin = (struct sockaddr_in *)sa;
3923                 IN_IFADDR_RLOCK();
3924                 TAILQ_FOREACH(ia, &V_in_ifaddrhead, ia_link)
3925                 {
3926                         if (sin->sin_family == ia->ia_addr.sin_family &&
3927                             sin->sin_len == ia->ia_addr.sin_len &&
3928                             sin->sin_addr.s_addr == ia->ia_addr.sin_addr.s_addr)
3929                         {
3930                                 IN_IFADDR_RUNLOCK();
3931                                 return 1;
3932                         }
3933                 }
3934                 IN_IFADDR_RUNLOCK();
3935                 break;
3936 #endif
3937 #ifdef INET6
3938         case AF_INET6:
3939                 return key_ismyaddr6((struct sockaddr_in6 *)sa);
3940 #endif
3941         }
3942
3943         return 0;
3944 }
3945
3946 #ifdef INET6
3947 /*
3948  * compare my own address for IPv6.
3949  * 1: ours
3950  * 0: other
3951  * NOTE: derived ip6_input() in KAME. This is necessary to modify more.
3952  */
3953 #include <netinet6/in6_var.h>
3954
3955 static int
3956 key_ismyaddr6(sin6)
3957         struct sockaddr_in6 *sin6;
3958 {
3959         struct in6_ifaddr *ia;
3960 #if 0
3961         struct in6_multi *in6m;
3962 #endif
3963
3964         IN6_IFADDR_RLOCK();
3965         TAILQ_FOREACH(ia, &V_in6_ifaddrhead, ia_link) {
3966                 if (key_sockaddrcmp((struct sockaddr *)&sin6,
3967                     (struct sockaddr *)&ia->ia_addr, 0) == 0) {
3968                         IN6_IFADDR_RUNLOCK();
3969                         return 1;
3970                 }
3971
3972 #if 0
3973                 /*
3974                  * XXX Multicast
3975                  * XXX why do we care about multlicast here while we don't care
3976                  * about IPv4 multicast??
3977                  * XXX scope
3978                  */
3979                 in6m = NULL;
3980                 IN6_LOOKUP_MULTI(sin6->sin6_addr, ia->ia_ifp, in6m);
3981                 if (in6m) {
3982                         IN6_IFADDR_RUNLOCK();
3983                         return 1;
3984                 }
3985 #endif
3986         }
3987         IN6_IFADDR_RUNLOCK();
3988
3989         /* loopback, just for safety */
3990         if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
3991                 return 1;
3992
3993         return 0;
3994 }
3995 #endif /*INET6*/
3996
3997 /*
3998  * compare two secasindex structure.
3999  * flag can specify to compare 2 saidxes.
4000  * compare two secasindex structure without both mode and reqid.
4001  * don't compare port.
4002  * IN:
4003  *      saidx0: source, it can be in SAD.
4004  *      saidx1: object.
4005  * OUT:
4006  *      1 : equal
4007  *      0 : not equal
4008  */
4009 static int
4010 key_cmpsaidx(
4011         const struct secasindex *saidx0,
4012         const struct secasindex *saidx1,
4013         int flag)
4014 {
4015         int chkport = 0;
4016
4017         /* sanity */
4018         if (saidx0 == NULL && saidx1 == NULL)
4019                 return 1;
4020
4021         if (saidx0 == NULL || saidx1 == NULL)
4022                 return 0;
4023
4024         if (saidx0->proto != saidx1->proto)
4025                 return 0;
4026
4027         if (flag == CMP_EXACTLY) {
4028                 if (saidx0->mode != saidx1->mode)
4029                         return 0;
4030                 if (saidx0->reqid != saidx1->reqid)
4031                         return 0;
4032                 if (bcmp(&saidx0->src, &saidx1->src, saidx0->src.sa.sa_len) != 0 ||
4033                     bcmp(&saidx0->dst, &saidx1->dst, saidx0->dst.sa.sa_len) != 0)
4034                         return 0;
4035         } else {
4036
4037                 /* CMP_MODE_REQID, CMP_REQID, CMP_HEAD */
4038                 if (flag == CMP_MODE_REQID
4039                   ||flag == CMP_REQID) {
4040                         /*
4041                          * If reqid of SPD is non-zero, unique SA is required.
4042                          * The result must be of same reqid in this case.
4043                          */
4044                         if (saidx1->reqid != 0 && saidx0->reqid != saidx1->reqid)
4045                                 return 0;
4046                 }
4047
4048                 if (flag == CMP_MODE_REQID) {
4049                         if (saidx0->mode != IPSEC_MODE_ANY
4050                          && saidx0->mode != saidx1->mode)
4051                                 return 0;
4052                 }
4053
4054 #ifdef IPSEC_NAT_T
4055                 /*
4056                  * If NAT-T is enabled, check ports for tunnel mode.
4057                  * Do not check ports if they are set to zero in the SPD.
4058                  * Also do not do it for native transport mode, as there
4059                  * is no port information available in the SP.
4060                  */
4061                 if ((saidx1->mode == IPSEC_MODE_TUNNEL ||
4062                      (saidx1->mode == IPSEC_MODE_TRANSPORT &&
4063                       saidx1->proto == IPPROTO_ESP)) &&
4064                     saidx1->src.sa.sa_family == AF_INET &&
4065                     saidx1->dst.sa.sa_family == AF_INET &&
4066                     ((const struct sockaddr_in *)(&saidx1->src))->sin_port &&
4067                     ((const struct sockaddr_in *)(&saidx1->dst))->sin_port)
4068                         chkport = 1;
4069 #endif /* IPSEC_NAT_T */
4070
4071                 if (key_sockaddrcmp(&saidx0->src.sa, &saidx1->src.sa, chkport) != 0) {
4072                         return 0;
4073                 }
4074                 if (key_sockaddrcmp(&saidx0->dst.sa, &saidx1->dst.sa, chkport) != 0) {
4075                         return 0;
4076                 }
4077         }
4078
4079         return 1;
4080 }
4081
4082 /*
4083  * compare two secindex structure exactly.
4084  * IN:
4085  *      spidx0: source, it is often in SPD.
4086  *      spidx1: object, it is often from PFKEY message.
4087  * OUT:
4088  *      1 : equal
4089  *      0 : not equal
4090  */
4091 static int
4092 key_cmpspidx_exactly(
4093         struct secpolicyindex *spidx0,
4094         struct secpolicyindex *spidx1)
4095 {
4096         /* sanity */
4097         if (spidx0 == NULL && spidx1 == NULL)
4098                 return 1;
4099
4100         if (spidx0 == NULL || spidx1 == NULL)
4101                 return 0;
4102
4103         if (spidx0->prefs != spidx1->prefs
4104          || spidx0->prefd != spidx1->prefd
4105          || spidx0->ul_proto != spidx1->ul_proto)
4106                 return 0;
4107
4108         return key_sockaddrcmp(&spidx0->src.sa, &spidx1->src.sa, 1) == 0 &&
4109                key_sockaddrcmp(&spidx0->dst.sa, &spidx1->dst.sa, 1) == 0;
4110 }
4111
4112 /*
4113  * compare two secindex structure with mask.
4114  * IN:
4115  *      spidx0: source, it is often in SPD.
4116  *      spidx1: object, it is often from IP header.
4117  * OUT:
4118  *      1 : equal
4119  *      0 : not equal
4120  */
4121 static int
4122 key_cmpspidx_withmask(
4123         struct secpolicyindex *spidx0,
4124         struct secpolicyindex *spidx1)
4125 {
4126         /* sanity */
4127         if (spidx0 == NULL && spidx1 == NULL)
4128                 return 1;
4129
4130         if (spidx0 == NULL || spidx1 == NULL)
4131                 return 0;
4132
4133         if (spidx0->src.sa.sa_family != spidx1->src.sa.sa_family ||
4134             spidx0->dst.sa.sa_family != spidx1->dst.sa.sa_family ||
4135             spidx0->src.sa.sa_len != spidx1->src.sa.sa_len ||
4136             spidx0->dst.sa.sa_len != spidx1->dst.sa.sa_len)
4137                 return 0;
4138
4139         /* if spidx.ul_proto == IPSEC_ULPROTO_ANY, ignore. */
4140         if (spidx0->ul_proto != (u_int16_t)IPSEC_ULPROTO_ANY
4141          && spidx0->ul_proto != spidx1->ul_proto)
4142                 return 0;
4143
4144         switch (spidx0->src.sa.sa_family) {
4145         case AF_INET:
4146                 if (spidx0->src.sin.sin_port != IPSEC_PORT_ANY
4147                  && spidx0->src.sin.sin_port != spidx1->src.sin.sin_port)
4148                         return 0;
4149                 if (!key_bbcmp(&spidx0->src.sin.sin_addr,
4150                     &spidx1->src.sin.sin_addr, spidx0->prefs))
4151                         return 0;
4152                 break;
4153         case AF_INET6:
4154                 if (spidx0->src.sin6.sin6_port != IPSEC_PORT_ANY
4155                  && spidx0->src.sin6.sin6_port != spidx1->src.sin6.sin6_port)
4156                         return 0;
4157                 /*
4158                  * scope_id check. if sin6_scope_id is 0, we regard it
4159                  * as a wildcard scope, which matches any scope zone ID.
4160                  */
4161                 if (spidx0->src.sin6.sin6_scope_id &&
4162                     spidx1->src.sin6.sin6_scope_id &&
4163                     spidx0->src.sin6.sin6_scope_id != spidx1->src.sin6.sin6_scope_id)
4164                         return 0;
4165                 if (!key_bbcmp(&spidx0->src.sin6.sin6_addr,
4166                     &spidx1->src.sin6.sin6_addr, spidx0->prefs))
4167                         return 0;
4168                 break;
4169         default:
4170                 /* XXX */
4171                 if (bcmp(&spidx0->src, &spidx1->src, spidx0->src.sa.sa_len) != 0)
4172                         return 0;
4173                 break;
4174         }
4175
4176         switch (spidx0->dst.sa.sa_family) {
4177         case AF_INET:
4178                 if (spidx0->dst.sin.sin_port != IPSEC_PORT_ANY
4179                  && spidx0->dst.sin.sin_port != spidx1->dst.sin.sin_port)
4180                         return 0;
4181                 if (!key_bbcmp(&spidx0->dst.sin.sin_addr,
4182                     &spidx1->dst.sin.sin_addr, spidx0->prefd))
4183                         return 0;
4184                 break;
4185         case AF_INET6:
4186                 if (spidx0->dst.sin6.sin6_port != IPSEC_PORT_ANY
4187                  && spidx0->dst.sin6.sin6_port != spidx1->dst.sin6.sin6_port)
4188                         return 0;
4189                 /*
4190                  * scope_id check. if sin6_scope_id is 0, we regard it
4191                  * as a wildcard scope, which matches any scope zone ID.
4192                  */
4193                 if (spidx0->dst.sin6.sin6_scope_id &&
4194                     spidx1->dst.sin6.sin6_scope_id &&
4195                     spidx0->dst.sin6.sin6_scope_id != spidx1->dst.sin6.sin6_scope_id)
4196                         return 0;
4197                 if (!key_bbcmp(&spidx0->dst.sin6.sin6_addr,
4198                     &spidx1->dst.sin6.sin6_addr, spidx0->prefd))
4199                         return 0;
4200                 break;
4201         default:
4202                 /* XXX */
4203                 if (bcmp(&spidx0->dst, &spidx1->dst, spidx0->dst.sa.sa_len) != 0)
4204                         return 0;
4205                 break;
4206         }
4207
4208         /* XXX Do we check other field ?  e.g. flowinfo */
4209
4210         return 1;
4211 }
4212
4213 /* returns 0 on match */
4214 static int
4215 key_sockaddrcmp(
4216         const struct sockaddr *sa1,
4217         const struct sockaddr *sa2,
4218         int port)
4219 {
4220 #ifdef satosin
4221 #undef satosin
4222 #endif
4223 #define satosin(s) ((const struct sockaddr_in *)s)
4224 #ifdef satosin6
4225 #undef satosin6
4226 #endif
4227 #define satosin6(s) ((const struct sockaddr_in6 *)s)
4228         if (sa1->sa_family != sa2->sa_family || sa1->sa_len != sa2->sa_len)
4229                 return 1;
4230
4231         switch (sa1->sa_family) {
4232         case AF_INET:
4233                 if (sa1->sa_len != sizeof(struct sockaddr_in))
4234                         return 1;
4235                 if (satosin(sa1)->sin_addr.s_addr !=
4236                     satosin(sa2)->sin_addr.s_addr) {
4237                         return 1;
4238                 }
4239                 if (port && satosin(sa1)->sin_port != satosin(sa2)->sin_port)
4240                         return 1;
4241                 break;
4242         case AF_INET6:
4243                 if (sa1->sa_len != sizeof(struct sockaddr_in6))
4244                         return 1;       /*EINVAL*/
4245                 if (satosin6(sa1)->sin6_scope_id !=
4246                     satosin6(sa2)->sin6_scope_id) {
4247                         return 1;
4248                 }
4249                 if (!IN6_ARE_ADDR_EQUAL(&satosin6(sa1)->sin6_addr,
4250                     &satosin6(sa2)->sin6_addr)) {
4251                         return 1;
4252                 }
4253                 if (port &&
4254                     satosin6(sa1)->sin6_port != satosin6(sa2)->sin6_port) {
4255                         return 1;
4256                 }
4257                 break;
4258         default:
4259                 if (bcmp(sa1, sa2, sa1->sa_len) != 0)
4260                         return 1;
4261                 break;
4262         }
4263
4264         return 0;
4265 #undef satosin
4266 #undef satosin6
4267 }
4268
4269 /*
4270  * compare two buffers with mask.
4271  * IN:
4272  *      addr1: source
4273  *      addr2: object
4274  *      bits:  Number of bits to compare
4275  * OUT:
4276  *      1 : equal
4277  *      0 : not equal
4278  */
4279 static int
4280 key_bbcmp(const void *a1, const void *a2, u_int bits)
4281 {
4282         const unsigned char *p1 = a1;
4283         const unsigned char *p2 = a2;
4284
4285         /* XXX: This could be considerably faster if we compare a word
4286          * at a time, but it is complicated on LSB Endian machines */
4287
4288         /* Handle null pointers */
4289         if (p1 == NULL || p2 == NULL)
4290                 return (p1 == p2);
4291
4292         while (bits >= 8) {
4293                 if (*p1++ != *p2++)
4294                         return 0;
4295                 bits -= 8;
4296         }
4297
4298         if (bits > 0) {
4299                 u_int8_t mask = ~((1<<(8-bits))-1);
4300                 if ((*p1 & mask) != (*p2 & mask))
4301                         return 0;
4302         }
4303         return 1;       /* Match! */
4304 }
4305
4306 static void
4307 key_flush_spd(time_t now)
4308 {
4309         static u_int16_t sptree_scangen = 0;
4310         u_int16_t gen = sptree_scangen++;
4311         struct secpolicy *sp;
4312         u_int dir;
4313
4314         /* SPD */
4315         for (dir = 0; dir < IPSEC_DIR_MAX; dir++) {
4316 restart:
4317                 SPTREE_LOCK();
4318                 LIST_FOREACH(sp, &V_sptree[dir], chain) {
4319                         if (sp->scangen == gen)         /* previously handled */
4320                                 continue;
4321                         sp->scangen = gen;
4322                         if (sp->state == IPSEC_SPSTATE_DEAD &&
4323                             sp->refcnt == 1) {
4324                                 /*
4325                                  * Ensure that we only decrease refcnt once,
4326                                  * when we're the last consumer.
4327                                  * Directly call SP_DELREF/key_delsp instead
4328                                  * of KEY_FREESP to avoid unlocking/relocking
4329                                  * SPTREE_LOCK before key_delsp: may refcnt
4330                                  * be increased again during that time ?
4331                                  * NB: also clean entries created by
4332                                  * key_spdflush
4333                                  */
4334                                 SP_DELREF(sp);
4335                                 key_delsp(sp);
4336                                 SPTREE_UNLOCK();
4337                                 goto restart;
4338                         }
4339                         if (sp->lifetime == 0 && sp->validtime == 0)
4340                                 continue;
4341                         if ((sp->lifetime && now - sp->created > sp->lifetime)
4342                          || (sp->validtime && now - sp->lastused > sp->validtime)) {
4343                                 sp->state = IPSEC_SPSTATE_DEAD;
4344                                 SPTREE_UNLOCK();
4345                                 key_spdexpire(sp);
4346                                 goto restart;
4347                         }
4348                 }
4349                 SPTREE_UNLOCK();
4350         }
4351 }
4352
4353 static void
4354 key_flush_sad(time_t now)
4355 {
4356         struct secashead *sah, *nextsah;
4357         struct secasvar *sav, *nextsav;
4358
4359         /* SAD */
4360         SAHTREE_LOCK();
4361         LIST_FOREACH_SAFE(sah, &V_sahtree, chain, nextsah) {
4362                 /* if sah has been dead, then delete it and process next sah. */
4363                 if (sah->state == SADB_SASTATE_DEAD) {
4364                         key_delsah(sah);
4365                         continue;
4366                 }
4367
4368                 /* if LARVAL entry doesn't become MATURE, delete it. */
4369                 LIST_FOREACH_SAFE(sav, &sah->savtree[SADB_SASTATE_LARVAL], chain, nextsav) {
4370                         /* Need to also check refcnt for a larval SA ??? */
4371                         if (now - sav->created > V_key_larval_lifetime)
4372                                 KEY_FREESAV(&sav);
4373                 }
4374
4375                 /*
4376                  * check MATURE entry to start to send expire message
4377                  * whether or not.
4378                  */
4379                 LIST_FOREACH_SAFE(sav, &sah->savtree[SADB_SASTATE_MATURE], chain, nextsav) {
4380                         /* we don't need to check. */
4381                         if (sav->lft_s == NULL)
4382                                 continue;
4383
4384                         /* sanity check */
4385                         if (sav->lft_c == NULL) {
4386                                 ipseclog((LOG_DEBUG,"%s: there is no CURRENT "
4387                                         "time, why?\n", __func__));
4388                                 continue;
4389                         }
4390
4391                         /* check SOFT lifetime */
4392                         if (sav->lft_s->addtime != 0 &&
4393                             now - sav->created > sav->lft_s->addtime) {
4394                                 key_sa_chgstate(sav, SADB_SASTATE_DYING);
4395                                 /*
4396                                  * Actually, only send expire message if
4397                                  * SA has been used, as it was done before,
4398                                  * but should we always send such message,
4399                                  * and let IKE daemon decide if it should be
4400                                  * renegotiated or not ?
4401                                  * XXX expire message will actually NOT be
4402                                  * sent if SA is only used after soft
4403                                  * lifetime has been reached, see below
4404                                  * (DYING state)
4405                                  */
4406                                 if (sav->lft_c->usetime != 0)
4407                                         key_expire(sav);
4408                         }
4409                         /* check SOFT lifetime by bytes */
4410                         /*
4411                          * XXX I don't know the way to delete this SA
4412                          * when new SA is installed.  Caution when it's
4413                          * installed too big lifetime by time.
4414                          */
4415                         else if (sav->lft_s->bytes != 0 &&
4416                             sav->lft_s->bytes < sav->lft_c->bytes) {
4417
4418                                 key_sa_chgstate(sav, SADB_SASTATE_DYING);
4419                                 /*
4420                                  * XXX If we keep to send expire
4421                                  * message in the status of
4422                                  * DYING. Do remove below code.
4423                                  */
4424                                 key_expire(sav);
4425                         }
4426                 }
4427
4428                 /* check DYING entry to change status to DEAD. */
4429                 LIST_FOREACH_SAFE(sav, &sah->savtree[SADB_SASTATE_DYING], chain, nextsav) {
4430                         /* we don't need to check. */
4431                         if (sav->lft_h == NULL)
4432                                 continue;
4433
4434                         /* sanity check */
4435                         if (sav->lft_c == NULL) {
4436                                 ipseclog((LOG_DEBUG, "%s: there is no CURRENT "
4437                                         "time, why?\n", __func__));
4438                                 continue;
4439                         }
4440
4441                         if (sav->lft_h->addtime != 0 &&
4442                             now - sav->created > sav->lft_h->addtime) {
4443                                 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
4444                                 KEY_FREESAV(&sav);
4445                         }
4446 #if 0   /* XXX Should we keep to send expire message until HARD lifetime ? */
4447                         else if (sav->lft_s != NULL
4448                               && sav->lft_s->addtime != 0
4449                               && now - sav->created > sav->lft_s->addtime) {
4450                                 /*
4451                                  * XXX: should be checked to be
4452                                  * installed the valid SA.
4453                                  */
4454
4455                                 /*
4456                                  * If there is no SA then sending
4457                                  * expire message.
4458                                  */
4459                                 key_expire(sav);
4460                         }
4461 #endif
4462                         /* check HARD lifetime by bytes */
4463                         else if (sav->lft_h->bytes != 0 &&
4464                             sav->lft_h->bytes < sav->lft_c->bytes) {
4465                                 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
4466                                 KEY_FREESAV(&sav);
4467                         }
4468                 }
4469
4470                 /* delete entry in DEAD */
4471                 LIST_FOREACH_SAFE(sav, &sah->savtree[SADB_SASTATE_DEAD], chain, nextsav) {
4472                         /* sanity check */
4473                         if (sav->state != SADB_SASTATE_DEAD) {
4474                                 ipseclog((LOG_DEBUG, "%s: invalid sav->state "
4475                                         "(queue: %d SA: %d): kill it anyway\n",
4476                                         __func__,
4477                                         SADB_SASTATE_DEAD, sav->state));
4478                         }
4479                         /*
4480                          * do not call key_freesav() here.
4481                          * sav should already be freed, and sav->refcnt
4482                          * shows other references to sav
4483                          * (such as from SPD).
4484                          */
4485                 }
4486         }
4487         SAHTREE_UNLOCK();
4488 }
4489
4490 static void
4491 key_flush_acq(time_t now)
4492 {
4493         struct secacq *acq, *nextacq;
4494
4495         /* ACQ tree */
4496         ACQ_LOCK();
4497         for (acq = LIST_FIRST(&V_acqtree); acq != NULL; acq = nextacq) {
4498                 nextacq = LIST_NEXT(acq, chain);
4499                 if (now - acq->created > V_key_blockacq_lifetime
4500                  && __LIST_CHAINED(acq)) {
4501                         LIST_REMOVE(acq, chain);
4502                         free(acq, M_IPSEC_SAQ);
4503                 }
4504         }
4505         ACQ_UNLOCK();
4506 }
4507
4508 static void
4509 key_flush_spacq(time_t now)
4510 {
4511         struct secspacq *acq, *nextacq;
4512
4513         /* SP ACQ tree */
4514         SPACQ_LOCK();
4515         for (acq = LIST_FIRST(&V_spacqtree); acq != NULL; acq = nextacq) {
4516                 nextacq = LIST_NEXT(acq, chain);
4517                 if (now - acq->created > V_key_blockacq_lifetime
4518                  && __LIST_CHAINED(acq)) {
4519                         LIST_REMOVE(acq, chain);
4520                         free(acq, M_IPSEC_SAQ);
4521                 }
4522         }
4523         SPACQ_UNLOCK();
4524 }
4525
4526 /*
4527  * time handler.
4528  * scanning SPD and SAD to check status for each entries,
4529  * and do to remove or to expire.
4530  * XXX: year 2038 problem may remain.
4531  */
4532 static void
4533 key_timehandler(void *arg)
4534 {
4535         VNET_ITERATOR_DECL(vnet_iter);
4536         time_t now = time_second;
4537
4538         VNET_LIST_RLOCK_NOSLEEP();
4539         VNET_FOREACH(vnet_iter) {
4540                 CURVNET_SET(vnet_iter);
4541                 key_flush_spd(now);
4542                 key_flush_sad(now);
4543                 key_flush_acq(now);
4544                 key_flush_spacq(now);
4545                 CURVNET_RESTORE();
4546         }
4547         VNET_LIST_RUNLOCK_NOSLEEP();
4548
4549 #ifndef IPSEC_DEBUG2
4550         /* do exchange to tick time !! */
4551         callout_schedule(&key_timer, hz);
4552 #endif /* IPSEC_DEBUG2 */
4553 }
4554
4555 u_long
4556 key_random()
4557 {
4558         u_long value;
4559
4560         key_randomfill(&value, sizeof(value));
4561         return value;
4562 }
4563
4564 void
4565 key_randomfill(p, l)
4566         void *p;
4567         size_t l;
4568 {
4569         size_t n;
4570         u_long v;
4571         static int warn = 1;
4572
4573         n = 0;
4574         n = (size_t)read_random(p, (u_int)l);
4575         /* last resort */
4576         while (n < l) {
4577                 v = random();
4578                 bcopy(&v, (u_int8_t *)p + n,
4579                     l - n < sizeof(v) ? l - n : sizeof(v));
4580                 n += sizeof(v);
4581
4582                 if (warn) {
4583                         printf("WARNING: pseudo-random number generator "
4584                             "used for IPsec processing\n");
4585                         warn = 0;
4586                 }
4587         }
4588 }
4589
4590 /*
4591  * map SADB_SATYPE_* to IPPROTO_*.
4592  * if satype == SADB_SATYPE then satype is mapped to ~0.
4593  * OUT:
4594  *      0: invalid satype.
4595  */
4596 static u_int16_t
4597 key_satype2proto(u_int8_t satype)
4598 {
4599         switch (satype) {
4600         case SADB_SATYPE_UNSPEC:
4601                 return IPSEC_PROTO_ANY;
4602         case SADB_SATYPE_AH:
4603                 return IPPROTO_AH;
4604         case SADB_SATYPE_ESP:
4605                 return IPPROTO_ESP;
4606         case SADB_X_SATYPE_IPCOMP:
4607                 return IPPROTO_IPCOMP;
4608         case SADB_X_SATYPE_TCPSIGNATURE:
4609                 return IPPROTO_TCP;
4610         default:
4611                 return 0;
4612         }
4613         /* NOTREACHED */
4614 }
4615
4616 /*
4617  * map IPPROTO_* to SADB_SATYPE_*
4618  * OUT:
4619  *      0: invalid protocol type.
4620  */
4621 static u_int8_t
4622 key_proto2satype(u_int16_t proto)
4623 {
4624         switch (proto) {
4625         case IPPROTO_AH:
4626                 return SADB_SATYPE_AH;
4627         case IPPROTO_ESP:
4628                 return SADB_SATYPE_ESP;
4629         case IPPROTO_IPCOMP:
4630                 return SADB_X_SATYPE_IPCOMP;
4631         case IPPROTO_TCP:
4632                 return SADB_X_SATYPE_TCPSIGNATURE;
4633         default:
4634                 return 0;
4635         }
4636         /* NOTREACHED */
4637 }
4638
4639 /* %%% PF_KEY */
4640 /*
4641  * SADB_GETSPI processing is to receive
4642  *      <base, (SA2), src address, dst address, (SPI range)>
4643  * from the IKMPd, to assign a unique spi value, to hang on the INBOUND
4644  * tree with the status of LARVAL, and send
4645  *      <base, SA(*), address(SD)>
4646  * to the IKMPd.
4647  *
4648  * IN:  mhp: pointer to the pointer to each header.
4649  * OUT: NULL if fail.
4650  *      other if success, return pointer to the message to send.
4651  */
4652 static int
4653 key_getspi(so, m, mhp)
4654         struct socket *so;
4655         struct mbuf *m;
4656         const struct sadb_msghdr *mhp;
4657 {
4658         struct sadb_address *src0, *dst0;
4659         struct secasindex saidx;
4660         struct secashead *newsah;
4661         struct secasvar *newsav;
4662         u_int8_t proto;
4663         u_int32_t spi;
4664         u_int8_t mode;
4665         u_int32_t reqid;
4666         int error;
4667
4668         IPSEC_ASSERT(so != NULL, ("null socket"));
4669         IPSEC_ASSERT(m != NULL, ("null mbuf"));
4670         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
4671         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
4672
4673         if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
4674             mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
4675                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
4676                         __func__));
4677                 return key_senderror(so, m, EINVAL);
4678         }
4679         if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
4680             mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
4681                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
4682                         __func__));
4683                 return key_senderror(so, m, EINVAL);
4684         }
4685         if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
4686                 mode = ((struct sadb_x_sa2 *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_mode;
4687                 reqid = ((struct sadb_x_sa2 *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_reqid;
4688         } else {
4689                 mode = IPSEC_MODE_ANY;
4690                 reqid = 0;
4691         }
4692
4693         src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
4694         dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
4695
4696         /* map satype to proto */
4697         if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
4698                 ipseclog((LOG_DEBUG, "%s: invalid satype is passed.\n",
4699                         __func__));
4700                 return key_senderror(so, m, EINVAL);
4701         }
4702
4703         /*
4704          * Make sure the port numbers are zero.
4705          * In case of NAT-T we will update them later if needed.
4706          */
4707         switch (((struct sockaddr *)(src0 + 1))->sa_family) {
4708         case AF_INET:
4709                 if (((struct sockaddr *)(src0 + 1))->sa_len !=
4710                     sizeof(struct sockaddr_in))
4711                         return key_senderror(so, m, EINVAL);
4712                 ((struct sockaddr_in *)(src0 + 1))->sin_port = 0;
4713                 break;
4714         case AF_INET6:
4715                 if (((struct sockaddr *)(src0 + 1))->sa_len !=
4716                     sizeof(struct sockaddr_in6))
4717                         return key_senderror(so, m, EINVAL);
4718                 ((struct sockaddr_in6 *)(src0 + 1))->sin6_port = 0;
4719                 break;
4720         default:
4721                 ; /*???*/
4722         }
4723         switch (((struct sockaddr *)(dst0 + 1))->sa_family) {
4724         case AF_INET:
4725                 if (((struct sockaddr *)(dst0 + 1))->sa_len !=
4726                     sizeof(struct sockaddr_in))
4727                         return key_senderror(so, m, EINVAL);
4728                 ((struct sockaddr_in *)(dst0 + 1))->sin_port = 0;
4729                 break;
4730         case AF_INET6:
4731                 if (((struct sockaddr *)(dst0 + 1))->sa_len !=
4732                     sizeof(struct sockaddr_in6))
4733                         return key_senderror(so, m, EINVAL);
4734                 ((struct sockaddr_in6 *)(dst0 + 1))->sin6_port = 0;
4735                 break;
4736         default:
4737                 ; /*???*/
4738         }
4739
4740         /* XXX boundary check against sa_len */
4741         KEY_SETSECASIDX(proto, mode, reqid, src0 + 1, dst0 + 1, &saidx);
4742
4743 #ifdef IPSEC_NAT_T
4744         /*
4745          * Handle NAT-T info if present.
4746          * We made sure the port numbers are zero above, so we do
4747          * not have to worry in case we do not update them.
4748          */
4749         if (mhp->ext[SADB_X_EXT_NAT_T_OAI] != NULL)
4750                 ipseclog((LOG_DEBUG, "%s: NAT-T OAi present\n", __func__));
4751         if (mhp->ext[SADB_X_EXT_NAT_T_OAR] != NULL)
4752                 ipseclog((LOG_DEBUG, "%s: NAT-T OAr present\n", __func__));
4753
4754         if (mhp->ext[SADB_X_EXT_NAT_T_TYPE] != NULL &&
4755             mhp->ext[SADB_X_EXT_NAT_T_SPORT] != NULL &&
4756             mhp->ext[SADB_X_EXT_NAT_T_DPORT] != NULL) {
4757                 struct sadb_x_nat_t_type *type;
4758                 struct sadb_x_nat_t_port *sport, *dport;
4759
4760                 if (mhp->extlen[SADB_X_EXT_NAT_T_TYPE] < sizeof(*type) ||
4761                     mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport) ||
4762                     mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport)) {
4763                         ipseclog((LOG_DEBUG, "%s: invalid nat-t message "
4764                             "passed.\n", __func__));
4765                         return key_senderror(so, m, EINVAL);
4766                 }
4767
4768                 sport = (struct sadb_x_nat_t_port *)
4769                     mhp->ext[SADB_X_EXT_NAT_T_SPORT];
4770                 dport = (struct sadb_x_nat_t_port *)
4771                     mhp->ext[SADB_X_EXT_NAT_T_DPORT];
4772
4773                 if (sport)
4774                         KEY_PORTTOSADDR(&saidx.src, sport->sadb_x_nat_t_port_port);
4775                 if (dport)
4776                         KEY_PORTTOSADDR(&saidx.dst, dport->sadb_x_nat_t_port_port);
4777         }
4778 #endif
4779
4780         /* SPI allocation */
4781         spi = key_do_getnewspi((struct sadb_spirange *)mhp->ext[SADB_EXT_SPIRANGE],
4782                                &saidx);
4783         if (spi == 0)
4784                 return key_senderror(so, m, EINVAL);
4785
4786         /* get a SA index */
4787         if ((newsah = key_getsah(&saidx)) == NULL) {
4788                 /* create a new SA index */
4789                 if ((newsah = key_newsah(&saidx)) == NULL) {
4790                         ipseclog((LOG_DEBUG, "%s: No more memory.\n",__func__));
4791                         return key_senderror(so, m, ENOBUFS);
4792                 }
4793         }
4794
4795         /* get a new SA */
4796         /* XXX rewrite */
4797         newsav = KEY_NEWSAV(m, mhp, newsah, &error);
4798         if (newsav == NULL) {
4799                 /* XXX don't free new SA index allocated in above. */
4800                 return key_senderror(so, m, error);
4801         }
4802
4803         /* set spi */
4804         newsav->spi = htonl(spi);
4805
4806         /* delete the entry in acqtree */
4807         if (mhp->msg->sadb_msg_seq != 0) {
4808                 struct secacq *acq;
4809                 if ((acq = key_getacqbyseq(mhp->msg->sadb_msg_seq)) != NULL) {
4810                         /* reset counter in order to deletion by timehandler. */
4811                         acq->created = time_second;
4812                         acq->count = 0;
4813                 }
4814         }
4815
4816     {
4817         struct mbuf *n, *nn;
4818         struct sadb_sa *m_sa;
4819         struct sadb_msg *newmsg;
4820         int off, len;
4821
4822         /* create new sadb_msg to reply. */
4823         len = PFKEY_ALIGN8(sizeof(struct sadb_msg)) +
4824             PFKEY_ALIGN8(sizeof(struct sadb_sa));
4825
4826         MGETHDR(n, M_NOWAIT, MT_DATA);
4827         if (len > MHLEN) {
4828                 MCLGET(n, M_NOWAIT);
4829                 if ((n->m_flags & M_EXT) == 0) {
4830                         m_freem(n);
4831                         n = NULL;
4832                 }
4833         }
4834         if (!n)
4835                 return key_senderror(so, m, ENOBUFS);
4836
4837         n->m_len = len;
4838         n->m_next = NULL;
4839         off = 0;
4840
4841         m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, caddr_t) + off);
4842         off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
4843
4844         m_sa = (struct sadb_sa *)(mtod(n, caddr_t) + off);
4845         m_sa->sadb_sa_len = PFKEY_UNIT64(sizeof(struct sadb_sa));
4846         m_sa->sadb_sa_exttype = SADB_EXT_SA;
4847         m_sa->sadb_sa_spi = htonl(spi);
4848         off += PFKEY_ALIGN8(sizeof(struct sadb_sa));
4849
4850         IPSEC_ASSERT(off == len,
4851                 ("length inconsistency (off %u len %u)", off, len));
4852
4853         n->m_next = key_gather_mbuf(m, mhp, 0, 2, SADB_EXT_ADDRESS_SRC,
4854             SADB_EXT_ADDRESS_DST);
4855         if (!n->m_next) {
4856                 m_freem(n);
4857                 return key_senderror(so, m, ENOBUFS);
4858         }
4859
4860         if (n->m_len < sizeof(struct sadb_msg)) {
4861                 n = m_pullup(n, sizeof(struct sadb_msg));
4862                 if (n == NULL)
4863                         return key_sendup_mbuf(so, m, KEY_SENDUP_ONE);
4864         }
4865
4866         n->m_pkthdr.len = 0;
4867         for (nn = n; nn; nn = nn->m_next)
4868                 n->m_pkthdr.len += nn->m_len;
4869
4870         newmsg = mtod(n, struct sadb_msg *);
4871         newmsg->sadb_msg_seq = newsav->seq;
4872         newmsg->sadb_msg_errno = 0;
4873         newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
4874
4875         m_freem(m);
4876         return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
4877     }
4878 }
4879
4880 /*
4881  * allocating new SPI
4882  * called by key_getspi().
4883  * OUT:
4884  *      0:      failure.
4885  *      others: success.
4886  */
4887 static u_int32_t
4888 key_do_getnewspi(spirange, saidx)
4889         struct sadb_spirange *spirange;
4890         struct secasindex *saidx;
4891 {
4892         u_int32_t newspi;
4893         u_int32_t min, max;
4894         int count = V_key_spi_trycnt;
4895
4896         /* set spi range to allocate */
4897         if (spirange != NULL) {
4898                 min = spirange->sadb_spirange_min;
4899                 max = spirange->sadb_spirange_max;
4900         } else {
4901                 min = V_key_spi_minval;
4902                 max = V_key_spi_maxval;
4903         }
4904         /* IPCOMP needs 2-byte SPI */
4905         if (saidx->proto == IPPROTO_IPCOMP) {
4906                 u_int32_t t;
4907                 if (min >= 0x10000)
4908                         min = 0xffff;
4909                 if (max >= 0x10000)
4910                         max = 0xffff;
4911                 if (min > max) {
4912                         t = min; min = max; max = t;
4913                 }
4914         }
4915
4916         if (min == max) {
4917                 if (key_checkspidup(saidx, min) != NULL) {
4918                         ipseclog((LOG_DEBUG, "%s: SPI %u exists already.\n",
4919                                 __func__, min));
4920                         return 0;
4921                 }
4922
4923                 count--; /* taking one cost. */
4924                 newspi = min;
4925
4926         } else {
4927
4928                 /* init SPI */
4929                 newspi = 0;
4930
4931                 /* when requesting to allocate spi ranged */
4932                 while (count--) {
4933                         /* generate pseudo-random SPI value ranged. */
4934                         newspi = min + (key_random() % (max - min + 1));
4935
4936                         if (key_checkspidup(saidx, newspi) == NULL)
4937                                 break;
4938                 }
4939
4940                 if (count == 0 || newspi == 0) {
4941                         ipseclog((LOG_DEBUG, "%s: to allocate spi is failed.\n",
4942                                 __func__));
4943                         return 0;
4944                 }
4945         }
4946
4947         /* statistics */
4948         keystat.getspi_count =
4949                 (keystat.getspi_count + V_key_spi_trycnt - count) / 2;
4950
4951         return newspi;
4952 }
4953
4954 /*
4955  * SADB_UPDATE processing
4956  * receive
4957  *   <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
4958  *       key(AE), (identity(SD),) (sensitivity)>
4959  * from the ikmpd, and update a secasvar entry whose status is SADB_SASTATE_LARVAL.
4960  * and send
4961  *   <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
4962  *       (identity(SD),) (sensitivity)>
4963  * to the ikmpd.
4964  *
4965  * m will always be freed.
4966  */
4967 static int
4968 key_update(so, m, mhp)
4969         struct socket *so;
4970         struct mbuf *m;
4971         const struct sadb_msghdr *mhp;
4972 {
4973         struct sadb_sa *sa0;
4974         struct sadb_address *src0, *dst0;
4975 #ifdef IPSEC_NAT_T
4976         struct sadb_x_nat_t_type *type;
4977         struct sadb_x_nat_t_port *sport, *dport;
4978         struct sadb_address *iaddr, *raddr;
4979         struct sadb_x_nat_t_frag *frag;
4980 #endif
4981         struct secasindex saidx;
4982         struct secashead *sah;
4983         struct secasvar *sav;
4984         u_int16_t proto;
4985         u_int8_t mode;
4986         u_int32_t reqid;
4987         int error;
4988
4989         IPSEC_ASSERT(so != NULL, ("null socket"));
4990         IPSEC_ASSERT(m != NULL, ("null mbuf"));
4991         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
4992         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
4993
4994         /* map satype to proto */
4995         if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
4996                 ipseclog((LOG_DEBUG, "%s: invalid satype is passed.\n",
4997                         __func__));
4998                 return key_senderror(so, m, EINVAL);
4999         }
5000
5001         if (mhp->ext[SADB_EXT_SA] == NULL ||
5002             mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
5003             mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
5004             (mhp->msg->sadb_msg_satype == SADB_SATYPE_ESP &&
5005              mhp->ext[SADB_EXT_KEY_ENCRYPT] == NULL) ||
5006             (mhp->msg->sadb_msg_satype == SADB_SATYPE_AH &&
5007              mhp->ext[SADB_EXT_KEY_AUTH] == NULL) ||
5008             (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL &&
5009              mhp->ext[SADB_EXT_LIFETIME_SOFT] == NULL) ||
5010             (mhp->ext[SADB_EXT_LIFETIME_HARD] == NULL &&
5011              mhp->ext[SADB_EXT_LIFETIME_SOFT] != NULL)) {
5012                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5013                         __func__));
5014                 return key_senderror(so, m, EINVAL);
5015         }
5016         if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
5017             mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
5018             mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
5019                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5020                         __func__));
5021                 return key_senderror(so, m, EINVAL);
5022         }
5023         if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
5024                 mode = ((struct sadb_x_sa2 *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_mode;
5025                 reqid = ((struct sadb_x_sa2 *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_reqid;
5026         } else {
5027                 mode = IPSEC_MODE_ANY;
5028                 reqid = 0;
5029         }
5030         /* XXX boundary checking for other extensions */
5031
5032         sa0 = (struct sadb_sa *)mhp->ext[SADB_EXT_SA];
5033         src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
5034         dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
5035
5036         /* XXX boundary check against sa_len */
5037         KEY_SETSECASIDX(proto, mode, reqid, src0 + 1, dst0 + 1, &saidx);
5038
5039         /*
5040          * Make sure the port numbers are zero.
5041          * In case of NAT-T we will update them later if needed.
5042          */
5043         KEY_PORTTOSADDR(&saidx.src, 0);
5044         KEY_PORTTOSADDR(&saidx.dst, 0);
5045
5046 #ifdef IPSEC_NAT_T
5047         /*
5048          * Handle NAT-T info if present.
5049          */
5050         if (mhp->ext[SADB_X_EXT_NAT_T_TYPE] != NULL &&
5051             mhp->ext[SADB_X_EXT_NAT_T_SPORT] != NULL &&
5052             mhp->ext[SADB_X_EXT_NAT_T_DPORT] != NULL) {
5053
5054                 if (mhp->extlen[SADB_X_EXT_NAT_T_TYPE] < sizeof(*type) ||
5055                     mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport) ||
5056                     mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport)) {
5057                         ipseclog((LOG_DEBUG, "%s: invalid message.\n",
5058                             __func__));
5059                         return key_senderror(so, m, EINVAL);
5060                 }
5061
5062                 type = (struct sadb_x_nat_t_type *)
5063                     mhp->ext[SADB_X_EXT_NAT_T_TYPE];
5064                 sport = (struct sadb_x_nat_t_port *)
5065                     mhp->ext[SADB_X_EXT_NAT_T_SPORT];
5066                 dport = (struct sadb_x_nat_t_port *)
5067                     mhp->ext[SADB_X_EXT_NAT_T_DPORT];
5068         } else {
5069                 type = 0;
5070                 sport = dport = 0;
5071         }
5072         if (mhp->ext[SADB_X_EXT_NAT_T_OAI] != NULL &&
5073             mhp->ext[SADB_X_EXT_NAT_T_OAR] != NULL) {
5074                 if (mhp->extlen[SADB_X_EXT_NAT_T_OAI] < sizeof(*iaddr) ||
5075                     mhp->extlen[SADB_X_EXT_NAT_T_OAR] < sizeof(*raddr)) {
5076                         ipseclog((LOG_DEBUG, "%s: invalid message\n",
5077                             __func__));
5078                         return key_senderror(so, m, EINVAL);
5079                 }
5080                 iaddr = (struct sadb_address *)mhp->ext[SADB_X_EXT_NAT_T_OAI];
5081                 raddr = (struct sadb_address *)mhp->ext[SADB_X_EXT_NAT_T_OAR];
5082                 ipseclog((LOG_DEBUG, "%s: NAT-T OAi/r present\n", __func__));
5083         } else {
5084                 iaddr = raddr = NULL;
5085         }
5086         if (mhp->ext[SADB_X_EXT_NAT_T_FRAG] != NULL) {
5087                 if (mhp->extlen[SADB_X_EXT_NAT_T_FRAG] < sizeof(*frag)) {
5088                         ipseclog((LOG_DEBUG, "%s: invalid message\n",
5089                             __func__));
5090                         return key_senderror(so, m, EINVAL);
5091                 }
5092                 frag = (struct sadb_x_nat_t_frag *)
5093                     mhp->ext[SADB_X_EXT_NAT_T_FRAG];
5094         } else {
5095                 frag = 0;
5096         }
5097 #endif
5098
5099         /* get a SA header */
5100         if ((sah = key_getsah(&saidx)) == NULL) {
5101                 ipseclog((LOG_DEBUG, "%s: no SA index found.\n", __func__));
5102                 return key_senderror(so, m, ENOENT);
5103         }
5104
5105         /* set spidx if there */
5106         /* XXX rewrite */
5107         error = key_setident(sah, m, mhp);
5108         if (error)
5109                 return key_senderror(so, m, error);
5110
5111         /* find a SA with sequence number. */
5112 #ifdef IPSEC_DOSEQCHECK
5113         if (mhp->msg->sadb_msg_seq != 0
5114          && (sav = key_getsavbyseq(sah, mhp->msg->sadb_msg_seq)) == NULL) {
5115                 ipseclog((LOG_DEBUG, "%s: no larval SA with sequence %u "
5116                         "exists.\n", __func__, mhp->msg->sadb_msg_seq));
5117                 return key_senderror(so, m, ENOENT);
5118         }
5119 #else
5120         SAHTREE_LOCK();
5121         sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
5122         SAHTREE_UNLOCK();
5123         if (sav == NULL) {
5124                 ipseclog((LOG_DEBUG, "%s: no such a SA found (spi:%u)\n",
5125                         __func__, (u_int32_t)ntohl(sa0->sadb_sa_spi)));
5126                 return key_senderror(so, m, EINVAL);
5127         }
5128 #endif
5129
5130         /* validity check */
5131         if (sav->sah->saidx.proto != proto) {
5132                 ipseclog((LOG_DEBUG, "%s: protocol mismatched "
5133                         "(DB=%u param=%u)\n", __func__,
5134                         sav->sah->saidx.proto, proto));
5135                 return key_senderror(so, m, EINVAL);
5136         }
5137 #ifdef IPSEC_DOSEQCHECK
5138         if (sav->spi != sa0->sadb_sa_spi) {
5139                 ipseclog((LOG_DEBUG, "%s: SPI mismatched (DB:%u param:%u)\n",
5140                     __func__,
5141                     (u_int32_t)ntohl(sav->spi),
5142                     (u_int32_t)ntohl(sa0->sadb_sa_spi)));
5143                 return key_senderror(so, m, EINVAL);
5144         }
5145 #endif
5146         if (sav->pid != mhp->msg->sadb_msg_pid) {
5147                 ipseclog((LOG_DEBUG, "%s: pid mismatched (DB:%u param:%u)\n",
5148                     __func__, sav->pid, mhp->msg->sadb_msg_pid));
5149                 return key_senderror(so, m, EINVAL);
5150         }
5151
5152         /* copy sav values */
5153         error = key_setsaval(sav, m, mhp);
5154         if (error) {
5155                 KEY_FREESAV(&sav);
5156                 return key_senderror(so, m, error);
5157         }
5158
5159 #ifdef IPSEC_NAT_T
5160         /*
5161          * Handle more NAT-T info if present,
5162          * now that we have a sav to fill.
5163          */
5164         if (type)
5165                 sav->natt_type = type->sadb_x_nat_t_type_type;
5166
5167         if (sport)
5168                 KEY_PORTTOSADDR(&sav->sah->saidx.src,
5169                     sport->sadb_x_nat_t_port_port);
5170         if (dport)
5171                 KEY_PORTTOSADDR(&sav->sah->saidx.dst,
5172                     dport->sadb_x_nat_t_port_port);
5173
5174 #if 0
5175         /*
5176          * In case SADB_X_EXT_NAT_T_FRAG was not given, leave it at 0.
5177          * We should actually check for a minimum MTU here, if we
5178          * want to support it in ip_output.
5179          */
5180         if (frag)
5181                 sav->natt_esp_frag_len = frag->sadb_x_nat_t_frag_fraglen;
5182 #endif
5183 #endif
5184
5185         /* check SA values to be mature. */
5186         if ((mhp->msg->sadb_msg_errno = key_mature(sav)) != 0) {
5187                 KEY_FREESAV(&sav);
5188                 return key_senderror(so, m, 0);
5189         }
5190
5191     {
5192         struct mbuf *n;
5193
5194         /* set msg buf from mhp */
5195         n = key_getmsgbuf_x1(m, mhp);
5196         if (n == NULL) {
5197                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
5198                 return key_senderror(so, m, ENOBUFS);
5199         }
5200
5201         m_freem(m);
5202         return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
5203     }
5204 }
5205
5206 /*
5207  * search SAD with sequence for a SA which state is SADB_SASTATE_LARVAL.
5208  * only called by key_update().
5209  * OUT:
5210  *      NULL    : not found
5211  *      others  : found, pointer to a SA.
5212  */
5213 #ifdef IPSEC_DOSEQCHECK
5214 static struct secasvar *
5215 key_getsavbyseq(sah, seq)
5216         struct secashead *sah;
5217         u_int32_t seq;
5218 {
5219         struct secasvar *sav;
5220         u_int state;
5221
5222         state = SADB_SASTATE_LARVAL;
5223
5224         /* search SAD with sequence number ? */
5225         LIST_FOREACH(sav, &sah->savtree[state], chain) {
5226
5227                 KEY_CHKSASTATE(state, sav->state, __func__);
5228
5229                 if (sav->seq == seq) {
5230                         sa_addref(sav);
5231                         KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
5232                                 printf("DP %s cause refcnt++:%d SA:%p\n",
5233                                         __func__, sav->refcnt, sav));
5234                         return sav;
5235                 }
5236         }
5237
5238         return NULL;
5239 }
5240 #endif
5241
5242 /*
5243  * SADB_ADD processing
5244  * add an entry to SA database, when received
5245  *   <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
5246  *       key(AE), (identity(SD),) (sensitivity)>
5247  * from the ikmpd,
5248  * and send
5249  *   <base, SA, (SA2), (lifetime(HSC),) address(SD), (address(P),)
5250  *       (identity(SD),) (sensitivity)>
5251  * to the ikmpd.
5252  *
5253  * IGNORE identity and sensitivity messages.
5254  *
5255  * m will always be freed.
5256  */
5257 static int
5258 key_add(so, m, mhp)
5259         struct socket *so;
5260         struct mbuf *m;
5261         const struct sadb_msghdr *mhp;
5262 {
5263         struct sadb_sa *sa0;
5264         struct sadb_address *src0, *dst0;
5265 #ifdef IPSEC_NAT_T
5266         struct sadb_x_nat_t_type *type;
5267         struct sadb_address *iaddr, *raddr;
5268         struct sadb_x_nat_t_frag *frag;
5269 #endif
5270         struct secasindex saidx;
5271         struct secashead *newsah;
5272         struct secasvar *newsav;
5273         u_int16_t proto;
5274         u_int8_t mode;
5275         u_int32_t reqid;
5276         int error;
5277
5278         IPSEC_ASSERT(so != NULL, ("null socket"));
5279         IPSEC_ASSERT(m != NULL, ("null mbuf"));
5280         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
5281         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
5282
5283         /* map satype to proto */
5284         if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
5285                 ipseclog((LOG_DEBUG, "%s: invalid satype is passed.\n",
5286                         __func__));
5287                 return key_senderror(so, m, EINVAL);
5288         }
5289
5290         if (mhp->ext[SADB_EXT_SA] == NULL ||
5291             mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
5292             mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
5293             (mhp->msg->sadb_msg_satype == SADB_SATYPE_ESP &&
5294              mhp->ext[SADB_EXT_KEY_ENCRYPT] == NULL) ||
5295             (mhp->msg->sadb_msg_satype == SADB_SATYPE_AH &&
5296              mhp->ext[SADB_EXT_KEY_AUTH] == NULL) ||
5297             (mhp->ext[SADB_EXT_LIFETIME_HARD] != NULL &&
5298              mhp->ext[SADB_EXT_LIFETIME_SOFT] == NULL) ||
5299             (mhp->ext[SADB_EXT_LIFETIME_HARD] == NULL &&
5300              mhp->ext[SADB_EXT_LIFETIME_SOFT] != NULL)) {
5301                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5302                         __func__));
5303                 return key_senderror(so, m, EINVAL);
5304         }
5305         if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
5306             mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
5307             mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
5308                 /* XXX need more */
5309                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5310                         __func__));
5311                 return key_senderror(so, m, EINVAL);
5312         }
5313         if (mhp->ext[SADB_X_EXT_SA2] != NULL) {
5314                 mode = ((struct sadb_x_sa2 *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_mode;
5315                 reqid = ((struct sadb_x_sa2 *)mhp->ext[SADB_X_EXT_SA2])->sadb_x_sa2_reqid;
5316         } else {
5317                 mode = IPSEC_MODE_ANY;
5318                 reqid = 0;
5319         }
5320
5321         sa0 = (struct sadb_sa *)mhp->ext[SADB_EXT_SA];
5322         src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
5323         dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
5324
5325         /* XXX boundary check against sa_len */
5326         KEY_SETSECASIDX(proto, mode, reqid, src0 + 1, dst0 + 1, &saidx);
5327
5328         /*
5329          * Make sure the port numbers are zero.
5330          * In case of NAT-T we will update them later if needed.
5331          */
5332         KEY_PORTTOSADDR(&saidx.src, 0);
5333         KEY_PORTTOSADDR(&saidx.dst, 0);
5334
5335 #ifdef IPSEC_NAT_T
5336         /*
5337          * Handle NAT-T info if present.
5338          */
5339         if (mhp->ext[SADB_X_EXT_NAT_T_TYPE] != NULL &&
5340             mhp->ext[SADB_X_EXT_NAT_T_SPORT] != NULL &&
5341             mhp->ext[SADB_X_EXT_NAT_T_DPORT] != NULL) {
5342                 struct sadb_x_nat_t_port *sport, *dport;
5343
5344                 if (mhp->extlen[SADB_X_EXT_NAT_T_TYPE] < sizeof(*type) ||
5345                     mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport) ||
5346                     mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport)) {
5347                         ipseclog((LOG_DEBUG, "%s: invalid message.\n",
5348                             __func__));
5349                         return key_senderror(so, m, EINVAL);
5350                 }
5351
5352                 type = (struct sadb_x_nat_t_type *)
5353                     mhp->ext[SADB_X_EXT_NAT_T_TYPE];
5354                 sport = (struct sadb_x_nat_t_port *)
5355                     mhp->ext[SADB_X_EXT_NAT_T_SPORT];
5356                 dport = (struct sadb_x_nat_t_port *)
5357                     mhp->ext[SADB_X_EXT_NAT_T_DPORT];
5358
5359                 if (sport)
5360                         KEY_PORTTOSADDR(&saidx.src,
5361                             sport->sadb_x_nat_t_port_port);
5362                 if (dport)
5363                         KEY_PORTTOSADDR(&saidx.dst,
5364                             dport->sadb_x_nat_t_port_port);
5365         } else {
5366                 type = 0;
5367         }
5368         if (mhp->ext[SADB_X_EXT_NAT_T_OAI] != NULL &&
5369             mhp->ext[SADB_X_EXT_NAT_T_OAR] != NULL) {
5370                 if (mhp->extlen[SADB_X_EXT_NAT_T_OAI] < sizeof(*iaddr) ||
5371                     mhp->extlen[SADB_X_EXT_NAT_T_OAR] < sizeof(*raddr)) {
5372                         ipseclog((LOG_DEBUG, "%s: invalid message\n",
5373                             __func__));
5374                         return key_senderror(so, m, EINVAL);
5375                 }
5376                 iaddr = (struct sadb_address *)mhp->ext[SADB_X_EXT_NAT_T_OAI];
5377                 raddr = (struct sadb_address *)mhp->ext[SADB_X_EXT_NAT_T_OAR];
5378                 ipseclog((LOG_DEBUG, "%s: NAT-T OAi/r present\n", __func__));
5379         } else {
5380                 iaddr = raddr = NULL;
5381         }
5382         if (mhp->ext[SADB_X_EXT_NAT_T_FRAG] != NULL) {
5383                 if (mhp->extlen[SADB_X_EXT_NAT_T_FRAG] < sizeof(*frag)) {
5384                         ipseclog((LOG_DEBUG, "%s: invalid message\n",
5385                             __func__));
5386                         return key_senderror(so, m, EINVAL);
5387                 }
5388                 frag = (struct sadb_x_nat_t_frag *)
5389                     mhp->ext[SADB_X_EXT_NAT_T_FRAG];
5390         } else {
5391                 frag = 0;
5392         }
5393 #endif
5394
5395         /* get a SA header */
5396         if ((newsah = key_getsah(&saidx)) == NULL) {
5397                 /* create a new SA header */
5398                 if ((newsah = key_newsah(&saidx)) == NULL) {
5399                         ipseclog((LOG_DEBUG, "%s: No more memory.\n",__func__));
5400                         return key_senderror(so, m, ENOBUFS);
5401                 }
5402         }
5403
5404         /* set spidx if there */
5405         /* XXX rewrite */
5406         error = key_setident(newsah, m, mhp);
5407         if (error) {
5408                 return key_senderror(so, m, error);
5409         }
5410
5411         /* create new SA entry. */
5412         /* We can create new SA only if SPI is differenct. */
5413         SAHTREE_LOCK();
5414         newsav = key_getsavbyspi(newsah, sa0->sadb_sa_spi);
5415         SAHTREE_UNLOCK();
5416         if (newsav != NULL) {
5417                 ipseclog((LOG_DEBUG, "%s: SA already exists.\n", __func__));
5418                 return key_senderror(so, m, EEXIST);
5419         }
5420         newsav = KEY_NEWSAV(m, mhp, newsah, &error);
5421         if (newsav == NULL) {
5422                 return key_senderror(so, m, error);
5423         }
5424
5425 #ifdef IPSEC_NAT_T
5426         /*
5427          * Handle more NAT-T info if present,
5428          * now that we have a sav to fill.
5429          */
5430         if (type)
5431                 newsav->natt_type = type->sadb_x_nat_t_type_type;
5432
5433 #if 0
5434         /*
5435          * In case SADB_X_EXT_NAT_T_FRAG was not given, leave it at 0.
5436          * We should actually check for a minimum MTU here, if we
5437          * want to support it in ip_output.
5438          */
5439         if (frag)
5440                 newsav->natt_esp_frag_len = frag->sadb_x_nat_t_frag_fraglen;
5441 #endif
5442 #endif
5443
5444         /* check SA values to be mature. */
5445         if ((error = key_mature(newsav)) != 0) {
5446                 KEY_FREESAV(&newsav);
5447                 return key_senderror(so, m, error);
5448         }
5449
5450         /*
5451          * don't call key_freesav() here, as we would like to keep the SA
5452          * in the database on success.
5453          */
5454
5455     {
5456         struct mbuf *n;
5457
5458         /* set msg buf from mhp */
5459         n = key_getmsgbuf_x1(m, mhp);
5460         if (n == NULL) {
5461                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
5462                 return key_senderror(so, m, ENOBUFS);
5463         }
5464
5465         m_freem(m);
5466         return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
5467     }
5468 }
5469
5470 /* m is retained */
5471 static int
5472 key_setident(sah, m, mhp)
5473         struct secashead *sah;
5474         struct mbuf *m;
5475         const struct sadb_msghdr *mhp;
5476 {
5477         const struct sadb_ident *idsrc, *iddst;
5478         int idsrclen, iddstlen;
5479
5480         IPSEC_ASSERT(sah != NULL, ("null secashead"));
5481         IPSEC_ASSERT(m != NULL, ("null mbuf"));
5482         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
5483         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
5484
5485         /* don't make buffer if not there */
5486         if (mhp->ext[SADB_EXT_IDENTITY_SRC] == NULL &&
5487             mhp->ext[SADB_EXT_IDENTITY_DST] == NULL) {
5488                 sah->idents = NULL;
5489                 sah->identd = NULL;
5490                 return 0;
5491         }
5492
5493         if (mhp->ext[SADB_EXT_IDENTITY_SRC] == NULL ||
5494             mhp->ext[SADB_EXT_IDENTITY_DST] == NULL) {
5495                 ipseclog((LOG_DEBUG, "%s: invalid identity.\n", __func__));
5496                 return EINVAL;
5497         }
5498
5499         idsrc = (const struct sadb_ident *)mhp->ext[SADB_EXT_IDENTITY_SRC];
5500         iddst = (const struct sadb_ident *)mhp->ext[SADB_EXT_IDENTITY_DST];
5501         idsrclen = mhp->extlen[SADB_EXT_IDENTITY_SRC];
5502         iddstlen = mhp->extlen[SADB_EXT_IDENTITY_DST];
5503
5504         /* validity check */
5505         if (idsrc->sadb_ident_type != iddst->sadb_ident_type) {
5506                 ipseclog((LOG_DEBUG, "%s: ident type mismatch.\n", __func__));
5507                 return EINVAL;
5508         }
5509
5510         switch (idsrc->sadb_ident_type) {
5511         case SADB_IDENTTYPE_PREFIX:
5512         case SADB_IDENTTYPE_FQDN:
5513         case SADB_IDENTTYPE_USERFQDN:
5514         default:
5515                 /* XXX do nothing */
5516                 sah->idents = NULL;
5517                 sah->identd = NULL;
5518                 return 0;
5519         }
5520
5521         /* make structure */
5522         sah->idents = malloc(sizeof(struct secident), M_IPSEC_MISC, M_NOWAIT);
5523         if (sah->idents == NULL) {
5524                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
5525                 return ENOBUFS;
5526         }
5527         sah->identd = malloc(sizeof(struct secident), M_IPSEC_MISC, M_NOWAIT);
5528         if (sah->identd == NULL) {
5529                 free(sah->idents, M_IPSEC_MISC);
5530                 sah->idents = NULL;
5531                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
5532                 return ENOBUFS;
5533         }
5534         sah->idents->type = idsrc->sadb_ident_type;
5535         sah->idents->id = idsrc->sadb_ident_id;
5536
5537         sah->identd->type = iddst->sadb_ident_type;
5538         sah->identd->id = iddst->sadb_ident_id;
5539
5540         return 0;
5541 }
5542
5543 /*
5544  * m will not be freed on return.
5545  * it is caller's responsibility to free the result.
5546  */
5547 static struct mbuf *
5548 key_getmsgbuf_x1(m, mhp)
5549         struct mbuf *m;
5550         const struct sadb_msghdr *mhp;
5551 {
5552         struct mbuf *n;
5553
5554         IPSEC_ASSERT(m != NULL, ("null mbuf"));
5555         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
5556         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
5557
5558         /* create new sadb_msg to reply. */
5559         n = key_gather_mbuf(m, mhp, 1, 9, SADB_EXT_RESERVED,
5560             SADB_EXT_SA, SADB_X_EXT_SA2,
5561             SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST,
5562             SADB_EXT_LIFETIME_HARD, SADB_EXT_LIFETIME_SOFT,
5563             SADB_EXT_IDENTITY_SRC, SADB_EXT_IDENTITY_DST);
5564         if (!n)
5565                 return NULL;
5566
5567         if (n->m_len < sizeof(struct sadb_msg)) {
5568                 n = m_pullup(n, sizeof(struct sadb_msg));
5569                 if (n == NULL)
5570                         return NULL;
5571         }
5572         mtod(n, struct sadb_msg *)->sadb_msg_errno = 0;
5573         mtod(n, struct sadb_msg *)->sadb_msg_len =
5574             PFKEY_UNIT64(n->m_pkthdr.len);
5575
5576         return n;
5577 }
5578
5579 static int key_delete_all __P((struct socket *, struct mbuf *,
5580         const struct sadb_msghdr *, u_int16_t));
5581
5582 /*
5583  * SADB_DELETE processing
5584  * receive
5585  *   <base, SA(*), address(SD)>
5586  * from the ikmpd, and set SADB_SASTATE_DEAD,
5587  * and send,
5588  *   <base, SA(*), address(SD)>
5589  * to the ikmpd.
5590  *
5591  * m will always be freed.
5592  */
5593 static int
5594 key_delete(so, m, mhp)
5595         struct socket *so;
5596         struct mbuf *m;
5597         const struct sadb_msghdr *mhp;
5598 {
5599         struct sadb_sa *sa0;
5600         struct sadb_address *src0, *dst0;
5601         struct secasindex saidx;
5602         struct secashead *sah;
5603         struct secasvar *sav = NULL;
5604         u_int16_t proto;
5605
5606         IPSEC_ASSERT(so != NULL, ("null socket"));
5607         IPSEC_ASSERT(m != NULL, ("null mbuf"));
5608         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
5609         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
5610
5611         /* map satype to proto */
5612         if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
5613                 ipseclog((LOG_DEBUG, "%s: invalid satype is passed.\n",
5614                         __func__));
5615                 return key_senderror(so, m, EINVAL);
5616         }
5617
5618         if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
5619             mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
5620                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5621                         __func__));
5622                 return key_senderror(so, m, EINVAL);
5623         }
5624
5625         if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
5626             mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
5627                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5628                         __func__));
5629                 return key_senderror(so, m, EINVAL);
5630         }
5631
5632         if (mhp->ext[SADB_EXT_SA] == NULL) {
5633                 /*
5634                  * Caller wants us to delete all non-LARVAL SAs
5635                  * that match the src/dst.  This is used during
5636                  * IKE INITIAL-CONTACT.
5637                  */
5638                 ipseclog((LOG_DEBUG, "%s: doing delete all.\n", __func__));
5639                 return key_delete_all(so, m, mhp, proto);
5640         } else if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa)) {
5641                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5642                         __func__));
5643                 return key_senderror(so, m, EINVAL);
5644         }
5645
5646         sa0 = (struct sadb_sa *)mhp->ext[SADB_EXT_SA];
5647         src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
5648         dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
5649
5650         /* XXX boundary check against sa_len */
5651         KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, &saidx);
5652
5653         /*
5654          * Make sure the port numbers are zero.
5655          * In case of NAT-T we will update them later if needed.
5656          */
5657         KEY_PORTTOSADDR(&saidx.src, 0);
5658         KEY_PORTTOSADDR(&saidx.dst, 0);
5659
5660 #ifdef IPSEC_NAT_T
5661         /*
5662          * Handle NAT-T info if present.
5663          */
5664         if (mhp->ext[SADB_X_EXT_NAT_T_SPORT] != NULL &&
5665             mhp->ext[SADB_X_EXT_NAT_T_DPORT] != NULL) {
5666                 struct sadb_x_nat_t_port *sport, *dport;
5667
5668                 if (mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport) ||
5669                     mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport)) {
5670                         ipseclog((LOG_DEBUG, "%s: invalid message.\n",
5671                             __func__));
5672                         return key_senderror(so, m, EINVAL);
5673                 }
5674
5675                 sport = (struct sadb_x_nat_t_port *)
5676                     mhp->ext[SADB_X_EXT_NAT_T_SPORT];
5677                 dport = (struct sadb_x_nat_t_port *)
5678                     mhp->ext[SADB_X_EXT_NAT_T_DPORT];
5679
5680                 if (sport)
5681                         KEY_PORTTOSADDR(&saidx.src,
5682                             sport->sadb_x_nat_t_port_port);
5683                 if (dport)
5684                         KEY_PORTTOSADDR(&saidx.dst,
5685                             dport->sadb_x_nat_t_port_port);
5686         }
5687 #endif
5688
5689         /* get a SA header */
5690         SAHTREE_LOCK();
5691         LIST_FOREACH(sah, &V_sahtree, chain) {
5692                 if (sah->state == SADB_SASTATE_DEAD)
5693                         continue;
5694                 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_HEAD) == 0)
5695                         continue;
5696
5697                 /* get a SA with SPI. */
5698                 sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
5699                 if (sav)
5700                         break;
5701         }
5702         if (sah == NULL) {
5703                 SAHTREE_UNLOCK();
5704                 ipseclog((LOG_DEBUG, "%s: no SA found.\n", __func__));
5705                 return key_senderror(so, m, ENOENT);
5706         }
5707
5708         key_sa_chgstate(sav, SADB_SASTATE_DEAD);
5709         KEY_FREESAV(&sav);
5710         SAHTREE_UNLOCK();
5711
5712     {
5713         struct mbuf *n;
5714         struct sadb_msg *newmsg;
5715
5716         /* create new sadb_msg to reply. */
5717         /* XXX-BZ NAT-T extensions? */
5718         n = key_gather_mbuf(m, mhp, 1, 4, SADB_EXT_RESERVED,
5719             SADB_EXT_SA, SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
5720         if (!n)
5721                 return key_senderror(so, m, ENOBUFS);
5722
5723         if (n->m_len < sizeof(struct sadb_msg)) {
5724                 n = m_pullup(n, sizeof(struct sadb_msg));
5725                 if (n == NULL)
5726                         return key_senderror(so, m, ENOBUFS);
5727         }
5728         newmsg = mtod(n, struct sadb_msg *);
5729         newmsg->sadb_msg_errno = 0;
5730         newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
5731
5732         m_freem(m);
5733         return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
5734     }
5735 }
5736
5737 /*
5738  * delete all SAs for src/dst.  Called from key_delete().
5739  */
5740 static int
5741 key_delete_all(struct socket *so, struct mbuf *m, const struct sadb_msghdr *mhp,
5742     u_int16_t proto)
5743 {
5744         struct sadb_address *src0, *dst0;
5745         struct secasindex saidx;
5746         struct secashead *sah;
5747         struct secasvar *sav, *nextsav;
5748         u_int stateidx, state;
5749
5750         src0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_SRC]);
5751         dst0 = (struct sadb_address *)(mhp->ext[SADB_EXT_ADDRESS_DST]);
5752
5753         /* XXX boundary check against sa_len */
5754         KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, &saidx);
5755
5756         /*
5757          * Make sure the port numbers are zero.
5758          * In case of NAT-T we will update them later if needed.
5759          */
5760         KEY_PORTTOSADDR(&saidx.src, 0);
5761         KEY_PORTTOSADDR(&saidx.dst, 0);
5762
5763 #ifdef IPSEC_NAT_T
5764         /*
5765          * Handle NAT-T info if present.
5766          */
5767
5768         if (mhp->ext[SADB_X_EXT_NAT_T_SPORT] != NULL &&
5769             mhp->ext[SADB_X_EXT_NAT_T_DPORT] != NULL) {
5770                 struct sadb_x_nat_t_port *sport, *dport;
5771
5772                 if (mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport) ||
5773                     mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport)) {
5774                         ipseclog((LOG_DEBUG, "%s: invalid message.\n",
5775                             __func__));
5776                         return key_senderror(so, m, EINVAL);
5777                 }
5778
5779                 sport = (struct sadb_x_nat_t_port *)
5780                     mhp->ext[SADB_X_EXT_NAT_T_SPORT];
5781                 dport = (struct sadb_x_nat_t_port *)
5782                     mhp->ext[SADB_X_EXT_NAT_T_DPORT];
5783
5784                 if (sport)
5785                         KEY_PORTTOSADDR(&saidx.src,
5786                             sport->sadb_x_nat_t_port_port);
5787                 if (dport)
5788                         KEY_PORTTOSADDR(&saidx.dst,
5789                             dport->sadb_x_nat_t_port_port);
5790         }
5791 #endif
5792
5793         SAHTREE_LOCK();
5794         LIST_FOREACH(sah, &V_sahtree, chain) {
5795                 if (sah->state == SADB_SASTATE_DEAD)
5796                         continue;
5797                 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_HEAD) == 0)
5798                         continue;
5799
5800                 /* Delete all non-LARVAL SAs. */
5801                 for (stateidx = 0;
5802                      stateidx < _ARRAYLEN(saorder_state_alive);
5803                      stateidx++) {
5804                         state = saorder_state_alive[stateidx];
5805                         if (state == SADB_SASTATE_LARVAL)
5806                                 continue;
5807                         for (sav = LIST_FIRST(&sah->savtree[state]);
5808                              sav != NULL; sav = nextsav) {
5809                                 nextsav = LIST_NEXT(sav, chain);
5810                                 /* sanity check */
5811                                 if (sav->state != state) {
5812                                         ipseclog((LOG_DEBUG, "%s: invalid "
5813                                                 "sav->state (queue %d SA %d)\n",
5814                                                 __func__, state, sav->state));
5815                                         continue;
5816                                 }
5817
5818                                 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
5819                                 KEY_FREESAV(&sav);
5820                         }
5821                 }
5822         }
5823         SAHTREE_UNLOCK();
5824     {
5825         struct mbuf *n;
5826         struct sadb_msg *newmsg;
5827
5828         /* create new sadb_msg to reply. */
5829         /* XXX-BZ NAT-T extensions? */
5830         n = key_gather_mbuf(m, mhp, 1, 3, SADB_EXT_RESERVED,
5831             SADB_EXT_ADDRESS_SRC, SADB_EXT_ADDRESS_DST);
5832         if (!n)
5833                 return key_senderror(so, m, ENOBUFS);
5834
5835         if (n->m_len < sizeof(struct sadb_msg)) {
5836                 n = m_pullup(n, sizeof(struct sadb_msg));
5837                 if (n == NULL)
5838                         return key_senderror(so, m, ENOBUFS);
5839         }
5840         newmsg = mtod(n, struct sadb_msg *);
5841         newmsg->sadb_msg_errno = 0;
5842         newmsg->sadb_msg_len = PFKEY_UNIT64(n->m_pkthdr.len);
5843
5844         m_freem(m);
5845         return key_sendup_mbuf(so, n, KEY_SENDUP_ALL);
5846     }
5847 }
5848
5849 /*
5850  * SADB_GET processing
5851  * receive
5852  *   <base, SA(*), address(SD)>
5853  * from the ikmpd, and get a SP and a SA to respond,
5854  * and send,
5855  *   <base, SA, (lifetime(HSC),) address(SD), (address(P),) key(AE),
5856  *       (identity(SD),) (sensitivity)>
5857  * to the ikmpd.
5858  *
5859  * m will always be freed.
5860  */
5861 static int
5862 key_get(so, m, mhp)
5863         struct socket *so;
5864         struct mbuf *m;
5865         const struct sadb_msghdr *mhp;
5866 {
5867         struct sadb_sa *sa0;
5868         struct sadb_address *src0, *dst0;
5869         struct secasindex saidx;
5870         struct secashead *sah;
5871         struct secasvar *sav = NULL;
5872         u_int16_t proto;
5873
5874         IPSEC_ASSERT(so != NULL, ("null socket"));
5875         IPSEC_ASSERT(m != NULL, ("null mbuf"));
5876         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
5877         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
5878
5879         /* map satype to proto */
5880         if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
5881                 ipseclog((LOG_DEBUG, "%s: invalid satype is passed.\n",
5882                         __func__));
5883                 return key_senderror(so, m, EINVAL);
5884         }
5885
5886         if (mhp->ext[SADB_EXT_SA] == NULL ||
5887             mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
5888             mhp->ext[SADB_EXT_ADDRESS_DST] == NULL) {
5889                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5890                         __func__));
5891                 return key_senderror(so, m, EINVAL);
5892         }
5893         if (mhp->extlen[SADB_EXT_SA] < sizeof(struct sadb_sa) ||
5894             mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
5895             mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address)) {
5896                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
5897                         __func__));
5898                 return key_senderror(so, m, EINVAL);
5899         }
5900
5901         sa0 = (struct sadb_sa *)mhp->ext[SADB_EXT_SA];
5902         src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
5903         dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
5904
5905         /* XXX boundary check against sa_len */
5906         KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, &saidx);
5907
5908         /*
5909          * Make sure the port numbers are zero.
5910          * In case of NAT-T we will update them later if needed.
5911          */
5912         KEY_PORTTOSADDR(&saidx.src, 0);
5913         KEY_PORTTOSADDR(&saidx.dst, 0);
5914
5915 #ifdef IPSEC_NAT_T
5916         /*
5917          * Handle NAT-T info if present.
5918          */
5919
5920         if (mhp->ext[SADB_X_EXT_NAT_T_SPORT] != NULL &&
5921             mhp->ext[SADB_X_EXT_NAT_T_DPORT] != NULL) {
5922                 struct sadb_x_nat_t_port *sport, *dport;
5923
5924                 if (mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport) ||
5925                     mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport)) {
5926                         ipseclog((LOG_DEBUG, "%s: invalid message.\n",
5927                             __func__));
5928                         return key_senderror(so, m, EINVAL);
5929                 }
5930
5931                 sport = (struct sadb_x_nat_t_port *)
5932                     mhp->ext[SADB_X_EXT_NAT_T_SPORT];
5933                 dport = (struct sadb_x_nat_t_port *)
5934                     mhp->ext[SADB_X_EXT_NAT_T_DPORT];
5935
5936                 if (sport)
5937                         KEY_PORTTOSADDR(&saidx.src,
5938                             sport->sadb_x_nat_t_port_port);
5939                 if (dport)
5940                         KEY_PORTTOSADDR(&saidx.dst,
5941                             dport->sadb_x_nat_t_port_port);
5942         }
5943 #endif
5944
5945         /* get a SA header */
5946         SAHTREE_LOCK();
5947         LIST_FOREACH(sah, &V_sahtree, chain) {
5948                 if (sah->state == SADB_SASTATE_DEAD)
5949                         continue;
5950                 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_HEAD) == 0)
5951                         continue;
5952
5953                 /* get a SA with SPI. */
5954                 sav = key_getsavbyspi(sah, sa0->sadb_sa_spi);
5955                 if (sav)
5956                         break;
5957         }
5958         SAHTREE_UNLOCK();
5959         if (sah == NULL) {
5960                 ipseclog((LOG_DEBUG, "%s: no SA found.\n", __func__));
5961                 return key_senderror(so, m, ENOENT);
5962         }
5963
5964     {
5965         struct mbuf *n;
5966         u_int8_t satype;
5967
5968         /* map proto to satype */
5969         if ((satype = key_proto2satype(sah->saidx.proto)) == 0) {
5970                 ipseclog((LOG_DEBUG, "%s: there was invalid proto in SAD.\n",
5971                         __func__));
5972                 return key_senderror(so, m, EINVAL);
5973         }
5974
5975         /* create new sadb_msg to reply. */
5976         n = key_setdumpsa(sav, SADB_GET, satype, mhp->msg->sadb_msg_seq,
5977             mhp->msg->sadb_msg_pid);
5978         if (!n)
5979                 return key_senderror(so, m, ENOBUFS);
5980
5981         m_freem(m);
5982         return key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
5983     }
5984 }
5985
5986 /* XXX make it sysctl-configurable? */
5987 static void
5988 key_getcomb_setlifetime(comb)
5989         struct sadb_comb *comb;
5990 {
5991
5992         comb->sadb_comb_soft_allocations = 1;
5993         comb->sadb_comb_hard_allocations = 1;
5994         comb->sadb_comb_soft_bytes = 0;
5995         comb->sadb_comb_hard_bytes = 0;
5996         comb->sadb_comb_hard_addtime = 86400;   /* 1 day */
5997         comb->sadb_comb_soft_addtime = comb->sadb_comb_soft_addtime * 80 / 100;
5998         comb->sadb_comb_soft_usetime = 28800;   /* 8 hours */
5999         comb->sadb_comb_hard_usetime = comb->sadb_comb_hard_usetime * 80 / 100;
6000 }
6001
6002 /*
6003  * XXX reorder combinations by preference
6004  * XXX no idea if the user wants ESP authentication or not
6005  */
6006 static struct mbuf *
6007 key_getcomb_esp()
6008 {
6009         struct sadb_comb *comb;
6010         struct enc_xform *algo;
6011         struct mbuf *result = NULL, *m, *n;
6012         int encmin;
6013         int i, off, o;
6014         int totlen;
6015         const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
6016
6017         m = NULL;
6018         for (i = 1; i <= SADB_EALG_MAX; i++) {
6019                 algo = esp_algorithm_lookup(i);
6020                 if (algo == NULL)
6021                         continue;
6022
6023                 /* discard algorithms with key size smaller than system min */
6024                 if (_BITS(algo->maxkey) < V_ipsec_esp_keymin)
6025                         continue;
6026                 if (_BITS(algo->minkey) < V_ipsec_esp_keymin)
6027                         encmin = V_ipsec_esp_keymin;
6028                 else
6029                         encmin = _BITS(algo->minkey);
6030
6031                 if (V_ipsec_esp_auth)
6032                         m = key_getcomb_ah();
6033                 else {
6034                         IPSEC_ASSERT(l <= MLEN,
6035                                 ("l=%u > MLEN=%lu", l, (u_long) MLEN));
6036                         MGET(m, M_NOWAIT, MT_DATA);
6037                         if (m) {
6038                                 M_ALIGN(m, l);
6039                                 m->m_len = l;
6040                                 m->m_next = NULL;
6041                                 bzero(mtod(m, caddr_t), m->m_len);
6042                         }
6043                 }
6044                 if (!m)
6045                         goto fail;
6046
6047                 totlen = 0;
6048                 for (n = m; n; n = n->m_next)
6049                         totlen += n->m_len;
6050                 IPSEC_ASSERT((totlen % l) == 0, ("totlen=%u, l=%u", totlen, l));
6051
6052                 for (off = 0; off < totlen; off += l) {
6053                         n = m_pulldown(m, off, l, &o);
6054                         if (!n) {
6055                                 /* m is already freed */
6056                                 goto fail;
6057                         }
6058                         comb = (struct sadb_comb *)(mtod(n, caddr_t) + o);
6059                         bzero(comb, sizeof(*comb));
6060                         key_getcomb_setlifetime(comb);
6061                         comb->sadb_comb_encrypt = i;
6062                         comb->sadb_comb_encrypt_minbits = encmin;
6063                         comb->sadb_comb_encrypt_maxbits = _BITS(algo->maxkey);
6064                 }
6065
6066                 if (!result)
6067                         result = m;
6068                 else
6069                         m_cat(result, m);
6070         }
6071
6072         return result;
6073
6074  fail:
6075         if (result)
6076                 m_freem(result);
6077         return NULL;
6078 }
6079
6080 static void
6081 key_getsizes_ah(
6082         const struct auth_hash *ah,
6083         int alg,
6084         u_int16_t* min,
6085         u_int16_t* max)
6086 {
6087
6088         *min = *max = ah->keysize;
6089         if (ah->keysize == 0) {
6090                 /*
6091                  * Transform takes arbitrary key size but algorithm
6092                  * key size is restricted.  Enforce this here.
6093                  */
6094                 switch (alg) {
6095                 case SADB_X_AALG_MD5:   *min = *max = 16; break;
6096                 case SADB_X_AALG_SHA:   *min = *max = 20; break;
6097                 case SADB_X_AALG_NULL:  *min = 1; *max = 256; break;
6098                 case SADB_X_AALG_SHA2_256: *min = *max = 32; break;
6099                 case SADB_X_AALG_SHA2_384: *min = *max = 48; break;
6100                 case SADB_X_AALG_SHA2_512: *min = *max = 64; break;
6101                 default:
6102                         DPRINTF(("%s: unknown AH algorithm %u\n",
6103                                 __func__, alg));
6104                         break;
6105                 }
6106         }
6107 }
6108
6109 /*
6110  * XXX reorder combinations by preference
6111  */
6112 static struct mbuf *
6113 key_getcomb_ah()
6114 {
6115         struct sadb_comb *comb;
6116         struct auth_hash *algo;
6117         struct mbuf *m;
6118         u_int16_t minkeysize, maxkeysize;
6119         int i;
6120         const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
6121
6122         m = NULL;
6123         for (i = 1; i <= SADB_AALG_MAX; i++) {
6124 #if 1
6125                 /* we prefer HMAC algorithms, not old algorithms */
6126                 if (i != SADB_AALG_SHA1HMAC &&
6127                     i != SADB_AALG_MD5HMAC  &&
6128                     i != SADB_X_AALG_SHA2_256 &&
6129                     i != SADB_X_AALG_SHA2_384 &&
6130                     i != SADB_X_AALG_SHA2_512)
6131                         continue;
6132 #endif
6133                 algo = ah_algorithm_lookup(i);
6134                 if (!algo)
6135                         continue;
6136                 key_getsizes_ah(algo, i, &minkeysize, &maxkeysize);
6137                 /* discard algorithms with key size smaller than system min */
6138                 if (_BITS(minkeysize) < V_ipsec_ah_keymin)
6139                         continue;
6140
6141                 if (!m) {
6142                         IPSEC_ASSERT(l <= MLEN,
6143                                 ("l=%u > MLEN=%lu", l, (u_long) MLEN));
6144                         MGET(m, M_NOWAIT, MT_DATA);
6145                         if (m) {
6146                                 M_ALIGN(m, l);
6147                                 m->m_len = l;
6148                                 m->m_next = NULL;
6149                         }
6150                 } else
6151                         M_PREPEND(m, l, M_NOWAIT);
6152                 if (!m)
6153                         return NULL;
6154
6155                 comb = mtod(m, struct sadb_comb *);
6156                 bzero(comb, sizeof(*comb));
6157                 key_getcomb_setlifetime(comb);
6158                 comb->sadb_comb_auth = i;
6159                 comb->sadb_comb_auth_minbits = _BITS(minkeysize);
6160                 comb->sadb_comb_auth_maxbits = _BITS(maxkeysize);
6161         }
6162
6163         return m;
6164 }
6165
6166 /*
6167  * not really an official behavior.  discussed in pf_key@inner.net in Sep2000.
6168  * XXX reorder combinations by preference
6169  */
6170 static struct mbuf *
6171 key_getcomb_ipcomp()
6172 {
6173         struct sadb_comb *comb;
6174         struct comp_algo *algo;
6175         struct mbuf *m;
6176         int i;
6177         const int l = PFKEY_ALIGN8(sizeof(struct sadb_comb));
6178
6179         m = NULL;
6180         for (i = 1; i <= SADB_X_CALG_MAX; i++) {
6181                 algo = ipcomp_algorithm_lookup(i);
6182                 if (!algo)
6183                         continue;
6184
6185                 if (!m) {
6186                         IPSEC_ASSERT(l <= MLEN,
6187                                 ("l=%u > MLEN=%lu", l, (u_long) MLEN));
6188                         MGET(m, M_NOWAIT, MT_DATA);
6189                         if (m) {
6190                                 M_ALIGN(m, l);
6191                                 m->m_len = l;
6192                                 m->m_next = NULL;
6193                         }
6194                 } else
6195                         M_PREPEND(m, l, M_NOWAIT);
6196                 if (!m)
6197                         return NULL;
6198
6199                 comb = mtod(m, struct sadb_comb *);
6200                 bzero(comb, sizeof(*comb));
6201                 key_getcomb_setlifetime(comb);
6202                 comb->sadb_comb_encrypt = i;
6203                 /* what should we set into sadb_comb_*_{min,max}bits? */
6204         }
6205
6206         return m;
6207 }
6208
6209 /*
6210  * XXX no way to pass mode (transport/tunnel) to userland
6211  * XXX replay checking?
6212  * XXX sysctl interface to ipsec_{ah,esp}_keymin
6213  */
6214 static struct mbuf *
6215 key_getprop(saidx)
6216         const struct secasindex *saidx;
6217 {
6218         struct sadb_prop *prop;
6219         struct mbuf *m, *n;
6220         const int l = PFKEY_ALIGN8(sizeof(struct sadb_prop));
6221         int totlen;
6222
6223         switch (saidx->proto)  {
6224         case IPPROTO_ESP:
6225                 m = key_getcomb_esp();
6226                 break;
6227         case IPPROTO_AH:
6228                 m = key_getcomb_ah();
6229                 break;
6230         case IPPROTO_IPCOMP:
6231                 m = key_getcomb_ipcomp();
6232                 break;
6233         default:
6234                 return NULL;
6235         }
6236
6237         if (!m)
6238                 return NULL;
6239         M_PREPEND(m, l, M_NOWAIT);
6240         if (!m)
6241                 return NULL;
6242
6243         totlen = 0;
6244         for (n = m; n; n = n->m_next)
6245                 totlen += n->m_len;
6246
6247         prop = mtod(m, struct sadb_prop *);
6248         bzero(prop, sizeof(*prop));
6249         prop->sadb_prop_len = PFKEY_UNIT64(totlen);
6250         prop->sadb_prop_exttype = SADB_EXT_PROPOSAL;
6251         prop->sadb_prop_replay = 32;    /* XXX */
6252
6253         return m;
6254 }
6255
6256 /*
6257  * SADB_ACQUIRE processing called by key_checkrequest() and key_acquire2().
6258  * send
6259  *   <base, SA, address(SD), (address(P)), x_policy,
6260  *       (identity(SD),) (sensitivity,) proposal>
6261  * to KMD, and expect to receive
6262  *   <base> with SADB_ACQUIRE if error occured,
6263  * or
6264  *   <base, src address, dst address, (SPI range)> with SADB_GETSPI
6265  * from KMD by PF_KEY.
6266  *
6267  * XXX x_policy is outside of RFC2367 (KAME extension).
6268  * XXX sensitivity is not supported.
6269  * XXX for ipcomp, RFC2367 does not define how to fill in proposal.
6270  * see comment for key_getcomb_ipcomp().
6271  *
6272  * OUT:
6273  *    0     : succeed
6274  *    others: error number
6275  */
6276 static int
6277 key_acquire(const struct secasindex *saidx, struct secpolicy *sp)
6278 {
6279         struct mbuf *result = NULL, *m;
6280         struct secacq *newacq;
6281         u_int8_t satype;
6282         int error = -1;
6283         u_int32_t seq;
6284
6285         IPSEC_ASSERT(saidx != NULL, ("null saidx"));
6286         satype = key_proto2satype(saidx->proto);
6287         IPSEC_ASSERT(satype != 0, ("null satype, protocol %u", saidx->proto));
6288
6289         /*
6290          * We never do anything about acquirng SA.  There is anather
6291          * solution that kernel blocks to send SADB_ACQUIRE message until
6292          * getting something message from IKEd.  In later case, to be
6293          * managed with ACQUIRING list.
6294          */
6295         /* Get an entry to check whether sending message or not. */
6296         if ((newacq = key_getacq(saidx)) != NULL) {
6297                 if (V_key_blockacq_count < newacq->count) {
6298                         /* reset counter and do send message. */
6299                         newacq->count = 0;
6300                 } else {
6301                         /* increment counter and do nothing. */
6302                         newacq->count++;
6303                         return 0;
6304                 }
6305         } else {
6306                 /* make new entry for blocking to send SADB_ACQUIRE. */
6307                 if ((newacq = key_newacq(saidx)) == NULL)
6308                         return ENOBUFS;
6309         }
6310
6311
6312         seq = newacq->seq;
6313         m = key_setsadbmsg(SADB_ACQUIRE, 0, satype, seq, 0, 0);
6314         if (!m) {
6315                 error = ENOBUFS;
6316                 goto fail;
6317         }
6318         result = m;
6319
6320         /*
6321          * No SADB_X_EXT_NAT_T_* here: we do not know
6322          * anything related to NAT-T at this time.
6323          */
6324
6325         /* set sadb_address for saidx's. */
6326         m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
6327             &saidx->src.sa, FULLMASK, IPSEC_ULPROTO_ANY);
6328         if (!m) {
6329                 error = ENOBUFS;
6330                 goto fail;
6331         }
6332         m_cat(result, m);
6333
6334         m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
6335             &saidx->dst.sa, FULLMASK, IPSEC_ULPROTO_ANY);
6336         if (!m) {
6337                 error = ENOBUFS;
6338                 goto fail;
6339         }
6340         m_cat(result, m);
6341
6342         /* XXX proxy address (optional) */
6343
6344         /* set sadb_x_policy */
6345         if (sp) {
6346                 m = key_setsadbxpolicy(sp->policy, sp->spidx.dir, sp->id);
6347                 if (!m) {
6348                         error = ENOBUFS;
6349                         goto fail;
6350                 }
6351                 m_cat(result, m);
6352         }
6353
6354         /* XXX identity (optional) */
6355 #if 0
6356         if (idexttype && fqdn) {
6357                 /* create identity extension (FQDN) */
6358                 struct sadb_ident *id;
6359                 int fqdnlen;
6360
6361                 fqdnlen = strlen(fqdn) + 1;     /* +1 for terminating-NUL */
6362                 id = (struct sadb_ident *)p;
6363                 bzero(id, sizeof(*id) + PFKEY_ALIGN8(fqdnlen));
6364                 id->sadb_ident_len = PFKEY_UNIT64(sizeof(*id) + PFKEY_ALIGN8(fqdnlen));
6365                 id->sadb_ident_exttype = idexttype;
6366                 id->sadb_ident_type = SADB_IDENTTYPE_FQDN;
6367                 bcopy(fqdn, id + 1, fqdnlen);
6368                 p += sizeof(struct sadb_ident) + PFKEY_ALIGN8(fqdnlen);
6369         }
6370
6371         if (idexttype) {
6372                 /* create identity extension (USERFQDN) */
6373                 struct sadb_ident *id;
6374                 int userfqdnlen;
6375
6376                 if (userfqdn) {
6377                         /* +1 for terminating-NUL */
6378                         userfqdnlen = strlen(userfqdn) + 1;
6379                 } else
6380                         userfqdnlen = 0;
6381                 id = (struct sadb_ident *)p;
6382                 bzero(id, sizeof(*id) + PFKEY_ALIGN8(userfqdnlen));
6383                 id->sadb_ident_len = PFKEY_UNIT64(sizeof(*id) + PFKEY_ALIGN8(userfqdnlen));
6384                 id->sadb_ident_exttype = idexttype;
6385                 id->sadb_ident_type = SADB_IDENTTYPE_USERFQDN;
6386                 /* XXX is it correct? */
6387                 if (curproc && curproc->p_cred)
6388                         id->sadb_ident_id = curproc->p_cred->p_ruid;
6389                 if (userfqdn && userfqdnlen)
6390                         bcopy(userfqdn, id + 1, userfqdnlen);
6391                 p += sizeof(struct sadb_ident) + PFKEY_ALIGN8(userfqdnlen);
6392         }
6393 #endif
6394
6395         /* XXX sensitivity (optional) */
6396
6397         /* create proposal/combination extension */
6398         m = key_getprop(saidx);
6399 #if 0
6400         /*
6401          * spec conformant: always attach proposal/combination extension,
6402          * the problem is that we have no way to attach it for ipcomp,
6403          * due to the way sadb_comb is declared in RFC2367.
6404          */
6405         if (!m) {
6406                 error = ENOBUFS;
6407                 goto fail;
6408         }
6409         m_cat(result, m);
6410 #else
6411         /*
6412          * outside of spec; make proposal/combination extension optional.
6413          */
6414         if (m)
6415                 m_cat(result, m);
6416 #endif
6417
6418         if ((result->m_flags & M_PKTHDR) == 0) {
6419                 error = EINVAL;
6420                 goto fail;
6421         }
6422
6423         if (result->m_len < sizeof(struct sadb_msg)) {
6424                 result = m_pullup(result, sizeof(struct sadb_msg));
6425                 if (result == NULL) {
6426                         error = ENOBUFS;
6427                         goto fail;
6428                 }
6429         }
6430
6431         result->m_pkthdr.len = 0;
6432         for (m = result; m; m = m->m_next)
6433                 result->m_pkthdr.len += m->m_len;
6434
6435         mtod(result, struct sadb_msg *)->sadb_msg_len =
6436             PFKEY_UNIT64(result->m_pkthdr.len);
6437
6438         return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
6439
6440  fail:
6441         if (result)
6442                 m_freem(result);
6443         return error;
6444 }
6445
6446 static struct secacq *
6447 key_newacq(const struct secasindex *saidx)
6448 {
6449         struct secacq *newacq;
6450
6451         /* get new entry */
6452         newacq = malloc(sizeof(struct secacq), M_IPSEC_SAQ, M_NOWAIT|M_ZERO);
6453         if (newacq == NULL) {
6454                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
6455                 return NULL;
6456         }
6457
6458         /* copy secindex */
6459         bcopy(saidx, &newacq->saidx, sizeof(newacq->saidx));
6460         newacq->seq = (V_acq_seq == ~0 ? 1 : ++V_acq_seq);
6461         newacq->created = time_second;
6462         newacq->count = 0;
6463
6464         /* add to acqtree */
6465         ACQ_LOCK();
6466         LIST_INSERT_HEAD(&V_acqtree, newacq, chain);
6467         ACQ_UNLOCK();
6468
6469         return newacq;
6470 }
6471
6472 static struct secacq *
6473 key_getacq(const struct secasindex *saidx)
6474 {
6475         struct secacq *acq;
6476
6477         ACQ_LOCK();
6478         LIST_FOREACH(acq, &V_acqtree, chain) {
6479                 if (key_cmpsaidx(saidx, &acq->saidx, CMP_EXACTLY))
6480                         break;
6481         }
6482         ACQ_UNLOCK();
6483
6484         return acq;
6485 }
6486
6487 static struct secacq *
6488 key_getacqbyseq(seq)
6489         u_int32_t seq;
6490 {
6491         struct secacq *acq;
6492
6493         ACQ_LOCK();
6494         LIST_FOREACH(acq, &V_acqtree, chain) {
6495                 if (acq->seq == seq)
6496                         break;
6497         }
6498         ACQ_UNLOCK();
6499
6500         return acq;
6501 }
6502
6503 static struct secspacq *
6504 key_newspacq(spidx)
6505         struct secpolicyindex *spidx;
6506 {
6507         struct secspacq *acq;
6508
6509         /* get new entry */
6510         acq = malloc(sizeof(struct secspacq), M_IPSEC_SAQ, M_NOWAIT|M_ZERO);
6511         if (acq == NULL) {
6512                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
6513                 return NULL;
6514         }
6515
6516         /* copy secindex */
6517         bcopy(spidx, &acq->spidx, sizeof(acq->spidx));
6518         acq->created = time_second;
6519         acq->count = 0;
6520
6521         /* add to spacqtree */
6522         SPACQ_LOCK();
6523         LIST_INSERT_HEAD(&V_spacqtree, acq, chain);
6524         SPACQ_UNLOCK();
6525
6526         return acq;
6527 }
6528
6529 static struct secspacq *
6530 key_getspacq(spidx)
6531         struct secpolicyindex *spidx;
6532 {
6533         struct secspacq *acq;
6534
6535         SPACQ_LOCK();
6536         LIST_FOREACH(acq, &V_spacqtree, chain) {
6537                 if (key_cmpspidx_exactly(spidx, &acq->spidx)) {
6538                         /* NB: return holding spacq_lock */
6539                         return acq;
6540                 }
6541         }
6542         SPACQ_UNLOCK();
6543
6544         return NULL;
6545 }
6546
6547 /*
6548  * SADB_ACQUIRE processing,
6549  * in first situation, is receiving
6550  *   <base>
6551  * from the ikmpd, and clear sequence of its secasvar entry.
6552  *
6553  * In second situation, is receiving
6554  *   <base, address(SD), (address(P),) (identity(SD),) (sensitivity,) proposal>
6555  * from a user land process, and return
6556  *   <base, address(SD), (address(P),) (identity(SD),) (sensitivity,) proposal>
6557  * to the socket.
6558  *
6559  * m will always be freed.
6560  */
6561 static int
6562 key_acquire2(so, m, mhp)
6563         struct socket *so;
6564         struct mbuf *m;
6565         const struct sadb_msghdr *mhp;
6566 {
6567         const struct sadb_address *src0, *dst0;
6568         struct secasindex saidx;
6569         struct secashead *sah;
6570         u_int16_t proto;
6571         int error;
6572
6573         IPSEC_ASSERT(so != NULL, ("null socket"));
6574         IPSEC_ASSERT(m != NULL, ("null mbuf"));
6575         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
6576         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
6577
6578         /*
6579          * Error message from KMd.
6580          * We assume that if error was occured in IKEd, the length of PFKEY
6581          * message is equal to the size of sadb_msg structure.
6582          * We do not raise error even if error occured in this function.
6583          */
6584         if (mhp->msg->sadb_msg_len == PFKEY_UNIT64(sizeof(struct sadb_msg))) {
6585                 struct secacq *acq;
6586
6587                 /* check sequence number */
6588                 if (mhp->msg->sadb_msg_seq == 0) {
6589                         ipseclog((LOG_DEBUG, "%s: must specify sequence "
6590                                 "number.\n", __func__));
6591                         m_freem(m);
6592                         return 0;
6593                 }
6594
6595                 if ((acq = key_getacqbyseq(mhp->msg->sadb_msg_seq)) == NULL) {
6596                         /*
6597                          * the specified larval SA is already gone, or we got
6598                          * a bogus sequence number.  we can silently ignore it.
6599                          */
6600                         m_freem(m);
6601                         return 0;
6602                 }
6603
6604                 /* reset acq counter in order to deletion by timehander. */
6605                 acq->created = time_second;
6606                 acq->count = 0;
6607                 m_freem(m);
6608                 return 0;
6609         }
6610
6611         /*
6612          * This message is from user land.
6613          */
6614
6615         /* map satype to proto */
6616         if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
6617                 ipseclog((LOG_DEBUG, "%s: invalid satype is passed.\n",
6618                         __func__));
6619                 return key_senderror(so, m, EINVAL);
6620         }
6621
6622         if (mhp->ext[SADB_EXT_ADDRESS_SRC] == NULL ||
6623             mhp->ext[SADB_EXT_ADDRESS_DST] == NULL ||
6624             mhp->ext[SADB_EXT_PROPOSAL] == NULL) {
6625                 /* error */
6626                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
6627                         __func__));
6628                 return key_senderror(so, m, EINVAL);
6629         }
6630         if (mhp->extlen[SADB_EXT_ADDRESS_SRC] < sizeof(struct sadb_address) ||
6631             mhp->extlen[SADB_EXT_ADDRESS_DST] < sizeof(struct sadb_address) ||
6632             mhp->extlen[SADB_EXT_PROPOSAL] < sizeof(struct sadb_prop)) {
6633                 /* error */
6634                 ipseclog((LOG_DEBUG, "%s: invalid message is passed.\n",
6635                         __func__));
6636                 return key_senderror(so, m, EINVAL);
6637         }
6638
6639         src0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_SRC];
6640         dst0 = (struct sadb_address *)mhp->ext[SADB_EXT_ADDRESS_DST];
6641
6642         /* XXX boundary check against sa_len */
6643         KEY_SETSECASIDX(proto, IPSEC_MODE_ANY, 0, src0 + 1, dst0 + 1, &saidx);
6644
6645         /*
6646          * Make sure the port numbers are zero.
6647          * In case of NAT-T we will update them later if needed.
6648          */
6649         KEY_PORTTOSADDR(&saidx.src, 0);
6650         KEY_PORTTOSADDR(&saidx.dst, 0);
6651
6652 #ifndef IPSEC_NAT_T
6653         /*
6654          * Handle NAT-T info if present.
6655          */
6656
6657         if (mhp->ext[SADB_X_EXT_NAT_T_SPORT] != NULL &&
6658             mhp->ext[SADB_X_EXT_NAT_T_DPORT] != NULL) {
6659                 struct sadb_x_nat_t_port *sport, *dport;
6660
6661                 if (mhp->extlen[SADB_X_EXT_NAT_T_SPORT] < sizeof(*sport) ||
6662                     mhp->extlen[SADB_X_EXT_NAT_T_DPORT] < sizeof(*dport)) {
6663                         ipseclog((LOG_DEBUG, "%s: invalid message.\n",
6664                             __func__));
6665                         return key_senderror(so, m, EINVAL);
6666                 }
6667
6668                 sport = (struct sadb_x_nat_t_port *)
6669                     mhp->ext[SADB_X_EXT_NAT_T_SPORT];
6670                 dport = (struct sadb_x_nat_t_port *)
6671                     mhp->ext[SADB_X_EXT_NAT_T_DPORT];
6672
6673                 if (sport)
6674                         KEY_PORTTOSADDR(&saidx.src,
6675                             sport->sadb_x_nat_t_port_port);
6676                 if (dport)
6677                         KEY_PORTTOSADDR(&saidx.dst,
6678                             dport->sadb_x_nat_t_port_port);
6679         }
6680 #endif
6681
6682         /* get a SA index */
6683         SAHTREE_LOCK();
6684         LIST_FOREACH(sah, &V_sahtree, chain) {
6685                 if (sah->state == SADB_SASTATE_DEAD)
6686                         continue;
6687                 if (key_cmpsaidx(&sah->saidx, &saidx, CMP_MODE_REQID))
6688                         break;
6689         }
6690         SAHTREE_UNLOCK();
6691         if (sah != NULL) {
6692                 ipseclog((LOG_DEBUG, "%s: a SA exists already.\n", __func__));
6693                 return key_senderror(so, m, EEXIST);
6694         }
6695
6696         error = key_acquire(&saidx, NULL);
6697         if (error != 0) {
6698                 ipseclog((LOG_DEBUG, "%s: error %d returned from key_acquire\n",
6699                         __func__, mhp->msg->sadb_msg_errno));
6700                 return key_senderror(so, m, error);
6701         }
6702
6703         return key_sendup_mbuf(so, m, KEY_SENDUP_REGISTERED);
6704 }
6705
6706 /*
6707  * SADB_REGISTER processing.
6708  * If SATYPE_UNSPEC has been passed as satype, only return sabd_supported.
6709  * receive
6710  *   <base>
6711  * from the ikmpd, and register a socket to send PF_KEY messages,
6712  * and send
6713  *   <base, supported>
6714  * to KMD by PF_KEY.
6715  * If socket is detached, must free from regnode.
6716  *
6717  * m will always be freed.
6718  */
6719 static int
6720 key_register(so, m, mhp)
6721         struct socket *so;
6722         struct mbuf *m;
6723         const struct sadb_msghdr *mhp;
6724 {
6725         struct secreg *reg, *newreg = 0;
6726
6727         IPSEC_ASSERT(so != NULL, ("null socket"));
6728         IPSEC_ASSERT(m != NULL, ("null mbuf"));
6729         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
6730         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
6731
6732         /* check for invalid register message */
6733         if (mhp->msg->sadb_msg_satype >= sizeof(V_regtree)/sizeof(V_regtree[0]))
6734                 return key_senderror(so, m, EINVAL);
6735
6736         /* When SATYPE_UNSPEC is specified, only return sabd_supported. */
6737         if (mhp->msg->sadb_msg_satype == SADB_SATYPE_UNSPEC)
6738                 goto setmsg;
6739
6740         /* check whether existing or not */
6741         REGTREE_LOCK();
6742         LIST_FOREACH(reg, &V_regtree[mhp->msg->sadb_msg_satype], chain) {
6743                 if (reg->so == so) {
6744                         REGTREE_UNLOCK();
6745                         ipseclog((LOG_DEBUG, "%s: socket exists already.\n",
6746                                 __func__));
6747                         return key_senderror(so, m, EEXIST);
6748                 }
6749         }
6750
6751         /* create regnode */
6752         newreg =  malloc(sizeof(struct secreg), M_IPSEC_SAR, M_NOWAIT|M_ZERO);
6753         if (newreg == NULL) {
6754                 REGTREE_UNLOCK();
6755                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
6756                 return key_senderror(so, m, ENOBUFS);
6757         }
6758
6759         newreg->so = so;
6760         ((struct keycb *)sotorawcb(so))->kp_registered++;
6761
6762         /* add regnode to regtree. */
6763         LIST_INSERT_HEAD(&V_regtree[mhp->msg->sadb_msg_satype], newreg, chain);
6764         REGTREE_UNLOCK();
6765
6766   setmsg:
6767     {
6768         struct mbuf *n;
6769         struct sadb_msg *newmsg;
6770         struct sadb_supported *sup;
6771         u_int len, alen, elen;
6772         int off;
6773         int i;
6774         struct sadb_alg *alg;
6775
6776         /* create new sadb_msg to reply. */
6777         alen = 0;
6778         for (i = 1; i <= SADB_AALG_MAX; i++) {
6779                 if (ah_algorithm_lookup(i))
6780                         alen += sizeof(struct sadb_alg);
6781         }
6782         if (alen)
6783                 alen += sizeof(struct sadb_supported);
6784         elen = 0;
6785         for (i = 1; i <= SADB_EALG_MAX; i++) {
6786                 if (esp_algorithm_lookup(i))
6787                         elen += sizeof(struct sadb_alg);
6788         }
6789         if (elen)
6790                 elen += sizeof(struct sadb_supported);
6791
6792         len = sizeof(struct sadb_msg) + alen + elen;
6793
6794         if (len > MCLBYTES)
6795                 return key_senderror(so, m, ENOBUFS);
6796
6797         MGETHDR(n, M_NOWAIT, MT_DATA);
6798         if (len > MHLEN) {
6799                 MCLGET(n, M_NOWAIT);
6800                 if ((n->m_flags & M_EXT) == 0) {
6801                         m_freem(n);
6802                         n = NULL;
6803                 }
6804         }
6805         if (!n)
6806                 return key_senderror(so, m, ENOBUFS);
6807
6808         n->m_pkthdr.len = n->m_len = len;
6809         n->m_next = NULL;
6810         off = 0;
6811
6812         m_copydata(m, 0, sizeof(struct sadb_msg), mtod(n, caddr_t) + off);
6813         newmsg = mtod(n, struct sadb_msg *);
6814         newmsg->sadb_msg_errno = 0;
6815         newmsg->sadb_msg_len = PFKEY_UNIT64(len);
6816         off += PFKEY_ALIGN8(sizeof(struct sadb_msg));
6817
6818         /* for authentication algorithm */
6819         if (alen) {
6820                 sup = (struct sadb_supported *)(mtod(n, caddr_t) + off);
6821                 sup->sadb_supported_len = PFKEY_UNIT64(alen);
6822                 sup->sadb_supported_exttype = SADB_EXT_SUPPORTED_AUTH;
6823                 off += PFKEY_ALIGN8(sizeof(*sup));
6824
6825                 for (i = 1; i <= SADB_AALG_MAX; i++) {
6826                         struct auth_hash *aalgo;
6827                         u_int16_t minkeysize, maxkeysize;
6828
6829                         aalgo = ah_algorithm_lookup(i);
6830                         if (!aalgo)
6831                                 continue;
6832                         alg = (struct sadb_alg *)(mtod(n, caddr_t) + off);
6833                         alg->sadb_alg_id = i;
6834                         alg->sadb_alg_ivlen = 0;
6835                         key_getsizes_ah(aalgo, i, &minkeysize, &maxkeysize);
6836                         alg->sadb_alg_minbits = _BITS(minkeysize);
6837                         alg->sadb_alg_maxbits = _BITS(maxkeysize);
6838                         off += PFKEY_ALIGN8(sizeof(*alg));
6839                 }
6840         }
6841
6842         /* for encryption algorithm */
6843         if (elen) {
6844                 sup = (struct sadb_supported *)(mtod(n, caddr_t) + off);
6845                 sup->sadb_supported_len = PFKEY_UNIT64(elen);
6846                 sup->sadb_supported_exttype = SADB_EXT_SUPPORTED_ENCRYPT;
6847                 off += PFKEY_ALIGN8(sizeof(*sup));
6848
6849                 for (i = 1; i <= SADB_EALG_MAX; i++) {
6850                         struct enc_xform *ealgo;
6851
6852                         ealgo = esp_algorithm_lookup(i);
6853                         if (!ealgo)
6854                                 continue;
6855                         alg = (struct sadb_alg *)(mtod(n, caddr_t) + off);
6856                         alg->sadb_alg_id = i;
6857                         alg->sadb_alg_ivlen = ealgo->blocksize;
6858                         alg->sadb_alg_minbits = _BITS(ealgo->minkey);
6859                         alg->sadb_alg_maxbits = _BITS(ealgo->maxkey);
6860                         off += PFKEY_ALIGN8(sizeof(struct sadb_alg));
6861                 }
6862         }
6863
6864         IPSEC_ASSERT(off == len,
6865                 ("length assumption failed (off %u len %u)", off, len));
6866
6867         m_freem(m);
6868         return key_sendup_mbuf(so, n, KEY_SENDUP_REGISTERED);
6869     }
6870 }
6871
6872 /*
6873  * free secreg entry registered.
6874  * XXX: I want to do free a socket marked done SADB_RESIGER to socket.
6875  */
6876 void
6877 key_freereg(struct socket *so)
6878 {
6879         struct secreg *reg;
6880         int i;
6881
6882         IPSEC_ASSERT(so != NULL, ("NULL so"));
6883
6884         /*
6885          * check whether existing or not.
6886          * check all type of SA, because there is a potential that
6887          * one socket is registered to multiple type of SA.
6888          */
6889         REGTREE_LOCK();
6890         for (i = 0; i <= SADB_SATYPE_MAX; i++) {
6891                 LIST_FOREACH(reg, &V_regtree[i], chain) {
6892                         if (reg->so == so && __LIST_CHAINED(reg)) {
6893                                 LIST_REMOVE(reg, chain);
6894                                 free(reg, M_IPSEC_SAR);
6895                                 break;
6896                         }
6897                 }
6898         }
6899         REGTREE_UNLOCK();
6900 }
6901
6902 /*
6903  * SADB_EXPIRE processing
6904  * send
6905  *   <base, SA, SA2, lifetime(C and one of HS), address(SD)>
6906  * to KMD by PF_KEY.
6907  * NOTE: We send only soft lifetime extension.
6908  *
6909  * OUT: 0       : succeed
6910  *      others  : error number
6911  */
6912 static int
6913 key_expire(struct secasvar *sav)
6914 {
6915         int satype;
6916         struct mbuf *result = NULL, *m;
6917         int len;
6918         int error = -1;
6919         struct sadb_lifetime *lt;
6920
6921         IPSEC_ASSERT (sav != NULL, ("null sav"));
6922         IPSEC_ASSERT (sav->sah != NULL, ("null sa header"));
6923
6924         /* set msg header */
6925         satype = key_proto2satype(sav->sah->saidx.proto);
6926         IPSEC_ASSERT(satype != 0, ("invalid proto, satype %u", satype));
6927         m = key_setsadbmsg(SADB_EXPIRE, 0, satype, sav->seq, 0, sav->refcnt);
6928         if (!m) {
6929                 error = ENOBUFS;
6930                 goto fail;
6931         }
6932         result = m;
6933
6934         /* create SA extension */
6935         m = key_setsadbsa(sav);
6936         if (!m) {
6937                 error = ENOBUFS;
6938                 goto fail;
6939         }
6940         m_cat(result, m);
6941
6942         /* create SA extension */
6943         m = key_setsadbxsa2(sav->sah->saidx.mode,
6944                         sav->replay ? sav->replay->count : 0,
6945                         sav->sah->saidx.reqid);
6946         if (!m) {
6947                 error = ENOBUFS;
6948                 goto fail;
6949         }
6950         m_cat(result, m);
6951
6952         /* create lifetime extension (current and soft) */
6953         len = PFKEY_ALIGN8(sizeof(*lt)) * 2;
6954         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
6955         if (m == NULL) {
6956                 error = ENOBUFS;
6957                 goto fail;
6958         }
6959         m_align(m, len);
6960         m->m_len = len;
6961         bzero(mtod(m, caddr_t), len);
6962         lt = mtod(m, struct sadb_lifetime *);
6963         lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
6964         lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
6965         lt->sadb_lifetime_allocations = sav->lft_c->allocations;
6966         lt->sadb_lifetime_bytes = sav->lft_c->bytes;
6967         lt->sadb_lifetime_addtime = sav->lft_c->addtime;
6968         lt->sadb_lifetime_usetime = sav->lft_c->usetime;
6969         lt = (struct sadb_lifetime *)(mtod(m, caddr_t) + len / 2);
6970         lt->sadb_lifetime_len = PFKEY_UNIT64(sizeof(struct sadb_lifetime));
6971         lt->sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT;
6972         lt->sadb_lifetime_allocations = sav->lft_s->allocations;
6973         lt->sadb_lifetime_bytes = sav->lft_s->bytes;
6974         lt->sadb_lifetime_addtime = sav->lft_s->addtime;
6975         lt->sadb_lifetime_usetime = sav->lft_s->usetime;
6976         m_cat(result, m);
6977
6978         /* set sadb_address for source */
6979         m = key_setsadbaddr(SADB_EXT_ADDRESS_SRC,
6980             &sav->sah->saidx.src.sa,
6981             FULLMASK, IPSEC_ULPROTO_ANY);
6982         if (!m) {
6983                 error = ENOBUFS;
6984                 goto fail;
6985         }
6986         m_cat(result, m);
6987
6988         /* set sadb_address for destination */
6989         m = key_setsadbaddr(SADB_EXT_ADDRESS_DST,
6990             &sav->sah->saidx.dst.sa,
6991             FULLMASK, IPSEC_ULPROTO_ANY);
6992         if (!m) {
6993                 error = ENOBUFS;
6994                 goto fail;
6995         }
6996         m_cat(result, m);
6997
6998         /*
6999          * XXX-BZ Handle NAT-T extensions here.
7000          */
7001
7002         if ((result->m_flags & M_PKTHDR) == 0) {
7003                 error = EINVAL;
7004                 goto fail;
7005         }
7006
7007         if (result->m_len < sizeof(struct sadb_msg)) {
7008                 result = m_pullup(result, sizeof(struct sadb_msg));
7009                 if (result == NULL) {
7010                         error = ENOBUFS;
7011                         goto fail;
7012                 }
7013         }
7014
7015         result->m_pkthdr.len = 0;
7016         for (m = result; m; m = m->m_next)
7017                 result->m_pkthdr.len += m->m_len;
7018
7019         mtod(result, struct sadb_msg *)->sadb_msg_len =
7020             PFKEY_UNIT64(result->m_pkthdr.len);
7021
7022         return key_sendup_mbuf(NULL, result, KEY_SENDUP_REGISTERED);
7023
7024  fail:
7025         if (result)
7026                 m_freem(result);
7027         return error;
7028 }
7029
7030 /*
7031  * SADB_FLUSH processing
7032  * receive
7033  *   <base>
7034  * from the ikmpd, and free all entries in secastree.
7035  * and send,
7036  *   <base>
7037  * to the ikmpd.
7038  * NOTE: to do is only marking SADB_SASTATE_DEAD.
7039  *
7040  * m will always be freed.
7041  */
7042 static int
7043 key_flush(so, m, mhp)
7044         struct socket *so;
7045         struct mbuf *m;
7046         const struct sadb_msghdr *mhp;
7047 {
7048         struct sadb_msg *newmsg;
7049         struct secashead *sah, *nextsah;
7050         struct secasvar *sav, *nextsav;
7051         u_int16_t proto;
7052         u_int8_t state;
7053         u_int stateidx;
7054
7055         IPSEC_ASSERT(so != NULL, ("null socket"));
7056         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
7057         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
7058
7059         /* map satype to proto */
7060         if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
7061                 ipseclog((LOG_DEBUG, "%s: invalid satype is passed.\n",
7062                         __func__));
7063                 return key_senderror(so, m, EINVAL);
7064         }
7065
7066         /* no SATYPE specified, i.e. flushing all SA. */
7067         SAHTREE_LOCK();
7068         for (sah = LIST_FIRST(&V_sahtree);
7069              sah != NULL;
7070              sah = nextsah) {
7071                 nextsah = LIST_NEXT(sah, chain);
7072
7073                 if (mhp->msg->sadb_msg_satype != SADB_SATYPE_UNSPEC
7074                  && proto != sah->saidx.proto)
7075                         continue;
7076
7077                 for (stateidx = 0;
7078                      stateidx < _ARRAYLEN(saorder_state_alive);
7079                      stateidx++) {
7080                         state = saorder_state_any[stateidx];
7081                         for (sav = LIST_FIRST(&sah->savtree[state]);
7082                              sav != NULL;
7083                              sav = nextsav) {
7084
7085                                 nextsav = LIST_NEXT(sav, chain);
7086
7087                                 key_sa_chgstate(sav, SADB_SASTATE_DEAD);
7088                                 KEY_FREESAV(&sav);
7089                         }
7090                 }
7091
7092                 sah->state = SADB_SASTATE_DEAD;
7093         }
7094         SAHTREE_UNLOCK();
7095
7096         if (m->m_len < sizeof(struct sadb_msg) ||
7097             sizeof(struct sadb_msg) > m->m_len + M_TRAILINGSPACE(m)) {
7098                 ipseclog((LOG_DEBUG, "%s: No more memory.\n", __func__));
7099                 return key_senderror(so, m, ENOBUFS);
7100         }
7101
7102         if (m->m_next)
7103                 m_freem(m->m_next);
7104         m->m_next = NULL;
7105         m->m_pkthdr.len = m->m_len = sizeof(struct sadb_msg);
7106         newmsg = mtod(m, struct sadb_msg *);
7107         newmsg->sadb_msg_errno = 0;
7108         newmsg->sadb_msg_len = PFKEY_UNIT64(m->m_pkthdr.len);
7109
7110         return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
7111 }
7112
7113 /*
7114  * SADB_DUMP processing
7115  * dump all entries including status of DEAD in SAD.
7116  * receive
7117  *   <base>
7118  * from the ikmpd, and dump all secasvar leaves
7119  * and send,
7120  *   <base> .....
7121  * to the ikmpd.
7122  *
7123  * m will always be freed.
7124  */
7125 static int
7126 key_dump(so, m, mhp)
7127         struct socket *so;
7128         struct mbuf *m;
7129         const struct sadb_msghdr *mhp;
7130 {
7131         struct secashead *sah;
7132         struct secasvar *sav;
7133         u_int16_t proto;
7134         u_int stateidx;
7135         u_int8_t satype;
7136         u_int8_t state;
7137         int cnt;
7138         struct sadb_msg *newmsg;
7139         struct mbuf *n;
7140
7141         IPSEC_ASSERT(so != NULL, ("null socket"));
7142         IPSEC_ASSERT(m != NULL, ("null mbuf"));
7143         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
7144         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
7145
7146         /* map satype to proto */
7147         if ((proto = key_satype2proto(mhp->msg->sadb_msg_satype)) == 0) {
7148                 ipseclog((LOG_DEBUG, "%s: invalid satype is passed.\n",
7149                         __func__));
7150                 return key_senderror(so, m, EINVAL);
7151         }
7152
7153         /* count sav entries to be sent to the userland. */
7154         cnt = 0;
7155         SAHTREE_LOCK();
7156         LIST_FOREACH(sah, &V_sahtree, chain) {
7157                 if (mhp->msg->sadb_msg_satype != SADB_SATYPE_UNSPEC
7158                  && proto != sah->saidx.proto)
7159                         continue;
7160
7161                 for (stateidx = 0;
7162                      stateidx < _ARRAYLEN(saorder_state_any);
7163                      stateidx++) {
7164                         state = saorder_state_any[stateidx];
7165                         LIST_FOREACH(sav, &sah->savtree[state], chain) {
7166                                 cnt++;
7167                         }
7168                 }
7169         }
7170
7171         if (cnt == 0) {
7172                 SAHTREE_UNLOCK();
7173                 return key_senderror(so, m, ENOENT);
7174         }
7175
7176         /* send this to the userland, one at a time. */
7177         newmsg = NULL;
7178         LIST_FOREACH(sah, &V_sahtree, chain) {
7179                 if (mhp->msg->sadb_msg_satype != SADB_SATYPE_UNSPEC
7180                  && proto != sah->saidx.proto)
7181                         continue;
7182
7183                 /* map proto to satype */
7184                 if ((satype = key_proto2satype(sah->saidx.proto)) == 0) {
7185                         SAHTREE_UNLOCK();
7186                         ipseclog((LOG_DEBUG, "%s: there was invalid proto in "
7187                                 "SAD.\n", __func__));
7188                         return key_senderror(so, m, EINVAL);
7189                 }
7190
7191                 for (stateidx = 0;
7192                      stateidx < _ARRAYLEN(saorder_state_any);
7193                      stateidx++) {
7194                         state = saorder_state_any[stateidx];
7195                         LIST_FOREACH(sav, &sah->savtree[state], chain) {
7196                                 n = key_setdumpsa(sav, SADB_DUMP, satype,
7197                                     --cnt, mhp->msg->sadb_msg_pid);
7198                                 if (!n) {
7199                                         SAHTREE_UNLOCK();
7200                                         return key_senderror(so, m, ENOBUFS);
7201                                 }
7202                                 key_sendup_mbuf(so, n, KEY_SENDUP_ONE);
7203                         }
7204                 }
7205         }
7206         SAHTREE_UNLOCK();
7207
7208         m_freem(m);
7209         return 0;
7210 }
7211
7212 /*
7213  * SADB_X_PROMISC processing
7214  *
7215  * m will always be freed.
7216  */
7217 static int
7218 key_promisc(so, m, mhp)
7219         struct socket *so;
7220         struct mbuf *m;
7221         const struct sadb_msghdr *mhp;
7222 {
7223         int olen;
7224
7225         IPSEC_ASSERT(so != NULL, ("null socket"));
7226         IPSEC_ASSERT(m != NULL, ("null mbuf"));
7227         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
7228         IPSEC_ASSERT(mhp->msg != NULL, ("null msg"));
7229
7230         olen = PFKEY_UNUNIT64(mhp->msg->sadb_msg_len);
7231
7232         if (olen < sizeof(struct sadb_msg)) {
7233 #if 1
7234                 return key_senderror(so, m, EINVAL);
7235 #else
7236                 m_freem(m);
7237                 return 0;
7238 #endif
7239         } else if (olen == sizeof(struct sadb_msg)) {
7240                 /* enable/disable promisc mode */
7241                 struct keycb *kp;
7242
7243                 if ((kp = (struct keycb *)sotorawcb(so)) == NULL)
7244                         return key_senderror(so, m, EINVAL);
7245                 mhp->msg->sadb_msg_errno = 0;
7246                 switch (mhp->msg->sadb_msg_satype) {
7247                 case 0:
7248                 case 1:
7249                         kp->kp_promisc = mhp->msg->sadb_msg_satype;
7250                         break;
7251                 default:
7252                         return key_senderror(so, m, EINVAL);
7253                 }
7254
7255                 /* send the original message back to everyone */
7256                 mhp->msg->sadb_msg_errno = 0;
7257                 return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
7258         } else {
7259                 /* send packet as is */
7260
7261                 m_adj(m, PFKEY_ALIGN8(sizeof(struct sadb_msg)));
7262
7263                 /* TODO: if sadb_msg_seq is specified, send to specific pid */
7264                 return key_sendup_mbuf(so, m, KEY_SENDUP_ALL);
7265         }
7266 }
7267
7268 static int (*key_typesw[]) __P((struct socket *, struct mbuf *,
7269                 const struct sadb_msghdr *)) = {
7270         NULL,           /* SADB_RESERVED */
7271         key_getspi,     /* SADB_GETSPI */
7272         key_update,     /* SADB_UPDATE */
7273         key_add,        /* SADB_ADD */
7274         key_delete,     /* SADB_DELETE */
7275         key_get,        /* SADB_GET */
7276         key_acquire2,   /* SADB_ACQUIRE */
7277         key_register,   /* SADB_REGISTER */
7278         NULL,           /* SADB_EXPIRE */
7279         key_flush,      /* SADB_FLUSH */
7280         key_dump,       /* SADB_DUMP */
7281         key_promisc,    /* SADB_X_PROMISC */
7282         NULL,           /* SADB_X_PCHANGE */
7283         key_spdadd,     /* SADB_X_SPDUPDATE */
7284         key_spdadd,     /* SADB_X_SPDADD */
7285         key_spddelete,  /* SADB_X_SPDDELETE */
7286         key_spdget,     /* SADB_X_SPDGET */
7287         NULL,           /* SADB_X_SPDACQUIRE */
7288         key_spddump,    /* SADB_X_SPDDUMP */
7289         key_spdflush,   /* SADB_X_SPDFLUSH */
7290         key_spdadd,     /* SADB_X_SPDSETIDX */
7291         NULL,           /* SADB_X_SPDEXPIRE */
7292         key_spddelete2, /* SADB_X_SPDDELETE2 */
7293 };
7294
7295 /*
7296  * parse sadb_msg buffer to process PFKEYv2,
7297  * and create a data to response if needed.
7298  * I think to be dealed with mbuf directly.
7299  * IN:
7300  *     msgp  : pointer to pointer to a received buffer pulluped.
7301  *             This is rewrited to response.
7302  *     so    : pointer to socket.
7303  * OUT:
7304  *    length for buffer to send to user process.
7305  */
7306 int
7307 key_parse(m, so)
7308         struct mbuf *m;
7309         struct socket *so;
7310 {
7311         struct sadb_msg *msg;
7312         struct sadb_msghdr mh;
7313         u_int orglen;
7314         int error;
7315         int target;
7316
7317         IPSEC_ASSERT(so != NULL, ("null socket"));
7318         IPSEC_ASSERT(m != NULL, ("null mbuf"));
7319
7320 #if 0   /*kdebug_sadb assumes msg in linear buffer*/
7321         KEYDEBUG(KEYDEBUG_KEY_DUMP,
7322                 ipseclog((LOG_DEBUG, "%s: passed sadb_msg\n", __func__));
7323                 kdebug_sadb(msg));
7324 #endif
7325
7326         if (m->m_len < sizeof(struct sadb_msg)) {
7327                 m = m_pullup(m, sizeof(struct sadb_msg));
7328                 if (!m)
7329                         return ENOBUFS;
7330         }
7331         msg = mtod(m, struct sadb_msg *);
7332         orglen = PFKEY_UNUNIT64(msg->sadb_msg_len);
7333         target = KEY_SENDUP_ONE;
7334
7335         if ((m->m_flags & M_PKTHDR) == 0 ||
7336             m->m_pkthdr.len != m->m_pkthdr.len) {
7337                 ipseclog((LOG_DEBUG, "%s: invalid message length.\n",__func__));
7338                 PFKEYSTAT_INC(out_invlen);
7339                 error = EINVAL;
7340                 goto senderror;
7341         }
7342
7343         if (msg->sadb_msg_version != PF_KEY_V2) {
7344                 ipseclog((LOG_DEBUG, "%s: PF_KEY version %u is mismatched.\n",
7345                     __func__, msg->sadb_msg_version));
7346                 PFKEYSTAT_INC(out_invver);
7347                 error = EINVAL;
7348                 goto senderror;
7349         }
7350
7351         if (msg->sadb_msg_type > SADB_MAX) {
7352                 ipseclog((LOG_DEBUG, "%s: invalid type %u is passed.\n",
7353                     __func__, msg->sadb_msg_type));
7354                 PFKEYSTAT_INC(out_invmsgtype);
7355                 error = EINVAL;
7356                 goto senderror;
7357         }
7358
7359         /* for old-fashioned code - should be nuked */
7360         if (m->m_pkthdr.len > MCLBYTES) {
7361                 m_freem(m);
7362                 return ENOBUFS;
7363         }
7364         if (m->m_next) {
7365                 struct mbuf *n;
7366
7367                 MGETHDR(n, M_NOWAIT, MT_DATA);
7368                 if (n && m->m_pkthdr.len > MHLEN) {
7369                         MCLGET(n, M_NOWAIT);
7370                         if ((n->m_flags & M_EXT) == 0) {
7371                                 m_free(n);
7372                                 n = NULL;
7373                         }
7374                 }
7375                 if (!n) {
7376                         m_freem(m);
7377                         return ENOBUFS;
7378                 }
7379                 m_copydata(m, 0, m->m_pkthdr.len, mtod(n, caddr_t));
7380                 n->m_pkthdr.len = n->m_len = m->m_pkthdr.len;
7381                 n->m_next = NULL;
7382                 m_freem(m);
7383                 m = n;
7384         }
7385
7386         /* align the mbuf chain so that extensions are in contiguous region. */
7387         error = key_align(m, &mh);
7388         if (error)
7389                 return error;
7390
7391         msg = mh.msg;
7392
7393         /* check SA type */
7394         switch (msg->sadb_msg_satype) {
7395         case SADB_SATYPE_UNSPEC:
7396                 switch (msg->sadb_msg_type) {
7397                 case SADB_GETSPI:
7398                 case SADB_UPDATE:
7399                 case SADB_ADD:
7400                 case SADB_DELETE:
7401                 case SADB_GET:
7402                 case SADB_ACQUIRE:
7403                 case SADB_EXPIRE:
7404                         ipseclog((LOG_DEBUG, "%s: must specify satype "
7405                             "when msg type=%u.\n", __func__,
7406                             msg->sadb_msg_type));
7407                         PFKEYSTAT_INC(out_invsatype);
7408                         error = EINVAL;
7409                         goto senderror;
7410                 }
7411                 break;
7412         case SADB_SATYPE_AH:
7413         case SADB_SATYPE_ESP:
7414         case SADB_X_SATYPE_IPCOMP:
7415         case SADB_X_SATYPE_TCPSIGNATURE:
7416                 switch (msg->sadb_msg_type) {
7417                 case SADB_X_SPDADD:
7418                 case SADB_X_SPDDELETE:
7419                 case SADB_X_SPDGET:
7420                 case SADB_X_SPDDUMP:
7421                 case SADB_X_SPDFLUSH:
7422                 case SADB_X_SPDSETIDX:
7423                 case SADB_X_SPDUPDATE:
7424                 case SADB_X_SPDDELETE2:
7425                         ipseclog((LOG_DEBUG, "%s: illegal satype=%u\n",
7426                                 __func__, msg->sadb_msg_type));
7427                         PFKEYSTAT_INC(out_invsatype);
7428                         error = EINVAL;
7429                         goto senderror;
7430                 }
7431                 break;
7432         case SADB_SATYPE_RSVP:
7433         case SADB_SATYPE_OSPFV2:
7434         case SADB_SATYPE_RIPV2:
7435         case SADB_SATYPE_MIP:
7436                 ipseclog((LOG_DEBUG, "%s: type %u isn't supported.\n",
7437                         __func__, msg->sadb_msg_satype));
7438                 PFKEYSTAT_INC(out_invsatype);
7439                 error = EOPNOTSUPP;
7440                 goto senderror;
7441         case 1: /* XXX: What does it do? */
7442                 if (msg->sadb_msg_type == SADB_X_PROMISC)
7443                         break;
7444                 /*FALLTHROUGH*/
7445         default:
7446                 ipseclog((LOG_DEBUG, "%s: invalid type %u is passed.\n",
7447                         __func__, msg->sadb_msg_satype));
7448                 PFKEYSTAT_INC(out_invsatype);
7449                 error = EINVAL;
7450                 goto senderror;
7451         }
7452
7453         /* check field of upper layer protocol and address family */
7454         if (mh.ext[SADB_EXT_ADDRESS_SRC] != NULL
7455          && mh.ext[SADB_EXT_ADDRESS_DST] != NULL) {
7456                 struct sadb_address *src0, *dst0;
7457                 u_int plen;
7458
7459                 src0 = (struct sadb_address *)(mh.ext[SADB_EXT_ADDRESS_SRC]);
7460                 dst0 = (struct sadb_address *)(mh.ext[SADB_EXT_ADDRESS_DST]);
7461
7462                 /* check upper layer protocol */
7463                 if (src0->sadb_address_proto != dst0->sadb_address_proto) {
7464                         ipseclog((LOG_DEBUG, "%s: upper layer protocol "
7465                                 "mismatched.\n", __func__));
7466                         PFKEYSTAT_INC(out_invaddr);
7467                         error = EINVAL;
7468                         goto senderror;
7469                 }
7470
7471                 /* check family */
7472                 if (PFKEY_ADDR_SADDR(src0)->sa_family !=
7473                     PFKEY_ADDR_SADDR(dst0)->sa_family) {
7474                         ipseclog((LOG_DEBUG, "%s: address family mismatched.\n",
7475                                 __func__));
7476                         PFKEYSTAT_INC(out_invaddr);
7477                         error = EINVAL;
7478                         goto senderror;
7479                 }
7480                 if (PFKEY_ADDR_SADDR(src0)->sa_len !=
7481                     PFKEY_ADDR_SADDR(dst0)->sa_len) {
7482                         ipseclog((LOG_DEBUG, "%s: address struct size "
7483                                 "mismatched.\n", __func__));
7484                         PFKEYSTAT_INC(out_invaddr);
7485                         error = EINVAL;
7486                         goto senderror;
7487                 }
7488
7489                 switch (PFKEY_ADDR_SADDR(src0)->sa_family) {
7490                 case AF_INET:
7491                         if (PFKEY_ADDR_SADDR(src0)->sa_len !=
7492                             sizeof(struct sockaddr_in)) {
7493                                 PFKEYSTAT_INC(out_invaddr);
7494                                 error = EINVAL;
7495                                 goto senderror;
7496                         }
7497                         break;
7498                 case AF_INET6:
7499                         if (PFKEY_ADDR_SADDR(src0)->sa_len !=
7500                             sizeof(struct sockaddr_in6)) {
7501                                 PFKEYSTAT_INC(out_invaddr);
7502                                 error = EINVAL;
7503                                 goto senderror;
7504                         }
7505                         break;
7506                 default:
7507                         ipseclog((LOG_DEBUG, "%s: unsupported address family\n",
7508                                 __func__));
7509                         PFKEYSTAT_INC(out_invaddr);
7510                         error = EAFNOSUPPORT;
7511                         goto senderror;
7512                 }
7513
7514                 switch (PFKEY_ADDR_SADDR(src0)->sa_family) {
7515                 case AF_INET:
7516                         plen = sizeof(struct in_addr) << 3;
7517                         break;
7518                 case AF_INET6:
7519                         plen = sizeof(struct in6_addr) << 3;
7520                         break;
7521                 default:
7522                         plen = 0;       /*fool gcc*/
7523                         break;
7524                 }
7525
7526                 /* check max prefix length */
7527                 if (src0->sadb_address_prefixlen > plen ||
7528                     dst0->sadb_address_prefixlen > plen) {
7529                         ipseclog((LOG_DEBUG, "%s: illegal prefixlen.\n",
7530                                 __func__));
7531                         PFKEYSTAT_INC(out_invaddr);
7532                         error = EINVAL;
7533                         goto senderror;
7534                 }
7535
7536                 /*
7537                  * prefixlen == 0 is valid because there can be a case when
7538                  * all addresses are matched.
7539                  */
7540         }
7541
7542         if (msg->sadb_msg_type >= sizeof(key_typesw)/sizeof(key_typesw[0]) ||
7543             key_typesw[msg->sadb_msg_type] == NULL) {
7544                 PFKEYSTAT_INC(out_invmsgtype);
7545                 error = EINVAL;
7546                 goto senderror;
7547         }
7548
7549         return (*key_typesw[msg->sadb_msg_type])(so, m, &mh);
7550
7551 senderror:
7552         msg->sadb_msg_errno = error;
7553         return key_sendup_mbuf(so, m, target);
7554 }
7555
7556 static int
7557 key_senderror(so, m, code)
7558         struct socket *so;
7559         struct mbuf *m;
7560         int code;
7561 {
7562         struct sadb_msg *msg;
7563
7564         IPSEC_ASSERT(m->m_len >= sizeof(struct sadb_msg),
7565                 ("mbuf too small, len %u", m->m_len));
7566
7567         msg = mtod(m, struct sadb_msg *);
7568         msg->sadb_msg_errno = code;
7569         return key_sendup_mbuf(so, m, KEY_SENDUP_ONE);
7570 }
7571
7572 /*
7573  * set the pointer to each header into message buffer.
7574  * m will be freed on error.
7575  * XXX larger-than-MCLBYTES extension?
7576  */
7577 static int
7578 key_align(m, mhp)
7579         struct mbuf *m;
7580         struct sadb_msghdr *mhp;
7581 {
7582         struct mbuf *n;
7583         struct sadb_ext *ext;
7584         size_t off, end;
7585         int extlen;
7586         int toff;
7587
7588         IPSEC_ASSERT(m != NULL, ("null mbuf"));
7589         IPSEC_ASSERT(mhp != NULL, ("null msghdr"));
7590         IPSEC_ASSERT(m->m_len >= sizeof(struct sadb_msg),
7591                 ("mbuf too small, len %u", m->m_len));
7592
7593         /* initialize */
7594         bzero(mhp, sizeof(*mhp));
7595
7596         mhp->msg = mtod(m, struct sadb_msg *);
7597         mhp->ext[0] = (struct sadb_ext *)mhp->msg;      /*XXX backward compat */
7598
7599         end = PFKEY_UNUNIT64(mhp->msg->sadb_msg_len);
7600         extlen = end;   /*just in case extlen is not updated*/
7601         for (off = sizeof(struct sadb_msg); off < end; off += extlen) {
7602                 n = m_pulldown(m, off, sizeof(struct sadb_ext), &toff);
7603                 if (!n) {
7604                         /* m is already freed */
7605                         return ENOBUFS;
7606                 }
7607                 ext = (struct sadb_ext *)(mtod(n, caddr_t) + toff);
7608
7609                 /* set pointer */
7610                 switch (ext->sadb_ext_type) {
7611                 case SADB_EXT_SA:
7612                 case SADB_EXT_ADDRESS_SRC:
7613                 case SADB_EXT_ADDRESS_DST:
7614                 case SADB_EXT_ADDRESS_PROXY:
7615                 case SADB_EXT_LIFETIME_CURRENT:
7616                 case SADB_EXT_LIFETIME_HARD:
7617                 case SADB_EXT_LIFETIME_SOFT:
7618                 case SADB_EXT_KEY_AUTH:
7619                 case SADB_EXT_KEY_ENCRYPT:
7620                 case SADB_EXT_IDENTITY_SRC:
7621                 case SADB_EXT_IDENTITY_DST:
7622                 case SADB_EXT_SENSITIVITY:
7623                 case SADB_EXT_PROPOSAL:
7624                 case SADB_EXT_SUPPORTED_AUTH:
7625                 case SADB_EXT_SUPPORTED_ENCRYPT:
7626                 case SADB_EXT_SPIRANGE:
7627                 case SADB_X_EXT_POLICY:
7628                 case SADB_X_EXT_SA2:
7629 #ifdef IPSEC_NAT_T
7630                 case SADB_X_EXT_NAT_T_TYPE:
7631                 case SADB_X_EXT_NAT_T_SPORT:
7632                 case SADB_X_EXT_NAT_T_DPORT:
7633                 case SADB_X_EXT_NAT_T_OAI:
7634                 case SADB_X_EXT_NAT_T_OAR:
7635                 case SADB_X_EXT_NAT_T_FRAG:
7636 #endif
7637                         /* duplicate check */
7638                         /*
7639                          * XXX Are there duplication payloads of either
7640                          * KEY_AUTH or KEY_ENCRYPT ?
7641                          */
7642                         if (mhp->ext[ext->sadb_ext_type] != NULL) {
7643                                 ipseclog((LOG_DEBUG, "%s: duplicate ext_type "
7644                                         "%u\n", __func__, ext->sadb_ext_type));
7645                                 m_freem(m);
7646                                 PFKEYSTAT_INC(out_dupext);
7647                                 return EINVAL;
7648                         }
7649                         break;
7650                 default:
7651                         ipseclog((LOG_DEBUG, "%s: invalid ext_type %u\n",
7652                                 __func__, ext->sadb_ext_type));
7653                         m_freem(m);
7654                         PFKEYSTAT_INC(out_invexttype);
7655                         return EINVAL;
7656                 }
7657
7658                 extlen = PFKEY_UNUNIT64(ext->sadb_ext_len);
7659
7660                 if (key_validate_ext(ext, extlen)) {
7661                         m_freem(m);
7662                         PFKEYSTAT_INC(out_invlen);
7663                         return EINVAL;
7664                 }
7665
7666                 n = m_pulldown(m, off, extlen, &toff);
7667                 if (!n) {
7668                         /* m is already freed */
7669                         return ENOBUFS;
7670                 }
7671                 ext = (struct sadb_ext *)(mtod(n, caddr_t) + toff);
7672
7673                 mhp->ext[ext->sadb_ext_type] = ext;
7674                 mhp->extoff[ext->sadb_ext_type] = off;
7675                 mhp->extlen[ext->sadb_ext_type] = extlen;
7676         }
7677
7678         if (off != end) {
7679                 m_freem(m);
7680                 PFKEYSTAT_INC(out_invlen);
7681                 return EINVAL;
7682         }
7683
7684         return 0;
7685 }
7686
7687 static int
7688 key_validate_ext(ext, len)
7689         const struct sadb_ext *ext;
7690         int len;
7691 {
7692         const struct sockaddr *sa;
7693         enum { NONE, ADDR } checktype = NONE;
7694         int baselen = 0;
7695         const int sal = offsetof(struct sockaddr, sa_len) + sizeof(sa->sa_len);
7696
7697         if (len != PFKEY_UNUNIT64(ext->sadb_ext_len))
7698                 return EINVAL;
7699
7700         /* if it does not match minimum/maximum length, bail */
7701         if (ext->sadb_ext_type >= sizeof(minsize) / sizeof(minsize[0]) ||
7702             ext->sadb_ext_type >= sizeof(maxsize) / sizeof(maxsize[0]))
7703                 return EINVAL;
7704         if (!minsize[ext->sadb_ext_type] || len < minsize[ext->sadb_ext_type])
7705                 return EINVAL;
7706         if (maxsize[ext->sadb_ext_type] && len > maxsize[ext->sadb_ext_type])
7707                 return EINVAL;
7708
7709         /* more checks based on sadb_ext_type XXX need more */
7710         switch (ext->sadb_ext_type) {
7711         case SADB_EXT_ADDRESS_SRC:
7712         case SADB_EXT_ADDRESS_DST:
7713         case SADB_EXT_ADDRESS_PROXY:
7714                 baselen = PFKEY_ALIGN8(sizeof(struct sadb_address));
7715                 checktype = ADDR;
7716                 break;
7717         case SADB_EXT_IDENTITY_SRC:
7718         case SADB_EXT_IDENTITY_DST:
7719                 if (((const struct sadb_ident *)ext)->sadb_ident_type ==
7720                     SADB_X_IDENTTYPE_ADDR) {
7721                         baselen = PFKEY_ALIGN8(sizeof(struct sadb_ident));
7722                         checktype = ADDR;
7723                 } else
7724                         checktype = NONE;
7725                 break;
7726         default:
7727                 checktype = NONE;
7728                 break;
7729         }
7730
7731         switch (checktype) {
7732         case NONE:
7733                 break;
7734         case ADDR:
7735                 sa = (const struct sockaddr *)(((const u_int8_t*)ext)+baselen);
7736                 if (len < baselen + sal)
7737                         return EINVAL;
7738                 if (baselen + PFKEY_ALIGN8(sa->sa_len) != len)
7739                         return EINVAL;
7740                 break;
7741         }
7742
7743         return 0;
7744 }
7745
7746 void
7747 key_init(void)
7748 {
7749         int i;
7750
7751         for (i = 0; i < IPSEC_DIR_MAX; i++)
7752                 LIST_INIT(&V_sptree[i]);
7753
7754         LIST_INIT(&V_sahtree);
7755
7756         for (i = 0; i <= SADB_SATYPE_MAX; i++)
7757                 LIST_INIT(&V_regtree[i]);
7758
7759         LIST_INIT(&V_acqtree);
7760         LIST_INIT(&V_spacqtree);
7761
7762         /* system default */
7763         V_ip4_def_policy.policy = IPSEC_POLICY_NONE;
7764         V_ip4_def_policy.refcnt++;      /*never reclaim this*/
7765
7766         if (!IS_DEFAULT_VNET(curvnet))
7767                 return;
7768
7769         SPTREE_LOCK_INIT();
7770         REGTREE_LOCK_INIT();
7771         SAHTREE_LOCK_INIT();
7772         ACQ_LOCK_INIT();
7773         SPACQ_LOCK_INIT();
7774
7775 #ifndef IPSEC_DEBUG2
7776         callout_init(&key_timer, CALLOUT_MPSAFE);
7777         callout_reset(&key_timer, hz, key_timehandler, NULL);
7778 #endif /*IPSEC_DEBUG2*/
7779
7780         /* initialize key statistics */
7781         keystat.getspi_count = 1;
7782
7783         printf("IPsec: Initialized Security Association Processing.\n");
7784 }
7785
7786 #ifdef VIMAGE
7787 void
7788 key_destroy(void)
7789 {
7790         struct secpolicy *sp, *nextsp;
7791         struct secacq *acq, *nextacq;
7792         struct secspacq *spacq, *nextspacq;
7793         struct secashead *sah, *nextsah;
7794         struct secreg *reg;
7795         int i;
7796
7797         SPTREE_LOCK();
7798         for (i = 0; i < IPSEC_DIR_MAX; i++) {
7799                 for (sp = LIST_FIRST(&V_sptree[i]);
7800                     sp != NULL; sp = nextsp) {
7801                         nextsp = LIST_NEXT(sp, chain);
7802                         if (__LIST_CHAINED(sp)) {
7803                                 LIST_REMOVE(sp, chain);
7804                                 free(sp, M_IPSEC_SP);
7805                         }
7806                 }
7807         }
7808         SPTREE_UNLOCK();
7809
7810         SAHTREE_LOCK();
7811         for (sah = LIST_FIRST(&V_sahtree); sah != NULL; sah = nextsah) {
7812                 nextsah = LIST_NEXT(sah, chain);
7813                 if (__LIST_CHAINED(sah)) {
7814                         LIST_REMOVE(sah, chain);
7815                         free(sah, M_IPSEC_SAH);
7816                 }
7817         }
7818         SAHTREE_UNLOCK();
7819
7820         REGTREE_LOCK();
7821         for (i = 0; i <= SADB_SATYPE_MAX; i++) {
7822                 LIST_FOREACH(reg, &V_regtree[i], chain) {
7823                         if (__LIST_CHAINED(reg)) {
7824                                 LIST_REMOVE(reg, chain);
7825                                 free(reg, M_IPSEC_SAR);
7826                                 break;
7827                         }
7828                 }
7829         }
7830         REGTREE_UNLOCK();
7831
7832         ACQ_LOCK();
7833         for (acq = LIST_FIRST(&V_acqtree); acq != NULL; acq = nextacq) {
7834                 nextacq = LIST_NEXT(acq, chain);
7835                 if (__LIST_CHAINED(acq)) {
7836                         LIST_REMOVE(acq, chain);
7837                         free(acq, M_IPSEC_SAQ);
7838                 }
7839         }
7840         ACQ_UNLOCK();
7841
7842         SPACQ_LOCK();
7843         for (spacq = LIST_FIRST(&V_spacqtree); spacq != NULL;
7844             spacq = nextspacq) {
7845                 nextspacq = LIST_NEXT(spacq, chain);
7846                 if (__LIST_CHAINED(spacq)) {
7847                         LIST_REMOVE(spacq, chain);
7848                         free(spacq, M_IPSEC_SAQ);
7849                 }
7850         }
7851         SPACQ_UNLOCK();
7852 }
7853 #endif
7854
7855 /*
7856  * XXX: maybe This function is called after INBOUND IPsec processing.
7857  *
7858  * Special check for tunnel-mode packets.
7859  * We must make some checks for consistency between inner and outer IP header.
7860  *
7861  * xxx more checks to be provided
7862  */
7863 int
7864 key_checktunnelsanity(sav, family, src, dst)
7865         struct secasvar *sav;
7866         u_int family;
7867         caddr_t src;
7868         caddr_t dst;
7869 {
7870         IPSEC_ASSERT(sav->sah != NULL, ("null SA header"));
7871
7872         /* XXX: check inner IP header */
7873
7874         return 1;
7875 }
7876
7877 /* record data transfer on SA, and update timestamps */
7878 void
7879 key_sa_recordxfer(sav, m)
7880         struct secasvar *sav;
7881         struct mbuf *m;
7882 {
7883         IPSEC_ASSERT(sav != NULL, ("Null secasvar"));
7884         IPSEC_ASSERT(m != NULL, ("Null mbuf"));
7885         if (!sav->lft_c)
7886                 return;
7887
7888         /*
7889          * XXX Currently, there is a difference of bytes size
7890          * between inbound and outbound processing.
7891          */
7892         sav->lft_c->bytes += m->m_pkthdr.len;
7893         /* to check bytes lifetime is done in key_timehandler(). */
7894
7895         /*
7896          * We use the number of packets as the unit of
7897          * allocations.  We increment the variable
7898          * whenever {esp,ah}_{in,out}put is called.
7899          */
7900         sav->lft_c->allocations++;
7901         /* XXX check for expires? */
7902
7903         /*
7904          * NOTE: We record CURRENT usetime by using wall clock,
7905          * in seconds.  HARD and SOFT lifetime are measured by the time
7906          * difference (again in seconds) from usetime.
7907          *
7908          *      usetime
7909          *      v     expire   expire
7910          * -----+-----+--------+---> t
7911          *      <--------------> HARD
7912          *      <-----> SOFT
7913          */
7914         sav->lft_c->usetime = time_second;
7915         /* XXX check for expires? */
7916
7917         return;
7918 }
7919
7920 /* dumb version */
7921 void
7922 key_sa_routechange(dst)
7923         struct sockaddr *dst;
7924 {
7925         struct secashead *sah;
7926         struct route *ro;
7927
7928         SAHTREE_LOCK();
7929         LIST_FOREACH(sah, &V_sahtree, chain) {
7930                 ro = &sah->route_cache.sa_route;
7931                 if (ro->ro_rt && dst->sa_len == ro->ro_dst.sa_len
7932                  && bcmp(dst, &ro->ro_dst, dst->sa_len) == 0) {
7933                         RTFREE(ro->ro_rt);
7934                         ro->ro_rt = (struct rtentry *)NULL;
7935                 }
7936         }
7937         SAHTREE_UNLOCK();
7938 }
7939
7940 static void
7941 key_sa_chgstate(struct secasvar *sav, u_int8_t state)
7942 {
7943         IPSEC_ASSERT(sav != NULL, ("NULL sav"));
7944         SAHTREE_LOCK_ASSERT();
7945
7946         if (sav->state != state) {
7947                 if (__LIST_CHAINED(sav))
7948                         LIST_REMOVE(sav, chain);
7949                 sav->state = state;
7950                 LIST_INSERT_HEAD(&sav->sah->savtree[state], sav, chain);
7951         }
7952 }
7953
7954 void
7955 key_sa_stir_iv(sav)
7956         struct secasvar *sav;
7957 {
7958
7959         IPSEC_ASSERT(sav->iv != NULL, ("null IV"));
7960         key_randomfill(sav->iv, sav->ivlen);
7961 }
7962
7963 /*
7964  * Take one of the kernel's security keys and convert it into a PF_KEY
7965  * structure within an mbuf, suitable for sending up to a waiting
7966  * application in user land.
7967  *
7968  * IN:
7969  *    src: A pointer to a kernel security key.
7970  *    exttype: Which type of key this is. Refer to the PF_KEY data structures.
7971  * OUT:
7972  *    a valid mbuf or NULL indicating an error
7973  *
7974  */
7975
7976 static struct mbuf *
7977 key_setkey(struct seckey *src, u_int16_t exttype)
7978 {
7979         struct mbuf *m;
7980         struct sadb_key *p;
7981         int len;
7982
7983         if (src == NULL)
7984                 return NULL;
7985
7986         len = PFKEY_ALIGN8(sizeof(struct sadb_key) + _KEYLEN(src));
7987         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
7988         if (m == NULL)
7989                 return NULL;
7990         m_align(m, len);
7991         m->m_len = len;
7992         p = mtod(m, struct sadb_key *);
7993         bzero(p, len);
7994         p->sadb_key_len = PFKEY_UNIT64(len);
7995         p->sadb_key_exttype = exttype;
7996         p->sadb_key_bits = src->bits;
7997         bcopy(src->key_data, _KEYBUF(p), _KEYLEN(src));
7998
7999         return m;
8000 }
8001
8002 /*
8003  * Take one of the kernel's lifetime data structures and convert it
8004  * into a PF_KEY structure within an mbuf, suitable for sending up to
8005  * a waiting application in user land.
8006  *
8007  * IN:
8008  *    src: A pointer to a kernel lifetime structure.
8009  *    exttype: Which type of lifetime this is. Refer to the PF_KEY
8010  *             data structures for more information.
8011  * OUT:
8012  *    a valid mbuf or NULL indicating an error
8013  *
8014  */
8015
8016 static struct mbuf *
8017 key_setlifetime(struct seclifetime *src, u_int16_t exttype)
8018 {
8019         struct mbuf *m = NULL;
8020         struct sadb_lifetime *p;
8021         int len = PFKEY_ALIGN8(sizeof(struct sadb_lifetime));
8022
8023         if (src == NULL)
8024                 return NULL;
8025
8026         m = m_get2(len, M_NOWAIT, MT_DATA, 0);
8027         if (m == NULL)
8028                 return m;
8029         m_align(m, len);
8030         m->m_len = len;
8031         p = mtod(m, struct sadb_lifetime *);
8032
8033         bzero(p, len);
8034         p->sadb_lifetime_len = PFKEY_UNIT64(len);
8035         p->sadb_lifetime_exttype = exttype;
8036         p->sadb_lifetime_allocations = src->allocations;
8037         p->sadb_lifetime_bytes = src->bytes;
8038         p->sadb_lifetime_addtime = src->addtime;
8039         p->sadb_lifetime_usetime = src->usetime;
8040
8041         return m;
8042
8043 }