?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
devfs - Fix broken assertion
[dragonfly.git] / lib / libipsec / pfkey.c
blobee881bc36359dc7ed8d136ae8c315afa25d0bacf
1 /* $FreeBSD: src/lib/libipsec/pfkey.c,v 1.1.2.2 2001/07/03 11:01:14 ume Exp $ */
2 /* $DragonFly: src/lib/libipsec/pfkey.c,v 1.4 2003/11/13 02:39:42 drhodus Exp $ */
3 /* $KAME: pfkey.c,v 1.39 2001/03/05 18:22:17 thorpej Exp $ */
4
5 /*
6 * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the project nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #include <sys/types.h>
35 #include <sys/param.h>
36 #include <sys/socket.h>
37 #include <net/pfkeyv2.h>
38 #include <netkey/key_var.h>
39 #include <netinet/in.h>
40 #include <netinet6/ipsec.h>
41
42 #include <stdlib.h>
43 #include <unistd.h>
44 #include <string.h>
45 #include <errno.h>
46 #include <stdio.h>
47
48 #include "ipsec_strerror.h"
49 #include "libpfkey.h"
50
51 #define CALLOC(size, cast) (cast)calloc(1, (size))
52
53 static int findsupportedmap (int);
54 static int setsupportedmap (struct sadb_supported *);
55 static struct sadb_alg *findsupportedalg (u_int, u_int);
56 static int pfkey_send_x1 (int, u_int, u_int, u_int, struct sockaddr *,
57 struct sockaddr *, u_int32_t, u_int32_t, u_int, caddr_t,
58 u_int, u_int, u_int, u_int, u_int, u_int32_t, u_int32_t,
59 u_int32_t, u_int32_t, u_int32_t);
60 static int pfkey_send_x2 (int, u_int, u_int, u_int,
61 struct sockaddr *, struct sockaddr *, u_int32_t);
62 static int pfkey_send_x3 (int, u_int, u_int);
63 static int pfkey_send_x4 (int, u_int, struct sockaddr *, u_int,
64 struct sockaddr *, u_int, u_int, u_int64_t, u_int64_t,
65 char *, int, u_int32_t);
66 static int pfkey_send_x5 (int, u_int, u_int32_t);
67
68 static caddr_t pfkey_setsadbmsg (caddr_t, caddr_t, u_int, u_int,
69 u_int, u_int32_t, pid_t);
70 static caddr_t pfkey_setsadbsa (caddr_t, caddr_t, u_int32_t, u_int,
71 u_int, u_int, u_int32_t);
72 static caddr_t pfkey_setsadbaddr (caddr_t, caddr_t, u_int,
73 struct sockaddr *, u_int, u_int);
74 static caddr_t pfkey_setsadbkey (caddr_t, caddr_t, u_int, caddr_t, u_int);
75 static caddr_t pfkey_setsadblifetime (caddr_t, caddr_t, u_int, u_int32_t,
76 u_int32_t, u_int32_t, u_int32_t);
77 static caddr_t pfkey_setsadbxsa2 (caddr_t, caddr_t, u_int32_t, u_int32_t);
78
79 /*
80 * make and search supported algorithm structure.
81 */
82 static struct sadb_supported *ipsec_supported[] = { NULL, NULL, NULL, NULL};
83
84 static int supported_map[] = {
85 SADB_SATYPE_AH,
86 SADB_SATYPE_ESP,
87 SADB_X_SATYPE_IPCOMP,
88 SADB_X_SATYPE_TCPSIGNATURE,
89 };
90
91 static int
92 findsupportedmap(satype)
93 int satype;
94 {
95 int i;
96
97 for (i = 0; i < sizeof(supported_map)/sizeof(supported_map[0]); i++)
98 if (supported_map[i] == satype)
99 return i;
100 return -1;
101 }
102
103 static struct sadb_alg *
104 findsupportedalg(satype, alg_id)
105 u_int satype, alg_id;
106 {
107 int algno;
108 int tlen;
109 caddr_t p;
110
111 /* validity check */
112 algno = findsupportedmap(satype);
113 if (algno == -1) {
114 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
115 return NULL;
116 }
117 if (ipsec_supported[algno] == NULL) {
118 __ipsec_errcode = EIPSEC_DO_GET_SUPP_LIST;
119 return NULL;
120 }
121
122 tlen = ipsec_supported[algno]->sadb_supported_len
123 - sizeof(struct sadb_supported);
124 p = (caddr_t)(ipsec_supported[algno] + 1);
125 while (tlen > 0) {
126 if (tlen < sizeof(struct sadb_alg)) {
127 /* invalid format */
128 break;
129 }
130 if (((struct sadb_alg *)p)->sadb_alg_id == alg_id)
131 return (struct sadb_alg *)p;
132
133 tlen -= sizeof(struct sadb_alg);
134 p += sizeof(struct sadb_alg);
135 }
136
137 __ipsec_errcode = EIPSEC_NOT_SUPPORTED;
138 return NULL;
139 }
140
141 static int
142 setsupportedmap(sup)
143 struct sadb_supported *sup;
144 {
145 struct sadb_supported **ipsup;
146
147 switch (sup->sadb_supported_exttype) {
148 case SADB_EXT_SUPPORTED_AUTH:
149 ipsup = &ipsec_supported[findsupportedmap(SADB_SATYPE_AH)];
150 break;
151 case SADB_EXT_SUPPORTED_ENCRYPT:
152 ipsup = &ipsec_supported[findsupportedmap(SADB_SATYPE_ESP)];
153 break;
154 default:
155 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
156 return -1;
157 }
158
159 if (*ipsup)
160 free(*ipsup);
161
162 *ipsup = malloc(sup->sadb_supported_len);
163 if (!*ipsup) {
164 __ipsec_set_strerror(strerror(errno));
165 return -1;
166 }
167 memcpy(*ipsup, sup, sup->sadb_supported_len);
168
169 return 0;
170 }
171
172 /*
173 * check key length against algorithm specified.
174 * This function is called with SADB_EXT_SUPPORTED_{AUTH,ENCRYPT} as the
175 * augument, and only calls to ipsec_check_keylen2();
176 * keylen is the unit of bit.
177 * OUT:
178 * -1: invalid.
179 * 0: valid.
180 */
181 int
182 ipsec_check_keylen(supported, alg_id, keylen)
183 u_int supported;
184 u_int alg_id;
185 u_int keylen;
186 {
187 int satype;
188
189 /* validity check */
190 switch (supported) {
191 case SADB_EXT_SUPPORTED_AUTH:
192 satype = SADB_SATYPE_AH;
193 break;
194 case SADB_EXT_SUPPORTED_ENCRYPT:
195 satype = SADB_SATYPE_ESP;
196 break;
197 default:
198 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
199 return -1;
200 }
201
202 return ipsec_check_keylen2(satype, alg_id, keylen);
203 }
204
205 /*
206 * check key length against algorithm specified.
207 * satype is one of satype defined at pfkeyv2.h.
208 * keylen is the unit of bit.
209 * OUT:
210 * -1: invalid.
211 * 0: valid.
212 */
213 int
214 ipsec_check_keylen2(satype, alg_id, keylen)
215 u_int satype;
216 u_int alg_id;
217 u_int keylen;
218 {
219 struct sadb_alg *alg;
220
221 alg = findsupportedalg(satype, alg_id);
222 if (!alg)
223 return -1;
224
225 if (keylen < alg->sadb_alg_minbits || keylen > alg->sadb_alg_maxbits) {
226 __ipsec_errcode = EIPSEC_INVAL_KEYLEN;
227 return -1;
228 }
229
230 __ipsec_errcode = EIPSEC_NO_ERROR;
231 return 0;
232 }
233
234 /*
235 * get max/min key length against algorithm specified.
236 * satype is one of satype defined at pfkeyv2.h.
237 * keylen is the unit of bit.
238 * OUT:
239 * -1: invalid.
240 * 0: valid.
241 */
242 int
243 ipsec_get_keylen(supported, alg_id, alg0)
244 u_int supported, alg_id;
245 struct sadb_alg *alg0;
246 {
247 struct sadb_alg *alg;
248 u_int satype;
249
250 /* validity check */
251 if (!alg0) {
252 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
253 return -1;
254 }
255
256 switch (supported) {
257 case SADB_EXT_SUPPORTED_AUTH:
258 satype = SADB_SATYPE_AH;
259 break;
260 case SADB_EXT_SUPPORTED_ENCRYPT:
261 satype = SADB_SATYPE_ESP;
262 break;
263 default:
264 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
265 return -1;
266 }
267
268 alg = findsupportedalg(satype, alg_id);
269 if (!alg)
270 return -1;
271
272 memcpy(alg0, alg, sizeof(*alg0));
273
274 __ipsec_errcode = EIPSEC_NO_ERROR;
275 return 0;
276 }
277
278 /*
279 * set the rate for SOFT lifetime against HARD one.
280 * If rate is more than 100 or equal to zero, then set to 100.
281 */
282 static u_int soft_lifetime_allocations_rate = PFKEY_SOFT_LIFETIME_RATE;
283 static u_int soft_lifetime_bytes_rate = PFKEY_SOFT_LIFETIME_RATE;
284 static u_int soft_lifetime_addtime_rate = PFKEY_SOFT_LIFETIME_RATE;
285 static u_int soft_lifetime_usetime_rate = PFKEY_SOFT_LIFETIME_RATE;
286
287 u_int
288 pfkey_set_softrate(type, rate)
289 u_int type, rate;
290 {
291 __ipsec_errcode = EIPSEC_NO_ERROR;
292
293 if (rate > 100 || rate == 0)
294 rate = 100;
295
296 switch (type) {
297 case SADB_X_LIFETIME_ALLOCATIONS:
298 soft_lifetime_allocations_rate = rate;
299 return 0;
300 case SADB_X_LIFETIME_BYTES:
301 soft_lifetime_bytes_rate = rate;
302 return 0;
303 case SADB_X_LIFETIME_ADDTIME:
304 soft_lifetime_addtime_rate = rate;
305 return 0;
306 case SADB_X_LIFETIME_USETIME:
307 soft_lifetime_usetime_rate = rate;
308 return 0;
309 }
310
311 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
312 return 1;
313 }
314
315 /*
316 * get current rate for SOFT lifetime against HARD one.
317 * ATTENTION: ~0 is returned if invalid type was passed.
318 */
319 u_int
320 pfkey_get_softrate(type)
321 u_int type;
322 {
323 switch (type) {
324 case SADB_X_LIFETIME_ALLOCATIONS:
325 return soft_lifetime_allocations_rate;
326 case SADB_X_LIFETIME_BYTES:
327 return soft_lifetime_bytes_rate;
328 case SADB_X_LIFETIME_ADDTIME:
329 return soft_lifetime_addtime_rate;
330 case SADB_X_LIFETIME_USETIME:
331 return soft_lifetime_usetime_rate;
332 }
333
334 return ~0;
335 }
336
337 /*
338 * sending SADB_GETSPI message to the kernel.
339 * OUT:
340 * positive: success and return length sent.
341 * -1 : error occured, and set errno.
342 */
343 int
344 pfkey_send_getspi(so, satype, mode, src, dst, min, max, reqid, seq)
345 int so;
346 u_int satype, mode;
347 struct sockaddr *src, *dst;
348 u_int32_t min, max, reqid, seq;
349 {
350 struct sadb_msg *newmsg;
351 caddr_t ep;
352 int len;
353 int need_spirange = 0;
354 caddr_t p;
355 int plen;
356
357 /* validity check */
358 if (src == NULL || dst == NULL) {
359 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
360 return -1;
361 }
362 if (src->sa_family != dst->sa_family) {
363 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH;
364 return -1;
365 }
366 if (min > max || (min > 0 && min <= 255)) {
367 __ipsec_errcode = EIPSEC_INVAL_SPI;
368 return -1;
369 }
370 switch (src->sa_family) {
371 case AF_INET:
372 plen = sizeof(struct in_addr) << 3;
373 break;
374 case AF_INET6:
375 plen = sizeof(struct in6_addr) << 3;
376 break;
377 default:
378 __ipsec_errcode = EIPSEC_INVAL_FAMILY;
379 return -1;
380 }
381
382 /* create new sadb_msg to send. */
383 len = sizeof(struct sadb_msg)
384 + sizeof(struct sadb_x_sa2)
385 + sizeof(struct sadb_address)
386 + PFKEY_ALIGN8(src->sa_len)
387 + sizeof(struct sadb_address)
388 + PFKEY_ALIGN8(dst->sa_len);
389
390 if (min > 255 && max < ~0) {
391 need_spirange++;
392 len += sizeof(struct sadb_spirange);
393 }
394
395 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) {
396 __ipsec_set_strerror(strerror(errno));
397 return -1;
398 }
399 ep = ((caddr_t)newmsg) + len;
400
401 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, SADB_GETSPI,
402 len, satype, seq, getpid());
403 if (!p) {
404 free(newmsg);
405 return -1;
406 }
407
408 p = pfkey_setsadbxsa2(p, ep, mode, reqid);
409 if (!p) {
410 free(newmsg);
411 return -1;
412 }
413
414 /* set sadb_address for source */
415 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, plen,
416 IPSEC_ULPROTO_ANY);
417 if (!p) {
418 free(newmsg);
419 return -1;
420 }
421
422 /* set sadb_address for destination */
423 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, plen,
424 IPSEC_ULPROTO_ANY);
425 if (!p) {
426 free(newmsg);
427 return -1;
428 }
429
430 /* proccessing spi range */
431 if (need_spirange) {
432 struct sadb_spirange spirange;
433
434 if (p + sizeof(spirange) > ep) {
435 free(newmsg);
436 return -1;
437 }
438
439 memset(&spirange, 0, sizeof(spirange));
440 spirange.sadb_spirange_len = PFKEY_UNIT64(sizeof(spirange));
441 spirange.sadb_spirange_exttype = SADB_EXT_SPIRANGE;
442 spirange.sadb_spirange_min = min;
443 spirange.sadb_spirange_max = max;
444
445 memcpy(p, &spirange, sizeof(spirange));
446
447 p += sizeof(spirange);
448 }
449 if (p != ep) {
450 free(newmsg);
451 return -1;
452 }
453
454 /* send message */
455 len = pfkey_send(so, newmsg, len);
456 free(newmsg);
457
458 if (len < 0)
459 return -1;
460
461 __ipsec_errcode = EIPSEC_NO_ERROR;
462 return len;
463 }
464
465 /*
466 * sending SADB_UPDATE message to the kernel.
467 * The length of key material is a_keylen + e_keylen.
468 * OUT:
469 * positive: success and return length sent.
470 * -1 : error occured, and set errno.
471 */
472 int
473 pfkey_send_update(so, satype, mode, src, dst, spi, reqid, wsize,
474 keymat, e_type, e_keylen, a_type, a_keylen, flags,
475 l_alloc, l_bytes, l_addtime, l_usetime, seq)
476 int so;
477 u_int satype, mode, wsize;
478 struct sockaddr *src, *dst;
479 u_int32_t spi, reqid;
480 caddr_t keymat;
481 u_int e_type, e_keylen, a_type, a_keylen, flags;
482 u_int32_t l_alloc;
483 u_int64_t l_bytes, l_addtime, l_usetime;
484 u_int32_t seq;
485 {
486 int len;
487 if ((len = pfkey_send_x1(so, SADB_UPDATE, satype, mode, src, dst, spi,
488 reqid, wsize,
489 keymat, e_type, e_keylen, a_type, a_keylen, flags,
490 l_alloc, l_bytes, l_addtime, l_usetime, seq)) < 0)
491 return -1;
492
493 return len;
494 }
495
496 /*
497 * sending SADB_ADD message to the kernel.
498 * The length of key material is a_keylen + e_keylen.
499 * OUT:
500 * positive: success and return length sent.
501 * -1 : error occured, and set errno.
502 */
503 int
504 pfkey_send_add(so, satype, mode, src, dst, spi, reqid, wsize,
505 keymat, e_type, e_keylen, a_type, a_keylen, flags,
506 l_alloc, l_bytes, l_addtime, l_usetime, seq)
507 int so;
508 u_int satype, mode, wsize;
509 struct sockaddr *src, *dst;
510 u_int32_t spi, reqid;
511 caddr_t keymat;
512 u_int e_type, e_keylen, a_type, a_keylen, flags;
513 u_int32_t l_alloc;
514 u_int64_t l_bytes, l_addtime, l_usetime;
515 u_int32_t seq;
516 {
517 int len;
518 if ((len = pfkey_send_x1(so, SADB_ADD, satype, mode, src, dst, spi,
519 reqid, wsize,
520 keymat, e_type, e_keylen, a_type, a_keylen, flags,
521 l_alloc, l_bytes, l_addtime, l_usetime, seq)) < 0)
522 return -1;
523
524 return len;
525 }
526
527 /*
528 * sending SADB_DELETE message to the kernel.
529 * OUT:
530 * positive: success and return length sent.
531 * -1 : error occured, and set errno.
532 */
533 int
534 pfkey_send_delete(so, satype, mode, src, dst, spi)
535 int so;
536 u_int satype, mode;
537 struct sockaddr *src, *dst;
538 u_int32_t spi;
539 {
540 int len;
541 if ((len = pfkey_send_x2(so, SADB_DELETE, satype, mode, src, dst, spi)) < 0)
542 return -1;
543
544 return len;
545 }
546
547 /*
548 * sending SADB_DELETE without spi to the kernel. This is
549 * the "delete all" request (an extension also present in
550 * Solaris).
551 *
552 * OUT:
553 * positive: success and return length sent
554 * -1 : error occured, and set errno
555 */
556 int
557 pfkey_send_delete_all(so, satype, mode, src, dst)
558 int so;
559 u_int satype, mode;
560 struct sockaddr *src, *dst;
561 {
562 struct sadb_msg *newmsg;
563 int len;
564 caddr_t p;
565 int plen;
566 caddr_t ep;
567
568 /* validity check */
569 if (src == NULL || dst == NULL) {
570 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
571 return -1;
572 }
573 if (src->sa_family != dst->sa_family) {
574 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH;
575 return -1;
576 }
577 switch (src->sa_family) {
578 case AF_INET:
579 plen = sizeof(struct in_addr) << 3;
580 break;
581 case AF_INET6:
582 plen = sizeof(struct in6_addr) << 3;
583 break;
584 default:
585 __ipsec_errcode = EIPSEC_INVAL_FAMILY;
586 return -1;
587 }
588
589 /* create new sadb_msg to reply. */
590 len = sizeof(struct sadb_msg)
591 + sizeof(struct sadb_address)
592 + PFKEY_ALIGN8(src->sa_len)
593 + sizeof(struct sadb_address)
594 + PFKEY_ALIGN8(dst->sa_len);
595
596 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) {
597 __ipsec_set_strerror(strerror(errno));
598 return -1;
599 }
600 ep = ((caddr_t)newmsg) + len;
601
602 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, SADB_DELETE, len, satype, 0,
603 getpid());
604 if (!p) {
605 free(newmsg);
606 return -1;
607 }
608 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, plen,
609 IPSEC_ULPROTO_ANY);
610 if (!p) {
611 free(newmsg);
612 return -1;
613 }
614 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, plen,
615 IPSEC_ULPROTO_ANY);
616 if (!p || p != ep) {
617 free(newmsg);
618 return -1;
619 }
620
621 /* send message */
622 len = pfkey_send(so, newmsg, len);
623 free(newmsg);
624
625 if (len < 0)
626 return -1;
627
628 __ipsec_errcode = EIPSEC_NO_ERROR;
629 return len;
630 }
631
632 /*
633 * sending SADB_GET message to the kernel.
634 * OUT:
635 * positive: success and return length sent.
636 * -1 : error occured, and set errno.
637 */
638 int
639 pfkey_send_get(so, satype, mode, src, dst, spi)
640 int so;
641 u_int satype, mode;
642 struct sockaddr *src, *dst;
643 u_int32_t spi;
644 {
645 int len;
646 if ((len = pfkey_send_x2(so, SADB_GET, satype, mode, src, dst, spi)) < 0)
647 return -1;
648
649 return len;
650 }
651
652 /*
653 * sending SADB_REGISTER message to the kernel.
654 * OUT:
655 * positive: success and return length sent.
656 * -1 : error occured, and set errno.
657 */
658 int
659 pfkey_send_register(so, satype)
660 int so;
661 u_int satype;
662 {
663 int len, algno;
664
665 if (satype == PF_UNSPEC) {
666 for (algno = 0;
667 algno < sizeof(supported_map)/sizeof(supported_map[0]);
668 algno++) {
669 if (ipsec_supported[algno]) {
670 free(ipsec_supported[algno]);
671 ipsec_supported[algno] = NULL;
672 }
673 }
674 } else {
675 algno = findsupportedmap(satype);
676 if (algno == -1) {
677 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
678 return -1;
679 }
680
681 if (ipsec_supported[algno]) {
682 free(ipsec_supported[algno]);
683 ipsec_supported[algno] = NULL;
684 }
685 }
686
687 if ((len = pfkey_send_x3(so, SADB_REGISTER, satype)) < 0)
688 return -1;
689
690 return len;
691 }
692
693 /*
694 * receiving SADB_REGISTER message from the kernel, and copy buffer for
695 * sadb_supported returned into ipsec_supported.
696 * OUT:
697 * 0: success and return length sent.
698 * -1: error occured, and set errno.
699 */
700 int
701 pfkey_recv_register(so)
702 int so;
703 {
704 pid_t pid = getpid();
705 struct sadb_msg *newmsg;
706 int error = -1;
707
708 /* receive message */
709 do {
710 if ((newmsg = pfkey_recv(so)) == NULL)
711 return -1;
712 } while (newmsg->sadb_msg_type != SADB_REGISTER
713 || newmsg->sadb_msg_pid != pid);
714
715 /* check and fix */
716 newmsg->sadb_msg_len = PFKEY_UNUNIT64(newmsg->sadb_msg_len);
717
718 error = pfkey_set_supported(newmsg, newmsg->sadb_msg_len);
719 free(newmsg);
720
721 if (error == 0)
722 __ipsec_errcode = EIPSEC_NO_ERROR;
723
724 return error;
725 }
726
727 /*
728 * receiving SADB_REGISTER message from the kernel, and copy buffer for
729 * sadb_supported returned into ipsec_supported.
730 * NOTE: sadb_msg_len must be host order.
731 * IN:
732 * tlen: msg length, it's to makeing sure.
733 * OUT:
734 * 0: success and return length sent.
735 * -1: error occured, and set errno.
736 */
737 int
738 pfkey_set_supported(msg, tlen)
739 struct sadb_msg *msg;
740 int tlen;
741 {
742 struct sadb_supported *sup;
743 caddr_t p;
744 caddr_t ep;
745
746 /* validity */
747 if (msg->sadb_msg_len != tlen) {
748 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
749 return -1;
750 }
751
752 p = (caddr_t)msg;
753 ep = p + tlen;
754
755 p += sizeof(struct sadb_msg);
756
757 while (p < ep) {
758 sup = (struct sadb_supported *)p;
759 if (ep < p + sizeof(*sup) ||
760 PFKEY_EXTLEN(sup) < sizeof(*sup) ||
761 ep < p + sup->sadb_supported_len) {
762 /* invalid format */
763 break;
764 }
765
766 switch (sup->sadb_supported_exttype) {
767 case SADB_EXT_SUPPORTED_AUTH:
768 case SADB_EXT_SUPPORTED_ENCRYPT:
769 break;
770 default:
771 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
772 return -1;
773 }
774
775 /* fixed length */
776 sup->sadb_supported_len = PFKEY_EXTLEN(sup);
777
778 /* set supported map */
779 if (setsupportedmap(sup) != 0)
780 return -1;
781
782 p += sup->sadb_supported_len;
783 }
784
785 if (p != ep) {
786 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
787 return -1;
788 }
789
790 __ipsec_errcode = EIPSEC_NO_ERROR;
791
792 return 0;
793 }
794
795 /*
796 * sending SADB_FLUSH message to the kernel.
797 * OUT:
798 * positive: success and return length sent.
799 * -1 : error occured, and set errno.
800 */
801 int
802 pfkey_send_flush(so, satype)
803 int so;
804 u_int satype;
805 {
806 int len;
807
808 if ((len = pfkey_send_x3(so, SADB_FLUSH, satype)) < 0)
809 return -1;
810
811 return len;
812 }
813
814 /*
815 * sending SADB_DUMP message to the kernel.
816 * OUT:
817 * positive: success and return length sent.
818 * -1 : error occured, and set errno.
819 */
820 int
821 pfkey_send_dump(so, satype)
822 int so;
823 u_int satype;
824 {
825 int len;
826
827 if ((len = pfkey_send_x3(so, SADB_DUMP, satype)) < 0)
828 return -1;
829
830 return len;
831 }
832
833 /*
834 * sending SADB_X_PROMISC message to the kernel.
835 * NOTE that this function handles promisc mode toggle only.
836 * IN:
837 * flag: set promisc off if zero, set promisc on if non-zero.
838 * OUT:
839 * positive: success and return length sent.
840 * -1 : error occured, and set errno.
841 * 0 : error occured, and set errno.
842 * others: a pointer to new allocated buffer in which supported
843 * algorithms is.
844 */
845 int
846 pfkey_send_promisc_toggle(so, flag)
847 int so;
848 int flag;
849 {
850 int len;
851
852 if ((len = pfkey_send_x3(so, SADB_X_PROMISC, (flag ? 1 : 0))) < 0)
853 return -1;
854
855 return len;
856 }
857
858 /*
859 * sending SADB_X_SPDADD message to the kernel.
860 * OUT:
861 * positive: success and return length sent.
862 * -1 : error occured, and set errno.
863 */
864 int
865 pfkey_send_spdadd(so, src, prefs, dst, prefd, proto, policy, policylen, seq)
866 int so;
867 struct sockaddr *src, *dst;
868 u_int prefs, prefd, proto;
869 caddr_t policy;
870 int policylen;
871 u_int32_t seq;
872 {
873 int len;
874
875 if ((len = pfkey_send_x4(so, SADB_X_SPDADD,
876 src, prefs, dst, prefd, proto,
877 0, 0,
878 policy, policylen, seq)) < 0)
879 return -1;
880
881 return len;
882 }
883
884 /*
885 * sending SADB_X_SPDADD message to the kernel.
886 * OUT:
887 * positive: success and return length sent.
888 * -1 : error occured, and set errno.
889 */
890 int
891 pfkey_send_spdadd2(so, src, prefs, dst, prefd, proto, ltime, vtime,
892 policy, policylen, seq)
893 int so;
894 struct sockaddr *src, *dst;
895 u_int prefs, prefd, proto;
896 u_int64_t ltime, vtime;
897 caddr_t policy;
898 int policylen;
899 u_int32_t seq;
900 {
901 int len;
902
903 if ((len = pfkey_send_x4(so, SADB_X_SPDADD,
904 src, prefs, dst, prefd, proto,
905 ltime, vtime,
906 policy, policylen, seq)) < 0)
907 return -1;
908
909 return len;
910 }
911
912 /*
913 * sending SADB_X_SPDUPDATE message to the kernel.
914 * OUT:
915 * positive: success and return length sent.
916 * -1 : error occured, and set errno.
917 */
918 int
919 pfkey_send_spdupdate(so, src, prefs, dst, prefd, proto, policy, policylen, seq)
920 int so;
921 struct sockaddr *src, *dst;
922 u_int prefs, prefd, proto;
923 caddr_t policy;
924 int policylen;
925 u_int32_t seq;
926 {
927 int len;
928
929 if ((len = pfkey_send_x4(so, SADB_X_SPDUPDATE,
930 src, prefs, dst, prefd, proto,
931 0, 0,
932 policy, policylen, seq)) < 0)
933 return -1;
934
935 return len;
936 }
937
938 /*
939 * sending SADB_X_SPDUPDATE message to the kernel.
940 * OUT:
941 * positive: success and return length sent.
942 * -1 : error occured, and set errno.
943 */
944 int
945 pfkey_send_spdupdate2(so, src, prefs, dst, prefd, proto, ltime, vtime,
946 policy, policylen, seq)
947 int so;
948 struct sockaddr *src, *dst;
949 u_int prefs, prefd, proto;
950 u_int64_t ltime, vtime;
951 caddr_t policy;
952 int policylen;
953 u_int32_t seq;
954 {
955 int len;
956
957 if ((len = pfkey_send_x4(so, SADB_X_SPDUPDATE,
958 src, prefs, dst, prefd, proto,
959 ltime, vtime,
960 policy, policylen, seq)) < 0)
961 return -1;
962
963 return len;
964 }
965
966 /*
967 * sending SADB_X_SPDDELETE message to the kernel.
968 * OUT:
969 * positive: success and return length sent.
970 * -1 : error occured, and set errno.
971 */
972 int
973 pfkey_send_spddelete(so, src, prefs, dst, prefd, proto, policy, policylen, seq)
974 int so;
975 struct sockaddr *src, *dst;
976 u_int prefs, prefd, proto;
977 caddr_t policy;
978 int policylen;
979 u_int32_t seq;
980 {
981 int len;
982
983 if (policylen != sizeof(struct sadb_x_policy)) {
984 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
985 return -1;
986 }
987
988 if ((len = pfkey_send_x4(so, SADB_X_SPDDELETE,
989 src, prefs, dst, prefd, proto,
990 0, 0,
991 policy, policylen, seq)) < 0)
992 return -1;
993
994 return len;
995 }
996
997 /*
998 * sending SADB_X_SPDDELETE message to the kernel.
999 * OUT:
1000 * positive: success and return length sent.
1001 * -1 : error occured, and set errno.
1002 */
1003 int
1004 pfkey_send_spddelete2(so, spid)
1005 int so;
1006 u_int32_t spid;
1007 {
1008 int len;
1009
1010 if ((len = pfkey_send_x5(so, SADB_X_SPDDELETE2, spid)) < 0)
1011 return -1;
1012
1013 return len;
1014 }
1015
1016 /*
1017 * sending SADB_X_SPDGET message to the kernel.
1018 * OUT:
1019 * positive: success and return length sent.
1020 * -1 : error occured, and set errno.
1021 */
1022 int
1023 pfkey_send_spdget(so, spid)
1024 int so;
1025 u_int32_t spid;
1026 {
1027 int len;
1028
1029 if ((len = pfkey_send_x5(so, SADB_X_SPDGET, spid)) < 0)
1030 return -1;
1031
1032 return len;
1033 }
1034
1035 /*
1036 * sending SADB_X_SPDSETIDX message to the kernel.
1037 * OUT:
1038 * positive: success and return length sent.
1039 * -1 : error occured, and set errno.
1040 */
1041 int
1042 pfkey_send_spdsetidx(so, src, prefs, dst, prefd, proto, policy, policylen, seq)
1043 int so;
1044 struct sockaddr *src, *dst;
1045 u_int prefs, prefd, proto;
1046 caddr_t policy;
1047 int policylen;
1048 u_int32_t seq;
1049 {
1050 int len;
1051
1052 if (policylen != sizeof(struct sadb_x_policy)) {
1053 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
1054 return -1;
1055 }
1056
1057 if ((len = pfkey_send_x4(so, SADB_X_SPDSETIDX,
1058 src, prefs, dst, prefd, proto,
1059 0, 0,
1060 policy, policylen, seq)) < 0)
1061 return -1;
1062
1063 return len;
1064 }
1065
1066 /*
1067 * sending SADB_SPDFLUSH message to the kernel.
1068 * OUT:
1069 * positive: success and return length sent.
1070 * -1 : error occured, and set errno.
1071 */
1072 int
1073 pfkey_send_spdflush(so)
1074 int so;
1075 {
1076 int len;
1077
1078 if ((len = pfkey_send_x3(so, SADB_X_SPDFLUSH, SADB_SATYPE_UNSPEC)) < 0)
1079 return -1;
1080
1081 return len;
1082 }
1083
1084 /*
1085 * sending SADB_SPDDUMP message to the kernel.
1086 * OUT:
1087 * positive: success and return length sent.
1088 * -1 : error occured, and set errno.
1089 */
1090 int
1091 pfkey_send_spddump(so)
1092 int so;
1093 {
1094 int len;
1095
1096 if ((len = pfkey_send_x3(so, SADB_X_SPDDUMP, SADB_SATYPE_UNSPEC)) < 0)
1097 return -1;
1098
1099 return len;
1100 }
1101
1102 /* sending SADB_ADD or SADB_UPDATE message to the kernel */
1103 static int
1104 pfkey_send_x1(so, type, satype, mode, src, dst, spi, reqid, wsize,
1105 keymat, e_type, e_keylen, a_type, a_keylen, flags,
1106 l_alloc, l_bytes, l_addtime, l_usetime, seq)
1107 int so;
1108 u_int type, satype, mode;
1109 struct sockaddr *src, *dst;
1110 u_int32_t spi, reqid;
1111 u_int wsize;
1112 caddr_t keymat;
1113 u_int e_type, e_keylen, a_type, a_keylen, flags;
1114 u_int32_t l_alloc, l_bytes, l_addtime, l_usetime, seq;
1115 {
1116 struct sadb_msg *newmsg;
1117 int len;
1118 caddr_t p;
1119 int plen;
1120 caddr_t ep;
1121
1122 /* validity check */
1123 if (src == NULL || dst == NULL) {
1124 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
1125 return -1;
1126 }
1127 if (src->sa_family != dst->sa_family) {
1128 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH;
1129 return -1;
1130 }
1131 switch (src->sa_family) {
1132 case AF_INET:
1133 plen = sizeof(struct in_addr) << 3;
1134 break;
1135 case AF_INET6:
1136 plen = sizeof(struct in6_addr) << 3;
1137 break;
1138 default:
1139 __ipsec_errcode = EIPSEC_INVAL_FAMILY;
1140 return -1;
1141 }
1142
1143 switch (satype) {
1144 case SADB_SATYPE_ESP:
1145 if (e_type == SADB_EALG_NONE) {
1146 __ipsec_errcode = EIPSEC_NO_ALGS;
1147 return -1;
1148 }
1149 break;
1150 case SADB_SATYPE_AH:
1151 if (e_type != SADB_EALG_NONE) {
1152 __ipsec_errcode = EIPSEC_INVAL_ALGS;
1153 return -1;
1154 }
1155 if (a_type == SADB_AALG_NONE) {
1156 __ipsec_errcode = EIPSEC_NO_ALGS;
1157 return -1;
1158 }
1159 break;
1160 case SADB_X_SATYPE_IPCOMP:
1161 if (e_type == SADB_X_CALG_NONE) {
1162 __ipsec_errcode = EIPSEC_INVAL_ALGS;
1163 return -1;
1164 }
1165 if (a_type != SADB_AALG_NONE) {
1166 __ipsec_errcode = EIPSEC_NO_ALGS;
1167 return -1;
1168 }
1169 break;
1170 case SADB_X_SATYPE_TCPSIGNATURE:
1171 if (e_type != SADB_EALG_NONE) {
1172 __ipsec_errcode = EIPSEC_INVAL_ALGS;
1173 return -1;
1174 }
1175 if (a_type != SADB_X_AALG_TCP_MD5) {
1176 __ipsec_errcode = EIPSEC_INVAL_ALGS;
1177 return -1;
1178 }
1179 break;
1180 default:
1181 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
1182 return -1;
1183 }
1184
1185 /* create new sadb_msg to reply. */
1186 len = sizeof(struct sadb_msg)
1187 + sizeof(struct sadb_sa)
1188 + sizeof(struct sadb_x_sa2)
1189 + sizeof(struct sadb_address)
1190 + PFKEY_ALIGN8(src->sa_len)
1191 + sizeof(struct sadb_address)
1192 + PFKEY_ALIGN8(dst->sa_len)
1193 + sizeof(struct sadb_lifetime)
1194 + sizeof(struct sadb_lifetime);
1195
1196 if (e_type != SADB_EALG_NONE)
1197 len += (sizeof(struct sadb_key) + PFKEY_ALIGN8(e_keylen));
1198 if (a_type != SADB_AALG_NONE)
1199 len += (sizeof(struct sadb_key) + PFKEY_ALIGN8(a_keylen));
1200
1201 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) {
1202 __ipsec_set_strerror(strerror(errno));
1203 return -1;
1204 }
1205 ep = ((caddr_t)newmsg) + len;
1206
1207 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len,
1208 satype, seq, getpid());
1209 if (!p) {
1210 free(newmsg);
1211 return -1;
1212 }
1213 p = pfkey_setsadbsa(p, ep, spi, wsize, a_type, e_type, flags);
1214 if (!p) {
1215 free(newmsg);
1216 return -1;
1217 }
1218 p = pfkey_setsadbxsa2(p, ep, mode, reqid);
1219 if (!p) {
1220 free(newmsg);
1221 return -1;
1222 }
1223 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, plen,
1224 IPSEC_ULPROTO_ANY);
1225 if (!p) {
1226 free(newmsg);
1227 return -1;
1228 }
1229 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, plen,
1230 IPSEC_ULPROTO_ANY);
1231 if (!p) {
1232 free(newmsg);
1233 return -1;
1234 }
1235
1236 if (e_type != SADB_EALG_NONE) {
1237 p = pfkey_setsadbkey(p, ep, SADB_EXT_KEY_ENCRYPT,
1238 keymat, e_keylen);
1239 if (!p) {
1240 free(newmsg);
1241 return -1;
1242 }
1243 }
1244 if (a_type != SADB_AALG_NONE) {
1245 p = pfkey_setsadbkey(p, ep, SADB_EXT_KEY_AUTH,
1246 keymat + e_keylen, a_keylen);
1247 if (!p) {
1248 free(newmsg);
1249 return -1;
1250 }
1251 }
1252
1253 /* set sadb_lifetime for destination */
1254 p = pfkey_setsadblifetime(p, ep, SADB_EXT_LIFETIME_HARD,
1255 l_alloc, l_bytes, l_addtime, l_usetime);
1256 if (!p) {
1257 free(newmsg);
1258 return -1;
1259 }
1260 p = pfkey_setsadblifetime(p, ep, SADB_EXT_LIFETIME_SOFT,
1261 l_alloc, l_bytes, l_addtime, l_usetime);
1262 if (!p || p != ep) {
1263 free(newmsg);
1264 return -1;
1265 }
1266
1267 /* send message */
1268 len = pfkey_send(so, newmsg, len);
1269 free(newmsg);
1270
1271 if (len < 0)
1272 return -1;
1273
1274 __ipsec_errcode = EIPSEC_NO_ERROR;
1275 return len;
1276 }
1277
1278 /* sending SADB_DELETE or SADB_GET message to the kernel */
1279 static int
1280 pfkey_send_x2(so, type, satype, mode, src, dst, spi)
1281 int so;
1282 u_int type, satype, mode;
1283 struct sockaddr *src, *dst;
1284 u_int32_t spi;
1285 {
1286 struct sadb_msg *newmsg;
1287 int len;
1288 caddr_t p;
1289 int plen;
1290 caddr_t ep;
1291
1292 /* validity check */
1293 if (src == NULL || dst == NULL) {
1294 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
1295 return -1;
1296 }
1297 if (src->sa_family != dst->sa_family) {
1298 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH;
1299 return -1;
1300 }
1301 switch (src->sa_family) {
1302 case AF_INET:
1303 plen = sizeof(struct in_addr) << 3;
1304 break;
1305 case AF_INET6:
1306 plen = sizeof(struct in6_addr) << 3;
1307 break;
1308 default:
1309 __ipsec_errcode = EIPSEC_INVAL_FAMILY;
1310 return -1;
1311 }
1312
1313 /* create new sadb_msg to reply. */
1314 len = sizeof(struct sadb_msg)
1315 + sizeof(struct sadb_sa)
1316 + sizeof(struct sadb_address)
1317 + PFKEY_ALIGN8(src->sa_len)
1318 + sizeof(struct sadb_address)
1319 + PFKEY_ALIGN8(dst->sa_len);
1320
1321 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) {
1322 __ipsec_set_strerror(strerror(errno));
1323 return -1;
1324 }
1325 ep = ((caddr_t)newmsg) + len;
1326
1327 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len, satype, 0,
1328 getpid());
1329 if (!p) {
1330 free(newmsg);
1331 return -1;
1332 }
1333 p = pfkey_setsadbsa(p, ep, spi, 0, 0, 0, 0);
1334 if (!p) {
1335 free(newmsg);
1336 return -1;
1337 }
1338 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, plen,
1339 IPSEC_ULPROTO_ANY);
1340 if (!p) {
1341 free(newmsg);
1342 return -1;
1343 }
1344 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, plen,
1345 IPSEC_ULPROTO_ANY);
1346 if (!p || p != ep) {
1347 free(newmsg);
1348 return -1;
1349 }
1350
1351 /* send message */
1352 len = pfkey_send(so, newmsg, len);
1353 free(newmsg);
1354
1355 if (len < 0)
1356 return -1;
1357
1358 __ipsec_errcode = EIPSEC_NO_ERROR;
1359 return len;
1360 }
1361
1362 /*
1363 * sending SADB_REGISTER, SADB_FLUSH, SADB_DUMP or SADB_X_PROMISC message
1364 * to the kernel
1365 */
1366 static int
1367 pfkey_send_x3(so, type, satype)
1368 int so;
1369 u_int type, satype;
1370 {
1371 struct sadb_msg *newmsg;
1372 int len;
1373 caddr_t p;
1374 caddr_t ep;
1375
1376 /* validity check */
1377 switch (type) {
1378 case SADB_X_PROMISC:
1379 if (satype != 0 && satype != 1) {
1380 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
1381 return -1;
1382 }
1383 break;
1384 default:
1385 switch (satype) {
1386 case SADB_SATYPE_UNSPEC:
1387 case SADB_SATYPE_AH:
1388 case SADB_SATYPE_ESP:
1389 case SADB_X_SATYPE_IPCOMP:
1390 case SADB_X_SATYPE_TCPSIGNATURE:
1391 break;
1392 default:
1393 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
1394 return -1;
1395 }
1396 }
1397
1398 /* create new sadb_msg to send. */
1399 len = sizeof(struct sadb_msg);
1400
1401 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) {
1402 __ipsec_set_strerror(strerror(errno));
1403 return -1;
1404 }
1405 ep = ((caddr_t)newmsg) + len;
1406
1407 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len, satype, 0,
1408 getpid());
1409 if (!p || p != ep) {
1410 free(newmsg);
1411 return -1;
1412 }
1413
1414 /* send message */
1415 len = pfkey_send(so, newmsg, len);
1416 free(newmsg);
1417
1418 if (len < 0)
1419 return -1;
1420
1421 __ipsec_errcode = EIPSEC_NO_ERROR;
1422 return len;
1423 }
1424
1425 /* sending SADB_X_SPDADD message to the kernel */
1426 static int
1427 pfkey_send_x4(so, type, src, prefs, dst, prefd, proto,
1428 ltime, vtime, policy, policylen, seq)
1429 int so;
1430 struct sockaddr *src, *dst;
1431 u_int type, prefs, prefd, proto;
1432 u_int64_t ltime, vtime;
1433 char *policy;
1434 int policylen;
1435 u_int32_t seq;
1436 {
1437 struct sadb_msg *newmsg;
1438 int len;
1439 caddr_t p;
1440 int plen;
1441 caddr_t ep;
1442
1443 /* validity check */
1444 if (src == NULL || dst == NULL) {
1445 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
1446 return -1;
1447 }
1448 if (src->sa_family != dst->sa_family) {
1449 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH;
1450 return -1;
1451 }
1452
1453 switch (src->sa_family) {
1454 case AF_INET:
1455 plen = sizeof(struct in_addr) << 3;
1456 break;
1457 case AF_INET6:
1458 plen = sizeof(struct in6_addr) << 3;
1459 break;
1460 default:
1461 __ipsec_errcode = EIPSEC_INVAL_FAMILY;
1462 return -1;
1463 }
1464 if (prefs > plen || prefd > plen) {
1465 __ipsec_errcode = EIPSEC_INVAL_PREFIXLEN;
1466 return -1;
1467 }
1468
1469 /* create new sadb_msg to reply. */
1470 len = sizeof(struct sadb_msg)
1471 + sizeof(struct sadb_address)
1472 + PFKEY_ALIGN8(src->sa_len)
1473 + sizeof(struct sadb_address)
1474 + PFKEY_ALIGN8(src->sa_len)
1475 + sizeof(struct sadb_lifetime)
1476 + policylen;
1477
1478 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) {
1479 __ipsec_set_strerror(strerror(errno));
1480 return -1;
1481 }
1482 ep = ((caddr_t)newmsg) + len;
1483
1484 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len,
1485 SADB_SATYPE_UNSPEC, seq, getpid());
1486 if (!p) {
1487 free(newmsg);
1488 return -1;
1489 }
1490 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_SRC, src, prefs, proto);
1491 if (!p) {
1492 free(newmsg);
1493 return -1;
1494 }
1495 p = pfkey_setsadbaddr(p, ep, SADB_EXT_ADDRESS_DST, dst, prefd, proto);
1496 if (!p) {
1497 free(newmsg);
1498 return -1;
1499 }
1500 p = pfkey_setsadblifetime(p, ep, SADB_EXT_LIFETIME_HARD,
1501 0, 0, ltime, vtime);
1502 if (!p || p + policylen != ep) {
1503 free(newmsg);
1504 return -1;
1505 }
1506 memcpy(p, policy, policylen);
1507
1508 /* send message */
1509 len = pfkey_send(so, newmsg, len);
1510 free(newmsg);
1511
1512 if (len < 0)
1513 return -1;
1514
1515 __ipsec_errcode = EIPSEC_NO_ERROR;
1516 return len;
1517 }
1518
1519 /* sending SADB_X_SPDGET or SADB_X_SPDDELETE message to the kernel */
1520 static int
1521 pfkey_send_x5(so, type, spid)
1522 int so;
1523 u_int type;
1524 u_int32_t spid;
1525 {
1526 struct sadb_msg *newmsg;
1527 struct sadb_x_policy xpl;
1528 int len;
1529 caddr_t p;
1530 caddr_t ep;
1531
1532 /* create new sadb_msg to reply. */
1533 len = sizeof(struct sadb_msg)
1534 + sizeof(xpl);
1535
1536 if ((newmsg = CALLOC(len, struct sadb_msg *)) == NULL) {
1537 __ipsec_set_strerror(strerror(errno));
1538 return -1;
1539 }
1540 ep = ((caddr_t)newmsg) + len;
1541
1542 p = pfkey_setsadbmsg((caddr_t)newmsg, ep, type, len,
1543 SADB_SATYPE_UNSPEC, 0, getpid());
1544 if (!p) {
1545 free(newmsg);
1546 return -1;
1547 }
1548
1549 if (p + sizeof(xpl) != ep) {
1550 free(newmsg);
1551 return -1;
1552 }
1553 memset(&xpl, 0, sizeof(xpl));
1554 xpl.sadb_x_policy_len = PFKEY_UNUNIT64(sizeof(xpl));
1555 xpl.sadb_x_policy_exttype = SADB_X_EXT_POLICY;
1556 xpl.sadb_x_policy_id = spid;
1557 memcpy(p, &xpl, sizeof(xpl));
1558
1559 /* send message */
1560 len = pfkey_send(so, newmsg, len);
1561 free(newmsg);
1562
1563 if (len < 0)
1564 return -1;
1565
1566 __ipsec_errcode = EIPSEC_NO_ERROR;
1567 return len;
1568 }
1569
1570 /*
1571 * open a socket.
1572 * OUT:
1573 * -1: fail.
1574 * others : success and return value of socket.
1575 */
1576 int
1577 pfkey_open()
1578 {
1579 int so;
1580 const int bufsiz = 128 * 1024; /*is 128K enough?*/
1581
1582 if ((so = socket(PF_KEY, SOCK_RAW, PF_KEY_V2)) < 0) {
1583 __ipsec_set_strerror(strerror(errno));
1584 return -1;
1585 }
1586
1587 /*
1588 * This is a temporary workaround for KAME PR 154.
1589 * Don't really care even if it fails.
1590 */
1591 (void)setsockopt(so, SOL_SOCKET, SO_SNDBUF, &bufsiz, sizeof(bufsiz));
1592 (void)setsockopt(so, SOL_SOCKET, SO_RCVBUF, &bufsiz, sizeof(bufsiz));
1593
1594 __ipsec_errcode = EIPSEC_NO_ERROR;
1595 return so;
1596 }
1597
1598 /*
1599 * close a socket.
1600 * OUT:
1601 * 0: success.
1602 * -1: fail.
1603 */
1604 void
1605 pfkey_close(so)
1606 int so;
1607 {
1608 (void)close(so);
1609
1610 __ipsec_errcode = EIPSEC_NO_ERROR;
1611 return;
1612 }
1613
1614 /*
1615 * receive sadb_msg data, and return pointer to new buffer allocated.
1616 * Must free this buffer later.
1617 * OUT:
1618 * NULL : error occured.
1619 * others : a pointer to sadb_msg structure.
1620 *
1621 * XXX should be rewritten to pass length explicitly
1622 */
1623 struct sadb_msg *
1624 pfkey_recv(so)
1625 int so;
1626 {
1627 struct sadb_msg buf, *newmsg;
1628 int len, reallen;
1629
1630 while ((len = recv(so, (caddr_t)&buf, sizeof(buf), MSG_PEEK)) < 0) {
1631 if (errno == EINTR)
1632 continue;
1633 __ipsec_set_strerror(strerror(errno));
1634 return NULL;
1635 }
1636
1637 if (len < sizeof(buf)) {
1638 recv(so, (caddr_t)&buf, sizeof(buf), 0);
1639 __ipsec_errcode = EIPSEC_MAX;
1640 return NULL;
1641 }
1642
1643 /* read real message */
1644 reallen = PFKEY_UNUNIT64(buf.sadb_msg_len);
1645 if ((newmsg = CALLOC(reallen, struct sadb_msg *)) == 0) {
1646 __ipsec_set_strerror(strerror(errno));
1647 return NULL;
1648 }
1649
1650 while ((len = recv(so, (caddr_t)newmsg, reallen, 0)) < 0) {
1651 if (errno == EINTR)
1652 continue;
1653 __ipsec_set_strerror(strerror(errno));
1654 free(newmsg);
1655 return NULL;
1656 }
1657
1658 if (len != reallen) {
1659 __ipsec_errcode = EIPSEC_SYSTEM_ERROR;
1660 free(newmsg);
1661 return NULL;
1662 }
1663
1664 /* don't trust what the kernel says, validate! */
1665 if (PFKEY_UNUNIT64(newmsg->sadb_msg_len) != len) {
1666 __ipsec_errcode = EIPSEC_SYSTEM_ERROR;
1667 free(newmsg);
1668 return NULL;
1669 }
1670
1671 __ipsec_errcode = EIPSEC_NO_ERROR;
1672 return newmsg;
1673 }
1674
1675 /*
1676 * send message to a socket.
1677 * OUT:
1678 * others: success and return length sent.
1679 * -1 : fail.
1680 */
1681 int
1682 pfkey_send(so, msg, len)
1683 int so;
1684 struct sadb_msg *msg;
1685 int len;
1686 {
1687 if ((len = send(so, (caddr_t)msg, len, 0)) < 0) {
1688 __ipsec_set_strerror(strerror(errno));
1689 return -1;
1690 }
1691
1692 __ipsec_errcode = EIPSEC_NO_ERROR;
1693 return len;
1694 }
1695
1696 /*
1697 * %%% Utilities
1698 * NOTE: These functions are derived from netkey/key.c in KAME.
1699 */
1700 /*
1701 * set the pointer to each header in this message buffer.
1702 * IN: msg: pointer to message buffer.
1703 * mhp: pointer to the buffer initialized like below:
1704 * caddr_t mhp[SADB_EXT_MAX + 1];
1705 * OUT: -1: invalid.
1706 * 0: valid.
1707 *
1708 * XXX should be rewritten to obtain length explicitly
1709 */
1710 int
1711 pfkey_align(msg, mhp)
1712 struct sadb_msg *msg;
1713 caddr_t *mhp;
1714 {
1715 struct sadb_ext *ext;
1716 int i;
1717 caddr_t p;
1718 caddr_t ep; /* XXX should be passed from upper layer */
1719
1720 /* validity check */
1721 if (msg == NULL || mhp == NULL) {
1722 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
1723 return -1;
1724 }
1725
1726 /* initialize */
1727 for (i = 0; i < SADB_EXT_MAX + 1; i++)
1728 mhp[i] = NULL;
1729
1730 mhp[0] = (caddr_t)msg;
1731
1732 /* initialize */
1733 p = (caddr_t) msg;
1734 ep = p + PFKEY_UNUNIT64(msg->sadb_msg_len);
1735
1736 /* skip base header */
1737 p += sizeof(struct sadb_msg);
1738
1739 while (p < ep) {
1740 ext = (struct sadb_ext *)p;
1741 if (ep < p + sizeof(*ext) || PFKEY_EXTLEN(ext) < sizeof(*ext) ||
1742 ep < p + PFKEY_EXTLEN(ext)) {
1743 /* invalid format */
1744 break;
1745 }
1746
1747 /* duplicate check */
1748 /* XXX Are there duplication either KEY_AUTH or KEY_ENCRYPT ?*/
1749 if (mhp[ext->sadb_ext_type] != NULL) {
1750 __ipsec_errcode = EIPSEC_INVAL_EXTTYPE;
1751 return -1;
1752 }
1753
1754 /* set pointer */
1755 switch (ext->sadb_ext_type) {
1756 case SADB_EXT_SA:
1757 case SADB_EXT_LIFETIME_CURRENT:
1758 case SADB_EXT_LIFETIME_HARD:
1759 case SADB_EXT_LIFETIME_SOFT:
1760 case SADB_EXT_ADDRESS_SRC:
1761 case SADB_EXT_ADDRESS_DST:
1762 case SADB_EXT_ADDRESS_PROXY:
1763 case SADB_EXT_KEY_AUTH:
1764 /* XXX should to be check weak keys. */
1765 case SADB_EXT_KEY_ENCRYPT:
1766 /* XXX should to be check weak keys. */
1767 case SADB_EXT_IDENTITY_SRC:
1768 case SADB_EXT_IDENTITY_DST:
1769 case SADB_EXT_SENSITIVITY:
1770 case SADB_EXT_PROPOSAL:
1771 case SADB_EXT_SUPPORTED_AUTH:
1772 case SADB_EXT_SUPPORTED_ENCRYPT:
1773 case SADB_EXT_SPIRANGE:
1774 case SADB_X_EXT_POLICY:
1775 case SADB_X_EXT_SA2:
1776 mhp[ext->sadb_ext_type] = (caddr_t)ext;
1777 break;
1778 default:
1779 __ipsec_errcode = EIPSEC_INVAL_EXTTYPE;
1780 return -1;
1781 }
1782
1783 p += PFKEY_EXTLEN(ext);
1784 }
1785
1786 if (p != ep) {
1787 __ipsec_errcode = EIPSEC_INVAL_SADBMSG;
1788 return -1;
1789 }
1790
1791 __ipsec_errcode = EIPSEC_NO_ERROR;
1792 return 0;
1793 }
1794
1795 /*
1796 * check basic usage for sadb_msg,
1797 * NOTE: This routine is derived from netkey/key.c in KAME.
1798 * IN: msg: pointer to message buffer.
1799 * mhp: pointer to the buffer initialized like below:
1800 *
1801 * caddr_t mhp[SADB_EXT_MAX + 1];
1802 *
1803 * OUT: -1: invalid.
1804 * 0: valid.
1805 */
1806 int
1807 pfkey_check(mhp)
1808 caddr_t *mhp;
1809 {
1810 struct sadb_msg *msg;
1811
1812 /* validity check */
1813 if (mhp == NULL || mhp[0] == NULL) {
1814 __ipsec_errcode = EIPSEC_INVAL_ARGUMENT;
1815 return -1;
1816 }
1817
1818 msg = (struct sadb_msg *)mhp[0];
1819
1820 /* check version */
1821 if (msg->sadb_msg_version != PF_KEY_V2) {
1822 __ipsec_errcode = EIPSEC_INVAL_VERSION;
1823 return -1;
1824 }
1825
1826 /* check type */
1827 if (msg->sadb_msg_type > SADB_MAX) {
1828 __ipsec_errcode = EIPSEC_INVAL_MSGTYPE;
1829 return -1;
1830 }
1831
1832 /* check SA type */
1833 switch (msg->sadb_msg_satype) {
1834 case SADB_SATYPE_UNSPEC:
1835 switch (msg->sadb_msg_type) {
1836 case SADB_GETSPI:
1837 case SADB_UPDATE:
1838 case SADB_ADD:
1839 case SADB_DELETE:
1840 case SADB_GET:
1841 case SADB_ACQUIRE:
1842 case SADB_EXPIRE:
1843 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
1844 return -1;
1845 }
1846 break;
1847 case SADB_SATYPE_ESP:
1848 case SADB_SATYPE_AH:
1849 case SADB_X_SATYPE_IPCOMP:
1850 case SADB_X_SATYPE_TCPSIGNATURE:
1851 switch (msg->sadb_msg_type) {
1852 case SADB_X_SPDADD:
1853 case SADB_X_SPDDELETE:
1854 case SADB_X_SPDGET:
1855 case SADB_X_SPDDUMP:
1856 case SADB_X_SPDFLUSH:
1857 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
1858 return -1;
1859 }
1860 break;
1861 case SADB_SATYPE_RSVP:
1862 case SADB_SATYPE_OSPFV2:
1863 case SADB_SATYPE_RIPV2:
1864 case SADB_SATYPE_MIP:
1865 __ipsec_errcode = EIPSEC_NOT_SUPPORTED;
1866 return -1;
1867 case 1: /* XXX: What does it do ? */
1868 if (msg->sadb_msg_type == SADB_X_PROMISC)
1869 break;
1870 /*FALLTHROUGH*/
1871 default:
1872 __ipsec_errcode = EIPSEC_INVAL_SATYPE;
1873 return -1;
1874 }
1875
1876 /* check field of upper layer protocol and address family */
1877 if (mhp[SADB_EXT_ADDRESS_SRC] != NULL
1878 && mhp[SADB_EXT_ADDRESS_DST] != NULL) {
1879 struct sadb_address *src0, *dst0;
1880
1881 src0 = (struct sadb_address *)(mhp[SADB_EXT_ADDRESS_SRC]);
1882 dst0 = (struct sadb_address *)(mhp[SADB_EXT_ADDRESS_DST]);
1883
1884 if (src0->sadb_address_proto != dst0->sadb_address_proto) {
1885 __ipsec_errcode = EIPSEC_PROTO_MISMATCH;
1886 return -1;
1887 }
1888
1889 if (PFKEY_ADDR_SADDR(src0)->sa_family
1890 != PFKEY_ADDR_SADDR(dst0)->sa_family) {
1891 __ipsec_errcode = EIPSEC_FAMILY_MISMATCH;
1892 return -1;
1893 }
1894
1895 switch (PFKEY_ADDR_SADDR(src0)->sa_family) {
1896 case AF_INET:
1897 case AF_INET6:
1898 break;
1899 default:
1900 __ipsec_errcode = EIPSEC_INVAL_FAMILY;
1901 return -1;
1902 }
1903
1904 /*
1905 * prefixlen == 0 is valid because there must be the case
1906 * all addresses are matched.
1907 */
1908 }
1909
1910 __ipsec_errcode = EIPSEC_NO_ERROR;
1911 return 0;
1912 }
1913
1914 /*
1915 * set data into sadb_msg.
1916 * `buf' must has been allocated sufficiently.
1917 */
1918 static caddr_t
1919 pfkey_setsadbmsg(buf, lim, type, tlen, satype, seq, pid)
1920 caddr_t buf;
1921 caddr_t lim;
1922 u_int type, satype;
1923 u_int tlen;
1924 u_int32_t seq;
1925 pid_t pid;
1926 {
1927 struct sadb_msg *p;
1928 u_int len;
1929
1930 p = (struct sadb_msg *)buf;
1931 len = sizeof(struct sadb_msg);
1932
1933 if (buf + len > lim)
1934 return NULL;
1935
1936 memset(p, 0, len);
1937 p->sadb_msg_version = PF_KEY_V2;
1938 p->sadb_msg_type = type;
1939 p->sadb_msg_errno = 0;
1940 p->sadb_msg_satype = satype;
1941 p->sadb_msg_len = PFKEY_UNIT64(tlen);
1942 p->sadb_msg_reserved = 0;
1943 p->sadb_msg_seq = seq;
1944 p->sadb_msg_pid = (u_int32_t)pid;
1945
1946 return(buf + len);
1947 }
1948
1949 /*
1950 * copy secasvar data into sadb_address.
1951 * `buf' must has been allocated sufficiently.
1952 */
1953 static caddr_t
1954 pfkey_setsadbsa(buf, lim, spi, wsize, auth, enc, flags)
1955 caddr_t buf;
1956 caddr_t lim;
1957 u_int32_t spi, flags;
1958 u_int wsize, auth, enc;
1959 {
1960 struct sadb_sa *p;
1961 u_int len;
1962
1963 p = (struct sadb_sa *)buf;
1964 len = sizeof(struct sadb_sa);
1965
1966 if (buf + len > lim)
1967 return NULL;
1968
1969 memset(p, 0, len);
1970 p->sadb_sa_len = PFKEY_UNIT64(len);
1971 p->sadb_sa_exttype = SADB_EXT_SA;
1972 p->sadb_sa_spi = spi;
1973 p->sadb_sa_replay = wsize;
1974 p->sadb_sa_state = SADB_SASTATE_LARVAL;
1975 p->sadb_sa_auth = auth;
1976 p->sadb_sa_encrypt = enc;
1977 p->sadb_sa_flags = flags;
1978
1979 return(buf + len);
1980 }
1981
1982 /*
1983 * set data into sadb_address.
1984 * `buf' must has been allocated sufficiently.
1985 * prefixlen is in bits.
1986 */
1987 static caddr_t
1988 pfkey_setsadbaddr(buf, lim, exttype, saddr, prefixlen, ul_proto)
1989 caddr_t buf;
1990 caddr_t lim;
1991 u_int exttype;
1992 struct sockaddr *saddr;
1993 u_int prefixlen;
1994 u_int ul_proto;
1995 {
1996 struct sadb_address *p;
1997 u_int len;
1998
1999 p = (struct sadb_address *)buf;
2000 len = sizeof(struct sadb_address) + PFKEY_ALIGN8(saddr->sa_len);
2001
2002 if (buf + len > lim)
2003 return NULL;
2004
2005 memset(p, 0, len);
2006 p->sadb_address_len = PFKEY_UNIT64(len);
2007 p->sadb_address_exttype = exttype & 0xffff;
2008 p->sadb_address_proto = ul_proto & 0xff;
2009 p->sadb_address_prefixlen = prefixlen;
2010 p->sadb_address_reserved = 0;
2011
2012 memcpy(p + 1, saddr, saddr->sa_len);
2013
2014 return(buf + len);
2015 }
2016
2017 /*
2018 * set sadb_key structure after clearing buffer with zero.
2019 * OUT: the pointer of buf + len.
2020 */
2021 static caddr_t
2022 pfkey_setsadbkey(buf, lim, type, key, keylen)
2023 caddr_t buf;
2024 caddr_t lim;
2025 caddr_t key;
2026 u_int type, keylen;
2027 {
2028 struct sadb_key *p;
2029 u_int len;
2030
2031 p = (struct sadb_key *)buf;
2032 len = sizeof(struct sadb_key) + PFKEY_ALIGN8(keylen);
2033
2034 if (buf + len > lim)
2035 return NULL;
2036
2037 memset(p, 0, len);
2038 p->sadb_key_len = PFKEY_UNIT64(len);
2039 p->sadb_key_exttype = type;
2040 p->sadb_key_bits = keylen << 3;
2041 p->sadb_key_reserved = 0;
2042
2043 memcpy(p + 1, key, keylen);
2044
2045 return buf + len;
2046 }
2047
2048 /*
2049 * set sadb_lifetime structure after clearing buffer with zero.
2050 * OUT: the pointer of buf + len.
2051 */
2052 static caddr_t
2053 pfkey_setsadblifetime(buf, lim, type, l_alloc, l_bytes, l_addtime, l_usetime)
2054 caddr_t buf;
2055 caddr_t lim;
2056 u_int type;
2057 u_int32_t l_alloc, l_bytes, l_addtime, l_usetime;
2058 {
2059 struct sadb_lifetime *p;
2060 u_int len;
2061
2062 p = (struct sadb_lifetime *)buf;
2063 len = sizeof(struct sadb_lifetime);
2064
2065 if (buf + len > lim)
2066 return NULL;
2067
2068 memset(p, 0, len);
2069 p->sadb_lifetime_len = PFKEY_UNIT64(len);
2070 p->sadb_lifetime_exttype = type;
2071
2072 switch (type) {
2073 case SADB_EXT_LIFETIME_SOFT:
2074 p->sadb_lifetime_allocations
2075 = (l_alloc * soft_lifetime_allocations_rate) /100;
2076 p->sadb_lifetime_bytes
2077 = (l_bytes * soft_lifetime_bytes_rate) /100;
2078 p->sadb_lifetime_addtime
2079 = (l_addtime * soft_lifetime_addtime_rate) /100;
2080 p->sadb_lifetime_usetime
2081 = (l_usetime * soft_lifetime_usetime_rate) /100;
2082 break;
2083 case SADB_EXT_LIFETIME_HARD:
2084 p->sadb_lifetime_allocations = l_alloc;
2085 p->sadb_lifetime_bytes = l_bytes;
2086 p->sadb_lifetime_addtime = l_addtime;
2087 p->sadb_lifetime_usetime = l_usetime;
2088 break;
2089 }
2090
2091 return buf + len;
2092 }
2093
2094 /*
2095 * copy secasvar data into sadb_address.
2096 * `buf' must has been allocated sufficiently.
2097 */
2098 static caddr_t
2099 pfkey_setsadbxsa2(buf, lim, mode0, reqid)
2100 caddr_t buf;
2101 caddr_t lim;
2102 u_int32_t mode0;
2103 u_int32_t reqid;
2104 {
2105 struct sadb_x_sa2 *p;
2106 u_int8_t mode = mode0 & 0xff;
2107 u_int len;
2108
2109 p = (struct sadb_x_sa2 *)buf;
2110 len = sizeof(struct sadb_x_sa2);
2111
2112 if (buf + len > lim)
2113 return NULL;
2114
2115 memset(p, 0, len);
2116 p->sadb_x_sa2_len = PFKEY_UNIT64(len);
2117 p->sadb_x_sa2_exttype = SADB_X_EXT_SA2;
2118 p->sadb_x_sa2_mode = mode;
2119 p->sadb_x_sa2_reqid = reqid;
2120
2121 return(buf + len);
2122 }
DragonFly BSD