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