?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - support dummy reallocblks in devfs
[dragonfly.git] / sbin / routed / parms.c
blob7ea019498012504b591e5d5cb75c30e0154ee512
1 /*
2 * Copyright (c) 1983, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $FreeBSD: src/sbin/routed/parms.c,v 1.7.2.1 2000/08/14 17:00:03 sheldonh Exp $
30 */
31
32 #include "defs.h"
33 #include "pathnames.h"
34 #include <sys/stat.h>
35
36 #if !defined(__NetBSD__)
37 static char sccsid[] __attribute__((unused)) = "@(#)if.c 8.1 (Berkeley) 6/5/93";
38 #elif defined(__NetBSD__)
39 __RCSID("$NetBSD$");
40 #endif
41
42
43 struct parm *parms;
44 struct intnet *intnets;
45 struct r1net *r1nets;
46 struct tgate *tgates;
47
48
49 /* use configured parameters
50 */
51 void
52 get_parms(struct interface *ifp)
53 {
54 static int warned_auth_in, warned_auth_out;
55 struct parm *parmp;
56 int i, num_passwds = 0;
57
58 /* get all relevant parameters
59 */
60 for (parmp = parms; parmp != NULL; parmp = parmp->parm_next) {
61 if (parmp->parm_name[0] == '\0'
62 || !strcmp(ifp->int_name, parmp->parm_name)
63 || (parmp->parm_name[0] == '\n'
64 && on_net(ifp->int_addr,
65 parmp->parm_net, parmp->parm_mask))) {
66
67 /* This group of parameters is relevant,
68 * so get its settings
69 */
70 ifp->int_state |= parmp->parm_int_state;
71 for (i = 0; i < MAX_AUTH_KEYS; i++) {
72 if (parmp->parm_auth[0].type == RIP_AUTH_NONE
73 || num_passwds >= MAX_AUTH_KEYS)
74 break;
75 memcpy(&ifp->int_auth[num_passwds++],
76 &parmp->parm_auth[i],
77 sizeof(ifp->int_auth[0]));
78 }
79 if (parmp->parm_rdisc_pref != 0)
80 ifp->int_rdisc_pref = parmp->parm_rdisc_pref;
81 if (parmp->parm_rdisc_int != 0)
82 ifp->int_rdisc_int = parmp->parm_rdisc_int;
83 if (parmp->parm_d_metric != 0)
84 ifp->int_d_metric = parmp->parm_d_metric;
85 }
86 }
87
88 /* Set general defaults.
89 *
90 * Default poor-man's router discovery to a metric that will
91 * be heard by old versions of `routed`. They ignored received
92 * routes with metric 15.
93 */
94 if ((ifp->int_state & IS_PM_RDISC)
95 && ifp->int_d_metric == 0)
96 ifp->int_d_metric = FAKE_METRIC;
97
98 if (ifp->int_rdisc_int == 0)
99 ifp->int_rdisc_int = DefMaxAdvertiseInterval;
100
101 if (!(ifp->int_if_flags & IFF_MULTICAST)
102 && !(ifp->int_state & IS_REMOTE))
103 ifp->int_state |= IS_BCAST_RDISC;
104
105 if (ifp->int_if_flags & IFF_POINTOPOINT) {
106 ifp->int_state |= IS_BCAST_RDISC;
107 /* By default, point-to-point links should be passive
108 * about router-discovery for the sake of demand-dialing.
109 */
110 if (0 == (ifp->int_state & GROUP_IS_SOL_OUT))
111 ifp->int_state |= IS_NO_SOL_OUT;
112 if (0 == (ifp->int_state & GROUP_IS_ADV_OUT))
113 ifp->int_state |= IS_NO_ADV_OUT;
114 }
115
116 if (0 != (ifp->int_state & (IS_PASSIVE | IS_REMOTE)))
117 ifp->int_state |= IS_NO_RDISC;
118 if (ifp->int_state & IS_PASSIVE)
119 ifp->int_state |= IS_NO_RIP;
120
121 if (!IS_RIP_IN_OFF(ifp->int_state)
122 && ifp->int_auth[0].type != RIP_AUTH_NONE
123 && !(ifp->int_state & IS_NO_RIPV1_IN)
124 && !warned_auth_in) {
125 msglog("Warning: RIPv1 input via %s"
126 " will be accepted without authentication",
127 ifp->int_name);
128 warned_auth_in = 1;
129 }
130 if (!IS_RIP_OUT_OFF(ifp->int_state)
131 && ifp->int_auth[0].type != RIP_AUTH_NONE
132 && !(ifp->int_state & IS_NO_RIPV1_OUT)) {
133 if (!warned_auth_out) {
134 msglog("Warning: RIPv1 output via %s"
135 " will be sent without authentication",
136 ifp->int_name);
137 warned_auth_out = 1;
138 }
139 }
140 }
141
142
143 /* Read a list of gateways from /etc/gateways and add them to our tables.
144 *
145 * This file contains a list of "remote" gateways. That is usually
146 * a gateway which we cannot immediately determine if it is present or
147 * not as we can do for those provided by directly connected hardware.
148 *
149 * If a gateway is marked "passive" in the file, then we assume it
150 * does not understand RIP and assume it is always present. Those
151 * not marked passive are treated as if they were directly connected
152 * and assumed to be broken if they do not send us advertisements.
153 * All remote interfaces are added to our list, and those not marked
154 * passive are sent routing updates.
155 *
156 * A passive interface can also be local, hardware interface exempt
157 * from RIP.
158 */
159 void
160 gwkludge(void)
161 {
162 FILE *fp;
163 char *p, *lptr;
164 const char *cp;
165 char lbuf[200], net_host[5], dname[64+1+64+1];
166 char gname[GNAME_LEN+1], qual[9];
167 struct interface *ifp;
168 naddr dst, netmask, gate;
169 int metric, n, lnum;
170 struct stat sb;
171 u_int state;
172 const char *type;
173
174
175 fp = fopen(_PATH_GATEWAYS, "r");
176 if (fp == NULL)
177 return;
178
179 if (0 > fstat(fileno(fp), &sb)) {
180 msglog("could not stat() "_PATH_GATEWAYS);
181 fclose(fp);
182 return;
183 }
184
185 for (lnum = 1; ; lnum++) {
186 if (0 == fgets(lbuf, sizeof(lbuf), fp))
187 break;
188 lptr = lbuf;
189 while (*lptr == ' ')
190 lptr++;
191 p = lptr+strlen(lptr)-1;
192 while (*p == '\n'
193 || (*p == ' ' && (p == lptr+1 || *(p-1) != '\\')))
194 *p-- = '\0';
195 if (*lptr == '\0' /* ignore null and comment lines */
196 || *lptr == '#')
197 continue;
198
199 /* notice newfangled parameter lines
200 */
201 if (strncasecmp("net", lptr, 3)
202 && strncasecmp("host", lptr, 4)) {
203 cp = parse_parms(lptr,
204 (sb.st_uid == 0
205 && !(sb.st_mode&(S_IRWXG|S_IRWXO))));
206 if (cp != NULL)
207 msglog("%s in line %d of "_PATH_GATEWAYS,
208 cp, lnum);
209 continue;
210 }
211
212 /* {net | host} XX[/M] XX gateway XX metric DD [passive | external]\n */
213 qual[0] = '\0';
214 /* the '64' here must be GNAME_LEN */
215 n = sscanf(lptr, "%4s %129[^ \t] gateway"
216 " %64[^ / \t] metric %u %8s\n",
217 net_host, dname, gname, &metric, qual);
218 if (n != 4 && n != 5) {
219 msglog("bad "_PATH_GATEWAYS" entry \"%s\"; %d values",
220 lptr, n);
221 continue;
222 }
223 if (metric >= HOPCNT_INFINITY) {
224 msglog("bad metric in "_PATH_GATEWAYS" entry \"%s\"",
225 lptr);
226 continue;
227 }
228 if (!strcasecmp(net_host, "host")) {
229 if (!gethost(dname, &dst)) {
230 msglog("bad host \"%s\" in "_PATH_GATEWAYS
231 " entry \"%s\"", dname, lptr);
232 continue;
233 }
234 netmask = HOST_MASK;
235 } else if (!strcasecmp(net_host, "net")) {
236 if (!getnet(dname, &dst, &netmask)) {
237 msglog("bad net \"%s\" in "_PATH_GATEWAYS
238 " entry \"%s\"", dname, lptr);
239 continue;
240 }
241 if (dst == RIP_DEFAULT) {
242 msglog("bad net \"%s\" in "_PATH_GATEWAYS
243 " entry \"%s\"--cannot be default",
244 dname, lptr);
245 continue;
246 }
247 dst = htonl(dst); /* make network # into IP address */
248 } else {
249 msglog("bad \"%s\" in "_PATH_GATEWAYS
250 " entry \"%s\"", net_host, lptr);
251 continue;
252 }
253
254 if (!gethost(gname, &gate)) {
255 msglog("bad gateway \"%s\" in "_PATH_GATEWAYS
256 " entry \"%s\"", gname, lptr);
257 continue;
258 }
259
260 if (!strcasecmp(qual, type = "passive")) {
261 /* Passive entries are not placed in our tables,
262 * only the kernel's, so we don't copy all of the
263 * external routing information within a net.
264 * Internal machines should use the default
265 * route to a suitable gateway (like us).
266 */
267 state = IS_REMOTE | IS_PASSIVE;
268 if (metric == 0)
269 metric = 1;
270
271 } else if (!strcasecmp(qual, type = "external")) {
272 /* External entries are handled by other means
273 * such as EGP, and are placed only in the daemon
274 * tables to prevent overriding them with something
275 * else.
276 */
277 strcpy(qual,"external");
278 state = IS_REMOTE | IS_PASSIVE | IS_EXTERNAL;
279 if (metric == 0)
280 metric = 1;
281
282 } else if (!strcasecmp(qual, "active")
283 || qual[0] == '\0') {
284 if (metric != 0) {
285 /* Entries that are neither "passive" nor
286 * "external" are "remote" and must behave
287 * like physical interfaces. If they are not
288 * heard from regularly, they are deleted.
289 */
290 state = IS_REMOTE;
291 type = "remote";
292 } else {
293 /* "remote" entries with a metric of 0
294 * are aliases for our own interfaces
295 */
296 state = IS_REMOTE | IS_PASSIVE | IS_ALIAS;
297 type = "alias";
298 }
299
300 } else {
301 msglog("bad "_PATH_GATEWAYS" entry \"%s\";"
302 " unknown type %s", lptr, qual);
303 continue;
304 }
305
306 if (0 != (state & (IS_PASSIVE | IS_REMOTE)))
307 state |= IS_NO_RDISC;
308 if (state & IS_PASSIVE)
309 state |= IS_NO_RIP;
310
311 ifp = check_dup(gate,dst,netmask,0);
312 if (ifp != NULL) {
313 msglog("duplicate "_PATH_GATEWAYS" entry \"%s\"",lptr);
314 continue;
315 }
316
317 ifp = (struct interface *)rtmalloc(sizeof(*ifp), "gwkludge()");
318 memset(ifp, 0, sizeof(*ifp));
319
320 ifp->int_state = state;
321 if (netmask == HOST_MASK)
322 ifp->int_if_flags = IFF_POINTOPOINT | IFF_UP;
323 else
324 ifp->int_if_flags = IFF_UP;
325 ifp->int_act_time = NEVER;
326 ifp->int_addr = gate;
327 ifp->int_dstaddr = dst;
328 ifp->int_mask = netmask;
329 ifp->int_ripv1_mask = netmask;
330 ifp->int_std_mask = std_mask(gate);
331 ifp->int_net = ntohl(dst);
332 ifp->int_std_net = ifp->int_net & ifp->int_std_mask;
333 ifp->int_std_addr = htonl(ifp->int_std_net);
334 ifp->int_metric = metric;
335 if (!(state & IS_EXTERNAL)
336 && ifp->int_mask != ifp->int_std_mask)
337 ifp->int_state |= IS_SUBNET;
338 sprintf(ifp->int_name, "%s(%s)", type, gname);
339 ifp->int_index = -1;
340
341 if_link(ifp);
342 }
343
344 /* After all of the parameter lines have been read,
345 * apply them to any remote interfaces.
346 */
347 for (ifp = ifnet; NULL != ifp; ifp = ifp->int_next) {
348 get_parms(ifp);
349
350 tot_interfaces++;
351 if (!IS_RIP_OFF(ifp->int_state))
352 rip_interfaces++;
353
354 trace_if("Add", ifp);
355 }
356
357 fclose(fp);
358 }
359
360
361 /* like strtok(), but honoring backslash and not changing the source string
362 */
363 static int /* 0=ok, -1=bad */
364 parse_quote(char **linep, /* look here */
365 const char *delims, /* for these delimiters */
366 char *delimp, /* 0 or put found delimiter here */
367 char *buf, /* copy token to here */
368 int lim) /* at most this many bytes */
369 {
370 char c = '\0', *pc;
371 const char *p;
372
373
374 pc = *linep;
375 if (*pc == '\0')
376 return -1;
377
378 while (lim != 0) {
379 c = *pc++;
380 if (c == '\0')
381 break;
382
383 if (c == '\\' && *pc != '\0') {
384 if ((c = *pc++) == 'n') {
385 c = '\n';
386 } else if (c == 'r') {
387 c = '\r';
388 } else if (c == 't') {
389 c = '\t';
390 } else if (c == 'b') {
391 c = '\b';
392 } else if (c >= '0' && c <= '7') {
393 c -= '0';
394 if (*pc >= '0' && *pc <= '7') {
395 c = (c<<3)+(*pc++ - '0');
396 if (*pc >= '0' && *pc <= '7')
397 c = (c<<3)+(*pc++ - '0');
398 }
399 }
400
401 } else {
402 for (p = delims; *p != '\0'; ++p) {
403 if (*p == c)
404 goto exit;
405 }
406 }
407
408 *buf++ = c;
409 --lim;
410 }
411 exit:
412 if (lim == 0)
413 return -1;
414
415 *buf = '\0'; /* terminate copy of token */
416 if (delimp != NULL)
417 *delimp = c; /* return delimiter */
418 *linep = pc-1; /* say where we ended */
419 return 0;
420 }
421
422
423 /* Parse password timestamp
424 */
425 static char *
426 parse_ts(time_t *tp,
427 char **valp,
428 char *val0,
429 char *delimp,
430 char *buf,
431 u_int bufsize)
432 {
433 struct tm tm;
434 #if defined(__NetBSD__)
435 char *ptr;
436 #endif
437
438 if (0 > parse_quote(valp, "| ,\n\r", delimp,
439 buf,bufsize)
440 || buf[bufsize-1] != '\0'
441 || buf[bufsize-2] != '\0') {
442 sprintf(buf,"bad timestamp %.25s", val0);
443 return buf;
444 }
445 strcat(buf,"\n");
446 memset(&tm, 0, sizeof(tm));
447 #if defined(__NetBSD__)
448 ptr = strptime(buf, "%y/%m/%d@%H:%M\n", &tm);
449 if (ptr == NULL || *ptr != '\0') {
450 sprintf(buf,"bad timestamp %.25s", val0);
451 return buf;
452 }
453 #else
454 if (5 != sscanf(buf, "%u/%u/%u@%u:%u\n",
455 &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
456 &tm.tm_hour, &tm.tm_min)
457 || tm.tm_mon < 1 || tm.tm_mon > 12
458 || tm.tm_mday < 1 || tm.tm_mday > 31) {
459 sprintf(buf,"bad timestamp %.25s", val0);
460 return buf;
461 }
462 tm.tm_mon--;
463 if (tm.tm_year <= 37) /* assume small years are in the */
464 tm.tm_year += 100; /* 3rd millenium */
465 #endif
466
467 if ((*tp = mktime(&tm)) == -1) {
468 sprintf(buf,"bad timestamp %.25s", val0);
469 return buf;
470 }
471
472 return 0;
473 }
474
475
476 /* Get a password, key ID, and expiration date in the format
477 * passwd|keyID|year/mon/day@hour:min|year/mon/day@hour:min
478 */
479 static const char * /* 0 or error message */
480 get_passwd(char *tgt,
481 char *val,
482 struct parm *parmp,
483 u_int16_t type,
484 int safe) /* 1=from secure file */
485 {
486 static char buf[80];
487 char *val0, *p, delim;
488 struct auth k, *ap, *ap2;
489 int i;
490 u_long l;
491
492
493 if (!safe)
494 return "ignore unsafe password";
495
496 for (ap = parmp->parm_auth, i = 0;
497 ap->type != RIP_AUTH_NONE; i++, ap++) {
498 if (i >= MAX_AUTH_KEYS)
499 return "too many passwords";
500 }
501
502 memset(&k, 0, sizeof(k));
503 k.type = type;
504 k.end = -1-DAY;
505
506 val0 = val;
507 if (0 > parse_quote(&val, "| ,\n\r", &delim,
508 (char *)k.key, sizeof(k.key)))
509 return tgt;
510
511 if (delim != '|') {
512 if (type == RIP_AUTH_MD5)
513 return "missing Keyid";
514 } else {
515 val0 = ++val;
516 buf[sizeof(buf)-1] = '\0';
517 if (0 > parse_quote(&val, "| ,\n\r", &delim, buf,sizeof(buf))
518 || buf[sizeof(buf)-1] != '\0'
519 || (l = strtoul(buf,&p,0)) > 255
520 || *p != '\0') {
521 sprintf(buf,"bad KeyID \"%.20s\"", val0);
522 return buf;
523 }
524 for (ap2 = parmp->parm_auth; ap2 < ap; ap2++) {
525 if (ap2->keyid == l) {
526 sprintf(buf,"duplicate KeyID \"%.20s\"", val0);
527 return buf;
528 }
529 }
530 k.keyid = (int)l;
531
532 if (delim == '|') {
533 val0 = ++val;
534 if (NULL != (p = parse_ts(&k.start,&val,val0,&delim,
535 buf,sizeof(buf))))
536 return p;
537 if (delim != '|')
538 return "missing second timestamp";
539 val0 = ++val;
540 if (NULL != (p = parse_ts(&k.end,&val,val0,&delim,
541 buf,sizeof(buf))))
542 return p;
543 if ((u_long)k.start > (u_long)k.end) {
544 sprintf(buf,"out of order timestamp %.30s",
545 val0);
546 return buf;
547 }
548 }
549 }
550 if (delim != '\0')
551 return tgt;
552
553 memmove(ap, &k, sizeof(*ap));
554 return 0;
555 }
556
557
558 static const char *
559 bad_str(const char *estr)
560 {
561 static char buf[100+8];
562
563 sprintf(buf, "bad \"%.100s\"", estr);
564 return buf;
565 }
566
567
568 /* Parse a set of parameters for an interface.
569 */
570 const char * /* 0 or error message */
571 parse_parms(char *line,
572 int safe) /* 1=from secure file */
573 {
574 #define PARS(str) (!strcasecmp(tgt, str))
575 #define PARSEQ(str) (!strncasecmp(tgt, str"=", sizeof(str)))
576 #define CKF(g,b) {if (0 != (parm.parm_int_state & ((g) & ~(b)))) break; \
577 parm.parm_int_state |= (b);}
578 struct parm parm;
579 struct intnet *intnetp;
580 struct r1net *r1netp;
581 struct tgate *tg;
582 naddr addr, mask;
583 char delim, *val0 = NULL, *tgt, *val, *p;
584 const char *msg;
585 char buf[BUFSIZ], buf2[BUFSIZ];
586 int i;
587
588
589 /* "subnet=x.y.z.u/mask[,metric]" must be alone on the line */
590 if (!strncasecmp(line, "subnet=", sizeof("subnet=")-1)
591 && *(val = &line[sizeof("subnet=")-1]) != '\0') {
592 if (0 > parse_quote(&val, ",", &delim, buf, sizeof(buf)))
593 return bad_str(line);
594 intnetp = (struct intnet*)rtmalloc(sizeof(*intnetp),
595 "parse_parms subnet");
596 intnetp->intnet_metric = 1;
597 if (delim == ',') {
598 intnetp->intnet_metric = (int)strtol(val+1,&p,0);
599 if (*p != '\0'
600 || intnetp->intnet_metric <= 0
601 || intnetp->intnet_metric >= HOPCNT_INFINITY)
602 return bad_str(line);
603 }
604 if (!getnet(buf, &intnetp->intnet_addr, &intnetp->intnet_mask)
605 || intnetp->intnet_mask == HOST_MASK
606 || intnetp->intnet_addr == RIP_DEFAULT) {
607 free(intnetp);
608 return bad_str(line);
609 }
610 intnetp->intnet_addr = htonl(intnetp->intnet_addr);
611 intnetp->intnet_next = intnets;
612 intnets = intnetp;
613 return 0;
614 }
615
616 /* "ripv1_mask=x.y.z.u/mask1,mask2" must be alone on the line.
617 * This requires that x.y.z.u/mask1 be considered a subnet of
618 * x.y.z.u/mask2, as if x.y.z.u/mask2 were a class-full network.
619 */
620 if (!strncasecmp(line, "ripv1_mask=", sizeof("ripv1_mask=")-1)
621 && *(val = &line[sizeof("ripv1_mask=")-1]) != '\0') {
622 if (0 > parse_quote(&val, ",", &delim, buf, sizeof(buf))
623 || delim == '\0')
624 return bad_str(line);
625 if ((i = (int)strtol(val+1, &p, 0)) <= 0
626 || i > 32 || *p != '\0')
627 return bad_str(line);
628 r1netp = (struct r1net *)rtmalloc(sizeof(*r1netp),
629 "parse_parms ripv1_mask");
630 r1netp->r1net_mask = HOST_MASK << (32-i);
631 if (!getnet(buf, &r1netp->r1net_net, &r1netp->r1net_match)
632 || r1netp->r1net_net == RIP_DEFAULT
633 || r1netp->r1net_mask > r1netp->r1net_match) {
634 free(r1netp);
635 return bad_str(line);
636 }
637 r1netp->r1net_next = r1nets;
638 r1nets = r1netp;
639 return 0;
640 }
641
642 memset(&parm, 0, sizeof(parm));
643
644 for (;;) {
645 tgt = line + strspn(line, " ,\n\r");
646 if (*tgt == '\0' || *tgt == '#')
647 break;
648 line = tgt+strcspn(tgt, "= #,\n\r");
649 delim = *line;
650 if (delim == '=') {
651 val0 = ++line;
652 if (0 > parse_quote(&line, " #,\n\r",&delim,
653 buf,sizeof(buf)))
654 return bad_str(tgt);
655 }
656 if (delim != '\0') {
657 for (;;) {
658 *line = '\0';
659 if (delim == '#')
660 break;
661 ++line;
662 if (delim != ' '
663 || (delim = *line) != ' ')
664 break;
665 }
666 }
667
668 if (PARSEQ("if")) {
669 if (parm.parm_name[0] != '\0'
670 || strlen(buf) > IF_NAME_LEN)
671 return bad_str(tgt);
672 strcpy(parm.parm_name, buf);
673
674 } else if (PARSEQ("addr")) {
675 /* This is a bad idea, because the address based
676 * sets of parameters cannot be checked for
677 * consistency with the interface name parameters.
678 * The parm_net stuff is needed to allow several
679 * -F settings.
680 */
681 if (!getnet(val0, &addr, &mask)
682 || parm.parm_name[0] != '\0')
683 return bad_str(tgt);
684 parm.parm_net = addr;
685 parm.parm_mask = mask;
686 parm.parm_name[0] = '\n';
687
688 } else if (PARSEQ("passwd")) {
689 /* since cleartext passwords are so weak allow
690 * them anywhere
691 */
692 msg = get_passwd(tgt,val0,&parm,RIP_AUTH_PW,1);
693 if (msg) {
694 *val0 = '\0';
695 return bad_str(msg);
696 }
697
698 } else if (PARSEQ("md5_passwd")) {
699 msg = get_passwd(tgt,val0,&parm,RIP_AUTH_MD5,safe);
700 if (msg) {
701 *val0 = '\0';
702 return bad_str(msg);
703 }
704
705 } else if (PARS("no_ag")) {
706 parm.parm_int_state |= (IS_NO_AG | IS_NO_SUPER_AG);
707
708 } else if (PARS("no_super_ag")) {
709 parm.parm_int_state |= IS_NO_SUPER_AG;
710
711 } else if (PARS("no_ripv1_in")) {
712 parm.parm_int_state |= IS_NO_RIPV1_IN;
713
714 } else if (PARS("no_ripv2_in")) {
715 parm.parm_int_state |= IS_NO_RIPV2_IN;
716
717 } else if (PARS("ripv2_out")) {
718 if (parm.parm_int_state & IS_NO_RIPV2_OUT)
719 return bad_str(tgt);
720 parm.parm_int_state |= IS_NO_RIPV1_OUT;
721
722 } else if (PARS("ripv2")) {
723 if ((parm.parm_int_state & IS_NO_RIPV2_OUT)
724 || (parm.parm_int_state & IS_NO_RIPV2_IN))
725 return bad_str(tgt);
726 parm.parm_int_state |= (IS_NO_RIPV1_IN
727 | IS_NO_RIPV1_OUT);
728
729 } else if (PARS("no_rip")) {
730 CKF(IS_PM_RDISC, IS_NO_RIP);
731
732 } else if (PARS("no_rip_mcast")) {
733 parm.parm_int_state |= IS_NO_RIP_MCAST;
734
735 } else if (PARS("no_rdisc")) {
736 CKF((GROUP_IS_SOL_OUT|GROUP_IS_ADV_OUT), IS_NO_RDISC);
737
738 } else if (PARS("no_solicit")) {
739 CKF(GROUP_IS_SOL_OUT, IS_NO_SOL_OUT);
740
741 } else if (PARS("send_solicit")) {
742 CKF(GROUP_IS_SOL_OUT, IS_SOL_OUT);
743
744 } else if (PARS("no_rdisc_adv")) {
745 CKF(GROUP_IS_ADV_OUT, IS_NO_ADV_OUT);
746
747 } else if (PARS("rdisc_adv")) {
748 CKF(GROUP_IS_ADV_OUT, IS_ADV_OUT);
749
750 } else if (PARS("bcast_rdisc")) {
751 parm.parm_int_state |= IS_BCAST_RDISC;
752
753 } else if (PARS("passive")) {
754 CKF((GROUP_IS_SOL_OUT|GROUP_IS_ADV_OUT), IS_NO_RDISC);
755 parm.parm_int_state |= IS_NO_RIP| IS_PASSIVE;
756
757 } else if (PARSEQ("rdisc_pref")) {
758 if (parm.parm_rdisc_pref != 0
759 || (parm.parm_rdisc_pref = (int)strtol(buf,&p,0),
760 *p != '\0'))
761 return bad_str(tgt);
762
763 } else if (PARS("pm_rdisc")) {
764 if (IS_RIP_OUT_OFF(parm.parm_int_state))
765 return bad_str(tgt);
766 parm.parm_int_state |= IS_PM_RDISC;
767
768 } else if (PARSEQ("rdisc_interval")) {
769 if (parm.parm_rdisc_int != 0
770 || (parm.parm_rdisc_int = (int)strtoul(buf,&p,0),
771 *p != '\0')
772 || parm.parm_rdisc_int < MinMaxAdvertiseInterval
773 || parm.parm_rdisc_int > MaxMaxAdvertiseInterval)
774 return bad_str(tgt);
775
776 } else if (PARSEQ("fake_default")) {
777 if (parm.parm_d_metric != 0
778 || IS_RIP_OUT_OFF(parm.parm_int_state)
779 || (parm.parm_d_metric = (int)strtoul(buf,&p,0),
780 *p != '\0')
781 || parm.parm_d_metric > HOPCNT_INFINITY-1)
782 return bad_str(tgt);
783
784 } else if (PARSEQ("trust_gateway")) {
785 /* look for trust_gateway=x.y.z|net/mask|...) */
786 p = buf;
787 if (0 > parse_quote(&p, "|", &delim,
788 buf2, sizeof(buf2))
789 || !gethost(buf2,&addr))
790 return bad_str(tgt);
791 tg = (struct tgate *)rtmalloc(sizeof(*tg),
792 "parse_parms"
793 "trust_gateway");
794 memset(tg, 0, sizeof(*tg));
795 tg->tgate_addr = addr;
796 i = 0;
797 /* The default is to trust all routes. */
798 while (delim == '|') {
799 p++;
800 if (i >= MAX_TGATE_NETS
801 || 0 > parse_quote(&p, "|", &delim,
802 buf2, sizeof(buf2))
803 || !getnet(buf2, &tg->tgate_nets[i].net,
804 &tg->tgate_nets[i].mask)
805 || tg->tgate_nets[i].net == RIP_DEFAULT
806 || tg->tgate_nets[i].mask == 0)
807 return bad_str(tgt);
808 i++;
809 }
810 tg->tgate_next = tgates;
811 tgates = tg;
812 parm.parm_int_state |= IS_DISTRUST;
813
814 } else if (PARS("redirect_ok")) {
815 parm.parm_int_state |= IS_REDIRECT_OK;
816
817 } else {
818 return bad_str(tgt); /* error */
819 }
820 }
821
822 return check_parms(&parm);
823 #undef PARS
824 #undef PARSEQ
825 }
826
827
828 /* check for duplicate parameter specifications */
829 const char * /* 0 or error message */
830 check_parms(struct parm *new)
831 {
832 struct parm *parmp, **parmpp;
833 int i, num_passwds;
834
835 /* set implicit values
836 */
837 if (new->parm_int_state & IS_NO_ADV_IN)
838 new->parm_int_state |= IS_NO_SOL_OUT;
839 if (new->parm_int_state & IS_NO_SOL_OUT)
840 new->parm_int_state |= IS_NO_ADV_IN;
841
842 for (i = num_passwds = 0; i < MAX_AUTH_KEYS; i++) {
843 if (new->parm_auth[i].type != RIP_AUTH_NONE)
844 num_passwds++;
845 }
846
847 /* compare with existing sets of parameters
848 */
849 for (parmpp = &parms;
850 (parmp = *parmpp) != NULL;
851 parmpp = &parmp->parm_next) {
852 if (strcmp(new->parm_name, parmp->parm_name))
853 continue;
854 if (!on_net(htonl(parmp->parm_net),
855 new->parm_net, new->parm_mask)
856 && !on_net(htonl(new->parm_net),
857 parmp->parm_net, parmp->parm_mask))
858 continue;
859
860 for (i = 0; i < MAX_AUTH_KEYS; i++) {
861 if (parmp->parm_auth[i].type != RIP_AUTH_NONE)
862 num_passwds++;
863 }
864 if (num_passwds > MAX_AUTH_KEYS)
865 return "too many conflicting passwords";
866
867 if ((0 != (new->parm_int_state & GROUP_IS_SOL_OUT)
868 && 0 != (parmp->parm_int_state & GROUP_IS_SOL_OUT)
869 && 0 != ((new->parm_int_state ^ parmp->parm_int_state)
870 & GROUP_IS_SOL_OUT))
871 || (0 != (new->parm_int_state & GROUP_IS_ADV_OUT)
872 && 0 != (parmp->parm_int_state & GROUP_IS_ADV_OUT)
873 && 0 != ((new->parm_int_state ^ parmp->parm_int_state)
874 & GROUP_IS_ADV_OUT))
875 || (new->parm_rdisc_pref != 0
876 && parmp->parm_rdisc_pref != 0
877 && new->parm_rdisc_pref != parmp->parm_rdisc_pref)
878 || (new->parm_rdisc_int != 0
879 && parmp->parm_rdisc_int != 0
880 && new->parm_rdisc_int != parmp->parm_rdisc_int)) {
881 return ("conflicting, duplicate router discovery"
882 " parameters");
883
884 }
885
886 if (new->parm_d_metric != 0
887 && parmp->parm_d_metric != 0
888 && new->parm_d_metric != parmp->parm_d_metric) {
889 return ("conflicting, duplicate poor man's router"
890 " discovery or fake default metric");
891 }
892 }
893
894 /* link new entry on the so that when the entries are scanned,
895 * they affect the result in the order the operator specified.
896 */
897 parmp = (struct parm*)rtmalloc(sizeof(*parmp), "check_parms");
898 memcpy(parmp, new, sizeof(*parmp));
899 *parmpp = parmp;
900
901 return 0;
902 }
903
904
905 /* get a network number as a name or a number, with an optional "/xx"
906 * netmask.
907 */
908 int /* 0=bad */
909 getnet(char *name,
910 naddr *netp, /* network in host byte order */
911 naddr *maskp) /* masks are always in host order */
912 {
913 int i;
914 struct netent *np;
915 naddr mask; /* in host byte order */
916 struct in_addr in; /* a network and so host byte order */
917 char hname[MAXHOSTNAMELEN+1];
918 char *mname, *p;
919
920
921 /* Detect and separate "1.2.3.4/24"
922 */
923 if (NULL != (mname = strrchr(name,'/'))) {
924 i = (int)(mname - name);
925 if (i > (int)sizeof(hname)-1) /* name too long */
926 return 0;
927 memmove(hname, name, i);
928 hname[i] = '\0';
929 mname++;
930 name = hname;
931 }
932
933 np = getnetbyname(name);
934 if (np != NULL) {
935 in.s_addr = (naddr)np->n_net;
936 if (0 == (in.s_addr & 0xff000000))
937 in.s_addr <<= 8;
938 if (0 == (in.s_addr & 0xff000000))
939 in.s_addr <<= 8;
940 if (0 == (in.s_addr & 0xff000000))
941 in.s_addr <<= 8;
942 } else if (inet_aton(name, &in) == 1) {
943 in.s_addr = ntohl(in.s_addr);
944 } else if (!mname && !strcasecmp(name,"default")) {
945 in.s_addr = RIP_DEFAULT;
946 } else {
947 return 0;
948 }
949
950 if (!mname) {
951 /* we cannot use the interfaces here because we have not
952 * looked at them yet.
953 */
954 mask = std_mask(htonl(in.s_addr));
955 if ((~mask & in.s_addr) != 0)
956 mask = HOST_MASK;
957 } else {
958 mask = (naddr)strtoul(mname, &p, 0);
959 if (*p != '\0' || mask > 32)
960 return 0;
961 if (mask != 0)
962 mask = HOST_MASK << (32-mask);
963 }
964
965 /* must have mask of 0 with default */
966 if (mask != 0 && in.s_addr == RIP_DEFAULT)
967 return 0;
968 /* no host bits allowed in a network number */
969 if ((~mask & in.s_addr) != 0)
970 return 0;
971 /* require non-zero network number */
972 if ((mask & in.s_addr) == 0 && in.s_addr != RIP_DEFAULT)
973 return 0;
974 if (in.s_addr>>24 == 0 && in.s_addr != RIP_DEFAULT)
975 return 0;
976 if (in.s_addr>>24 == 0xff)
977 return 0;
978
979 *netp = in.s_addr;
980 *maskp = mask;
981 return 1;
982 }
983
984
985 int /* 0=bad */
986 gethost(char *name,
987 naddr *addrp)
988 {
989 struct hostent *hp;
990 struct in_addr in;
991
992
993 /* Try for a number first, even in IRIX where gethostbyname()
994 * is smart. This avoids hitting the name server which
995 * might be sick because routing is.
996 */
997 if (inet_aton(name, &in) == 1) {
998 /* get a good number, but check that it it makes some
999 * sense.
1000 */
1001 if (ntohl(in.s_addr)>>24 == 0
1002 || ntohl(in.s_addr)>>24 == 0xff)
1003 return 0;
1004 *addrp = in.s_addr;
1005 return 1;
1006 }
1007
1008 hp = gethostbyname(name);
1009 if (hp) {
1010 memcpy(addrp, hp->h_addr, sizeof(*addrp));
1011 return 1;
1012 }
1013
1014 return 0;
1015 }
DragonFly BSD