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