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