?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - CAM cleanup 1/N - Remove ancient scsi pccard drivers ncv, nsp, stg
[dragonfly.git] / usr.sbin / setkey / parse.y
blobe48b2f9771e95c303cf70e6a73f94f7e1cd02235
1 /* $FreeBSD: src/usr.sbin/setkey/parse.y,v 1.1.2.2 2001/07/03 11:02:17 ume Exp $ */
2 /* $DragonFly: src/usr.sbin/setkey/parse.y,v 1.4 2004/03/24 18:23:46 cpressey Exp $ */
3 /* $KAME: kame/kame/kame/setkey/parse.y,v 1.36 2001/06/07 15:53:12 sakane 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 %{
35 #include <sys/types.h>
36 #include <sys/param.h>
37 #include <sys/socket.h>
38
39 #include <net/route.h>
40 #include <netinet/in.h>
41 #include <net/pfkeyv2.h>
42 #include <netkey/key_var.h>
43 #include <netinet6/ipsec.h>
44 #include <arpa/inet.h>
45
46 #include <string.h>
47 #include <unistd.h>
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <netdb.h>
51 #include <ctype.h>
52 #include <errno.h>
53
54 #include "libpfkey.h"
55 #include "vchar.h"
56
57 #define ATOX(c) \
58 (isdigit(c) ? (c - '0') : (isupper(c) ? (c - 'A' + 10) : (c - 'a' + 10) ))
59
60 u_int p_type;
61 u_int32_t p_spi;
62 int p_no_spi;
63 struct sockaddr *p_src, *p_dst;
64 u_int p_prefs, p_prefd, p_upper;
65 u_int p_satype, p_ext, p_alg_enc, p_alg_auth, p_replay, p_mode;
66 u_int32_t p_reqid;
67 u_int p_key_enc_len, p_key_auth_len;
68 caddr_t p_key_enc, p_key_auth;
69 time_t p_lt_hard, p_lt_soft;
70
71 u_int p_policy_len;
72 char *p_policy;
73
74 /* temporary buffer */
75 static struct sockaddr *pp_addr;
76 static u_int pp_prefix;
77 static u_int pp_port;
78 static caddr_t pp_key;
79
80 extern u_char m_buf[BUFSIZ];
81 extern u_int m_len;
82 extern char cmdarg[8192];
83 extern int f_debug;
84
85 static struct addrinfo *parse_addr(char *, char *, int);
86 static int setvarbuf(int *, struct sadb_ext *, int, caddr_t, int);
87 void parse_init(void);
88 void free_buffer(void);
89
90 extern int setkeymsg(void);
91 extern int sendkeymsg(void);
92
93 extern int yylex(void);
94 extern void yyfatal(const char *);
95 extern void yyerror(const char *);
96 %}
97
98 %union {
99 unsigned long num;
100 vchar_t val;
101 }
102
103 %token EOT
104 %token ADD GET DELETE DELETEALL FLUSH DUMP
105 %token ADDRESS PREFIX PORT PORTANY
106 %token UP_PROTO PR_ESP PR_AH PR_IPCOMP PR_TCP
107 %token F_PROTOCOL F_AUTH F_ENC F_REPLAY F_COMP F_RAWCPI
108 %token F_MODE MODE F_REQID
109 %token F_EXT EXTENSION NOCYCLICSEQ
110 %token ALG_AUTH ALG_ENC ALG_ENC_DESDERIV ALG_ENC_DES32IV ALG_COMP
111 %token F_LIFETIME_HARD F_LIFETIME_SOFT
112 %token DECSTRING QUOTEDSTRING HEXSTRING STRING ANY
113 /* SPD management */
114 %token SPDADD SPDDELETE SPDDUMP SPDFLUSH
115 %token F_POLICY PL_REQUESTS
116
117 %type <num> PORT PREFIX EXTENSION MODE
118 %type <num> UP_PROTO PR_ESP PR_AH PR_IPCOMP PR_TCP
119 %type <num> ALG_AUTH ALG_ENC ALG_ENC_DESDERIV ALG_ENC_DES32IV ALG_COMP
120 %type <num> DECSTRING
121 %type <val> ADDRESS PL_REQUESTS
122 %type <val> key_string policy_requests
123 %type <val> QUOTEDSTRING HEXSTRING STRING
124
125 %%
126 commands
127 : /*NOTHING*/
128 | commands command
129 {
130 if (f_debug) {
131 printf("cmdarg:\n%s\n", cmdarg);
132 } else {
133 setkeymsg();
134 sendkeymsg();
135 }
136 free_buffer();
137 parse_init();
138 }
139 ;
140
141 command
142 : add_command
143 | get_command
144 | delete_command
145 | deleteall_command
146 | flush_command
147 | dump_command
148 | spdadd_command
149 | spddelete_command
150 | spddump_command
151 | spdflush_command
152 ;
153 /* commands concerned with management, there is in tail of this file. */
154
155 /* add command */
156 add_command
157 : ADD { p_type = SADB_ADD; }
158 sa_selector_spec extension_spec algorithm_spec EOT
159 ;
160
161 /* delete */
162 delete_command
163 : DELETE { p_type = SADB_DELETE; }
164 sa_selector_spec extension_spec
165 {
166 if (p_mode != IPSEC_MODE_ANY)
167 yyerror("WARNING: mode is obsoleted.");
168 }
169 EOT
170 ;
171
172 /* deleteall command */
173 deleteall_command
174 : DELETEALL { p_type = SADB_DELETE; }
175 ipaddress { p_src = pp_addr; }
176 ipaddress { p_dst = pp_addr; }
177 protocol_spec
178 { p_no_spi = 1; }
179 EOT
180 ;
181
182 /* get command */
183 get_command
184 : GET { p_type = SADB_GET; }
185 sa_selector_spec extension_spec
186 {
187 if (p_mode != IPSEC_MODE_ANY)
188 yyerror("WARNING: mode is obsoleted.");
189 }
190 EOT
191 ;
192
193 /* flush */
194 flush_command
195 : FLUSH { p_type = SADB_FLUSH; }
196 protocol_spec EOT
197 ;
198
199 /* dump */
200 dump_command
201 : DUMP { p_type = SADB_DUMP; }
202 protocol_spec EOT
203 ;
204
205 /* sa_selector_spec */
206 sa_selector_spec
207 : ipaddress { p_src = pp_addr; }
208 ipaddress { p_dst = pp_addr; }
209 protocol_spec spi
210 ;
211
212 protocol_spec
213 : /*NOTHING*/ { p_satype = SADB_SATYPE_UNSPEC; }
214 | PR_ESP
215 {
216 p_satype = SADB_SATYPE_ESP;
217 if ($1 == 1)
218 p_ext |= SADB_X_EXT_OLD;
219 else
220 p_ext &= ~SADB_X_EXT_OLD;
221 }
222 | PR_AH
223 {
224 p_satype = SADB_SATYPE_AH;
225 if ($1 == 1)
226 p_ext |= SADB_X_EXT_OLD;
227 else
228 p_ext &= ~SADB_X_EXT_OLD;
229 }
230 | PR_IPCOMP
231 {
232 p_satype = SADB_X_SATYPE_IPCOMP;
233 }
234 | PR_TCP
235 {
236 p_satype = SADB_X_SATYPE_TCPSIGNATURE;
237 }
238 ;
239
240 spi
241 : DECSTRING { p_spi = $1; }
242 | HEXSTRING
243 {
244 caddr_t bp;
245 caddr_t yp = $1.buf;
246 char buf0[4], buf[4];
247 int i, j;
248
249 /* sanity check */
250 if ($1.len > 4) {
251 yyerror("SPI too big.");
252 free($1.buf);
253 return -1;
254 }
255
256 bp = buf0;
257 while (*yp) {
258 *bp = (ATOX(yp[0]) << 4) | ATOX(yp[1]);
259 yp += 2, bp++;
260 }
261
262 /* initialize */
263 for (i = 0; i < 4; i++) buf[i] = 0;
264
265 for (j = $1.len - 1, i = 3; j >= 0; j--, i--)
266 buf[i] = buf0[j];
267
268 /* XXX: endian */
269 p_spi = ntohl(*(u_int32_t *)buf);
270
271 free($1.buf);
272 }
273 ;
274
275 algorithm_spec
276 : esp_spec
277 | ah_spec
278 | ipcomp_spec
279 ;
280
281 esp_spec
282 : F_ENC enc_alg enc_key F_AUTH auth_alg auth_key
283 | F_ENC enc_alg enc_key
284 ;
285
286 ah_spec
287 : F_AUTH auth_alg auth_key
288 ;
289
290 ipcomp_spec
291 : F_COMP ALG_COMP { p_alg_enc = $2; }
292 | F_COMP ALG_COMP { p_alg_enc = $2; }
293 F_RAWCPI { p_ext |= SADB_X_EXT_RAWCPI; }
294 ;
295
296 enc_alg
297 : ALG_ENC { p_alg_enc = $1; }
298 | ALG_ENC_DESDERIV
299 {
300 p_alg_enc = $1;
301 if (p_ext & SADB_X_EXT_OLD) {
302 yyerror("algorithm mismatched.");
303 return -1;
304 }
305 p_ext |= SADB_X_EXT_DERIV;
306 }
307 | ALG_ENC_DES32IV
308 {
309 p_alg_enc = $1;
310 if (!(p_ext & SADB_X_EXT_OLD)) {
311 yyerror("algorithm mismatched.");
312 return -1;
313 }
314 p_ext |= SADB_X_EXT_IV4B;
315 }
316 ;
317
318 enc_key
319 : /*NOTHING*/
320 {
321 if (p_alg_enc != SADB_EALG_NULL) {
322 yyerror("no key found.");
323 return -1;
324 }
325 }
326 | key_string
327 {
328 p_key_enc_len = $1.len;
329 p_key_enc = pp_key;
330
331 if (ipsec_check_keylen(SADB_EXT_SUPPORTED_ENCRYPT,
332 p_alg_enc,
333 PFKEY_UNUNIT64(p_key_enc_len)) < 0) {
334 yyerror(ipsec_strerror());
335 return -1;
336 }
337 }
338 ;
339
340 auth_alg
341 : ALG_AUTH { p_alg_auth = $1; }
342 ;
343
344 auth_key
345 : /*NOTHING*/
346 {
347 if (p_alg_auth != SADB_X_AALG_NULL) {
348 yyerror("no key found.");
349 return -1;
350 }
351 }
352 | key_string
353 {
354 p_key_auth_len = $1.len;
355 p_key_auth = pp_key;
356
357 if (p_alg_auth == SADB_X_AALG_TCP_MD5) {
358 if ((p_key_auth_len < 1) || (p_key_auth_len >
359 80))
360 return -1;
361 } else if (ipsec_check_keylen(SADB_EXT_SUPPORTED_AUTH,
362 p_alg_auth,
363 PFKEY_UNUNIT64(p_key_auth_len)) < 0) {
364 yyerror(ipsec_strerror());
365 return -1;
366 }
367 }
368 ;
369
370 key_string
371 : QUOTEDSTRING
372 {
373 pp_key = $1.buf;
374 /* free pp_key later */
375 }
376 | HEXSTRING
377 {
378 caddr_t bp;
379 caddr_t yp = $1.buf;
380
381 if ((pp_key = malloc($1.len)) == 0) {
382 free($1.buf);
383 yyerror("not enough core");
384 return -1;
385 }
386 memset(pp_key, 0, $1.len);
387
388 bp = pp_key;
389 while (*yp) {
390 *bp = (ATOX(yp[0]) << 4) | ATOX(yp[1]);
391 yp += 2, bp++;
392 }
393
394 free($1.buf);
395 }
396 ;
397
398 extension_spec
399 : /*NOTHING*/
400 | extension_spec extension
401 ;
402
403 extension
404 : F_EXT EXTENSION { p_ext |= $2; }
405 | F_EXT NOCYCLICSEQ { p_ext &= ~SADB_X_EXT_CYCSEQ; }
406 | F_MODE MODE { p_mode = $2; }
407 | F_MODE ANY { p_mode = IPSEC_MODE_ANY; }
408 | F_REQID DECSTRING { p_reqid = $2; }
409 | F_REPLAY DECSTRING
410 {
411 if (p_ext & SADB_X_EXT_OLD) {
412 yyerror("replay prevention "
413 "only use on new spec.");
414 return -1;
415 }
416 p_replay = $2;
417 }
418 | F_LIFETIME_HARD DECSTRING { p_lt_hard = $2; }
419 | F_LIFETIME_SOFT DECSTRING { p_lt_soft = $2; }
420 ;
421
422 /* definition about command for SPD management */
423 /* spdadd */
424 spdadd_command
425 : SPDADD
426 {
427 p_type = SADB_X_SPDADD;
428 p_satype = SADB_SATYPE_UNSPEC;
429 }
430 sp_selector_spec policy_spec EOT
431 ;
432
433 spddelete_command:
434 SPDDELETE
435 {
436 p_type = SADB_X_SPDDELETE;
437 p_satype = SADB_SATYPE_UNSPEC;
438 }
439 sp_selector_spec policy_spec EOT
440 ;
441
442 spddump_command:
443 SPDDUMP
444 {
445 p_type = SADB_X_SPDDUMP;
446 p_satype = SADB_SATYPE_UNSPEC;
447 }
448 EOT
449 ;
450
451 spdflush_command:
452 SPDFLUSH
453 {
454 p_type = SADB_X_SPDFLUSH;
455 p_satype = SADB_SATYPE_UNSPEC;
456 }
457 EOT
458 ;
459
460 /* sp_selector_spec */
461 sp_selector_spec
462 : ipaddress { p_src = pp_addr; }
463 prefix { p_prefs = pp_prefix; }
464 port
465 {
466 switch (p_src->sa_family) {
467 case AF_INET:
468 ((struct sockaddr_in *)p_src)->sin_port =
469 htons(pp_port);
470 break;
471 #ifdef INET6
472 case AF_INET6:
473 ((struct sockaddr_in6 *)p_src)->sin6_port =
474 htons(pp_port);
475 break;
476 #endif
477 default:
478 exit(1); /*XXX*/
479 }
480 }
481 ipaddress { p_dst = pp_addr; }
482 prefix { p_prefd = pp_prefix; }
483 port
484 {
485 switch (p_dst->sa_family) {
486 case AF_INET:
487 ((struct sockaddr_in *)p_dst)->sin_port =
488 htons(pp_port);
489 break;
490 #ifdef INET6
491 case AF_INET6:
492 ((struct sockaddr_in6 *)p_dst)->sin6_port =
493 htons(pp_port);
494 break;
495 #endif
496 default:
497 exit(1); /*XXX*/
498 }
499 }
500 upper_spec
501 {
502 /* XXX is it something userland should check? */
503 #if 0
504 switch (p_upper) {
505 case IPPROTO_ICMP:
506 case IPPROTO_ICMPV6:
507 if (_INPORTBYSA(p_src) != IPSEC_PORT_ANY
508 || _INPORTBYSA(p_dst) != IPSEC_PORT_ANY) {
509 yyerror("port number must be \"any\".");
510 return -1;
511 }
512 if ((pp_addr->sa_family == AF_INET6
513 && p_upper == IPPROTO_ICMP)
514 || (pp_addr->sa_family == AF_INET
515 && p_upper == IPPROTO_ICMPV6)) {
516 yyerror("upper layer protocol "
517 "mismatched.\n");
518 return -1;
519 }
520 break;
521 default:
522 break;
523 }
524 #endif
525 }
526 ;
527
528 ipaddress
529 : ADDRESS
530 {
531 struct addrinfo *res;
532
533 res = parse_addr($1.buf, NULL, AI_NUMERICHOST);
534 if (res == NULL) {
535 free($1.buf);
536 return -1;
537 }
538 pp_addr = (struct sockaddr *)malloc(res->ai_addrlen);
539 if (!pp_addr) {
540 yyerror("not enough core");
541 goto end;
542 }
543
544 memcpy(pp_addr, res->ai_addr, res->ai_addrlen);
545 end:
546 freeaddrinfo(res);
547 free($1.buf);
548 }
549 ;
550
551 prefix
552 : /*NOTHING*/ { pp_prefix = ~0; }
553 | PREFIX { pp_prefix = $1; }
554 ;
555
556 port
557 : /*NOTHING*/ { pp_port = IPSEC_PORT_ANY; }
558 | PORT { pp_port = $1; }
559 | PORTANY { pp_port = IPSEC_PORT_ANY; }
560 ;
561
562 upper_spec
563 : DECSTRING { p_upper = $1; }
564 | UP_PROTO { p_upper = $1; }
565 | ANY { p_upper = IPSEC_ULPROTO_ANY; }
566 | STRING
567 {
568 struct protoent *ent;
569
570 ent = getprotobyname($1.buf);
571 if (ent)
572 p_upper = ent->p_proto;
573 else {
574 if (strcmp("icmp6", $1.buf) == 0) {
575 p_upper = IPPROTO_ICMPV6;
576 } else if(strcmp("ip4", $1.buf) == 0) {
577 p_upper = IPPROTO_IPV4;
578 } else {
579 yyerror("invalid upper layer protocol");
580 free($1.buf);
581 return -1;
582 }
583 }
584 free($1.buf);
585 }
586 ;
587
588 policy_spec
589 : F_POLICY policy_requests
590 {
591 p_policy = ipsec_set_policy($2.buf, $2.len);
592 if (p_policy == NULL) {
593 free($2.buf);
594 p_policy = NULL;
595 yyerror(ipsec_strerror());
596 return -1;
597 }
598
599 p_policy_len = ipsec_get_policylen(p_policy);
600
601 free($2.buf);
602 }
603 ;
604
605 policy_requests
606 : PL_REQUESTS { $$ = $1; }
607 ;
608
609 %%
610
611 int
612 setkeymsg(void)
613 {
614 struct sadb_msg m_msg;
615
616 m_msg.sadb_msg_version = PF_KEY_V2;
617 m_msg.sadb_msg_type = p_type;
618 m_msg.sadb_msg_errno = 0;
619 m_msg.sadb_msg_satype = p_satype;
620 m_msg.sadb_msg_reserved = 0;
621 m_msg.sadb_msg_seq = 0;
622 m_msg.sadb_msg_pid = getpid();
623
624 m_len = sizeof(struct sadb_msg);
625 memcpy(m_buf, &m_msg, m_len);
626
627 switch (p_type) {
628 case SADB_FLUSH:
629 case SADB_DUMP:
630 break;
631
632 case SADB_ADD:
633 /* set encryption algorithm, if present. */
634 if (p_satype != SADB_X_SATYPE_IPCOMP && p_alg_enc != SADB_EALG_NONE) {
635 struct sadb_key m_key;
636
637 m_key.sadb_key_len =
638 PFKEY_UNIT64(sizeof(m_key)
639 + PFKEY_ALIGN8(p_key_enc_len));
640 m_key.sadb_key_exttype = SADB_EXT_KEY_ENCRYPT;
641 m_key.sadb_key_bits = p_key_enc_len * 8;
642 m_key.sadb_key_reserved = 0;
643
644 setvarbuf(&m_len,
645 (struct sadb_ext *)&m_key, sizeof(m_key),
646 (caddr_t)p_key_enc, p_key_enc_len);
647 }
648
649 /* set authentication algorithm, if present. */
650 if (p_alg_auth != SADB_AALG_NONE) {
651 struct sadb_key m_key;
652
653 m_key.sadb_key_len =
654 PFKEY_UNIT64(sizeof(m_key)
655 + PFKEY_ALIGN8(p_key_auth_len));
656 m_key.sadb_key_exttype = SADB_EXT_KEY_AUTH;
657 m_key.sadb_key_bits = p_key_auth_len * 8;
658 m_key.sadb_key_reserved = 0;
659
660 setvarbuf(&m_len,
661 (struct sadb_ext *)&m_key, sizeof(m_key),
662 (caddr_t)p_key_auth, p_key_auth_len);
663 }
664
665 /* set lifetime for HARD */
666 if (p_lt_hard != 0) {
667 struct sadb_lifetime m_lt;
668 u_int len = sizeof(struct sadb_lifetime);
669
670 m_lt.sadb_lifetime_len = PFKEY_UNIT64(len);
671 m_lt.sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
672 m_lt.sadb_lifetime_allocations = 0;
673 m_lt.sadb_lifetime_bytes = 0;
674 m_lt.sadb_lifetime_addtime = p_lt_hard;
675 m_lt.sadb_lifetime_usetime = 0;
676
677 memcpy(m_buf + m_len, &m_lt, len);
678 m_len += len;
679 }
680
681 /* set lifetime for SOFT */
682 if (p_lt_soft != 0) {
683 struct sadb_lifetime m_lt;
684 u_int len = sizeof(struct sadb_lifetime);
685
686 m_lt.sadb_lifetime_len = PFKEY_UNIT64(len);
687 m_lt.sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT;
688 m_lt.sadb_lifetime_allocations = 0;
689 m_lt.sadb_lifetime_bytes = 0;
690 m_lt.sadb_lifetime_addtime = p_lt_soft;
691 m_lt.sadb_lifetime_usetime = 0;
692
693 memcpy(m_buf + m_len, &m_lt, len);
694 m_len += len;
695 }
696 /* FALLTHROUGH */
697
698 case SADB_DELETE:
699 case SADB_GET:
700 {
701 struct sadb_sa m_sa;
702 struct sadb_x_sa2 m_sa2;
703 struct sadb_address m_addr;
704 u_int len;
705
706 if (p_no_spi == 0) {
707 len = sizeof(struct sadb_sa);
708 m_sa.sadb_sa_len = PFKEY_UNIT64(len);
709 m_sa.sadb_sa_exttype = SADB_EXT_SA;
710 m_sa.sadb_sa_spi = htonl(p_spi);
711 m_sa.sadb_sa_replay = p_replay;
712 m_sa.sadb_sa_state = 0;
713 m_sa.sadb_sa_auth = p_alg_auth;
714 m_sa.sadb_sa_encrypt = p_alg_enc;
715 m_sa.sadb_sa_flags = p_ext;
716
717 memcpy(m_buf + m_len, &m_sa, len);
718 m_len += len;
719
720 len = sizeof(struct sadb_x_sa2);
721 m_sa2.sadb_x_sa2_len = PFKEY_UNIT64(len);
722 m_sa2.sadb_x_sa2_exttype = SADB_X_EXT_SA2;
723 m_sa2.sadb_x_sa2_mode = p_mode;
724 m_sa2.sadb_x_sa2_reqid = p_reqid;
725
726 memcpy(m_buf + m_len, &m_sa2, len);
727 m_len += len;
728 }
729
730 /* set src */
731 m_addr.sadb_address_len =
732 PFKEY_UNIT64(sizeof(m_addr)
733 + PFKEY_ALIGN8(p_src->sa_len));
734 m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_SRC;
735 m_addr.sadb_address_proto = IPSEC_ULPROTO_ANY;
736 switch (p_src->sa_family) {
737 case AF_INET:
738 m_addr.sadb_address_prefixlen =
739 sizeof(struct in_addr) << 3;
740 break;
741 #ifdef INET6
742 case AF_INET6:
743 m_addr.sadb_address_prefixlen =
744 sizeof(struct in6_addr) << 3;
745 break;
746 #endif
747 default:
748 yyerror("unsupported address family");
749 exit(1); /*XXX*/
750 }
751 m_addr.sadb_address_reserved = 0;
752
753 setvarbuf(&m_len,
754 (struct sadb_ext *)&m_addr, sizeof(m_addr),
755 (caddr_t)p_src, p_src->sa_len);
756
757 /* set dst */
758 m_addr.sadb_address_len =
759 PFKEY_UNIT64(sizeof(m_addr)
760 + PFKEY_ALIGN8(p_dst->sa_len));
761 m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_DST;
762 m_addr.sadb_address_proto = IPSEC_ULPROTO_ANY;
763 switch (p_dst->sa_family) {
764 case AF_INET:
765 m_addr.sadb_address_prefixlen =
766 sizeof(struct in_addr) << 3;
767 break;
768 #ifdef INET6
769 case AF_INET6:
770 m_addr.sadb_address_prefixlen =
771 sizeof(struct in6_addr) << 3;
772 break;
773 #endif
774 default:
775 yyerror("unsupported address family");
776 exit(1); /*XXX*/
777 }
778 m_addr.sadb_address_reserved = 0;
779
780 setvarbuf(&m_len,
781 (struct sadb_ext *)&m_addr, sizeof(m_addr),
782 (caddr_t)p_dst, p_dst->sa_len);
783 }
784 break;
785
786 /* for SPD management */
787 case SADB_X_SPDFLUSH:
788 case SADB_X_SPDDUMP:
789 break;
790
791 case SADB_X_SPDADD:
792 case SADB_X_SPDDELETE:
793 {
794 struct sadb_address m_addr;
795 u_int8_t plen;
796
797 memcpy(m_buf + m_len, p_policy, p_policy_len);
798 m_len += p_policy_len;
799 free(p_policy);
800 p_policy = NULL;
801
802 /* set src */
803 m_addr.sadb_address_len =
804 PFKEY_UNIT64(sizeof(m_addr)
805 + PFKEY_ALIGN8(p_src->sa_len));
806 m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_SRC;
807 m_addr.sadb_address_proto = p_upper;
808 switch (p_src->sa_family) {
809 case AF_INET:
810 plen = sizeof(struct in_addr) << 3;
811 break;
812 #ifdef INET6
813 case AF_INET6:
814 plen = sizeof(struct in6_addr) << 3;
815 break;
816 #endif
817 default:
818 yyerror("unsupported address family");
819 exit(1); /*XXX*/
820 }
821 m_addr.sadb_address_prefixlen =
822 (p_prefs != ~0 ? p_prefs : plen);
823 m_addr.sadb_address_reserved = 0;
824
825 setvarbuf(&m_len,
826 (struct sadb_ext *)&m_addr, sizeof(m_addr),
827 (caddr_t)p_src, p_src->sa_len);
828
829 /* set dst */
830 m_addr.sadb_address_len =
831 PFKEY_UNIT64(sizeof(m_addr)
832 + PFKEY_ALIGN8(p_dst->sa_len));
833 m_addr.sadb_address_exttype = SADB_EXT_ADDRESS_DST;
834 m_addr.sadb_address_proto = p_upper;
835 switch (p_dst->sa_family) {
836 case AF_INET:
837 plen = sizeof(struct in_addr) << 3;
838 break;
839 #ifdef INET6
840 case AF_INET6:
841 plen = sizeof(struct in6_addr) << 3;
842 break;
843 #endif
844 default:
845 yyerror("unsupported address family");
846 exit(1); /*XXX*/
847 }
848 m_addr.sadb_address_prefixlen =
849 (p_prefd != ~0 ? p_prefd : plen);
850 m_addr.sadb_address_reserved = 0;
851
852 setvarbuf(&m_len,
853 (struct sadb_ext *)&m_addr, sizeof(m_addr),
854 (caddr_t)p_dst, p_dst->sa_len);
855 }
856 break;
857 }
858
859 ((struct sadb_msg *)m_buf)->sadb_msg_len = PFKEY_UNIT64(m_len);
860
861 return 0;
862 }
863
864 static struct addrinfo *
865 parse_addr(char *host, char *port, int flag)
866 {
867 struct addrinfo hints, *res = NULL;
868 int error;
869
870 memset(&hints, 0, sizeof(hints));
871 hints.ai_family = PF_UNSPEC;
872 hints.ai_socktype = SOCK_DGRAM;
873 hints.ai_flags = flag;
874 error = getaddrinfo(host, port, &hints, &res);
875 if (error != 0) {
876 yyerror(gai_strerror(error));
877 return NULL;
878 }
879 if (res->ai_next != NULL) {
880 yyerror(gai_strerror(error));
881 }
882 return res;
883 }
884
885 static int
886 setvarbuf(int *off, struct sadb_ext *ebuf, int elen, caddr_t vbuf, int vlen)
887 {
888 memset(m_buf + *off, 0, PFKEY_UNUNIT64(ebuf->sadb_ext_len));
889 memcpy(m_buf + *off, (caddr_t)ebuf, elen);
890 memcpy(m_buf + *off + elen, vbuf, vlen);
891 (*off) += PFKEY_ALIGN8(elen + vlen);
892
893 return 0;
894 }
895
896 void
897 parse_init(void)
898 {
899 p_type = 0;
900 p_spi = 0;
901 p_no_spi = 0;
902
903 p_src = 0, p_dst = 0;
904 pp_prefix = p_prefs = p_prefd = ~0;
905 pp_port = IPSEC_PORT_ANY;
906 p_upper = 0;
907
908 p_satype = 0;
909 p_ext = SADB_X_EXT_CYCSEQ;
910 p_alg_enc = SADB_EALG_NONE;
911 p_alg_auth = SADB_AALG_NONE;
912 p_mode = IPSEC_MODE_ANY;
913 p_reqid = 0;
914 p_replay = 0;
915 p_key_enc_len = p_key_auth_len = 0;
916 p_key_enc = p_key_auth = 0;
917 p_lt_hard = p_lt_soft = 0;
918
919 p_policy_len = 0;
920 p_policy = NULL;
921
922 memset(cmdarg, 0, sizeof(cmdarg));
923
924 return;
925 }
926
927 void
928 free_buffer(void)
929 {
930 if (p_src) free(p_src);
931 if (p_dst) free(p_dst);
932 if (p_key_enc) free(p_key_enc);
933 if (p_key_auth) free(p_key_auth);
934
935 return;
936 }
937
DragonFly BSD