sys/netproto/ipsec/key.c

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