2 * Copyright (c) 1983, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
29 * @(#)if.c 8.1 (Berkeley) 6/5/93
30 * $FreeBSD: src/sbin/routed/parms.c,v 1.7.2.1 2000/08/14 17:00:03 sheldonh Exp $
34 #include "pathnames.h"
38 struct intnet
*intnets
;
43 /* use configured parameters
46 get_parms(struct interface
*ifp
)
48 static int warned_auth_in
, warned_auth_out
;
50 int i
, num_passwds
= 0;
52 /* get all relevant parameters
54 for (parmp
= parms
; parmp
!= NULL
; parmp
= parmp
->parm_next
) {
55 if (parmp
->parm_name
[0] == '\0'
56 || !strcmp(ifp
->int_name
, parmp
->parm_name
)
57 || (parmp
->parm_name
[0] == '\n'
58 && on_net(ifp
->int_addr
,
59 parmp
->parm_net
, parmp
->parm_mask
))) {
61 /* This group of parameters is relevant,
64 ifp
->int_state
|= parmp
->parm_int_state
;
65 for (i
= 0; i
< MAX_AUTH_KEYS
; i
++) {
66 if (parmp
->parm_auth
[0].type
== RIP_AUTH_NONE
67 || num_passwds
>= MAX_AUTH_KEYS
)
69 memcpy(&ifp
->int_auth
[num_passwds
++],
71 sizeof(ifp
->int_auth
[0]));
73 if (parmp
->parm_rdisc_pref
!= 0)
74 ifp
->int_rdisc_pref
= parmp
->parm_rdisc_pref
;
75 if (parmp
->parm_rdisc_int
!= 0)
76 ifp
->int_rdisc_int
= parmp
->parm_rdisc_int
;
77 if (parmp
->parm_d_metric
!= 0)
78 ifp
->int_d_metric
= parmp
->parm_d_metric
;
82 /* Set general defaults.
84 * Default poor-man's router discovery to a metric that will
85 * be heard by old versions of `routed`. They ignored received
86 * routes with metric 15.
88 if ((ifp
->int_state
& IS_PM_RDISC
)
89 && ifp
->int_d_metric
== 0)
90 ifp
->int_d_metric
= FAKE_METRIC
;
92 if (ifp
->int_rdisc_int
== 0)
93 ifp
->int_rdisc_int
= DefMaxAdvertiseInterval
;
95 if (!(ifp
->int_if_flags
& IFF_MULTICAST
)
96 && !(ifp
->int_state
& IS_REMOTE
))
97 ifp
->int_state
|= IS_BCAST_RDISC
;
99 if (ifp
->int_if_flags
& IFF_POINTOPOINT
) {
100 ifp
->int_state
|= IS_BCAST_RDISC
;
101 /* By default, point-to-point links should be passive
102 * about router-discovery for the sake of demand-dialing.
104 if (0 == (ifp
->int_state
& GROUP_IS_SOL_OUT
))
105 ifp
->int_state
|= IS_NO_SOL_OUT
;
106 if (0 == (ifp
->int_state
& GROUP_IS_ADV_OUT
))
107 ifp
->int_state
|= IS_NO_ADV_OUT
;
110 if (0 != (ifp
->int_state
& (IS_PASSIVE
| IS_REMOTE
)))
111 ifp
->int_state
|= IS_NO_RDISC
;
112 if (ifp
->int_state
& IS_PASSIVE
)
113 ifp
->int_state
|= IS_NO_RIP
;
115 if (!IS_RIP_IN_OFF(ifp
->int_state
)
116 && ifp
->int_auth
[0].type
!= RIP_AUTH_NONE
117 && !(ifp
->int_state
& IS_NO_RIPV1_IN
)
118 && !warned_auth_in
) {
119 msglog("Warning: RIPv1 input via %s"
120 " will be accepted without authentication",
124 if (!IS_RIP_OUT_OFF(ifp
->int_state
)
125 && ifp
->int_auth
[0].type
!= RIP_AUTH_NONE
126 && !(ifp
->int_state
& IS_NO_RIPV1_OUT
)) {
127 if (!warned_auth_out
) {
128 msglog("Warning: RIPv1 output via %s"
129 " will be sent without authentication",
137 /* Read a list of gateways from /etc/gateways and add them to our tables.
139 * This file contains a list of "remote" gateways. That is usually
140 * a gateway which we cannot immediately determine if it is present or
141 * not as we can do for those provided by directly connected hardware.
143 * If a gateway is marked "passive" in the file, then we assume it
144 * does not understand RIP and assume it is always present. Those
145 * not marked passive are treated as if they were directly connected
146 * and assumed to be broken if they do not send us advertisements.
147 * All remote interfaces are added to our list, and those not marked
148 * passive are sent routing updates.
150 * A passive interface can also be local, hardware interface exempt
159 char lbuf
[200], net_host
[5], dname
[64+1+64+1];
160 char gname
[GNAME_LEN
+1], qual
[9];
161 struct interface
*ifp
;
162 naddr dst
, netmask
, gate
;
169 fp
= fopen(_PATH_GATEWAYS
, "r");
173 if (0 > fstat(fileno(fp
), &sb
)) {
174 msglog("could not stat() "_PATH_GATEWAYS
);
179 for (lnum
= 1; ; lnum
++) {
180 if (0 == fgets(lbuf
, sizeof(lbuf
), fp
))
185 p
= lptr
+strlen(lptr
)-1;
187 || (*p
== ' ' && (p
== lptr
+1 || *(p
-1) != '\\')))
189 if (*lptr
== '\0' /* ignore null and comment lines */
193 /* notice newfangled parameter lines
195 if (strncasecmp("net", lptr
, 3)
196 && strncasecmp("host", lptr
, 4)) {
197 cp
= parse_parms(lptr
,
199 && !(sb
.st_mode
&(S_IRWXG
|S_IRWXO
))));
201 msglog("%s in line %d of "_PATH_GATEWAYS
,
206 /* {net | host} XX[/M] XX gateway XX metric DD [passive | external]\n */
208 /* the '64' here must be GNAME_LEN */
209 n
= sscanf(lptr
, "%4s %129[^ \t] gateway"
210 " %64[^ / \t] metric %u %8s\n",
211 net_host
, dname
, gname
, &metric
, qual
);
212 if (n
!= 4 && n
!= 5) {
213 msglog("bad "_PATH_GATEWAYS
" entry \"%s\"; %d values",
217 if (metric
>= HOPCNT_INFINITY
) {
218 msglog("bad metric in "_PATH_GATEWAYS
" entry \"%s\"",
222 if (!strcasecmp(net_host
, "host")) {
223 if (!gethost(dname
, &dst
)) {
224 msglog("bad host \"%s\" in "_PATH_GATEWAYS
225 " entry \"%s\"", dname
, lptr
);
229 } else if (!strcasecmp(net_host
, "net")) {
230 if (!getnet(dname
, &dst
, &netmask
)) {
231 msglog("bad net \"%s\" in "_PATH_GATEWAYS
232 " entry \"%s\"", dname
, lptr
);
235 if (dst
== RIP_DEFAULT
) {
236 msglog("bad net \"%s\" in "_PATH_GATEWAYS
237 " entry \"%s\"--cannot be default",
241 dst
= htonl(dst
); /* make network # into IP address */
243 msglog("bad \"%s\" in "_PATH_GATEWAYS
244 " entry \"%s\"", net_host
, lptr
);
248 if (!gethost(gname
, &gate
)) {
249 msglog("bad gateway \"%s\" in "_PATH_GATEWAYS
250 " entry \"%s\"", gname
, lptr
);
254 if (!strcasecmp(qual
, type
= "passive")) {
255 /* Passive entries are not placed in our tables,
256 * only the kernel's, so we don't copy all of the
257 * external routing information within a net.
258 * Internal machines should use the default
259 * route to a suitable gateway (like us).
261 state
= IS_REMOTE
| IS_PASSIVE
;
265 } else if (!strcasecmp(qual
, type
= "external")) {
266 /* External entries are handled by other means
267 * such as EGP, and are placed only in the daemon
268 * tables to prevent overriding them with something
271 strcpy(qual
,"external");
272 state
= IS_REMOTE
| IS_PASSIVE
| IS_EXTERNAL
;
276 } else if (!strcasecmp(qual
, "active")
277 || qual
[0] == '\0') {
279 /* Entries that are neither "passive" nor
280 * "external" are "remote" and must behave
281 * like physical interfaces. If they are not
282 * heard from regularly, they are deleted.
287 /* "remote" entries with a metric of 0
288 * are aliases for our own interfaces
290 state
= IS_REMOTE
| IS_PASSIVE
| IS_ALIAS
;
295 msglog("bad "_PATH_GATEWAYS
" entry \"%s\";"
296 " unknown type %s", lptr
, qual
);
300 if (0 != (state
& (IS_PASSIVE
| IS_REMOTE
)))
301 state
|= IS_NO_RDISC
;
302 if (state
& IS_PASSIVE
)
305 ifp
= check_dup(gate
,dst
,netmask
,0);
307 msglog("duplicate "_PATH_GATEWAYS
" entry \"%s\"",lptr
);
311 ifp
= (struct interface
*)rtmalloc(sizeof(*ifp
), "gwkludge()");
312 memset(ifp
, 0, sizeof(*ifp
));
314 ifp
->int_state
= state
;
315 if (netmask
== HOST_MASK
)
316 ifp
->int_if_flags
= IFF_POINTOPOINT
| IFF_UP
;
318 ifp
->int_if_flags
= IFF_UP
;
319 ifp
->int_act_time
= NEVER
;
320 ifp
->int_addr
= gate
;
321 ifp
->int_dstaddr
= dst
;
322 ifp
->int_mask
= netmask
;
323 ifp
->int_ripv1_mask
= netmask
;
324 ifp
->int_std_mask
= std_mask(gate
);
325 ifp
->int_net
= ntohl(dst
);
326 ifp
->int_std_net
= ifp
->int_net
& ifp
->int_std_mask
;
327 ifp
->int_std_addr
= htonl(ifp
->int_std_net
);
328 ifp
->int_metric
= metric
;
329 if (!(state
& IS_EXTERNAL
)
330 && ifp
->int_mask
!= ifp
->int_std_mask
)
331 ifp
->int_state
|= IS_SUBNET
;
332 sprintf(ifp
->int_name
, "%s(%s)", type
, gname
);
338 /* After all of the parameter lines have been read,
339 * apply them to any remote interfaces.
341 for (ifp
= ifnet
; NULL
!= ifp
; ifp
= ifp
->int_next
) {
345 if (!IS_RIP_OFF(ifp
->int_state
))
348 trace_if("Add", ifp
);
355 /* like strtok(), but honoring backslash and not changing the source string
357 static int /* 0=ok, -1=bad */
358 parse_quote(char **linep
, /* look here */
359 const char *delims
, /* for these delimiters */
360 char *delimp
, /* 0 or put found delimiter here */
361 char *buf
, /* copy token to here */
362 int lim
) /* at most this many bytes */
377 if (c
== '\\' && *pc
!= '\0') {
378 if ((c
= *pc
++) == 'n') {
380 } else if (c
== 'r') {
382 } else if (c
== 't') {
384 } else if (c
== 'b') {
386 } else if (c
>= '0' && c
<= '7') {
388 if (*pc
>= '0' && *pc
<= '7') {
389 c
= (c
<<3)+(*pc
++ - '0');
390 if (*pc
>= '0' && *pc
<= '7')
391 c
= (c
<<3)+(*pc
++ - '0');
396 for (p
= delims
; *p
!= '\0'; ++p
) {
409 *buf
= '\0'; /* terminate copy of token */
411 *delimp
= c
; /* return delimiter */
412 *linep
= pc
-1; /* say where we ended */
417 /* Parse password timestamp
428 #if defined(__NetBSD__)
432 if (0 > parse_quote(valp
, "| ,\n\r", delimp
,
434 || buf
[bufsize
-1] != '\0'
435 || buf
[bufsize
-2] != '\0') {
436 sprintf(buf
,"bad timestamp %.25s", val0
);
440 memset(&tm
, 0, sizeof(tm
));
441 #if defined(__NetBSD__)
442 ptr
= strptime(buf
, "%y/%m/%d@%H:%M\n", &tm
);
443 if (ptr
== NULL
|| *ptr
!= '\0') {
444 sprintf(buf
,"bad timestamp %.25s", val0
);
448 if (5 != sscanf(buf
, "%u/%u/%u@%u:%u\n",
449 &tm
.tm_year
, &tm
.tm_mon
, &tm
.tm_mday
,
450 &tm
.tm_hour
, &tm
.tm_min
)
451 || tm
.tm_mon
< 1 || tm
.tm_mon
> 12
452 || tm
.tm_mday
< 1 || tm
.tm_mday
> 31) {
453 sprintf(buf
,"bad timestamp %.25s", val0
);
457 if (tm
.tm_year
<= 37) /* assume small years are in the */
458 tm
.tm_year
+= 100; /* 3rd millenium */
461 if ((*tp
= mktime(&tm
)) == -1) {
462 sprintf(buf
,"bad timestamp %.25s", val0
);
470 /* Get a password, key ID, and expiration date in the format
471 * passwd|keyID|year/mon/day@hour:min|year/mon/day@hour:min
473 static const char * /* 0 or error message */
474 get_passwd(char *tgt
,
478 int safe
) /* 1=from secure file */
481 char *val0
, *p
, delim
;
482 struct auth k
, *ap
, *ap2
;
488 return "ignore unsafe password";
490 for (ap
= parmp
->parm_auth
, i
= 0;
491 ap
->type
!= RIP_AUTH_NONE
; i
++, ap
++) {
492 if (i
>= MAX_AUTH_KEYS
)
493 return "too many passwords";
496 memset(&k
, 0, sizeof(k
));
501 if (0 > parse_quote(&val
, "| ,\n\r", &delim
,
502 (char *)k
.key
, sizeof(k
.key
)))
506 if (type
== RIP_AUTH_MD5
)
507 return "missing Keyid";
510 buf
[sizeof(buf
)-1] = '\0';
511 if (0 > parse_quote(&val
, "| ,\n\r", &delim
, buf
,sizeof(buf
))
512 || buf
[sizeof(buf
)-1] != '\0'
513 || (l
= strtoul(buf
,&p
,0)) > 255
515 sprintf(buf
,"bad KeyID \"%.20s\"", val0
);
518 for (ap2
= parmp
->parm_auth
; ap2
< ap
; ap2
++) {
519 if (ap2
->keyid
== l
) {
520 sprintf(buf
,"duplicate KeyID \"%.20s\"", val0
);
528 if (NULL
!= (p
= parse_ts(&k
.start
,&val
,val0
,&delim
,
532 return "missing second timestamp";
534 if (NULL
!= (p
= parse_ts(&k
.end
,&val
,val0
,&delim
,
537 if ((u_long
)k
.start
> (u_long
)k
.end
) {
538 sprintf(buf
,"out of order timestamp %.30s",
547 memmove(ap
, &k
, sizeof(*ap
));
553 bad_str(const char *estr
)
555 static char buf
[100+8];
557 sprintf(buf
, "bad \"%.100s\"", estr
);
562 /* Parse a set of parameters for an interface.
564 const char * /* 0 or error message */
565 parse_parms(char *line
,
566 int safe
) /* 1=from secure file */
568 #define PARS(str) (!strcasecmp(tgt, str))
569 #define PARSEQ(str) (!strncasecmp(tgt, str"=", sizeof(str)))
570 #define CKF(g,b) {if (0 != (parm.parm_int_state & ((g) & ~(b)))) break; \
571 parm.parm_int_state |= (b);}
573 struct intnet
*intnetp
;
574 struct r1net
*r1netp
;
577 char delim
, *val0
= NULL
, *tgt
, *val
, *p
;
579 char buf
[BUFSIZ
], buf2
[BUFSIZ
];
583 /* "subnet=x.y.z.u/mask[,metric]" must be alone on the line */
584 if (!strncasecmp(line
, "subnet=", sizeof("subnet=")-1)
585 && *(val
= &line
[sizeof("subnet=")-1]) != '\0') {
586 if (0 > parse_quote(&val
, ",", &delim
, buf
, sizeof(buf
)))
587 return bad_str(line
);
588 intnetp
= (struct intnet
*)rtmalloc(sizeof(*intnetp
),
589 "parse_parms subnet");
590 intnetp
->intnet_metric
= 1;
592 intnetp
->intnet_metric
= (int)strtol(val
+1,&p
,0);
594 || intnetp
->intnet_metric
<= 0
595 || intnetp
->intnet_metric
>= HOPCNT_INFINITY
)
596 return bad_str(line
);
598 if (!getnet(buf
, &intnetp
->intnet_addr
, &intnetp
->intnet_mask
)
599 || intnetp
->intnet_mask
== HOST_MASK
600 || intnetp
->intnet_addr
== RIP_DEFAULT
) {
602 return bad_str(line
);
604 intnetp
->intnet_addr
= htonl(intnetp
->intnet_addr
);
605 intnetp
->intnet_next
= intnets
;
610 /* "ripv1_mask=x.y.z.u/mask1,mask2" must be alone on the line.
611 * This requires that x.y.z.u/mask1 be considered a subnet of
612 * x.y.z.u/mask2, as if x.y.z.u/mask2 were a class-full network.
614 if (!strncasecmp(line
, "ripv1_mask=", sizeof("ripv1_mask=")-1)
615 && *(val
= &line
[sizeof("ripv1_mask=")-1]) != '\0') {
616 if (0 > parse_quote(&val
, ",", &delim
, buf
, sizeof(buf
))
618 return bad_str(line
);
619 if ((i
= (int)strtol(val
+1, &p
, 0)) <= 0
620 || i
> 32 || *p
!= '\0')
621 return bad_str(line
);
622 r1netp
= (struct r1net
*)rtmalloc(sizeof(*r1netp
),
623 "parse_parms ripv1_mask");
624 r1netp
->r1net_mask
= HOST_MASK
<< (32-i
);
625 if (!getnet(buf
, &r1netp
->r1net_net
, &r1netp
->r1net_match
)
626 || r1netp
->r1net_net
== RIP_DEFAULT
627 || r1netp
->r1net_mask
> r1netp
->r1net_match
) {
629 return bad_str(line
);
631 r1netp
->r1net_next
= r1nets
;
636 memset(&parm
, 0, sizeof(parm
));
639 tgt
= line
+ strspn(line
, " ,\n\r");
640 if (*tgt
== '\0' || *tgt
== '#')
642 line
= tgt
+strcspn(tgt
, "= #,\n\r");
646 if (0 > parse_quote(&line
, " #,\n\r",&delim
,
657 || (delim
= *line
) != ' ')
663 if (parm
.parm_name
[0] != '\0'
664 || strlen(buf
) > IF_NAME_LEN
)
666 strcpy(parm
.parm_name
, buf
);
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
675 if (!getnet(val0
, &addr
, &mask
)
676 || parm
.parm_name
[0] != '\0')
678 parm
.parm_net
= addr
;
679 parm
.parm_mask
= mask
;
680 parm
.parm_name
[0] = '\n';
682 } else if (PARSEQ("passwd")) {
683 /* since cleartext passwords are so weak allow
686 msg
= get_passwd(tgt
,val0
,&parm
,RIP_AUTH_PW
,1);
692 } else if (PARSEQ("md5_passwd")) {
693 msg
= get_passwd(tgt
,val0
,&parm
,RIP_AUTH_MD5
,safe
);
699 } else if (PARS("no_ag")) {
700 parm
.parm_int_state
|= (IS_NO_AG
| IS_NO_SUPER_AG
);
702 } else if (PARS("no_super_ag")) {
703 parm
.parm_int_state
|= IS_NO_SUPER_AG
;
705 } else if (PARS("no_ripv1_in")) {
706 parm
.parm_int_state
|= IS_NO_RIPV1_IN
;
708 } else if (PARS("no_ripv2_in")) {
709 parm
.parm_int_state
|= IS_NO_RIPV2_IN
;
711 } else if (PARS("ripv2_out")) {
712 if (parm
.parm_int_state
& IS_NO_RIPV2_OUT
)
714 parm
.parm_int_state
|= IS_NO_RIPV1_OUT
;
716 } else if (PARS("ripv2")) {
717 if ((parm
.parm_int_state
& IS_NO_RIPV2_OUT
)
718 || (parm
.parm_int_state
& IS_NO_RIPV2_IN
))
720 parm
.parm_int_state
|= (IS_NO_RIPV1_IN
723 } else if (PARS("no_rip")) {
724 CKF(IS_PM_RDISC
, IS_NO_RIP
);
726 } else if (PARS("no_rip_mcast")) {
727 parm
.parm_int_state
|= IS_NO_RIP_MCAST
;
729 } else if (PARS("no_rdisc")) {
730 CKF((GROUP_IS_SOL_OUT
|GROUP_IS_ADV_OUT
), IS_NO_RDISC
);
732 } else if (PARS("no_solicit")) {
733 CKF(GROUP_IS_SOL_OUT
, IS_NO_SOL_OUT
);
735 } else if (PARS("send_solicit")) {
736 CKF(GROUP_IS_SOL_OUT
, IS_SOL_OUT
);
738 } else if (PARS("no_rdisc_adv")) {
739 CKF(GROUP_IS_ADV_OUT
, IS_NO_ADV_OUT
);
741 } else if (PARS("rdisc_adv")) {
742 CKF(GROUP_IS_ADV_OUT
, IS_ADV_OUT
);
744 } else if (PARS("bcast_rdisc")) {
745 parm
.parm_int_state
|= IS_BCAST_RDISC
;
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
;
751 } else if (PARSEQ("rdisc_pref")) {
752 if (parm
.parm_rdisc_pref
!= 0
753 || (parm
.parm_rdisc_pref
= (int)strtol(buf
,&p
,0),
757 } else if (PARS("pm_rdisc")) {
758 if (IS_RIP_OUT_OFF(parm
.parm_int_state
))
760 parm
.parm_int_state
|= IS_PM_RDISC
;
762 } else if (PARSEQ("rdisc_interval")) {
763 if (parm
.parm_rdisc_int
!= 0
764 || (parm
.parm_rdisc_int
= (int)strtoul(buf
,&p
,0),
766 || parm
.parm_rdisc_int
< MinMaxAdvertiseInterval
767 || parm
.parm_rdisc_int
> MaxMaxAdvertiseInterval
)
770 } else if (PARSEQ("fake_default")) {
771 if (parm
.parm_d_metric
!= 0
772 || IS_RIP_OUT_OFF(parm
.parm_int_state
)
773 || (parm
.parm_d_metric
= (int)strtoul(buf
,&p
,0),
775 || parm
.parm_d_metric
> HOPCNT_INFINITY
-1)
778 } else if (PARSEQ("trust_gateway")) {
779 /* look for trust_gateway=x.y.z|net/mask|...) */
781 if (0 > parse_quote(&p
, "|", &delim
,
783 || !gethost(buf2
,&addr
))
785 tg
= (struct tgate
*)rtmalloc(sizeof(*tg
),
788 memset(tg
, 0, sizeof(*tg
));
789 tg
->tgate_addr
= addr
;
791 /* The default is to trust all routes. */
792 while (delim
== '|') {
794 if (i
>= MAX_TGATE_NETS
795 || 0 > parse_quote(&p
, "|", &delim
,
797 || !getnet(buf2
, &tg
->tgate_nets
[i
].net
,
798 &tg
->tgate_nets
[i
].mask
)
799 || tg
->tgate_nets
[i
].net
== RIP_DEFAULT
800 || tg
->tgate_nets
[i
].mask
== 0)
804 tg
->tgate_next
= tgates
;
806 parm
.parm_int_state
|= IS_DISTRUST
;
808 } else if (PARS("redirect_ok")) {
809 parm
.parm_int_state
|= IS_REDIRECT_OK
;
812 return bad_str(tgt
); /* error */
816 return check_parms(&parm
);
822 /* check for duplicate parameter specifications */
823 const char * /* 0 or error message */
824 check_parms(struct parm
*new)
826 struct parm
*parmp
, **parmpp
;
829 /* set implicit values
831 if (new->parm_int_state
& IS_NO_ADV_IN
)
832 new->parm_int_state
|= IS_NO_SOL_OUT
;
833 if (new->parm_int_state
& IS_NO_SOL_OUT
)
834 new->parm_int_state
|= IS_NO_ADV_IN
;
836 for (i
= num_passwds
= 0; i
< MAX_AUTH_KEYS
; i
++) {
837 if (new->parm_auth
[i
].type
!= RIP_AUTH_NONE
)
841 /* compare with existing sets of parameters
843 for (parmpp
= &parms
;
844 (parmp
= *parmpp
) != NULL
;
845 parmpp
= &parmp
->parm_next
) {
846 if (strcmp(new->parm_name
, parmp
->parm_name
))
848 if (!on_net(htonl(parmp
->parm_net
),
849 new->parm_net
, new->parm_mask
)
850 && !on_net(htonl(new->parm_net
),
851 parmp
->parm_net
, parmp
->parm_mask
))
854 for (i
= 0; i
< MAX_AUTH_KEYS
; i
++) {
855 if (parmp
->parm_auth
[i
].type
!= RIP_AUTH_NONE
)
858 if (num_passwds
> MAX_AUTH_KEYS
)
859 return "too many conflicting passwords";
861 if ((0 != (new->parm_int_state
& GROUP_IS_SOL_OUT
)
862 && 0 != (parmp
->parm_int_state
& GROUP_IS_SOL_OUT
)
863 && 0 != ((new->parm_int_state
^ parmp
->parm_int_state
)
865 || (0 != (new->parm_int_state
& GROUP_IS_ADV_OUT
)
866 && 0 != (parmp
->parm_int_state
& GROUP_IS_ADV_OUT
)
867 && 0 != ((new->parm_int_state
^ parmp
->parm_int_state
)
869 || (new->parm_rdisc_pref
!= 0
870 && parmp
->parm_rdisc_pref
!= 0
871 && new->parm_rdisc_pref
!= parmp
->parm_rdisc_pref
)
872 || (new->parm_rdisc_int
!= 0
873 && parmp
->parm_rdisc_int
!= 0
874 && new->parm_rdisc_int
!= parmp
->parm_rdisc_int
)) {
875 return ("conflicting, duplicate router discovery"
880 if (new->parm_d_metric
!= 0
881 && parmp
->parm_d_metric
!= 0
882 && new->parm_d_metric
!= parmp
->parm_d_metric
) {
883 return ("conflicting, duplicate poor man's router"
884 " discovery or fake default metric");
888 /* link new entry on the so that when the entries are scanned,
889 * they affect the result in the order the operator specified.
891 parmp
= (struct parm
*)rtmalloc(sizeof(*parmp
), "check_parms");
892 memcpy(parmp
, new, sizeof(*parmp
));
899 /* get a network number as a name or a number, with an optional "/xx"
904 naddr
*netp
, /* network in host byte order */
905 naddr
*maskp
) /* masks are always in host order */
909 naddr mask
; /* in host byte order */
910 struct in_addr in
; /* a network and so host byte order */
911 char hname
[MAXHOSTNAMELEN
+1];
915 /* Detect and separate "1.2.3.4/24"
917 if (NULL
!= (mname
= strrchr(name
,'/'))) {
918 i
= (int)(mname
- name
);
919 if (i
> (int)sizeof(hname
)-1) /* name too long */
921 memmove(hname
, name
, i
);
927 np
= getnetbyname(name
);
929 in
.s_addr
= (naddr
)np
->n_net
;
930 if (0 == (in
.s_addr
& 0xff000000))
932 if (0 == (in
.s_addr
& 0xff000000))
934 if (0 == (in
.s_addr
& 0xff000000))
936 } else if (inet_aton(name
, &in
) == 1) {
937 in
.s_addr
= ntohl(in
.s_addr
);
938 } else if (!mname
&& !strcasecmp(name
,"default")) {
939 in
.s_addr
= RIP_DEFAULT
;
945 /* we cannot use the interfaces here because we have not
946 * looked at them yet.
948 mask
= std_mask(htonl(in
.s_addr
));
949 if ((~mask
& in
.s_addr
) != 0)
952 mask
= (naddr
)strtoul(mname
, &p
, 0);
953 if (*p
!= '\0' || mask
> 32)
956 mask
= HOST_MASK
<< (32-mask
);
959 /* must have mask of 0 with default */
960 if (mask
!= 0 && in
.s_addr
== RIP_DEFAULT
)
962 /* no host bits allowed in a network number */
963 if ((~mask
& in
.s_addr
) != 0)
965 /* require non-zero network number */
966 if ((mask
& in
.s_addr
) == 0 && in
.s_addr
!= RIP_DEFAULT
)
968 if (in
.s_addr
>>24 == 0 && in
.s_addr
!= RIP_DEFAULT
)
970 if (in
.s_addr
>>24 == 0xff)
987 /* Try for a number first, even in IRIX where gethostbyname()
988 * is smart. This avoids hitting the name server which
989 * might be sick because routing is.
991 if (inet_aton(name
, &in
) == 1) {
992 /* get a good number, but check that it it makes some
995 if (ntohl(in
.s_addr
)>>24 == 0
996 || ntohl(in
.s_addr
)>>24 == 0xff)
1002 hp
= gethostbyname(name
);
1004 memcpy(addrp
, hp
->h_addr
, sizeof(*addrp
));