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