sbin/routed/parms.c

   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  * @(#)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 $
  31  */
  32
  33 #include "defs.h"
  34 #include "pathnames.h"
  35 #include <sys/stat.h>
  36
  37 struct parm *parms;
  38 struct intnet *intnets;
  39 struct r1net *r1nets;
  40 struct tgate *tgates;
  41
  42
  43 /* use configured parameters
  44  */
  45 void
  46 get_parms(struct interface *ifp)
  47 {
  48         static int warned_auth_in, warned_auth_out;
  49         struct parm *parmp;
  50         int i, num_passwds = 0;
  51
  52         /* get all relevant parameters
  53          */
  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))) {
  60
  61                         /* This group of parameters is relevant,
  62                          * so get its settings
  63                          */
  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)
  68                                         break;
  69                                 memcpy(&ifp->int_auth[num_passwds++],
  70                                        &parmp->parm_auth[i],
  71                                        sizeof(ifp->int_auth[0]));
  72                         }
  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;
  79                 }
  80         }
  81
  82         /* Set general defaults.
  83          *
  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.
  87          */
  88         if ((ifp->int_state & IS_PM_RDISC)
  89             && ifp->int_d_metric == 0)
  90                 ifp->int_d_metric = FAKE_METRIC;
  91
  92         if (ifp->int_rdisc_int == 0)
  93                 ifp->int_rdisc_int = DefMaxAdvertiseInterval;
  94
  95         if (!(ifp->int_if_flags & IFF_MULTICAST)
  96             && !(ifp->int_state & IS_REMOTE))
  97                 ifp->int_state |= IS_BCAST_RDISC;
  98
  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.
 103                  */
 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;
 108         }
 109
 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;
 114
 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",
 121                        ifp->int_name);
 122                 warned_auth_in = 1;
 123         }
 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",
 130                                ifp->int_name);
 131                         warned_auth_out = 1;
 132                 }
 133         }
 134 }
 135
 136
 137 /* Read a list of gateways from /etc/gateways and add them to our tables.
 138  *
 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.
 142  *
 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.
 149  *
 150  * A passive interface can also be local, hardware interface exempt
 151  * from RIP.
 152  */
 153 void
 154 gwkludge(void)
 155 {
 156         FILE *fp;
 157         char *p, *lptr;
 158         const char *cp;
 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;
 163         int metric, n, lnum;
 164         struct stat sb;
 165         u_int state;
 166         const char *type;
 167
 168
 169         fp = fopen(_PATH_GATEWAYS, "r");
 170         if (fp == NULL)
 171                 return;
 172
 173         if (0 > fstat(fileno(fp), &sb)) {
 174                 msglog("could not stat() "_PATH_GATEWAYS);
 175                 fclose(fp);
 176                 return;
 177         }
 178
 179         for (lnum = 1; ; lnum++) {
 180                 if (0 == fgets(lbuf, sizeof(lbuf), fp))
 181                         break;
 182                 lptr = lbuf;
 183                 while (*lptr == ' ')
 184                         lptr++;
 185                 p = lptr+strlen(lptr)-1;
 186                 while (*p == '\n'
 187                        || (*p == ' ' && (p == lptr+1 || *(p-1) != '\\')))
 188                         *p-- = '\0';
 189                 if (*lptr == '\0'       /* ignore null and comment lines */
 190                     || *lptr == '#')
 191                         continue;
 192
 193                 /* notice newfangled parameter lines
 194                  */
 195                 if (strncasecmp("net", lptr, 3)
 196                     && strncasecmp("host", lptr, 4)) {
 197                         cp = parse_parms(lptr,
 198                                          (sb.st_uid == 0
 199                                           && !(sb.st_mode&(S_IRWXG|S_IRWXO))));
 200                         if (cp != NULL)
 201                                 msglog("%s in line %d of "_PATH_GATEWAYS,
 202                                        cp, lnum);
 203                         continue;
 204                 }
 205
 206 /*  {net | host} XX[/M] XX gateway XX metric DD [passive | external]\n */
 207                 qual[0] = '\0';
 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",
 214                                lptr, n);
 215                         continue;
 216                 }
 217                 if (metric >= HOPCNT_INFINITY) {
 218                         msglog("bad metric in "_PATH_GATEWAYS" entry \"%s\"",
 219                                lptr);
 220                         continue;
 221                 }
 222                 if (!strcasecmp(net_host, "host")) {
 223                         if (!gethost(dname, &dst)) {
 224                                 msglog("bad host \"%s\" in "_PATH_GATEWAYS
 225                                        " entry \"%s\"", dname, lptr);
 226                                 continue;
 227                         }
 228                         netmask = HOST_MASK;
 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);
 233                                 continue;
 234                         }
 235                         if (dst == RIP_DEFAULT) {
 236                                 msglog("bad net \"%s\" in "_PATH_GATEWAYS
 237                                        " entry \"%s\"--cannot be default",
 238                                        dname, lptr);
 239                                 continue;
 240                         }
 241                         dst = htonl(dst); /* make network # into IP address */
 242                 } else {
 243                         msglog("bad \"%s\" in "_PATH_GATEWAYS
 244                                " entry \"%s\"", net_host, lptr);
 245                         continue;
 246                 }
 247
 248                 if (!gethost(gname, &gate)) {
 249                         msglog("bad gateway \"%s\" in "_PATH_GATEWAYS
 250                                " entry \"%s\"", gname, lptr);
 251                         continue;
 252                 }
 253
 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).
 260                          */
 261                         state = IS_REMOTE | IS_PASSIVE;
 262                         if (metric == 0)
 263                                 metric = 1;
 264
 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
 269                          * else.
 270                          */
 271                         strcpy(qual,"external");
 272                         state = IS_REMOTE | IS_PASSIVE | IS_EXTERNAL;
 273                         if (metric == 0)
 274                                 metric = 1;
 275
 276                 } else if (!strcasecmp(qual, "active")
 277                            || qual[0] == '\0') {
 278                         if (metric != 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.
 283                                  */
 284                                 state = IS_REMOTE;
 285                                 type = "remote";
 286                         } else {
 287                                 /* "remote" entries with a metric of 0
 288                                  * are aliases for our own interfaces
 289                                  */
 290                                 state = IS_REMOTE | IS_PASSIVE | IS_ALIAS;
 291                                 type = "alias";
 292                         }
 293
 294                 } else {
 295                         msglog("bad "_PATH_GATEWAYS" entry \"%s\";"
 296                                " unknown type %s", lptr, qual);
 297                         continue;
 298                 }
 299
 300                 if (0 != (state & (IS_PASSIVE | IS_REMOTE)))
 301                         state |= IS_NO_RDISC;
 302                 if (state & IS_PASSIVE)
 303                         state |= IS_NO_RIP;
 304
 305                 ifp = check_dup(gate,dst,netmask,0);
 306                 if (ifp != NULL) {
 307                         msglog("duplicate "_PATH_GATEWAYS" entry \"%s\"",lptr);
 308                         continue;
 309                 }
 310
 311                 ifp = (struct interface *)rtmalloc(sizeof(*ifp), "gwkludge()");
 312                 memset(ifp, 0, sizeof(*ifp));
 313
 314                 ifp->int_state = state;
 315                 if (netmask == HOST_MASK)
 316                         ifp->int_if_flags = IFF_POINTOPOINT | IFF_UP;
 317                 else
 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);
 333                 ifp->int_index = -1;
 334
 335                 if_link(ifp);
 336         }
 337
 338         /* After all of the parameter lines have been read,
 339          * apply them to any remote interfaces.
 340          */
 341         for (ifp = ifnet; NULL != ifp; ifp = ifp->int_next) {
 342                 get_parms(ifp);
 343
 344                 tot_interfaces++;
 345                 if (!IS_RIP_OFF(ifp->int_state))
 346                         rip_interfaces++;
 347
 348                 trace_if("Add", ifp);
 349         }
 350
 351         fclose(fp);
 352 }
 353
 354
 355 /* like strtok(), but honoring backslash and not changing the source string
 356  */
 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 */
 363 {
 364         char c = '\0', *pc;
 365         const char *p;
 366
 367
 368         pc = *linep;
 369         if (*pc == '\0')
 370                 return -1;
 371
 372         while (lim != 0) {
 373                 c = *pc++;
 374                 if (c == '\0')
 375                         break;
 376
 377                 if (c == '\\' && *pc != '\0') {
 378                         if ((c = *pc++) == 'n') {
 379                                 c = '\n';
 380                         } else if (c == 'r') {
 381                                 c = '\r';
 382                         } else if (c == 't') {
 383                                 c = '\t';
 384                         } else if (c == 'b') {
 385                                 c = '\b';
 386                         } else if (c >= '0' && c <= '7') {
 387                                 c -= '0';
 388                                 if (*pc >= '0' && *pc <= '7') {
 389                                         c = (c<<3)+(*pc++ - '0');
 390                                         if (*pc >= '0' && *pc <= '7')
 391                                             c = (c<<3)+(*pc++ - '0');
 392                                 }
 393                         }
 394
 395                 } else {
 396                         for (p = delims; *p != '\0'; ++p) {
 397                                 if (*p == c)
 398                                         goto exit;
 399                         }
 400                 }
 401
 402                 *buf++ = c;
 403                 --lim;
 404         }
 405 exit:
 406         if (lim == 0)
 407                 return -1;
 408
 409         *buf = '\0';                    /* terminate copy of token */
 410         if (delimp != NULL)
 411                 *delimp = c;            /* return delimiter */
 412         *linep = pc-1;                  /* say where we ended */
 413         return 0;
 414 }
 415
 416
 417 /* Parse password timestamp
 418  */
 419 static char *
 420 parse_ts(time_t *tp,
 421          char **valp,
 422          char *val0,
 423          char *delimp,
 424          char *buf,
 425          u_int bufsize)
 426 {
 427         struct tm tm;
 428 #if defined(__NetBSD__)
 429         char *ptr;
 430 #endif
 431
 432         if (0 > parse_quote(valp, "| ,\n\r", delimp,
 433                             buf,bufsize)
 434             || buf[bufsize-1] != '\0'
 435             || buf[bufsize-2] != '\0') {
 436                 sprintf(buf,"bad timestamp %.25s", val0);
 437                 return buf;
 438         }
 439         strcat(buf,"\n");
 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);
 445                 return buf;
 446         }
 447 #else
 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);
 454                 return buf;
 455         }
 456         tm.tm_mon--;
 457         if (tm.tm_year <= 37)           /* assume small years are in the */
 458                 tm.tm_year += 100;      /* 3rd millenium */
 459 #endif
 460
 461         if ((*tp = mktime(&tm)) == -1) {
 462                 sprintf(buf,"bad timestamp %.25s", val0);
 463                 return buf;
 464         }
 465
 466         return 0;
 467 }
 468
 469
 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
 472  */
 473 static const char *                     /* 0 or error message */
 474 get_passwd(char *tgt,
 475            char *val,
 476            struct parm *parmp,
 477            u_int16_t type,
 478            int safe)                    /* 1=from secure file */
 479 {
 480         static char buf[80];
 481         char *val0, *p, delim;
 482         struct auth k, *ap, *ap2;
 483         int i;
 484         u_long l;
 485
 486
 487         if (!safe)
 488                 return "ignore unsafe password";
 489
 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";
 494         }
 495
 496         memset(&k, 0, sizeof(k));
 497         k.type = type;
 498         k.end = -1-DAY;
 499
 500         val0 = val;
 501         if (0 > parse_quote(&val, "| ,\n\r", &delim,
 502                             (char *)k.key, sizeof(k.key)))
 503                 return tgt;
 504
 505         if (delim != '|') {
 506                 if (type == RIP_AUTH_MD5)
 507                         return "missing Keyid";
 508         } else {
 509                 val0 = ++val;
 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
 514                     || *p != '\0') {
 515                         sprintf(buf,"bad KeyID \"%.20s\"", val0);
 516                         return buf;
 517                 }
 518                 for (ap2 = parmp->parm_auth; ap2 < ap; ap2++) {
 519                         if (ap2->keyid == l) {
 520                                 sprintf(buf,"duplicate KeyID \"%.20s\"", val0);
 521                                 return buf;
 522                         }
 523                 }
 524                 k.keyid = (int)l;
 525
 526                 if (delim == '|') {
 527                         val0 = ++val;
 528                         if (NULL != (p = parse_ts(&k.start,&val,val0,&delim,
 529                                                buf,sizeof(buf))))
 530                                 return p;
 531                         if (delim != '|')
 532                                 return "missing second timestamp";
 533                         val0 = ++val;
 534                         if (NULL != (p = parse_ts(&k.end,&val,val0,&delim,
 535                                                buf,sizeof(buf))))
 536                                 return p;
 537                         if ((u_long)k.start > (u_long)k.end) {
 538                                 sprintf(buf,"out of order timestamp %.30s",
 539                                         val0);
 540                                 return buf;
 541                         }
 542                 }
 543         }
 544         if (delim != '\0')
 545                 return tgt;
 546
 547         memmove(ap, &k, sizeof(*ap));
 548         return 0;
 549 }
 550
 551
 552 static const char *
 553 bad_str(const char *estr)
 554 {
 555         static char buf[100+8];
 556
 557         sprintf(buf, "bad \"%.100s\"", estr);
 558         return buf;
 559 }
 560
 561
 562 /* Parse a set of parameters for an interface.
 563  */
 564 const char *                                    /* 0 or error message */
 565 parse_parms(char *line,
 566             int safe)                   /* 1=from secure file */
 567 {
 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);}
 572         struct parm parm;
 573         struct intnet *intnetp;
 574         struct r1net *r1netp;
 575         struct tgate *tg;
 576         naddr addr, mask;
 577         char delim, *val0 = NULL, *tgt, *val, *p;
 578         const char *msg;
 579         char buf[BUFSIZ], buf2[BUFSIZ];
 580         int i;
 581
 582
 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;
 591                 if (delim == ',') {
 592                         intnetp->intnet_metric = (int)strtol(val+1,&p,0);
 593                         if (*p != '\0'
 594                             || intnetp->intnet_metric <= 0
 595                             || intnetp->intnet_metric >= HOPCNT_INFINITY)
 596                                 return bad_str(line);
 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                 }
 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 (!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                         msg = get_passwd(tgt,val0,&parm,RIP_AUTH_PW,1);
 687                         if (msg) {
 688                                 *val0 = '\0';
 689                                 return bad_str(msg);
 690                         }
 691
 692                 } else if (PARSEQ("md5_passwd")) {
 693                         msg = get_passwd(tgt,val0,&parm,RIP_AUTH_MD5,safe);
 694                         if (msg) {
 695                                 *val0 = '\0';
 696                                 return bad_str(msg);
 697                         }
 698
 699                 } else if (PARS("no_ag")) {
 700                         parm.parm_int_state |= (IS_NO_AG | IS_NO_SUPER_AG);
 701
 702                 } else if (PARS("no_super_ag")) {
 703                         parm.parm_int_state |= IS_NO_SUPER_AG;
 704
 705                 } else if (PARS("no_ripv1_in")) {
 706                         parm.parm_int_state |= IS_NO_RIPV1_IN;
 707
 708                 } else if (PARS("no_ripv2_in")) {
 709                         parm.parm_int_state |= IS_NO_RIPV2_IN;
 710
 711                 } else if (PARS("ripv2_out")) {
 712                         if (parm.parm_int_state & IS_NO_RIPV2_OUT)
 713                                 return bad_str(tgt);
 714                         parm.parm_int_state |= IS_NO_RIPV1_OUT;
 715
 716                 } else if (PARS("ripv2")) {
 717                         if ((parm.parm_int_state & IS_NO_RIPV2_OUT)
 718                             || (parm.parm_int_state & IS_NO_RIPV2_IN))
 719                                 return bad_str(tgt);
 720                         parm.parm_int_state |= (IS_NO_RIPV1_IN
 721                                                 | IS_NO_RIPV1_OUT);
 722
 723                 } else if (PARS("no_rip")) {
 724                         CKF(IS_PM_RDISC, IS_NO_RIP);
 725
 726                 } else if (PARS("no_rip_mcast")) {
 727                         parm.parm_int_state |= IS_NO_RIP_MCAST;
 728
 729                 } else if (PARS("no_rdisc")) {
 730                         CKF((GROUP_IS_SOL_OUT|GROUP_IS_ADV_OUT), IS_NO_RDISC);
 731
 732                 } else if (PARS("no_solicit")) {
 733                         CKF(GROUP_IS_SOL_OUT, IS_NO_SOL_OUT);
 734
 735                 } else if (PARS("send_solicit")) {
 736                         CKF(GROUP_IS_SOL_OUT, IS_SOL_OUT);
 737
 738                 } else if (PARS("no_rdisc_adv")) {
 739                         CKF(GROUP_IS_ADV_OUT, IS_NO_ADV_OUT);
 740
 741                 } else if (PARS("rdisc_adv")) {
 742                         CKF(GROUP_IS_ADV_OUT, IS_ADV_OUT);
 743
 744                 } else if (PARS("bcast_rdisc")) {
 745                         parm.parm_int_state |= IS_BCAST_RDISC;
 746
 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;
 750
 751                 } else if (PARSEQ("rdisc_pref")) {
 752                         if (parm.parm_rdisc_pref != 0
 753                             || (parm.parm_rdisc_pref = (int)strtol(buf,&p,0),
 754                                 *p != '\0'))
 755                                 return bad_str(tgt);
 756
 757                 } else if (PARS("pm_rdisc")) {
 758                         if (IS_RIP_OUT_OFF(parm.parm_int_state))
 759                                 return bad_str(tgt);
 760                         parm.parm_int_state |= IS_PM_RDISC;
 761
 762                 } else if (PARSEQ("rdisc_interval")) {
 763                         if (parm.parm_rdisc_int != 0
 764                             || (parm.parm_rdisc_int = (int)strtoul(buf,&p,0),
 765                                 *p != '\0')
 766                             || parm.parm_rdisc_int < MinMaxAdvertiseInterval
 767                             || parm.parm_rdisc_int > MaxMaxAdvertiseInterval)
 768                                 return bad_str(tgt);
 769
 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),
 774                                 *p != '\0')
 775                             || parm.parm_d_metric > HOPCNT_INFINITY-1)
 776                                 return bad_str(tgt);
 777
 778                 } else if (PARSEQ("trust_gateway")) {
 779                         /* look for trust_gateway=x.y.z|net/mask|...) */
 780                         p = buf;
 781                         if (0 > parse_quote(&p, "|", &delim,
 782                                             buf2, sizeof(buf2))
 783                             || !gethost(buf2,&addr))
 784                                 return bad_str(tgt);
 785                         tg = (struct tgate *)rtmalloc(sizeof(*tg),
 786                                                       "parse_parms"
 787                                                       "trust_gateway");
 788                         memset(tg, 0, sizeof(*tg));
 789                         tg->tgate_addr = addr;
 790                         i = 0;
 791                         /* The default is to trust all routes. */
 792                         while (delim == '|') {
 793                                 p++;
 794                                 if (i >= MAX_TGATE_NETS
 795                                     || 0 > parse_quote(&p, "|", &delim,
 796                                                        buf2, sizeof(buf2))
 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)
 801                                         return bad_str(tgt);
 802                                 i++;
 803                         }
 804                         tg->tgate_next = tgates;
 805                         tgates = tg;
 806                         parm.parm_int_state |= IS_DISTRUST;
 807
 808                 } else if (PARS("redirect_ok")) {
 809                         parm.parm_int_state |= IS_REDIRECT_OK;
 810
 811                 } else {
 812                         return bad_str(tgt);    /* error */
 813                 }
 814         }
 815
 816         return check_parms(&parm);
 817 #undef PARS
 818 #undef PARSEQ
 819 }
 820
 821
 822 /* check for duplicate parameter specifications */
 823 const char *                            /* 0 or error message */
 824 check_parms(struct parm *new)
 825 {
 826         struct parm *parmp, **parmpp;
 827         int i, num_passwds;
 828
 829         /* set implicit values
 830          */
 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;
 835
 836         for (i = num_passwds = 0; i < MAX_AUTH_KEYS; i++) {
 837                 if (new->parm_auth[i].type != RIP_AUTH_NONE)
 838                         num_passwds++;
 839         }
 840
 841         /* compare with existing sets of parameters
 842          */
 843         for (parmpp = &parms;
 844              (parmp = *parmpp) != NULL;
 845              parmpp = &parmp->parm_next) {
 846                 if (strcmp(new->parm_name, parmp->parm_name))
 847                         continue;
 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))
 852                         continue;
 853
 854                 for (i = 0; i < MAX_AUTH_KEYS; i++) {
 855                         if (parmp->parm_auth[i].type != RIP_AUTH_NONE)
 856                                 num_passwds++;
 857                 }
 858                 if (num_passwds > MAX_AUTH_KEYS)
 859                         return "too many conflicting passwords";
 860
 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)
 864                               & GROUP_IS_SOL_OUT))
 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)
 868                                  & GROUP_IS_ADV_OUT))
 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"
 876                                 " parameters");
 877
 878                 }
 879
 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");
 885                 }
 886         }
 887
 888         /* link new entry on the so that when the entries are scanned,
 889          * they affect the result in the order the operator specified.
 890          */
 891         parmp = (struct parm*)rtmalloc(sizeof(*parmp), "check_parms");
 892         memcpy(parmp, new, sizeof(*parmp));
 893         *parmpp = parmp;
 894
 895         return 0;
 896 }
 897
 898
 899 /* get a network number as a name or a number, with an optional "/xx"
 900  * netmask.
 901  */
 902 int                                     /* 0=bad */
 903 getnet(char *name,
 904        naddr *netp,                     /* network in host byte order */
 905        naddr *maskp)                    /* masks are always in host order */
 906 {
 907         int i;
 908         struct netent *np;
 909         naddr mask;                     /* in host byte order */
 910         struct in_addr in;              /* a network and so host byte order */
 911         char hname[MAXHOSTNAMELEN+1];
 912         char *mname, *p;
 913
 914
 915         /* Detect and separate "1.2.3.4/24"
 916          */
 917         if (NULL != (mname = strrchr(name,'/'))) {
 918                 i = (int)(mname - name);
 919                 if (i > (int)sizeof(hname)-1)   /* name too long */
 920                         return 0;
 921                 memmove(hname, name, i);
 922                 hname[i] = '\0';
 923                 mname++;
 924                 name = hname;
 925         }
 926
 927         np = getnetbyname(name);
 928         if (np != NULL) {
 929                 in.s_addr = (naddr)np->n_net;
 930                 if (0 == (in.s_addr & 0xff000000))
 931                         in.s_addr <<= 8;
 932                 if (0 == (in.s_addr & 0xff000000))
 933                         in.s_addr <<= 8;
 934                 if (0 == (in.s_addr & 0xff000000))
 935                         in.s_addr <<= 8;
 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;
 940         } else {
 941                 return 0;
 942         }
 943
 944         if (!mname) {
 945                 /* we cannot use the interfaces here because we have not
 946                  * looked at them yet.
 947                  */
 948                 mask = std_mask(htonl(in.s_addr));
 949                 if ((~mask & in.s_addr) != 0)
 950                         mask = HOST_MASK;
 951         } else {
 952                 mask = (naddr)strtoul(mname, &p, 0);
 953                 if (*p != '\0' || mask > 32)
 954                         return 0;
 955                 if (mask != 0)
 956                         mask = HOST_MASK << (32-mask);
 957         }
 958
 959         /* must have mask of 0 with default */
 960         if (mask != 0 && in.s_addr == RIP_DEFAULT)
 961                 return 0;
 962         /* no host bits allowed in a network number */
 963         if ((~mask & in.s_addr) != 0)
 964                 return 0;
 965         /* require non-zero network number */
 966         if ((mask & in.s_addr) == 0 && in.s_addr != RIP_DEFAULT)
 967                 return 0;
 968         if (in.s_addr>>24 == 0 && in.s_addr != RIP_DEFAULT)
 969                 return 0;
 970         if (in.s_addr>>24 == 0xff)
 971                 return 0;
 972
 973         *netp = in.s_addr;
 974         *maskp = mask;
 975         return 1;
 976 }
 977
 978
 979 int                                     /* 0=bad */
 980 gethost(char *name,
 981         naddr *addrp)
 982 {
 983         struct hostent *hp;
 984         struct in_addr in;
 985
 986
 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.
 990          */
 991         if (inet_aton(name, &in) == 1) {
 992                 /* get a good number, but check that it it makes some
 993                  * sense.
 994                  */
 995                 if (ntohl(in.s_addr)>>24 == 0
 996                     || ntohl(in.s_addr)>>24 == 0xff)
 997                         return 0;
 998                 *addrp = in.s_addr;
 999                 return 1;
1000         }
1001
1002         hp = gethostbyname(name);
1003         if (hp) {
1004                 memcpy(addrp, hp->h_addr, sizeof(*addrp));
1005                 return 1;
1006         }
1007
1008         return 0;
1009 }