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