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