/* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * * Copyright (c) 1983, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgment: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD: src/sbin/routed/parms.c,v 1.9 2000/08/11 08:24:38 sheldonh Exp $ */ #include "defs.h" #include "pathnames.h" #include #include #include #define PARMS_MAXLINELEN 500 static struct parm *parms; struct intnet *intnets; struct r1net *r1nets; struct tgate *tgates; static void addroutefordefault(in_addr_t, in_addr_t, in_addr_t, uint32_t, uint16_t); /* use configured parameters */ void get_parms(struct interface *ifp) { static boolean_t warned_auth_in, warned_auth_out; struct parm *parmp; int i, num_passwds = 0; if (ifp == NULL) return; /* get all relevant parameters */ for (parmp = parms; parmp != NULL; parmp = parmp->parm_next) { if (parmp->parm_name[0] == '\0' || strcmp(ifp->int_name, parmp->parm_name) == 0 || (parmp->parm_name[0] == '\n' && on_net(ifp->int_addr, parmp->parm_net, parmp->parm_mask))) { /* * This group of parameters is relevant, * so get its settings */ ifp->int_state |= parmp->parm_int_state; for (i = 0; i < MAX_AUTH_KEYS; i++) { if (parmp->parm_auth[i].type == RIP_AUTH_NONE || num_passwds >= MAX_AUTH_KEYS) break; ifp->int_auth[num_passwds++] = parmp->parm_auth[i]; } if (parmp->parm_rdisc_pref != 0) ifp->int_rdisc_pref = parmp->parm_rdisc_pref; if (parmp->parm_rdisc_int != 0) ifp->int_rdisc_int = parmp->parm_rdisc_int; if (parmp->parm_d_metric != 0) ifp->int_d_metric = parmp->parm_d_metric; if (parmp->parm_ripout_addr != 0) ifp->int_ripout_addr = parmp->parm_ripout_addr; } } /* * Set general defaults. * * Default poor-man's router discovery to a metric that will * be heard by old versions of `routed`. They ignored received * routes with metric 15. */ if ((ifp->int_state & IS_PM_RDISC) && ifp->int_d_metric == 0) ifp->int_d_metric = FAKE_METRIC; if (ifp->int_rdisc_int == 0) ifp->int_rdisc_int = DEF_MAXADVERTISEINTERVAL; if (!(ifp->int_if_flags & IFF_MULTICAST) && !(ifp->int_state & IS_REMOTE)) ifp->int_state |= IS_BCAST_RDISC; if (ifp->int_if_flags & IFF_POINTOPOINT) { ifp->int_state |= IS_BCAST_RDISC; /* * By default, point-to-point links should be passive * about router-discovery for the sake of demand-dialing. */ if (!(ifp->int_state & GROUP_IS_SOL_OUT)) ifp->int_state |= IS_NO_SOL_OUT; if (!(ifp->int_state & GROUP_IS_ADV_OUT)) ifp->int_state |= IS_NO_ADV_OUT; } if (0 != (ifp->int_state & (IS_PASSIVE | IS_REMOTE))) ifp->int_state |= IS_NO_RDISC; if (ifp->int_state & IS_PASSIVE) ifp->int_state |= IS_NO_RIP; if (!IS_RIP_IN_OFF(ifp->int_state) && ifp->int_auth[0].type != RIP_AUTH_NONE && !(ifp->int_state & IS_NO_RIPV1_IN) && !warned_auth_in) { writelog(LOG_WARNING, "RIPv1 input via %s" " will be accepted without authentication", ifp->int_name); warned_auth_in = _B_TRUE; } if (!IS_RIP_OUT_OFF(ifp->int_state) && ifp->int_auth[0].type != RIP_AUTH_NONE && !(ifp->int_state & IS_NO_RIPV1_OUT)) { if (!warned_auth_out) { writelog(LOG_WARNING, "RIPv1 output via %s" " will be sent without authentication", ifp->int_name); warned_auth_out = _B_TRUE; } } /* * If not overriden by the rip_neighbor option, set the * default address to which RIP packets will be sent on * this interface. */ if (ifp->int_ripout_addr == 0) { if (ifp->int_state & IS_REMOTE) { /* * By definition we always send RIP packets to * the address assigned to a remote interface. */ ifp->int_ripout_addr = ifp->int_addr; } else if ((ifp->int_state & IS_NO_RIPV1_OUT) && (ifp->int_if_flags & IFF_MULTICAST) && !(ifp->int_state & IS_NO_RIP_MCAST)) { /* * If the interface is being used for RIPv2 * and it supports multicast, and if the user * has not explicitely turned off multicast * RIP output, send to the all RIP routers * multicast address. */ ifp->int_ripout_addr = htonl(INADDR_RIP_GROUP); } else if (ifp->int_if_flags & IFF_POINTOPOINT) { /* * For point-to-point interfaces which don't * fall into the two categories above, just * send to the destination address of the * interface. */ ifp->int_ripout_addr = ifp->int_dstaddr; } else { /* Otherwise, use the broadcast address. */ ifp->int_ripout_addr = ifp->int_brdaddr; } } } /* * Read a list of gateways from /etc/gateways and add them to our tables. * * This file contains a list of "remote" gateways. That is usually * a gateway which we cannot immediately determine if it is present or * not as we can do for those provided by directly connected hardware. * * If a gateway is marked "passive" in the file, then we assume it * does not understand RIP and assume it is always present. Those * not marked passive are treated as if they were directly connected * and assumed to be broken if they do not send us advertisements. * All remote interfaces are added to our list, and those not marked * passive are sent routing updates. * * A passive interface can also be local, hardware interface exempt * from RIP. */ void gwkludge(void) { #define STR2(x) #x #define STR(x) STR2(x) #define NETHOST_LEN 4 #define DNAME_LEN MAXHOSTNAMELEN #define GNAME_LEN MAXHOSTNAMELEN #define QUAL_LEN 8 FILE *fp; char *p, *lptr; const char *cp; char lbuf[PARMS_MAXLINELEN], net_host[NETHOST_LEN + 1]; char dname[MAXHOSTNAMELEN + 1]; char gname[MAXHOSTNAMELEN + 1], qual[QUAL_LEN +1]; struct interface *ifp; uint32_t dst, netmask, gate; int n; uint32_t lnum; struct stat sb; uint32_t state, metric; boolean_t default_dst; fp = fopen(PATH_GATEWAYS, "r"); if (fp == NULL) return; if (0 > fstat(fileno(fp), &sb)) { msglog("fstat() failed: %s for "PATH_GATEWAYS, rip_strerror(errno)); (void) fclose(fp); return; } for (lnum = 1; ; lnum++) { if (NULL == fgets(lbuf, sizeof (lbuf), fp)) break; /* Eliminate the /n character at the end of the lbuf */ if (strlen(lbuf) > 0) lbuf[strlen(lbuf) - 1] = '\0'; /* Move lptr to the first non-space character */ for (lptr = lbuf; isspace(*lptr); lptr++) ; if (*lptr == '#' || *lptr == '\0') continue; /* Move p to the end of the line */ p = lptr + strlen(lptr) - 1; /* Skip all trailing spaces except escaped space */ while (p > lptr && (isspace(*p) && *(p-1) != '\\')) p--; /* truncate the line to remove trailing spaces */ *++p = '\0'; /* notice newfangled parameter lines */ if (strncasecmp("net", lptr, 3) != 0 && strncasecmp("host", lptr, 4) != 0) { cp = parse_parms(lptr, (sb.st_uid == 0 && !(sb.st_mode&(S_IRWXG|S_IRWXO)))); if (cp != 0) msglog("%s in line %u of "PATH_GATEWAYS, cp, lnum); continue; } /* * Processes lines of the follwoing format: * net|host [/mask] gateway metric * passive|active|extern */ qual[0] = '\0'; n = sscanf(lptr, "%"STR(NETHOST_LEN)"s %"STR(DNAME_LEN) "[^ \t] gateway %"STR(GNAME_LEN)"[^ / \t] metric %u %" STR(QUAL_LEN)"s\n", net_host, dname, gname, &metric, qual); if (n != 4 && n != 5) { msglog("bad "PATH_GATEWAYS" entry \"%s\"; %d values", lptr, n); continue; } if (metric >= HOPCNT_INFINITY) { msglog("bad metric in "PATH_GATEWAYS" entry \"%s\"", lptr); continue; } default_dst = _B_FALSE; if (strcasecmp(net_host, "host") == 0) { if (!gethost(dname, &dst)) { msglog("bad host \"%s\" in "PATH_GATEWAYS " entry \"%s\"", dname, lptr); continue; } netmask = HOST_MASK; } else if (strcasecmp(net_host, "net") == 0) { if (!getnet(dname, &dst, &netmask)) { msglog("bad net \"%s\" in "PATH_GATEWAYS " entry \"%s\"", dname, lptr); continue; } default_dst = (dst == RIP_DEFAULT); dst = htonl(dst); /* make network # into IP address */ } else { msglog("bad \"%s\" in "PATH_GATEWAYS " entry \"%s\"", net_host, lptr); continue; } if (!gethost(gname, &gate)) { msglog("bad gateway \"%s\" in "PATH_GATEWAYS " entry \"%s\"", gname, lptr); continue; } if (strcasecmp(qual, "passive") == 0) { /* * Passive entries are not placed in our tables, * only the kernel's, so we don't copy all of the * external routing information within a net. * Internal machines should use the default * route to a suitable gateway (like us). */ state = IS_REMOTE | IS_PASSIVE; if (metric == 0) metric = 1; } else if (strcasecmp(qual, "external") == 0) { /* * External entries are handled by other means * such as EGP, and are placed only in the daemon * tables to prevent overriding them with something * else. */ (void) strlcpy(qual, "external", sizeof (qual)); state = IS_REMOTE | IS_PASSIVE | IS_EXTERNAL; if (metric == 0) metric = 1; } else if (strcasecmp(qual, "active") == 0 || qual[0] == '\0') { if (default_dst) { msglog("bad net \"%s\" in "PATH_GATEWAYS " entry \"%s\"-- cannot be default", dname, lptr); continue; } if (metric != 0) { /* * Entries that are neither "passive" nor * "external" are "remote" and must behave * like physical interfaces. If they are not * heard from regularly, they are deleted. */ state = IS_REMOTE; } else { /* * "remote" entries with a metric of 0 * are aliases for our own interfaces */ state = IS_REMOTE | IS_PASSIVE | IS_ALIAS; } } else { msglog("bad "PATH_GATEWAYS" entry \"%s\";" " unknown type %s", lptr, qual); continue; } if (0 != (state & (IS_PASSIVE | IS_REMOTE))) state |= IS_NO_RDISC; if (state & IS_PASSIVE) state |= IS_NO_RIP; if (default_dst) { addroutefordefault(dst, gate, netmask, metric, ((state & IS_EXTERNAL)? RTS_EXTERNAL : 0)); continue; } ifp = check_dup(NULL, gate, dst, netmask, 0, _B_FALSE); if (ifp != NULL) { msglog("duplicate "PATH_GATEWAYS" entry \"%s\"", lptr); continue; } ifp = rtmalloc(sizeof (*ifp), "gwkludge()"); (void) memset(ifp, 0, sizeof (*ifp)); ifp->int_state = state; if (netmask == HOST_MASK) ifp->int_if_flags = IFF_POINTOPOINT | IFF_UP; else ifp->int_if_flags = IFF_UP; ifp->int_act_time = NEVER; ifp->int_addr = gate; ifp->int_dstaddr = dst; ifp->int_mask = netmask; ifp->int_ripv1_mask = netmask; ifp->int_std_mask = std_mask(gate); ifp->int_net = ntohl(dst); ifp->int_std_net = ifp->int_net & ifp->int_std_mask; ifp->int_std_addr = htonl(ifp->int_std_net); ifp->int_metric = metric; if (!(state & IS_EXTERNAL) && ifp->int_mask != ifp->int_std_mask) ifp->int_state |= IS_SUBNET; (void) snprintf(ifp->int_name, sizeof (ifp->int_name), "remote(%s)", gname); if_link(ifp, 0); } (void) fclose(fp); /* * After all of the parameter lines have been read, * apply them to any remote interfaces. */ for (ifp = ifnet; NULL != ifp; ifp = ifp->int_next) { get_parms(ifp); tot_interfaces++; if (!IS_RIP_OFF(ifp->int_state)) rip_interfaces++; if (!IS_RIP_OUT_OFF(ifp->int_state)) ripout_interfaces++; trace_if("Add", ifp); } } /* Parse password timestamp */ static char * parse_ts(time_t *tp, char **valp, char *val0, char *delimp, char *buf, uint_t bufsize) { struct tm tm; if (0 > parse_quote(valp, "| ,", delimp, buf, bufsize) || buf[bufsize-1] != '\0' || buf[bufsize-2] != '\0') { (void) snprintf(buf, bufsize, "bad timestamp %.25s", val0); return (buf); } (void) strlcat(buf, "\n", bufsize); (void) memset(&tm, 0, sizeof (tm)); if (5 != sscanf(buf, "%u/%u/%u@%u:%u\n", (unsigned *)&tm.tm_year, (unsigned *)&tm.tm_mon, (unsigned *)&tm.tm_mday, (unsigned *)&tm.tm_hour, (unsigned *)&tm.tm_min) || tm.tm_mon < 1 || tm.tm_mon > 12 || tm.tm_mday < 1 || tm.tm_mday > 31) { (void) snprintf(buf, bufsize, "bad timestamp %.25s", val0); return (buf); } tm.tm_mon--; /* assume small years are in the 3rd millenium */ if (tm.tm_year <= 37) tm.tm_year += 100; if (tm.tm_year >= 1900) tm.tm_year -= 1900; if ((*tp = mktime(&tm)) == -1) { (void) snprintf(buf, bufsize, "bad timestamp %.25s", val0); return (buf); } return (NULL); } /* * Get a password, key ID, and expiration date in the format * passwd|keyID|year/mon/day@hour:min|year/mon/day@hour:min * returns NULL or error message */ static const char * get_passwd(char *tgt, char *val, struct parm *parmp, uint16_t type, boolean_t safe) /* 1=from secure file */ { static char buf[80]; char *val0, *p, delim; struct auth k, *ap, *ap2; int i; ulong_t l; if (!safe) return ("ignore unsafe password"); for (ap = parmp->parm_auth, i = 0; ap->type != RIP_AUTH_NONE; i++, ap++) { if (i >= MAX_AUTH_KEYS) return ("too many passwords"); } (void) memset(&k, 0, sizeof (k)); k.type = type; k.end = -1-DAY; val0 = val; if (0 > parse_quote(&val, "| ,", &delim, (char *)k.key, sizeof (k.key))) return (tgt); if (delim != '|') { if (type == RIP_AUTH_MD5) return ("missing Keyid"); } else { val0 = ++val; buf[sizeof (buf)-1] = '\0'; if (0 > parse_quote(&val, "| ,", &delim, buf, sizeof (buf)) || buf[sizeof (buf) - 1] != '\0' || (l = strtoul(buf, &p, 0)) > 255 || p == buf || *p != '\0') { (void) snprintf(buf, sizeof (buf), "bad KeyID \"%.20s\"", val0); return (buf); } for (ap2 = parmp->parm_auth; ap2 < ap; ap2++) { if (ap2->keyid == l) { (void) snprintf(buf, sizeof (buf), "duplicate KeyID \"%.20s\"", val0); return (buf); } } k.keyid = (int)l; if (delim == '|') { val0 = ++val; if (NULL != (p = parse_ts(&k.start, &val, val0, &delim, buf, sizeof (buf)))) return (p); if (delim != '|') return ("missing second timestamp"); val0 = ++val; if (NULL != (p = parse_ts(&k.end, &val, val0, &delim, buf, sizeof (buf)))) return (p); if ((ulong_t)k.start > (ulong_t)k.end) { (void) snprintf(buf, sizeof (buf), "out of order timestamp %.30s", val0); return (buf); } } } if (delim != '\0') return (tgt); (void) memmove(ap, &k, sizeof (*ap)); return (NULL); } static const char * bad_str(const char *estr) { static char buf[100+8]; (void) snprintf(buf, sizeof (buf), "bad \"%.100s\"", estr); return (buf); } /* * Parse a set of parameters for an interface. * returns NULL or error message */ const char * parse_parms(char *line, boolean_t safe) /* 1=from secure file */ { #define PARS(str) (strcasecmp(tgt, str) == 0) #define PARSEQ(str) (strncasecmp(tgt, str"=", sizeof (str)) == 0) /* * This macro checks for conflicting configurations options * For eg one can set either the IS_NO_SOL_OUT flag bit or the IS_SOL_OUT flag * bit, but not both. */ #define CKF(g, b) {if (0 != (parm.parm_int_state & ((g) & ~(b)))) break; \ parm.parm_int_state |= (b); } struct parm parm; struct intnet *intnetp; struct r1net *r1netp; struct tgate *tg; uint32_t addr, mask; char delim, *val0 = 0, *tgt, *val, *p; const char *msg; char buf[PARMS_MAXLINELEN], buf2[PARMS_MAXLINELEN]; int i; /* "subnet=x.y.z.u/mask[,metric]" must be alone on the line */ if (strncasecmp(line, "subnet=", sizeof ("subnet=") - 1) == 0 && *(val = &line[sizeof ("subnet=") -1 ]) != '\0') { if (0 > parse_quote(&val, ",", &delim, buf, sizeof (buf))) return (bad_str(line)); intnetp = rtmalloc(sizeof (*intnetp), "parse_parms subnet"); intnetp->intnet_metric = 1; if (delim == ',') { intnetp->intnet_metric = (int)strtol(val+1, &p, 0); if (*p != '\0' || intnetp->intnet_metric <= 0 || val+1 == p || intnetp->intnet_metric >= HOPCNT_INFINITY) { free(intnetp); return (bad_str(line)); } } if (!getnet(buf, &intnetp->intnet_addr, &intnetp->intnet_mask) || intnetp->intnet_mask == HOST_MASK || intnetp->intnet_addr == RIP_DEFAULT) { free(intnetp); return (bad_str(line)); } intnetp->intnet_addr = htonl(intnetp->intnet_addr); intnetp->intnet_next = intnets; intnets = intnetp; return (NULL); } /* * "ripv1_mask=x.y.z.u/mask1,mask2" must be alone on the line. * This requires that x.y.z.u/mask1 be considered a subnet of * x.y.z.u/mask2, as if x.y.z.u/mask2 were a class-full network. */ if (!strncasecmp(line, "ripv1_mask=", sizeof ("ripv1_mask=") - 1) && *(val = &line[sizeof ("ripv1_mask=")-1]) != '\0') { if (0 > parse_quote(&val, ",", &delim, buf, sizeof (buf)) || delim == '\0') return (bad_str(line)); if ((i = (int)strtol(val+1, &p, 0)) <= 0 || i > 32 || *p != '\0') return (bad_str(line)); r1netp = rtmalloc(sizeof (*r1netp), "parse_parms ripv1_mask"); r1netp->r1net_mask = HOST_MASK << (32-i); if (!getnet(buf, &r1netp->r1net_net, &r1netp->r1net_match) || r1netp->r1net_net == RIP_DEFAULT || r1netp->r1net_mask > r1netp->r1net_match) { free(r1netp); return (bad_str(line)); } r1netp->r1net_next = r1nets; r1nets = r1netp; return (NULL); } (void) memset(&parm, 0, sizeof (parm)); /* * Support of the following for Solaris backward compatibility * norip * noripin * noripout */ if (strncasecmp("norip", line, 5) == 0) { char cmd[64], ifname[64]; int n; n = sscanf(line, "%63s %63s\n", cmd, ifname); if (n != 2) { /* Not enough parameters */ return (bad_str(line)); } /* * Get the interface name and turn on the appropriate * interface flags */ (void) strlcpy(parm.parm_name, ifname, sizeof (parm.parm_name)); if (strcasecmp("norip", cmd) == 0) { parm.parm_int_state |= IS_NO_RIP; } else if (strcasecmp("noripin", cmd) == 0) { parm.parm_int_state |= IS_NO_RIP_IN; } else if (strcasecmp("noripout", cmd) == 0) { parm.parm_int_state |= IS_NO_RIP_OUT; } else { /* Bad command */ return (bad_str(line)); } /* * Look for duplication, and if new, * link to the rest of the parm entries. */ return (insert_parm(&parm)); } for (;;) { tgt = line + strspn(line, " ,\n\r"); if (*tgt == '\0' || *tgt == '#') break; line = tgt+strcspn(tgt, "= #,\n\r"); delim = *line; if (delim == '=') { val0 = ++line; if (0 > parse_quote(&line, " #,", &delim, buf, sizeof (buf))) return (bad_str(tgt)); } if (delim != '\0') { for (;;) { *line = '\0'; if (delim == '#') break; ++line; if (!isspace(delim) || ((delim = *line), !isspace(delim))) break; } } if (PARSEQ("if")) { if (parm.parm_name[0] != '\0' || strlen(buf) > IF_NAME_LEN) return (bad_str(tgt)); (void) strlcpy(parm.parm_name, buf, sizeof (parm.parm_name)); } else if (PARSEQ("addr")) { /* * This is a bad idea, because the address based * sets of parameters cannot be checked for * consistency with the interface name parameters. * The parm_net stuff is needed to allow several * -F settings. */ if (!getnet(val0, &addr, &mask) || parm.parm_name[0] != '\0') return (bad_str(tgt)); parm.parm_net = addr; parm.parm_mask = mask; parm.parm_name[0] = '\n'; } else if (PARSEQ("passwd")) { /* * since cleartext passwords are so weak allow * them anywhere */ msg = get_passwd(tgt, val0, &parm, RIP_AUTH_PW, 1); if (msg) { *val0 = '\0'; return (bad_str(msg)); } } else if (PARSEQ("md5_passwd")) { msg = get_passwd(tgt, val0, &parm, RIP_AUTH_MD5, safe); if (msg) { *val0 = '\0'; return (bad_str(msg)); } } else if (PARS("no_ag")) { parm.parm_int_state |= (IS_NO_AG | IS_NO_SUPER_AG); } else if (PARS("no_host")) { parm.parm_int_state |= IS_NO_HOST; } else if (PARS("no_super_ag")) { parm.parm_int_state |= IS_NO_SUPER_AG; } else if (PARS("no_ripv1_in")) { parm.parm_int_state |= IS_NO_RIPV1_IN; } else if (PARS("no_ripv2_in")) { parm.parm_int_state |= IS_NO_RIPV2_IN; } else if (PARS("ripv2_out")) { if (parm.parm_int_state & IS_NO_RIPV2_OUT) return (bad_str(tgt)); parm.parm_int_state |= IS_NO_RIPV1_OUT; } else if (PARS("ripv2")) { if ((parm.parm_int_state & IS_NO_RIPV2_OUT) || (parm.parm_int_state & IS_NO_RIPV2_IN)) return (bad_str(tgt)); parm.parm_int_state |= (IS_NO_RIPV1_IN | IS_NO_RIPV1_OUT); } else if (PARS("no_rip")) { CKF(IS_PM_RDISC, IS_NO_RIP); } else if (PARS("no_rip_mcast")) { parm.parm_int_state |= IS_NO_RIP_MCAST; } else if (PARS("no_rdisc")) { CKF((GROUP_IS_SOL_OUT|GROUP_IS_ADV_OUT), IS_NO_RDISC); } else if (PARS("no_solicit")) { CKF(GROUP_IS_SOL_OUT, IS_NO_SOL_OUT); } else if (PARS("send_solicit")) { CKF(GROUP_IS_SOL_OUT, IS_SOL_OUT); } else if (PARS("no_rdisc_adv")) { CKF(GROUP_IS_ADV_OUT, IS_NO_ADV_OUT); } else if (PARS("rdisc_adv")) { CKF(GROUP_IS_ADV_OUT, IS_ADV_OUT); } else if (PARS("bcast_rdisc")) { parm.parm_int_state |= IS_BCAST_RDISC; } else if (PARS("passive")) { CKF((GROUP_IS_SOL_OUT|GROUP_IS_ADV_OUT), IS_NO_RDISC); parm.parm_int_state |= IS_NO_RIP | IS_PASSIVE; } else if (PARSEQ("rdisc_pref")) { if (parm.parm_rdisc_pref != 0 || (parm.parm_rdisc_pref = (int)strtol(buf, &p, 0), *p != '\0') || (buf == p)) return (bad_str(tgt)); } else if (PARS("pm_rdisc")) { if (IS_RIP_OUT_OFF(parm.parm_int_state)) return (bad_str(tgt)); parm.parm_int_state |= IS_PM_RDISC; } else if (PARSEQ("rdisc_interval")) { if (parm.parm_rdisc_int != 0 || (parm.parm_rdisc_int = (int)strtoul(buf, &p, 0), *p != '\0') || (buf == p) || parm.parm_rdisc_int < MIN_MAXADVERTISEINTERVAL || parm.parm_rdisc_int > MAX_MAXADVERTISEINTERVAL) return (bad_str(tgt)); } else if (PARSEQ("fake_default")) { if (parm.parm_d_metric != 0 || IS_RIP_OUT_OFF(parm.parm_int_state) || (parm.parm_d_metric = (int)strtoul(buf, &p, 0), *p != '\0') || (buf == p) || parm.parm_d_metric > HOPCNT_INFINITY-1) return (bad_str(tgt)); } else if (PARSEQ("trust_gateway")) { /* look for trust_gateway=x.y.z|net/mask|...) */ p = buf; if (0 > parse_quote(&p, "|", &delim, buf2, sizeof (buf2)) || !gethost(buf2, &addr)) return (bad_str(tgt)); tg = rtmalloc(sizeof (*tg), "parse_parms trust_gateway"); (void) memset(tg, 0, sizeof (*tg)); tg->tgate_addr = addr; i = 0; /* The default is to trust all routes. */ while (delim == '|') { p++; if (i >= MAX_TGATE_NETS || 0 > parse_quote(&p, "|", &delim, buf2, sizeof (buf2)) || !getnet(buf2, &tg->tgate_nets[i].net, &tg->tgate_nets[i].mask) || tg->tgate_nets[i].net == RIP_DEFAULT || tg->tgate_nets[i].mask == 0) { free(tg); return (bad_str(tgt)); } i++; } tg->tgate_next = tgates; tgates = tg; parm.parm_int_state |= IS_DISTRUST; } else if (PARS("redirect_ok")) { parm.parm_int_state |= IS_REDIRECT_OK; } else if (PARSEQ("rip_neighbor")) { if (parm.parm_name[0] == '\0' || gethost(buf, &parm.parm_ripout_addr) != 1) return (bad_str(tgt)); } else { return (bad_str(tgt)); /* error */ } } return (insert_parm(&parm)); #undef PARS #undef PARSEQ #undef CKF } /* * Insert parameter specifications into the parms list. Returns NULL if * successful, or an error message otherwise. */ const char * insert_parm(struct parm *new) { struct parm *parmp, **parmpp; int i, num_passwds; /* set implicit values */ if (new->parm_int_state & (IS_NO_ADV_IN|IS_NO_SOL_OUT)) new->parm_int_state |= IS_NO_ADV_IN|IS_NO_SOL_OUT; for (i = num_passwds = 0; i < MAX_AUTH_KEYS; i++) { if (new->parm_auth[i].type != RIP_AUTH_NONE) num_passwds++; } /* compare with existing sets of parameters */ for (parmpp = &parms; (parmp = *parmpp) != 0; parmpp = &parmp->parm_next) { if (strcmp(new->parm_name, parmp->parm_name) != 0) continue; if (!on_net(htonl(parmp->parm_net), new->parm_net, new->parm_mask) && !on_net(htonl(new->parm_net), parmp->parm_net, parmp->parm_mask)) continue; for (i = 0; i < MAX_AUTH_KEYS; i++) { if (parmp->parm_auth[i].type != RIP_AUTH_NONE) num_passwds++; } if (num_passwds > MAX_AUTH_KEYS) return ("too many conflicting passwords"); if ((0 != (new->parm_int_state & GROUP_IS_SOL_OUT) && 0 != (parmp->parm_int_state & GROUP_IS_SOL_OUT) && 0 != ((new->parm_int_state ^ parmp->parm_int_state) && GROUP_IS_SOL_OUT)) || (0 != (new->parm_int_state & GROUP_IS_ADV_OUT) && 0 != (parmp->parm_int_state & GROUP_IS_ADV_OUT) && 0 != ((new->parm_int_state ^ parmp->parm_int_state) && GROUP_IS_ADV_OUT)) || (new->parm_rdisc_pref != 0 && parmp->parm_rdisc_pref != 0 && new->parm_rdisc_pref != parmp->parm_rdisc_pref) || (new->parm_rdisc_int != 0 && parmp->parm_rdisc_int != 0 && new->parm_rdisc_int != parmp->parm_rdisc_int)) { return ("conflicting, duplicate router discovery" " parameters"); } if (new->parm_d_metric != 0 && parmp->parm_d_metric != 0 && new->parm_d_metric != parmp->parm_d_metric) { return ("conflicting, duplicate poor man's router" " discovery or fake default metric"); } } /* * link new entry on the list so that when the entries are scanned, * they affect the result in the order the operator specified. */ parmp = rtmalloc(sizeof (*parmp), "insert_parm"); (void) memcpy(parmp, new, sizeof (*parmp)); *parmpp = parmp; return (NULL); } int /* 0=bad */ gethost(char *name, in_addr_t *addrp) { struct hostent *hp; struct in_addr in; /* * Try for a number first. This avoids hitting the name * server which might be sick because routing is. */ if ((in.s_addr = inet_addr(name)) != (in_addr_t)-1) { /* * get a good number, but check that it makes some * sense. */ if ((ntohl(in.s_addr) >> 24) == 0 || (ntohl(in.s_addr) >> 24) == 0xff) return (0); *addrp = in.s_addr; return (1); } hp = gethostbyname(name); if (hp != NULL) { (void) memcpy(addrp, hp->h_addr, sizeof (*addrp)); return (1); } return (0); } static void addroutefordefault(in_addr_t dst, in_addr_t gate, in_addr_t mask, uint32_t metric, uint16_t rts_flags) { struct rt_spare new; struct interface *ifp; uint16_t rt_newstate = RS_STATIC; ifp = iflookup(gate); if (ifp == NULL) { msglog("unreachable gateway %s in "PATH_GATEWAYS, naddr_ntoa(gate)); return; } trace_misc("addroutefordefault: found interface %s", ifp->int_name); (void) memset(&new, 0, sizeof (new)); new.rts_ifp = ifp; new.rts_router = gate; new.rts_gate = gate; new.rts_metric = metric; new.rts_time = now.tv_sec; new.rts_flags = rts_flags; new.rts_origin = RO_FILE; input_route(dst, mask, &new, NULL, rt_newstate); }