Annotation of embedaddon/pimd/config.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 1998-2001
! 3: * University of Southern California/Information Sciences Institute.
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: * 3. Neither the name of the project nor the names of its contributors
! 15: * may be used to endorse or promote products derived from this software
! 16: * without specific prior written permission.
! 17: *
! 18: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
! 19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 21: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
! 22: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 28: * SUCH DAMAGE.
! 29: */
! 30: /*
! 31: * Part of this program has been derived from mrouted.
! 32: * The mrouted program is covered by the license in the accompanying file
! 33: * named "LICENSE.mrouted".
! 34: *
! 35: * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
! 36: * Leland Stanford Junior University.
! 37: *
! 38: */
! 39:
! 40: #include "defs.h"
! 41:
! 42: #define WARN(fmt, args...) logit(LOG_WARNING, 0, "%s:%u - " fmt, config_file, lineno, ##args)
! 43: #define BAILOUT(msg, arg...) { WARN(msg ", bailing out!", ##arg); return FALSE; }
! 44: #define IGNORING(msg, arg...) { WARN(msg ", ignoring ...", ##arg); continue; }
! 45:
! 46: /* Helper macros */
! 47: #define QUERIER_TIMEOUT(qintv) (IGMP_ROBUSTNESS_VARIABLE * (qintv) + IGMP_QUERY_RESPONSE_INTERVAL / 2)
! 48:
! 49: #define LINE_BUFSIZ 1024 /* Max. line length of the config file */
! 50:
! 51: #define CONF_UNKNOWN -1
! 52: #define CONF_EMPTY 1
! 53: #define CONF_PHYINT 2
! 54: #define CONF_CANDIDATE_RP 3
! 55: #define CONF_RP_ADDRESS 4
! 56: #define CONF_GROUP_PREFIX 5
! 57: #define CONF_BOOTSTRAP_RP 6
! 58: #define CONF_COMPAT_THRESHOLD 7
! 59: #define CONF_SPT_THRESHOLD 8
! 60: #define CONF_DEFAULT_ROUTE_METRIC 9
! 61: #define CONF_DEFAULT_ROUTE_DISTANCE 10
! 62: #define CONF_ALTNET 11
! 63: #define CONF_MASKLEN 12
! 64: #define CONF_SCOPED 13
! 65: #define CONF_IGMP_QUERY_INTERVAL 14
! 66: #define CONF_IGMP_QUERIER_TIMEOUT 15
! 67: #define CONF_HELLO_INTERVAL 16
! 68:
! 69: /*
! 70: * Global settings
! 71: */
! 72: uint16_t pim_timer_hello_interval = PIM_TIMER_HELLO_INTERVAL;
! 73: uint16_t pim_timer_hello_holdtime = PIM_TIMER_HELLO_HOLDTIME;
! 74:
! 75: /*
! 76: * Forward declarations.
! 77: */
! 78: static char *next_word (char **);
! 79: static int parse_phyint (char *s);
! 80: static uint32_t ifname2addr (char *s);
! 81:
! 82: static uint32_t lineno;
! 83: extern struct rp_hold *g_rp_hold;
! 84:
! 85: /*
! 86: * Query the kernel to find network interfaces that are multicast-capable
! 87: * and install them in the uvifs array.
! 88: */
! 89: void config_vifs_from_kernel(void)
! 90: {
! 91: struct ifreq *ifrp, *ifend;
! 92: struct uvif *v;
! 93: vifi_t vifi;
! 94: uint32_t n;
! 95: uint32_t addr, mask, subnet;
! 96: short flags;
! 97: int num_ifreq = 64;
! 98: struct ifconf ifc;
! 99: char *newbuf;
! 100:
! 101: total_interfaces = 0; /* The total number of physical interfaces */
! 102:
! 103: ifc.ifc_len = num_ifreq * sizeof(struct ifreq);
! 104: ifc.ifc_buf = calloc(ifc.ifc_len, sizeof(char));
! 105: while (ifc.ifc_buf) {
! 106: if (ioctl(udp_socket, SIOCGIFCONF, (char *)&ifc) < 0)
! 107: logit(LOG_ERR, errno, "Failed querying kernel network interfaces");
! 108:
! 109: /*
! 110: * If the buffer was large enough to hold all the addresses
! 111: * then break out, otherwise increase the buffer size and
! 112: * try again.
! 113: *
! 114: * The only way to know that we definitely had enough space
! 115: * is to know that there was enough space for at least one
! 116: * more struct ifreq. ???
! 117: */
! 118: if ((num_ifreq * sizeof(struct ifreq)) >= ifc.ifc_len + sizeof(struct ifreq))
! 119: break;
! 120:
! 121: num_ifreq *= 2;
! 122: ifc.ifc_len = num_ifreq * sizeof(struct ifreq);
! 123: newbuf = realloc(ifc.ifc_buf, ifc.ifc_len);
! 124: if (newbuf == NULL)
! 125: free(ifc.ifc_buf);
! 126: ifc.ifc_buf = newbuf;
! 127: }
! 128: if (ifc.ifc_buf == NULL)
! 129: logit(LOG_ERR, 0, "config_vifs_from_kernel() ran out of memory");
! 130:
! 131: ifrp = (struct ifreq *)ifc.ifc_buf;
! 132: ifend = (struct ifreq *)(ifc.ifc_buf + ifc.ifc_len);
! 133: /*
! 134: * Loop through all of the interfaces.
! 135: */
! 136: for (; ifrp < ifend; ifrp = (struct ifreq *)((char *)ifrp + n)) {
! 137: struct ifreq ifr;
! 138:
! 139: memset (&ifr, 0, sizeof (ifr));
! 140:
! 141: #ifdef HAVE_SA_LEN
! 142: n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
! 143: if (n < sizeof(*ifrp))
! 144: n = sizeof(*ifrp);
! 145: #else
! 146: n = sizeof(*ifrp);
! 147: #endif /* HAVE_SA_LEN */
! 148:
! 149: /*
! 150: * Ignore any interface for an address family other than IP.
! 151: */
! 152: if (ifrp->ifr_addr.sa_family != AF_INET) {
! 153: total_interfaces++; /* Eventually may have IP address later */
! 154: continue;
! 155: }
! 156:
! 157: addr = ((struct sockaddr_in *)&ifrp->ifr_addr)->sin_addr.s_addr;
! 158:
! 159: /*
! 160: * Need a template to preserve address info that is
! 161: * used below to locate the next entry. (Otherwise,
! 162: * SIOCGIFFLAGS stomps over it because the requests
! 163: * are returned in a union.)
! 164: */
! 165: memcpy(ifr.ifr_name, ifrp->ifr_name, sizeof(ifr.ifr_name));
! 166:
! 167: /*
! 168: * Ignore loopback interfaces and interfaces that do not
! 169: * support multicast.
! 170: */
! 171: if (ioctl(udp_socket, SIOCGIFFLAGS, (char *)&ifr) < 0)
! 172: logit(LOG_ERR, errno, "Failed reading interface flags for phyint %s", ifr.ifr_name);
! 173:
! 174: flags = ifr.ifr_flags;
! 175: if ((flags & (IFF_LOOPBACK | IFF_MULTICAST)) != IFF_MULTICAST)
! 176: continue;
! 177:
! 178: /*
! 179: * Everyone below is a potential vif interface.
! 180: * We don't care if it has wrong configuration or not configured
! 181: * at all.
! 182: */
! 183: total_interfaces++;
! 184:
! 185: /*
! 186: * Ignore any interface whose address and mask do not define a
! 187: * valid subnet number, or whose address is of the form
! 188: * {subnet,0} or {subnet,-1}.
! 189: */
! 190: if (ioctl(udp_socket, SIOCGIFNETMASK, (char *)&ifr) < 0) {
! 191: if (!(flags & IFF_POINTOPOINT))
! 192: logit(LOG_ERR, errno, "Failed reading interface netmask for phyint %s", ifr.ifr_name);
! 193:
! 194: mask = 0xffffffff;
! 195: } else {
! 196: mask = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr;
! 197: }
! 198:
! 199: subnet = addr & mask;
! 200: #ifdef DISABLE_MASKLEN_CHECK
! 201: if (mask != 0xffffffff) {
! 202: #endif
! 203: if ((!inet_valid_subnet(subnet, mask)) || (addr == subnet) || addr == (subnet | ~mask)) {
! 204: if (!(inet_valid_host(addr) && ((mask == htonl(0xfffffffe)) || (flags & IFF_POINTOPOINT)))) {
! 205: logit(LOG_WARNING, 0, "Ignoring %s, has invalid address %s and/or netmask %s",
! 206: ifr.ifr_name, inet_fmt(addr, s1, sizeof(s1)), inet_fmt(mask, s2, sizeof(s2)));
! 207: continue;
! 208: }
! 209: }
! 210: #ifdef DISABLE_MASKLEN_CHECK
! 211: }
! 212: #endif
! 213:
! 214: /*
! 215: * Ignore any interface that is connected to the same subnet as
! 216: * one already installed in the uvifs array.
! 217: */
! 218: /*
! 219: * TODO: XXX: bug or "feature" is to allow only one interface per
! 220: * subnet?
! 221: */
! 222: for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
! 223: if (strcmp(v->uv_name, ifr.ifr_name) == 0) {
! 224: logit(LOG_DEBUG, 0, "Ignoring %s (%s on subnet %s) (alias for vif#%u?)",
! 225: v->uv_name, inet_fmt(addr, s1, sizeof(s1)), netname(subnet, mask), vifi);
! 226: break;
! 227: }
! 228: /* we don't care about point-to-point links in same subnet */
! 229: if (flags & IFF_POINTOPOINT)
! 230: continue;
! 231: if (v->uv_flags & VIFF_POINT_TO_POINT)
! 232: continue;
! 233: #if 0
! 234: /*
! 235: * TODO: to allow different interfaces belong to
! 236: * overlapping subnet addresses, use this version instead
! 237: */
! 238: if (((addr & mask ) == v->uv_subnet) && (v->uv_subnetmask == mask)) {
! 239: logit(LOG_WARNING, 0, "Ignoring %s, same subnet as %s", ifr.ifr_name, v->uv_name);
! 240: break;
! 241: }
! 242: #else
! 243: if ((addr & v->uv_subnetmask) == v->uv_subnet || (v->uv_subnet & mask) == subnet) {
! 244: logit(LOG_WARNING, 0, "Ignoring %s, same subnet as %s", ifr.ifr_name, v->uv_name);
! 245: break;
! 246: }
! 247: #endif /* 0 */
! 248: }
! 249: if (vifi != numvifs)
! 250: continue;
! 251:
! 252: /*
! 253: * If there is room in the uvifs array, install this interface.
! 254: */
! 255: if (numvifs == MAXVIFS) {
! 256: logit(LOG_WARNING, 0, "Too many vifs, ignoring %s", ifr.ifr_name);
! 257: continue;
! 258: }
! 259: v = &uvifs[numvifs];
! 260: zero_vif(v, FALSE);
! 261: v->uv_lcl_addr = addr;
! 262: v->uv_subnet = subnet;
! 263: v->uv_subnetmask = mask;
! 264: if (mask != htonl(0xfffffffe))
! 265: v->uv_subnetbcast = subnet | ~mask;
! 266: else
! 267: v->uv_subnetbcast = 0xffffffff;
! 268:
! 269: strlcpy(v->uv_name, ifr.ifr_name, IFNAMSIZ);
! 270:
! 271: /*
! 272: * Figure out MTU of interface, needed as a seed value when
! 273: * fragmenting PIM register messages. We should really do
! 274: * a PMTU check on initial PIM register send to a new RP...
! 275: */
! 276: if (ioctl(udp_socket, SIOCGIFMTU, &ifr) < 0)
! 277: v->uv_mtu = 1500;
! 278: else
! 279: v->uv_mtu = ifr.ifr_mtu;
! 280:
! 281: if (flags & IFF_POINTOPOINT) {
! 282: v->uv_flags |= (VIFF_REXMIT_PRUNES | VIFF_POINT_TO_POINT);
! 283: if (ioctl(udp_socket, SIOCGIFDSTADDR, (char *)&ifr) < 0)
! 284: logit(LOG_ERR, errno, "Failed reading point-to-point address for %s", v->uv_name);
! 285: else
! 286: v->uv_rmt_addr = ((struct sockaddr_in *)(&ifr.ifr_dstaddr))->sin_addr.s_addr;
! 287: } else if (mask == htonl(0xfffffffe)) {
! 288: /*
! 289: * Handle RFC 3021 /31 netmasks as point-to-point links
! 290: */
! 291: v->uv_flags |= (VIFF_REXMIT_PRUNES | VIFF_POINT_TO_POINT);
! 292: if (addr == subnet)
! 293: v->uv_rmt_addr = addr + htonl(1);
! 294: else
! 295: v->uv_rmt_addr = subnet;
! 296: }
! 297: #ifdef __linux__
! 298: {
! 299: struct ifreq ifridx;
! 300:
! 301: memset(&ifridx, 0, sizeof(ifridx));
! 302: strlcpy(ifridx.ifr_name,v->uv_name, IFNAMSIZ);
! 303: if (ioctl(udp_socket, SIOGIFINDEX, (char *) &ifridx) < 0)
! 304: logit(LOG_ERR, errno, "Failed reading interface index for %s", ifridx.ifr_name);
! 305: v->uv_ifindex = ifridx.ifr_ifindex;
! 306: }
! 307: if (v->uv_flags & VIFF_POINT_TO_POINT) {
! 308: logit(LOG_INFO, 0, "Installing %s (%s -> %s) as vif #%u-%d - rate %d",
! 309: v->uv_name, inet_fmt(addr, s1, sizeof(s1)), inet_fmt(v->uv_rmt_addr, s2, sizeof(s2)),
! 310: numvifs, v->uv_ifindex, v->uv_rate_limit);
! 311: } else {
! 312: logit(LOG_INFO, 0, "Installing %s (%s on subnet %s) as vif #%u-%d - rate %d",
! 313: v->uv_name, inet_fmt(addr, s1, sizeof(s1)), netname(subnet, mask),
! 314: numvifs, v->uv_ifindex, v->uv_rate_limit);
! 315: }
! 316: #else /* !__linux__ */
! 317: if (v->uv_flags & VIFF_POINT_TO_POINT) {
! 318: logit(LOG_INFO, 0, "Installing %s (%s -> %s) as vif #%u - rate=%d",
! 319: v->uv_name, inet_fmt(addr, s1, sizeof(s1)), inet_fmt(v->uv_rmt_addr, s2, sizeof(s2)),
! 320: numvifs, v->uv_rate_limit);
! 321: } else {
! 322: logit(LOG_INFO, 0, "Installing %s (%s on subnet %s) as vif #%u - rate %d",
! 323: v->uv_name, inet_fmt(addr, s1, sizeof(s1)), netname(subnet, mask),
! 324: numvifs, v->uv_rate_limit);
! 325: }
! 326: #endif /* __linux__ */
! 327:
! 328: ++numvifs;
! 329:
! 330: /*
! 331: * If the interface is not yet up, set the vifs_down flag to
! 332: * remind us to check again later.
! 333: */
! 334: if (!(flags & IFF_UP)) {
! 335: v->uv_flags |= VIFF_DOWN;
! 336: vifs_down = TRUE;
! 337: }
! 338: }
! 339: }
! 340:
! 341: static int deprecated(char *word, char *new_word, int code)
! 342: {
! 343: WARN("The %s option is deprecated, replaced with %s", word, new_word);
! 344: WARN("Please update your configuration file!");
! 345:
! 346: return code;
! 347: }
! 348:
! 349: /**
! 350: * parse_option - Convert result of string comparisons into numerics.
! 351: * @input: Pointer to the word
! 352: *
! 353: * This function is called by config_vifs_from_file().
! 354: *
! 355: * Returns:
! 356: * A number corresponding to the code of the word, or %CONF_UNKNOWN.
! 357: */
! 358: static int parse_option(char *word)
! 359: {
! 360: if (EQUAL(word, ""))
! 361: return CONF_EMPTY;
! 362: if (EQUAL(word, "phyint"))
! 363: return CONF_PHYINT;
! 364: if (EQUAL(word, "bsr-candidate"))
! 365: return CONF_BOOTSTRAP_RP;
! 366: if (EQUAL(word, "rp-candidate"))
! 367: return CONF_CANDIDATE_RP;
! 368: if (EQUAL(word, "rp-address"))
! 369: return CONF_RP_ADDRESS;
! 370: if (EQUAL(word, "group-prefix"))
! 371: return CONF_GROUP_PREFIX;
! 372: if (EQUAL(word, "spt-threshold"))
! 373: return CONF_SPT_THRESHOLD;
! 374: if (EQUAL(word, "default-route-metric"))
! 375: return CONF_DEFAULT_ROUTE_METRIC;
! 376: if (EQUAL(word, "default-route-distance"))
! 377: return CONF_DEFAULT_ROUTE_DISTANCE;
! 378: if (EQUAL(word, "igmp-query-interval"))
! 379: return CONF_IGMP_QUERY_INTERVAL;
! 380: if (EQUAL(word, "igmp-querier-timeout"))
! 381: return CONF_IGMP_QUERIER_TIMEOUT;
! 382: if (EQUAL(word, "altnet"))
! 383: return CONF_ALTNET;
! 384: if (EQUAL(word, "masklen"))
! 385: return CONF_MASKLEN;
! 386: if (EQUAL(word, "scoped"))
! 387: return CONF_SCOPED;
! 388: if (EQUAL(word, "hello-interval"))
! 389: return CONF_HELLO_INTERVAL;
! 390:
! 391: /* Compatibility with old config files that use _ instead of - */
! 392: if (EQUAL(word, "cand_bootstrap_router"))
! 393: return CONF_BOOTSTRAP_RP;
! 394: if (EQUAL(word, "cand_rp"))
! 395: return CONF_CANDIDATE_RP;
! 396: if (EQUAL(word, "group_prefix"))
! 397: return CONF_GROUP_PREFIX;
! 398: if (EQUAL(word, "rp_address"))
! 399: return CONF_RP_ADDRESS;
! 400: if (EQUAL(word, "switch_register_threshold"))
! 401: return deprecated(word, "spt-threshold", CONF_COMPAT_THRESHOLD);
! 402: if (EQUAL(word, "switch_data_threshold"))
! 403: return deprecated(word, "spt-threshold", CONF_COMPAT_THRESHOLD);
! 404: if (EQUAL(word, "spt_threshold"))
! 405: return CONF_SPT_THRESHOLD;
! 406: if (EQUAL(word, "default_source_metric"))
! 407: return CONF_DEFAULT_ROUTE_METRIC;
! 408: if (EQUAL(word, "default_source_preference"))
! 409: return CONF_DEFAULT_ROUTE_DISTANCE;
! 410: if (EQUAL(word, "default_igmp_query_interval")) /* compat */
! 411: return CONF_IGMP_QUERY_INTERVAL;
! 412: if (EQUAL(word, "default_igmp_querier_timeout")) /* compat */
! 413: return CONF_IGMP_QUERIER_TIMEOUT;
! 414: if (EQUAL(word, "hello_period"))
! 415: return CONF_HELLO_INTERVAL;
! 416:
! 417: return CONF_UNKNOWN;
! 418: }
! 419:
! 420: /* Check for optional /PREFIXLEN suffix to the address/group */
! 421: static void parse_prefix_len(char *token, uint32_t *len)
! 422: {
! 423: char *masklen = strchr(token, '/');
! 424:
! 425: if (masklen) {
! 426: *masklen = 0;
! 427: masklen++;
! 428: if (!sscanf(masklen, "%u", len)) {
! 429: WARN("Invalid masklen '%s'", masklen);
! 430: *len = PIM_GROUP_PREFIX_DEFAULT_MASKLEN;
! 431: }
! 432: }
! 433: }
! 434:
! 435: static void validate_prefix_len(uint32_t *len)
! 436: {
! 437: if (*len > (sizeof(uint32_t) * 8)) {
! 438: *len = (sizeof(uint32_t) * 8);
! 439: } else if (*len < PIM_GROUP_PREFIX_MIN_MASKLEN) {
! 440: WARN("Too small masklen %u. Defaulting to %d", *len, PIM_GROUP_PREFIX_MIN_MASKLEN);
! 441: *len = PIM_GROUP_PREFIX_MIN_MASKLEN;
! 442: }
! 443: }
! 444:
! 445:
! 446: /**
! 447: * parse_phyint - Parse physical interface configuration, if any.
! 448: * @s: String token
! 449: *
! 450: * Syntax:
! 451: * phyint <local-addr | ifname> [disable | enable]
! 452: * [igmpv2 | igmpv3]
! 453: * [dr-priority <1-4294967294>]
! 454: * [ttl-threshold <1-255>]
! 455: * [distance <1-255>] [metric <1-1024>]
! 456: * [altnet <net-addr>/<masklen>]
! 457: * [altnet <net-addr> masklen <masklen>]
! 458: * [scoped <net-addr>/<masklen>]
! 459: * [scoped <net-addr> masklen <masklen>]
! 460: *
! 461: * Returns:
! 462: * %TRUE if the parsing was successful, o.w. %FALSE
! 463: */
! 464: static int parse_phyint(char *s)
! 465: {
! 466: char *w, c;
! 467: uint32_t local, altnet_addr, scoped_addr;
! 468: vifi_t vifi;
! 469: struct uvif *v;
! 470: uint32_t n, altnet_masklen = 0, scoped_masklen = 0;
! 471: struct phaddr *ph;
! 472: struct vif_acl *v_acl;
! 473:
! 474: if (EQUAL((w = next_word(&s)), "")) {
! 475: WARN("Missing phyint address");
! 476: return FALSE;
! 477: }
! 478:
! 479: local = ifname2addr(w);
! 480: if (!local) {
! 481: local = inet_parse(w, 4);
! 482: if (!inet_valid_host(local)) {
! 483: WARN("Invalid phyint address '%s'", w);
! 484: return FALSE;
! 485: }
! 486: }
! 487:
! 488: for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
! 489: if (vifi == numvifs) {
! 490: WARN("phyint %s is not a valid interface", inet_fmt(local, s1, sizeof(s1)));
! 491: return FALSE;
! 492: }
! 493:
! 494: if (local != v->uv_lcl_addr)
! 495: continue;
! 496:
! 497: while (!EQUAL((w = next_word(&s)), "")) {
! 498: if (EQUAL(w, "disable")) {
! 499: v->uv_flags |= VIFF_DISABLED;
! 500: continue;
! 501: }
! 502:
! 503: if (EQUAL(w, "enable")) {
! 504: v->uv_flags &= ~VIFF_DISABLED;
! 505: continue;
! 506: }
! 507:
! 508: if (EQUAL(w, "igmpv2")) {
! 509: v->uv_flags &= ~VIFF_IGMPV1;
! 510: v->uv_flags |= VIFF_IGMPV2;
! 511: continue;
! 512: }
! 513:
! 514: if (EQUAL(w, "igmpv3")) {
! 515: v->uv_flags &= ~VIFF_IGMPV1;
! 516: v->uv_flags &= ~VIFF_IGMPV2;
! 517: continue;
! 518: }
! 519:
! 520: if (EQUAL(w, "altnet")) {
! 521: if (EQUAL((w = next_word(&s)), "")) {
! 522: WARN("Missing ALTNET for phyint %s", inet_fmt(local, s1, sizeof(s1)));
! 523: continue;
! 524: }
! 525:
! 526: parse_prefix_len (w, &altnet_masklen);
! 527:
! 528: altnet_addr = ifname2addr(w);
! 529: if (!altnet_addr) {
! 530: altnet_addr = inet_parse(w, 4);
! 531: if (!inet_valid_host(altnet_addr)) {
! 532: WARN("Invalid altnet address '%s'", w);
! 533: return FALSE;
! 534: }
! 535: }
! 536:
! 537: if (EQUAL((w = next_word(&s)), "masklen")) {
! 538: if (EQUAL((w = next_word(&s)), "")) {
! 539: WARN("Missing ALTNET masklen for phyint %s", inet_fmt(local, s1, sizeof (s1)));
! 540: continue;
! 541: }
! 542:
! 543: if (!sscanf(w, "%u", &altnet_masklen)) {
! 544: WARN("Invalid altnet masklen '%s' for phyint %s", w, inet_fmt(local, s1, sizeof(s1)));
! 545: continue;
! 546: }
! 547: }
! 548:
! 549: ph = (struct phaddr *)calloc(1, sizeof(struct phaddr));
! 550: if (!ph)
! 551: return FALSE;
! 552:
! 553: if (altnet_masklen) {
! 554: VAL_TO_MASK(ph->pa_subnetmask, altnet_masklen);
! 555: } else {
! 556: ph->pa_subnetmask = v->uv_subnetmask;
! 557: }
! 558:
! 559: ph->pa_subnet = altnet_addr & ph->pa_subnetmask;
! 560: ph->pa_subnetbcast = ph->pa_subnet | ~ph->pa_subnetmask;
! 561: if (altnet_addr & ~ph->pa_subnetmask)
! 562: WARN("Extra subnet %s/%d has host bits set", inet_fmt(altnet_addr, s1, sizeof(s1)), altnet_masklen);
! 563:
! 564: ph->pa_next = v->uv_addrs;
! 565: v->uv_addrs = ph;
! 566: logit(LOG_DEBUG, 0, "ALTNET: %s/%d", inet_fmt(altnet_addr, s1, sizeof(s1)), altnet_masklen);
! 567: } /* altnet */
! 568:
! 569: /* scoped mcast groups/masklen */
! 570: if (EQUAL(w, "scoped")) {
! 571: if (EQUAL((w = next_word(&s)), "")) {
! 572: WARN("Missing SCOPED for phyint %s", inet_fmt(local, s1, sizeof(s1)));
! 573: continue;
! 574: }
! 575:
! 576: parse_prefix_len (w, &scoped_masklen);
! 577:
! 578: scoped_addr = ifname2addr(w);
! 579: if (!scoped_addr) {
! 580: scoped_addr = inet_parse(w, 4);
! 581: if (!IN_MULTICAST(ntohl(scoped_addr))) {
! 582: WARN("Invalid scoped address '%s'", w);
! 583: return FALSE;
! 584: }
! 585: }
! 586:
! 587: if (EQUAL((w = next_word(&s)), "masklen")) {
! 588: if (EQUAL((w = next_word(&s)), "")) {
! 589: WARN("Missing SCOPED masklen for phyint %s", inet_fmt(local, s1, sizeof(s1)));
! 590: continue;
! 591: }
! 592: if (sscanf(w, "%u", &scoped_masklen) != 1) {
! 593: WARN("Invalid scoped masklen '%s' for phyint %s", w, inet_fmt(local, s1, sizeof(s1)));
! 594: continue;
! 595: }
! 596: }
! 597:
! 598: /* Invalid config. VAL_TO_MASK() also requires len > 0 or shift op will fail. */
! 599: if (!scoped_masklen) {
! 600: WARN("Too small (0) scoped masklen for phyint %s", inet_fmt(local, s1, sizeof(s1)));
! 601: continue;
! 602: }
! 603:
! 604: v_acl = (struct vif_acl *)calloc(1, sizeof(struct vif_acl));
! 605: if (!v_acl)
! 606: return FALSE;
! 607:
! 608: VAL_TO_MASK(v_acl->acl_mask, scoped_masklen);
! 609: v_acl->acl_addr = scoped_addr & v_acl->acl_mask;
! 610: if (scoped_addr & ~v_acl->acl_mask)
! 611: WARN("Boundary spec %s/%d has host bits set", inet_fmt(scoped_addr, s1, sizeof(s1)), scoped_masklen);
! 612:
! 613: v_acl->acl_next = v->uv_acl;
! 614: v->uv_acl = v_acl;
! 615: logit(LOG_DEBUG, 0, "SCOPED %s/%x", inet_fmt(v_acl->acl_addr, s1, sizeof(s1)), v_acl->acl_mask);
! 616: } /* scoped */
! 617:
! 618: if (EQUAL(w, "ttl-threshold") || EQUAL(w, "threshold")) {
! 619: if (EQUAL((w = next_word(&s)), "")) {
! 620: WARN("Missing threshold for phyint %s", inet_fmt(local, s1, sizeof(s1)));
! 621: continue;
! 622: }
! 623:
! 624: if (sscanf(w, "%u%c", &n, &c) != 1 || n < 1 || n > 255 ) {
! 625: WARN("Invalid threshold '%s' for phyint %s", w, inet_fmt(local, s1, sizeof(s1)));
! 626: continue;
! 627: }
! 628:
! 629: v->uv_threshold = n;
! 630: continue;
! 631: } /* threshold */
! 632:
! 633: if (EQUAL(w, "distance") || EQUAL(w, "preference")) {
! 634: if (EQUAL((w = next_word(&s)), "")) {
! 635: WARN("Missing distance value for phyint %s", inet_fmt(local, s1, sizeof(s1)));
! 636: continue;
! 637: }
! 638:
! 639: if (sscanf(w, "%u%c", &n, &c) != 1 || n < 1 || n > 255 ) {
! 640: WARN("Invalid distance value '%s' for phyint %s", w, inet_fmt(local, s1, sizeof(s1)));
! 641: continue;
! 642: }
! 643:
! 644: IF_DEBUG(DEBUG_ASSERT)
! 645: logit(LOG_DEBUG, 0, "Config setting default local preference on %s to %d", inet_fmt(local, s1, sizeof(s1)), n);
! 646:
! 647: v->uv_local_pref = n;
! 648: continue;
! 649: }
! 650:
! 651: if (EQUAL(w, "metric")) {
! 652: if (EQUAL((w = next_word(&s)), "")) {
! 653: WARN("Missing metric value for phyint %s", inet_fmt(local, s1, sizeof(s1)));
! 654: continue;
! 655: }
! 656:
! 657: if (sscanf(w, "%u%c", &n, &c) != 1 || n < 1 || n > 1024 ) {
! 658: WARN("Invalid metric value '%s' for phyint %s", w, inet_fmt(local, s1, sizeof(s1)));
! 659: continue;
! 660: }
! 661:
! 662: IF_DEBUG(DEBUG_ASSERT)
! 663: logit(LOG_DEBUG, 0, "Setting default local metric on %s to %d", inet_fmt(local, s1, sizeof(s1)), n);
! 664:
! 665: v->uv_local_metric = n;
! 666: continue;
! 667: }
! 668:
! 669: if (EQUAL(w, "dr-priority")) {
! 670: if (EQUAL((w = next_word(&s)), "")) {
! 671: WARN("Missing dr-priority value for phyint %s", inet_fmt(local, s1, sizeof(s1)));
! 672: continue;
! 673: }
! 674:
! 675: if (sscanf(w, "%u%c", &n, &c) != 1 || n < 1 || n > 4294967294u) {
! 676: WARN("Invalid dr-priority value '%s' for phyint %s", w, inet_fmt(local, s1, sizeof(s1)));
! 677: continue;
! 678: }
! 679:
! 680: IF_DEBUG(DEBUG_PIM_HELLO)
! 681: logit(LOG_DEBUG, 0, "Setting dr-priority on %s to %d", inet_fmt(local, s1, sizeof(s1)), n);
! 682:
! 683: v->uv_dr_prio = n;
! 684: continue;
! 685: }
! 686: } /* while(... != "") */
! 687:
! 688: break;
! 689: }
! 690:
! 691: return TRUE;
! 692: }
! 693:
! 694:
! 695: /**
! 696: * parse_rp_candidate - Parse candidate Rendez-Vous Point information.
! 697: * @s: String token
! 698: *
! 699: * Syntax:
! 700: * rp-candidate [address | ifname] [priority <0-255>] [time <10-16383>]
! 701: *
! 702: * Returns:
! 703: * %TRUE if the parsing was successful, o.w. %FALSE
! 704: */
! 705: int parse_rp_candidate(char *s)
! 706: {
! 707: u_int time = PIM_DEFAULT_CAND_RP_ADV_PERIOD;
! 708: u_int priority = PIM_DEFAULT_CAND_RP_PRIORITY;
! 709: char *w;
! 710: uint32_t local = INADDR_ANY_N;
! 711:
! 712: cand_rp_flag = FALSE;
! 713: my_cand_rp_adv_period = PIM_DEFAULT_CAND_RP_ADV_PERIOD;
! 714: while (!EQUAL((w = next_word(&s)), "")) {
! 715: if (EQUAL(w, "priority")) {
! 716: if (EQUAL((w = next_word(&s)), "")) {
! 717: WARN("Missing priority, defaulting to %u", w, PIM_DEFAULT_CAND_RP_PRIORITY);
! 718: priority = PIM_DEFAULT_CAND_RP_PRIORITY;
! 719: continue;
! 720: }
! 721:
! 722: if (sscanf(w, "%u", &priority) != 1) {
! 723: WARN("Invalid priority %s, defaulting to %u", w, PIM_DEFAULT_CAND_RP_PRIORITY);
! 724: priority = PIM_DEFAULT_CAND_RP_PRIORITY;
! 725: }
! 726:
! 727: if (priority > PIM_MAX_CAND_RP_PRIORITY) {
! 728: WARN("Too high Cand-RP priority %u, defaulting to %d", priority, PIM_MAX_CAND_RP_PRIORITY);
! 729: priority = PIM_MAX_CAND_RP_PRIORITY;
! 730: }
! 731:
! 732: continue;
! 733: }
! 734:
! 735: if (EQUAL(w, "time")) {
! 736: if (EQUAL((w = next_word(&s)), "")) {
! 737: WARN("Missing Cand-RP announce interval, defaulting to %u", PIM_DEFAULT_CAND_RP_ADV_PERIOD);
! 738: time = PIM_DEFAULT_CAND_RP_ADV_PERIOD;
! 739: continue;
! 740: }
! 741:
! 742: if (sscanf(w, "%u", &time) != 1) {
! 743: WARN("Invalid Cand-RP announce interval, defaulting to %u", PIM_DEFAULT_CAND_RP_ADV_PERIOD);
! 744: time = PIM_DEFAULT_CAND_RP_ADV_PERIOD;
! 745: continue;
! 746: }
! 747:
! 748: if (time < PIM_MIN_CAND_RP_ADV_PERIOD)
! 749: time = PIM_MIN_CAND_RP_ADV_PERIOD;
! 750:
! 751: if (time > PIM_MAX_CAND_RP_ADV_PERIOD)
! 752: time = PIM_MAX_CAND_RP_ADV_PERIOD;
! 753:
! 754: my_cand_rp_adv_period = time;
! 755: continue;
! 756: }
! 757:
! 758: /* Cand-RP interface or address */
! 759: local = ifname2addr(w);
! 760: if (!local)
! 761: local = inet_parse(w, 4);
! 762:
! 763: if (!inet_valid_host(local)) {
! 764: local = max_local_address();
! 765: WARN("Invalid Cand-RP address '%s', defaulting to %s", w, inet_fmt(local, s1, sizeof(s1)));
! 766: } else if (local_address(local) == NO_VIF) {
! 767: local = max_local_address();
! 768: WARN("Cand-RP address '%s' is not local, defaulting to %s", w, inet_fmt(local, s1, sizeof(s1)));
! 769: }
! 770: }
! 771:
! 772: if (local == INADDR_ANY_N) {
! 773: /* If address not provided, use the max. local */
! 774: local = max_local_address();
! 775: }
! 776:
! 777: my_cand_rp_address = local;
! 778: my_cand_rp_priority = priority;
! 779: my_cand_rp_adv_period = time;
! 780: cand_rp_flag = TRUE;
! 781:
! 782: logit(LOG_INFO, 0, "Local Cand-RP address %s, priority %u, interval %u sec",
! 783: inet_fmt(local, s1, sizeof(s1)), priority, time);
! 784:
! 785: return TRUE;
! 786: }
! 787:
! 788:
! 789: /**
! 790: * parse_group_prefix - Parse group-prefix configured information.
! 791: * @s: String token
! 792:
! 793: * Syntax:
! 794: * group-prefix <group>[/<masklen>]
! 795: * <group> [masklen <masklen>]
! 796: *
! 797: * Returns:
! 798: * %TRUE if the parsing was successful, o.w. %FALSE
! 799: */
! 800: int parse_group_prefix(char *s)
! 801: {
! 802: char *w;
! 803: uint32_t group_addr;
! 804: uint32_t masklen = PIM_GROUP_PREFIX_DEFAULT_MASKLEN;
! 805:
! 806: w = next_word(&s);
! 807: if (EQUAL(w, "")) {
! 808: WARN("Missing group-prefix address");
! 809: return FALSE;
! 810: }
! 811:
! 812: parse_prefix_len (w, &masklen);
! 813:
! 814: group_addr = inet_parse(w, 4);
! 815: if (!IN_MULTICAST(ntohl(group_addr))) {
! 816: WARN("Group address '%s' is not a valid multicast address", inet_fmt(group_addr, s1, sizeof(s1)));
! 817: return FALSE;
! 818: }
! 819:
! 820: /* Was if (!(~(*cand_rp_adv_message.prefix_cnt_ptr))) which Arm GCC 4.4.2 dislikes:
! 821: * --> "config.c:693: warning: promoted ~unsigned is always non-zero"
! 822: * The prefix_cnt_ptr is a uint8_t so it seems this check was to prevent overruns.
! 823: * I've changed the check to see if we've already read 255 entries, if so the cnt
! 824: * is maximized and we need to tell the user. --Joachim Nilsson 2010-01-16 */
! 825: if (*cand_rp_adv_message.prefix_cnt_ptr == 255) {
! 826: WARN("Too many multicast groups configured!");
! 827: return FALSE;
! 828: }
! 829:
! 830: if (EQUAL((w = next_word(&s)), "masklen")) {
! 831: w = next_word(&s);
! 832: if (!sscanf(w, "%u", &masklen))
! 833: masklen = PIM_GROUP_PREFIX_DEFAULT_MASKLEN;
! 834: }
! 835:
! 836: validate_prefix_len(&masklen);
! 837:
! 838: PUT_EGADDR(group_addr, (uint8_t)masklen, 0, cand_rp_adv_message.insert_data_ptr);
! 839: (*cand_rp_adv_message.prefix_cnt_ptr)++;
! 840:
! 841: logit(LOG_INFO, 0, "Adding Cand-RP group prefix %s/%d", inet_fmt(group_addr, s1, sizeof(s1)), masklen);
! 842:
! 843: return TRUE;
! 844: }
! 845:
! 846:
! 847: /**
! 848: * parse_bsr_candidate - Parse the candidate BSR configured information.
! 849: * @s: String token
! 850: *
! 851: * Syntax:
! 852: * bsr-candidate [address | ifname] [priority <0-255>]
! 853: */
! 854: int parse_bsr_candidate(char *s)
! 855: {
! 856: char *w;
! 857: uint32_t local = INADDR_ANY_N;
! 858: uint32_t priority = PIM_DEFAULT_BSR_PRIORITY;
! 859:
! 860: cand_bsr_flag = FALSE;
! 861: while (!EQUAL((w = next_word(&s)), "")) {
! 862: if (EQUAL(w, "priority")) {
! 863: if (EQUAL((w = next_word(&s)), "")) {
! 864: WARN("Missing Cand-BSR priority, defaulting to %u", PIM_DEFAULT_BSR_PRIORITY);
! 865: priority = PIM_DEFAULT_BSR_PRIORITY;
! 866: continue;
! 867: }
! 868:
! 869: if (sscanf(w, "%u", &priority) != 1) {
! 870: WARN("Invalid Cand-BSR priority %s, defaulting to %u", PIM_DEFAULT_BSR_PRIORITY);
! 871: priority = PIM_DEFAULT_BSR_PRIORITY;
! 872: continue;
! 873: }
! 874:
! 875: if (priority > PIM_MAX_CAND_BSR_PRIORITY) {
! 876: WARN("Too high Cand-BSR priority %u, defaulting to %d", priority, PIM_MAX_CAND_BSR_PRIORITY);
! 877: priority = PIM_MAX_CAND_BSR_PRIORITY;
! 878: }
! 879:
! 880: my_bsr_priority = (uint8_t)priority;
! 881: continue;
! 882: }
! 883:
! 884: /* Cand-BSR interface or address */
! 885: local = ifname2addr(w);
! 886: if (!local)
! 887: local = inet_parse(w, 4);
! 888:
! 889: if (!inet_valid_host(local)) {
! 890: local = max_local_address();
! 891: WARN("Invalid Cand-BSR address '%s', defaulting to %s", w, inet_fmt(local, s1, sizeof(s1)));
! 892: continue;
! 893: }
! 894:
! 895: if (local_address(local) == NO_VIF) {
! 896: local = max_local_address();
! 897: WARN("Cand-BSR address '%s' is not local, defaulting to %s", w, inet_fmt(local, s1, sizeof(s1)));
! 898: }
! 899: }
! 900:
! 901: if (local == INADDR_ANY_N) {
! 902: /* If address not provided, use the max. local */
! 903: local = max_local_address();
! 904: }
! 905:
! 906: my_bsr_address = local;
! 907: my_bsr_priority = priority;
! 908: MASKLEN_TO_MASK(RP_DEFAULT_IPV4_HASHMASKLEN, my_bsr_hash_mask);
! 909: cand_bsr_flag = TRUE;
! 910: logit(LOG_INFO, 0, "Local Cand-BSR address %s, priority %u", inet_fmt(local, s1, sizeof(s1)), priority);
! 911:
! 912: return TRUE;
! 913: }
! 914:
! 915: /**
! 916: * parse_rp_address - Parse rp-address config option.
! 917: * @s: String token.
! 918: *
! 919: * This is an extension to the original pimd to add pimd.conf support for static
! 920: * Rendez-Vous Point addresses.
! 921: *
! 922: * The function has been extended by pjf@asn.pl, of Lintrack, to allow specifying
! 923: * multicast group addresses as well.
! 924: *
! 925: * Syntax:
! 926: * rp-address <ADDRESS> [<GROUP>[</LENGTH> masklen <LENGTH>]
! 927: *
! 928: * Returns:
! 929: * When parsing @s is successful this function returns %TRUE, otherwise %FALSE.
! 930: */
! 931: int parse_rp_address(char *s)
! 932: {
! 933: char *w;
! 934: uint32_t local = 0xffffff;
! 935: uint32_t group_addr = htonl(INADDR_UNSPEC_GROUP);
! 936: uint32_t masklen = PIM_GROUP_PREFIX_DEFAULT_MASKLEN;
! 937: struct rp_hold *rph;
! 938:
! 939: /* next is RP addr */
! 940: w = next_word(&s);
! 941: if (EQUAL(w, "")) {
! 942: logit(LOG_WARNING, 0, "Missing rp-address argument");
! 943: return FALSE;
! 944: }
! 945:
! 946: local = inet_parse(w, 4);
! 947: if (local == 0xffffff) {
! 948: WARN("Invalid rp-address %s", w);
! 949: return FALSE;
! 950: }
! 951:
! 952: /* next is group addr if exist */
! 953: w = next_word(&s);
! 954: if (!EQUAL(w, "")) {
! 955: parse_prefix_len (w, &masklen);
! 956:
! 957: group_addr = inet_parse(w, 4);
! 958: if (!IN_MULTICAST(ntohl(group_addr))) {
! 959: WARN("%s is not a valid multicast address", inet_fmt(group_addr, s1, sizeof(s1)));
! 960: return FALSE;
! 961: }
! 962:
! 963: /* next is prefix or priority if exist */
! 964: while (!EQUAL((w = next_word(&s)), "")) {
! 965: if (EQUAL(w, "masklen")) {
! 966: w = next_word(&s);
! 967: if (!sscanf(w, "%u", &masklen)) {
! 968: WARN("Invalid masklen %s. Defaulting to %d)", w, PIM_GROUP_PREFIX_DEFAULT_MASKLEN);
! 969: masklen = PIM_GROUP_PREFIX_DEFAULT_MASKLEN;
! 970: }
! 971: }
! 972:
! 973: /* Unused, but keeping for backwards compatibility for people who
! 974: * may still have this option in their pimd.conf
! 975: * The priority of a static RP is hardcoded to always be 1, see Juniper's
! 976: * configuration or similar sources for reference. */
! 977: if (EQUAL(w, "priority")) {
! 978: w = next_word(&s);
! 979: WARN("The priority of static RP's is, as of pimd 2.2.0, always 1.");
! 980: }
! 981: }
! 982: } else {
! 983: group_addr = htonl(INADDR_UNSPEC_GROUP);
! 984: masklen = PIM_GROUP_PREFIX_MIN_MASKLEN;
! 985: }
! 986:
! 987: validate_prefix_len(&masklen);
! 988:
! 989: rph = calloc(1, sizeof(*rph));
! 990: if (!rph) {
! 991: logit(LOG_WARNING, 0, "Out of memory when parsing rp-address %s",
! 992: inet_fmt(local, s1, sizeof(s1)));
! 993: return FALSE;
! 994: }
! 995:
! 996: rph->address = local;
! 997: rph->group = group_addr;
! 998: VAL_TO_MASK(rph->mask, masklen);
! 999:
! 1000: /* attach at the beginning */
! 1001: rph->next = g_rp_hold;
! 1002: g_rp_hold = rph;
! 1003:
! 1004: logit(LOG_INFO, 0, "Local static RP: %s, group %s/%d",
! 1005: inet_fmt(local, s1, sizeof(s1)), inet_fmt(group_addr, s2, sizeof(s2)), masklen);
! 1006:
! 1007: return TRUE;
! 1008: }
! 1009:
! 1010:
! 1011: /**
! 1012: * parse_compat_threshold - Parse old deprecated pimd.conf thresholds
! 1013: * @line:
! 1014: *
! 1015: * This is a backwards compatible parser for the two older threshold
! 1016: * settings used in pimd prior to v2.2.0. The switchover mechanism has
! 1017: * been completely changed, however, so we simply read the settings as
! 1018: * if they where the same as the new spt-threshold, only converting the
! 1019: * rate argument differently (bps vs kbps). Last line to be read is
! 1020: * what is activated in pimd as spt-threshold.
! 1021: *
! 1022: * Note, previously the parser was very lenient to errors, but since the
! 1023: * default has changed it is much more strict. Any syntax error and pimd
! 1024: * bails out ignoring the line.
! 1025: *
! 1026: * Syntax:
! 1027: * switch_register_threshold [rate <BPS> interval <SEC>]
! 1028: * switch_data_threshold [rate <BPS> interval <SEC>]
! 1029: *
! 1030: * Returns:
! 1031: * When parsing @line is successful, returns %TRUE, otherwise %FALSE.
! 1032: */
! 1033: static int parse_compat_threshold(char *line)
! 1034: {
! 1035: char *w;
! 1036: int rate = -1;
! 1037: int interval = -1;
! 1038:
! 1039: while (!EQUAL((w = next_word(&line)), "")) {
! 1040: if (EQUAL(w, "rate")) {
! 1041: if (EQUAL((w = next_word(&line)), ""))
! 1042: BAILOUT("Missing rate value in compat threshold parser");
! 1043:
! 1044: /* 10 --> 1,000,000,000 == 100 Gbps */
! 1045: if (sscanf(w, "%10d", &rate) != 1)
! 1046: BAILOUT("Invalid rate value %s in compat threshold parser", w);
! 1047:
! 1048: continue;
! 1049: }
! 1050:
! 1051: if (EQUAL(w, "interval")) {
! 1052: if (EQUAL((w = next_word(&line)), ""))
! 1053: IGNORING("Missing interval value in compat threshold parser");
! 1054:
! 1055: /* 5 --> 99,999 ~= 27h */
! 1056: if (sscanf(w, "%5d", &interval) != 1)
! 1057: IGNORING("Invalid interval %s in compat threshold parser", w);
! 1058:
! 1059: continue;
! 1060: }
! 1061: }
! 1062:
! 1063: /* Set polling mode */
! 1064: spt_threshold.mode = SPT_RATE;
! 1065:
! 1066: /* Only accept values if they don't messup for new spt-threshold */
! 1067: if (interval >= TIMER_INTERVAL)
! 1068: spt_threshold.interval = interval;
! 1069:
! 1070: /* Accounting for headers we can approximate 1 byte/s == 10 bits/s (bps) */
! 1071: spt_threshold.bytes = rate * spt_threshold.interval / 10;
! 1072:
! 1073: logit(LOG_INFO, 0, "Compatibility set spt-treshold rate %u kbps with interval %u sec",
! 1074: spt_threshold.bytes, spt_threshold.interval);
! 1075:
! 1076: return TRUE;
! 1077: }
! 1078:
! 1079:
! 1080: /**
! 1081: * parse_hello_interval - Parse and assign the hello interval
! 1082: * @s: Input data
! 1083: *
! 1084: * Syntax:
! 1085: * hello-interval <SEC>
! 1086: *
! 1087: * Returns:
! 1088: * %TRUE if successful, otherwise %FALSE.
! 1089: */
! 1090: int parse_hello_interval(char *s)
! 1091: {
! 1092: char *w;
! 1093: u_int period;
! 1094: u_int holdtime;
! 1095:
! 1096: if (!EQUAL((w = next_word(&s)), "")) {
! 1097: if (sscanf(w, "%u", &period) != 1) {
! 1098: logit(LOG_WARNING, 0, "Invalid hello-interval %s; defaulting to %u", w, PIM_TIMER_HELLO_INTERVAL);
! 1099: period = PIM_TIMER_HELLO_INTERVAL;
! 1100: holdtime = PIM_TIMER_HELLO_HOLDTIME;
! 1101: } else {
! 1102: if (period <= (u_int)(UINT16_MAX / 3.5)) {
! 1103: holdtime = period * 3.5;
! 1104: } else {
! 1105: logit(LOG_WARNING, 0, "Too large hello-interval %s; defaulting to %u", w, PIM_TIMER_HELLO_INTERVAL);
! 1106: period = PIM_TIMER_HELLO_INTERVAL;
! 1107: holdtime = PIM_TIMER_HELLO_HOLDTIME;
! 1108: }
! 1109: }
! 1110: } else {
! 1111: logit(LOG_WARNING, 0, "Missing hello-interval value; defaulting to %u", PIM_TIMER_HELLO_INTERVAL);
! 1112: period = PIM_TIMER_HELLO_INTERVAL;
! 1113: holdtime = PIM_TIMER_HELLO_HOLDTIME;
! 1114: }
! 1115:
! 1116: logit(LOG_INFO, 0, "hello-interval is %u", period);
! 1117: pim_timer_hello_interval = period;
! 1118: pim_timer_hello_holdtime = holdtime;
! 1119:
! 1120: return TRUE;
! 1121: }
! 1122:
! 1123:
! 1124: /**
! 1125: * parse_spt_threshold - Parse spt-threshold option
! 1126: * @s: String token
! 1127: *
! 1128: * This configuration setting replaces the switch_register_threshold and
! 1129: * switch_data_threshold. It is more intuitive and more in line with
! 1130: * what major vendors are also using.
! 1131: *
! 1132: * Note that the rate is in kbps instead of bps, compared to the old
! 1133: * syntax. Both the above parse_compat_threshold() and this function
! 1134: * target the same backend.
! 1135: *
! 1136: * Syntax:
! 1137: * spt-threshold [rate <KBPS> | packets <NUM> | infinity] [interval <SEC>]
! 1138: *
! 1139: * Returns:
! 1140: * When parsing @s is successful this function returns %TRUE, otherwise %FALSE.
! 1141: */
! 1142: static int parse_spt_threshold(char *s)
! 1143: {
! 1144: char *w;
! 1145: uint32_t rate = SPT_THRESHOLD_DEFAULT_RATE;
! 1146: uint32_t packets = SPT_THRESHOLD_DEFAULT_PACKETS;
! 1147: uint32_t interval = SPT_THRESHOLD_DEFAULT_INTERVAL;
! 1148: spt_mode_t mode = SPT_THRESHOLD_DEFAULT_MODE;
! 1149:
! 1150: while (!EQUAL((w = next_word(&s)), "")) {
! 1151: if (EQUAL(w, "rate")) {
! 1152: mode = SPT_RATE;
! 1153:
! 1154: if (EQUAL((w = next_word(&s)), "")) {
! 1155: WARN("Missing spt-threshold rate argument, defaulting to %u", SPT_THRESHOLD_DEFAULT_RATE);
! 1156: rate = SPT_THRESHOLD_DEFAULT_RATE;
! 1157: continue;
! 1158: }
! 1159:
! 1160: /* 10 --> 1,000,000,000 == 100 Gbps */
! 1161: if (sscanf(w, "%10u", &rate) != 1) {
! 1162: WARN("Invalid spt-threshold rate %s, defaulting to %u", w, SPT_THRESHOLD_DEFAULT_RATE);
! 1163: rate = SPT_THRESHOLD_DEFAULT_RATE;
! 1164: }
! 1165:
! 1166: continue;
! 1167: }
! 1168:
! 1169: if (EQUAL(w, "interval")) {
! 1170: if (EQUAL((w = next_word(&s)), "")) {
! 1171: WARN("Missing spt-threshold interval; defaulting to %u sec", SPT_THRESHOLD_DEFAULT_INTERVAL);
! 1172: interval = SPT_THRESHOLD_DEFAULT_INTERVAL;
! 1173: continue;
! 1174: }
! 1175:
! 1176: /* 5 --> 99,999 ~= 27h */
! 1177: if (sscanf(w, "%5u", &interval) != 1) {
! 1178: WARN("Invalid spt-threshold interval %s; defaulting to %u sec", w, SPT_THRESHOLD_DEFAULT_INTERVAL);
! 1179: interval = SPT_THRESHOLD_DEFAULT_INTERVAL;
! 1180: }
! 1181:
! 1182: if (interval < TIMER_INTERVAL) {
! 1183: WARN("Too low spt-threshold interval %s; defaulting to %u sec", w, TIMER_INTERVAL);
! 1184: interval = TIMER_INTERVAL;
! 1185: }
! 1186:
! 1187: continue;
! 1188: }
! 1189:
! 1190: if (EQUAL(w, "packets")) {
! 1191: mode = SPT_PACKETS;
! 1192:
! 1193: if (EQUAL((w = next_word(&s)), "")) {
! 1194: WARN("Missing spt-threshold number of packets; defaulting to %u", SPT_THRESHOLD_DEFAULT_PACKETS);
! 1195: packets = SPT_THRESHOLD_DEFAULT_PACKETS;
! 1196: continue;
! 1197: }
! 1198:
! 1199: /* 10 --> 4294967295, which is max of uint32_t */
! 1200: if (sscanf(w, "%10u", &packets) != 1) {
! 1201: WARN("Invalid spt-threshold packets %s; defaulting to %u",
! 1202: w, SPT_THRESHOLD_DEFAULT_PACKETS);
! 1203: packets = SPT_THRESHOLD_DEFAULT_INTERVAL;
! 1204: }
! 1205:
! 1206: continue;
! 1207: }
! 1208:
! 1209: if (EQUAL(w, "infinity")) {
! 1210: mode = SPT_INF;
! 1211: continue;
! 1212: }
! 1213:
! 1214: WARN("Invalid spt-threshold parameter %s; reverting to defaults.", w);
! 1215: mode = SPT_THRESHOLD_DEFAULT_MODE;
! 1216: rate = SPT_THRESHOLD_DEFAULT_RATE;
! 1217: packets = SPT_THRESHOLD_DEFAULT_PACKETS;
! 1218: interval = SPT_THRESHOLD_DEFAULT_INTERVAL;
! 1219: break;
! 1220: }
! 1221:
! 1222: spt_threshold.mode = mode;
! 1223: switch (mode) {
! 1224: case SPT_INF:
! 1225: logit(LOG_INFO, 0, "spt-threshold infinity => RP and lasthop router will never switch to SPT.");
! 1226: break;
! 1227:
! 1228: case SPT_RATE:
! 1229: /* Accounting for headers we can approximate 1 byte/s == 10 bits/s (bps)
! 1230: * Note, in the new spt_threshold setting the rate is in kbps as well! */
! 1231: spt_threshold.bytes = rate * interval / 10 * 1000;
! 1232: spt_threshold.interval = interval;
! 1233: logit(LOG_INFO, 0, "spt-threshold rate %u interval %u", rate, interval);
! 1234: break;
! 1235:
! 1236: case SPT_PACKETS:
! 1237: spt_threshold.packets = packets;
! 1238: spt_threshold.interval = interval;
! 1239: logit(LOG_INFO, 0, "spt-threshold packets %u interval %u", packets, interval);
! 1240: break;
! 1241:
! 1242: }
! 1243:
! 1244: return TRUE;
! 1245: }
! 1246:
! 1247:
! 1248: /**
! 1249: * parse_default_route_metric - Parse default-route-metric option
! 1250: * @s: String token
! 1251: *
! 1252: * Reads and assigns the route metric used for PIM Asserts by default.
! 1253: * This is used if pimd cannot read unicast route metrics from the
! 1254: * OS/kernel.
! 1255: *
! 1256: * Syntax:
! 1257: * default-route-metric <1-1024>
! 1258: *
! 1259: * Default routing protocol distance and route metric statements should
! 1260: * precede all phyint statements in the config file.
! 1261: *
! 1262: * Returns:
! 1263: * When parsing @s is successful this function returns %TRUE, otherwise %FALSE.
! 1264: */
! 1265: int parse_default_route_metric(char *s)
! 1266: {
! 1267: char *w;
! 1268: u_int value;
! 1269: vifi_t vifi;
! 1270: struct uvif *v;
! 1271:
! 1272: value = UCAST_DEFAULT_ROUTE_METRIC;
! 1273: if (EQUAL((w = next_word(&s)), "")) {
! 1274: WARN("Missing route metric default; defaulting to %u", UCAST_DEFAULT_ROUTE_METRIC);
! 1275: } else if (sscanf(w, "%u", &value) != 1) {
! 1276: WARN("Invalid route metric default; defaulting to %u", UCAST_DEFAULT_ROUTE_METRIC);
! 1277: value = UCAST_DEFAULT_ROUTE_METRIC;
! 1278: }
! 1279:
! 1280: default_route_metric = value;
! 1281: logit(LOG_INFO, 0, "default-route-metric is %u", value);
! 1282:
! 1283: for (vifi = 0, v = uvifs; vifi < MAXVIFS; ++vifi, ++v)
! 1284: v->uv_local_metric = default_route_metric;
! 1285:
! 1286: return TRUE;
! 1287: }
! 1288:
! 1289:
! 1290: /**
! 1291: * parse_default_route_distance - Parse default-route-distance option
! 1292: * @s: String token
! 1293: *
! 1294: * Reads and assigns the default source metric preference, i.e. routing
! 1295: * protocol distance. This is used if pimd cannot read unicast routing
! 1296: * protocol information from the OS/kernel.
! 1297: *
! 1298: * Syntax:
! 1299: * default-route-distance <1-255>
! 1300: *
! 1301: * Default routing protocol distance and route metric statements should
! 1302: * precede all phyint statements in the config file.
! 1303: *
! 1304: * Returns:
! 1305: * When parsing @s is successful this function returns %TRUE, otherwise %FALSE.
! 1306: */
! 1307: int parse_default_route_distance(char *s)
! 1308: {
! 1309: char *w;
! 1310: u_int value;
! 1311: vifi_t vifi;
! 1312: struct uvif *v;
! 1313:
! 1314: value = UCAST_DEFAULT_ROUTE_DISTANCE;
! 1315: if (EQUAL((w = next_word(&s)), "")) {
! 1316: WARN("Missing default routing protocol distance; defaulting to %u", UCAST_DEFAULT_ROUTE_DISTANCE);
! 1317: } else if (sscanf(w, "%u", &value) != 1) {
! 1318: WARN("Invalid default routing protocol distance; defaulting to %u", UCAST_DEFAULT_ROUTE_DISTANCE);
! 1319: value = UCAST_DEFAULT_ROUTE_DISTANCE;
! 1320: }
! 1321:
! 1322: default_route_distance = value;
! 1323: logit(LOG_INFO, 0, "default-route-distance is %u", value);
! 1324: for (vifi = 0, v = uvifs; vifi < MAXVIFS; ++vifi, ++v)
! 1325: v->uv_local_pref = default_route_distance;
! 1326:
! 1327: return TRUE;
! 1328: }
! 1329:
! 1330: /**
! 1331: * parse_igmp_query_interval - Parse igmp-query-interval option
! 1332: * @s: String token
! 1333: *
! 1334: * Reads and assigns the default IGMP query interval. If the argument
! 1335: * is missing or invalid the parser defaults to %IGMP_QUERY_INTERVAL
! 1336: *
! 1337: * Syntax:
! 1338: * igmp-query-interval <SEC>
! 1339: *
! 1340: * Returns:
! 1341: * When parsing @s is successful this function returns %TRUE, otherwise %FALSE.
! 1342: */
! 1343: static int parse_igmp_query_interval(char *s)
! 1344: {
! 1345: char *w;
! 1346: uint32_t value = IGMP_QUERY_INTERVAL;
! 1347:
! 1348: if (EQUAL((w = next_word(&s)), "")) {
! 1349: WARN("Missing argument to igmp-query-interval; defaulting to %u", IGMP_QUERY_INTERVAL);
! 1350: } else if (sscanf(w, "%u", &value) != 1) {
! 1351: WARN("Invalid default igmp-query-interval; defaulting to %u", IGMP_QUERY_INTERVAL);
! 1352: value = IGMP_QUERY_INTERVAL;
! 1353: }
! 1354:
! 1355: igmp_query_interval = value;
! 1356:
! 1357: /* Calculate new querier timeout, or expect config option after this. */
! 1358: igmp_querier_timeout = 0;
! 1359:
! 1360: return TRUE;
! 1361: }
! 1362:
! 1363: /**
! 1364: * parse_igmp_querier_timeout - Parse igmp-querier-timeout option
! 1365: * @s: String token
! 1366: *
! 1367: * Reads and assigns default querier timeout for an active IGMP querier.
! 1368: * This is the time it takes before pimd tries to take over as the
! 1369: * active querier. If the argument is missing or invalid the system
! 1370: * will calculate a fallback based on the query interval.
! 1371: *
! 1372: * Syntax:
! 1373: * igmp-querier-timeout <SEC>
! 1374: *
! 1375: * Returns:
! 1376: * When parsing @s is successful this function returns %TRUE, otherwise %FALSE.
! 1377: */
! 1378: static int parse_igmp_querier_timeout(char *s)
! 1379: {
! 1380: char *w;
! 1381: uint32_t value = 0;
! 1382: uint32_t recommended = QUERIER_TIMEOUT(igmp_query_interval);
! 1383:
! 1384: if (EQUAL((w = next_word(&s)), "")) {
! 1385: WARN("Missing argument to igmp-querier-timeout!");
! 1386: } else if (sscanf(w, "%u", &value) != 1) {
! 1387: WARN("Invalid default igmp-querier-timeout!");
! 1388: value = 0;
! 1389: }
! 1390:
! 1391: /* Do some sanity checks to prevent invalid configuration and to recommend
! 1392: * better settings, see GitHub issue troglobit/pimd#31 for details. */
! 1393: if (value != 0) {
! 1394: /* 1) Prevent invalid configuration */
! 1395: if (value <= igmp_query_interval) {
! 1396: WARN("IGMP querier timeout %d must be larger than the query interval %d, forcing default!",
! 1397: value, igmp_query_interval);
! 1398: value = recommended;
! 1399: }
! 1400:
! 1401: /* 2) Warn power user of potentially too low setting. */
! 1402: if (value < recommended)
! 1403: WARN("The IGMP querier timeout %d is smaller than the recommended value %d, allowing ...",
! 1404: value, recommended);
! 1405:
! 1406: logit(LOG_WARNING, 0, "Recommended querier timeout = Robustness x query-interval + response-time / 2 = %d x %d + %d / 2 = %d",
! 1407: IGMP_ROBUSTNESS_VARIABLE, igmp_query_interval, IGMP_QUERY_RESPONSE_INTERVAL, recommended);
! 1408: }
! 1409:
! 1410: igmp_querier_timeout = value;
! 1411:
! 1412: return TRUE;
! 1413: }
! 1414:
! 1415: static void fallback_config(void)
! 1416: {
! 1417: char buf[LINE_BUFSIZ], *s = buf;
! 1418:
! 1419: logit(LOG_NOTICE, 0, "Using built-in defaults, including RP/BSR candidate.");
! 1420:
! 1421: snprintf(buf, sizeof(buf), "priority 20 time 30");
! 1422: parse_rp_candidate(s);
! 1423:
! 1424: snprintf(buf, sizeof(buf), "priority 5");
! 1425: parse_bsr_candidate(s);
! 1426: }
! 1427:
! 1428: void config_vifs_from_file(void)
! 1429: {
! 1430: FILE *fp;
! 1431: char linebuf[LINE_BUFSIZ];
! 1432: char *w, *s;
! 1433: int option;
! 1434: uint8_t *data_ptr;
! 1435: int error_flag;
! 1436:
! 1437: error_flag = FALSE;
! 1438: lineno = 0;
! 1439:
! 1440: /* TODO: HARDCODING!!! */
! 1441: cand_rp_adv_message.buffer = calloc(1, 4 + sizeof(pim_encod_uni_addr_t) +
! 1442: 255 * sizeof(pim_encod_grp_addr_t));
! 1443: if (!cand_rp_adv_message.buffer)
! 1444: logit(LOG_ERR, errno, "Ran out of memory in config_vifs_from_file()");
! 1445:
! 1446: cand_rp_adv_message.prefix_cnt_ptr = cand_rp_adv_message.buffer;
! 1447: /* By default, if no group-prefix configured, then prefix_cnt == 0
! 1448: * implies group-prefix = 224.0.0.0 and masklen = 4.
! 1449: */
! 1450: *cand_rp_adv_message.prefix_cnt_ptr = 0;
! 1451: cand_rp_adv_message.insert_data_ptr = cand_rp_adv_message.buffer;
! 1452: /* TODO: XXX: HARDCODING!!! */
! 1453: cand_rp_adv_message.insert_data_ptr += (4 + 6);
! 1454:
! 1455: fp = fopen(config_file, "r");
! 1456: if (!fp) {
! 1457: logit(LOG_WARNING, errno, "Cannot open configuration file %s", config_file);
! 1458: fallback_config();
! 1459: goto nofile;
! 1460: }
! 1461:
! 1462: while (fgets(linebuf, sizeof(linebuf), fp)) {
! 1463: if (strlen(linebuf) >= (LINE_BUFSIZ - 1)) {
! 1464: WARN("Line length must be shorter than %d", LINE_BUFSIZ);
! 1465: error_flag = TRUE;
! 1466: }
! 1467: lineno++;
! 1468:
! 1469: s = linebuf;
! 1470: w = next_word(&s);
! 1471: option = parse_option(w);
! 1472:
! 1473: switch (option) {
! 1474: case CONF_EMPTY:
! 1475: continue;
! 1476: break;
! 1477:
! 1478: case CONF_PHYINT:
! 1479: parse_phyint(s);
! 1480: break;
! 1481:
! 1482: case CONF_CANDIDATE_RP:
! 1483: parse_rp_candidate(s);
! 1484: break;
! 1485:
! 1486: case CONF_RP_ADDRESS:
! 1487: parse_rp_address(s);
! 1488: break;
! 1489:
! 1490: case CONF_GROUP_PREFIX:
! 1491: parse_group_prefix(s);
! 1492: break;
! 1493:
! 1494: case CONF_BOOTSTRAP_RP:
! 1495: parse_bsr_candidate(s);
! 1496: break;
! 1497:
! 1498: case CONF_COMPAT_THRESHOLD:
! 1499: parse_compat_threshold(s);
! 1500: break;
! 1501:
! 1502: case CONF_SPT_THRESHOLD:
! 1503: parse_spt_threshold(s);
! 1504: break;
! 1505:
! 1506: case CONF_DEFAULT_ROUTE_METRIC:
! 1507: parse_default_route_metric(s);
! 1508: break;
! 1509:
! 1510: case CONF_DEFAULT_ROUTE_DISTANCE:
! 1511: parse_default_route_distance(s);
! 1512: break;
! 1513:
! 1514: case CONF_IGMP_QUERY_INTERVAL:
! 1515: parse_igmp_query_interval(s);
! 1516: break;
! 1517:
! 1518: case CONF_IGMP_QUERIER_TIMEOUT:
! 1519: parse_igmp_querier_timeout(s);
! 1520: break;
! 1521:
! 1522: case CONF_HELLO_INTERVAL:
! 1523: parse_hello_interval(s);
! 1524: break;
! 1525:
! 1526: default:
! 1527: logit(LOG_WARNING, 0, "%s:%u - Unknown command '%s'", config_file, lineno, w);
! 1528: error_flag = TRUE;
! 1529: }
! 1530: }
! 1531:
! 1532: fclose(fp);
! 1533:
! 1534: nofile:
! 1535: /* A static RP address is needed for SSM. We use a link-local
! 1536: * address. It is not required to be configured on any interface. */
! 1537: strncpy(linebuf, "169.254.0.1 232.0.0.0/8\n", sizeof(linebuf));
! 1538: s = linebuf;
! 1539: parse_rp_address(s);
! 1540:
! 1541: if (error_flag)
! 1542: logit(LOG_ERR, 0, "%s:%u - Syntax error", config_file, lineno);
! 1543:
! 1544: cand_rp_adv_message.message_size = cand_rp_adv_message.insert_data_ptr - cand_rp_adv_message.buffer;
! 1545: if (cand_rp_flag != FALSE) {
! 1546: /* Prepare the RP info */
! 1547: my_cand_rp_holdtime = 2.5 * my_cand_rp_adv_period;
! 1548:
! 1549: /* TODO: HARDCODING! */
! 1550: data_ptr = cand_rp_adv_message.buffer + 1;
! 1551: PUT_BYTE(my_cand_rp_priority, data_ptr);
! 1552: PUT_HOSTSHORT(my_cand_rp_holdtime, data_ptr);
! 1553: PUT_EUADDR(my_cand_rp_address, data_ptr);
! 1554: }
! 1555:
! 1556: /* If no IGMP querier timeout was set, calculate from query interval */
! 1557: if (!igmp_querier_timeout)
! 1558: igmp_querier_timeout = QUERIER_TIMEOUT(igmp_query_interval);
! 1559:
! 1560: IF_DEBUG(DEBUG_IGMP) {
! 1561: logit(LOG_INFO, 0, "IGMP query interval : %u sec", igmp_query_interval);
! 1562: logit(LOG_INFO, 0, "IGMP querier timeout : %u sec", igmp_querier_timeout);
! 1563: }
! 1564: }
! 1565:
! 1566:
! 1567: static uint32_t ifname2addr(char *s)
! 1568: {
! 1569: vifi_t vifi;
! 1570: struct uvif *v;
! 1571:
! 1572: for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
! 1573: if (!strcmp(v->uv_name, s))
! 1574: return v->uv_lcl_addr;
! 1575: }
! 1576:
! 1577: return 0;
! 1578: }
! 1579:
! 1580: static char *next_word(char **s)
! 1581: {
! 1582: char *w;
! 1583:
! 1584: w = *s;
! 1585: while (*w == ' ' || *w == '\t')
! 1586: w++;
! 1587:
! 1588: *s = w;
! 1589: while (**s != 0) {
! 1590: switch (**s) {
! 1591: case ' ':
! 1592: case '\t':
! 1593: **s = '\0';
! 1594: (*s)++;
! 1595: return w;
! 1596:
! 1597: case '\n':
! 1598: case '#':
! 1599: **s = '\0';
! 1600: return w;
! 1601:
! 1602: default:
! 1603: if (isascii((int)**s) && isupper((int)**s))
! 1604: **s = tolower((int)**s);
! 1605: (*s)++;
! 1606: }
! 1607: }
! 1608:
! 1609: return w;
! 1610: }
! 1611:
! 1612: /**
! 1613: * Local Variables:
! 1614: * version-control: t
! 1615: * indent-tabs-mode: t
! 1616: * c-file-style: "ellemtel"
! 1617: * c-basic-offset: 4
! 1618: * End:
! 1619: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to config.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimd