Annotation of embedaddon/mrouted/mapper.c, revision 1.1
1.1 ! misho 1: /* Mapper for connections between MRouteD multicast routers.
! 2: * Written by Pavel Curtis
! 3: */
! 4:
! 5:
! 6: /*
! 7: * Copyright (c) 1992, 2001 Xerox Corporation. All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without modification,
! 10: * are permitted provided that the following conditions are met:
! 11: *
! 12: * Redistributions of source code must retain the above copyright notice,
! 13: * this list of conditions and the following disclaimer.
! 14: *
! 15: * Redistributions in binary form must reproduce the above copyright notice,
! 16: * this list of conditions and the following disclaimer in the documentation
! 17: * and/or other materials provided with the distribution.
! 18:
! 19: * Neither name of the Xerox, PARC, nor the names of its contributors may be used
! 20: * to endorse or promote products derived from this software
! 21: * without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
! 24: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
! 25: * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 26: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE XEROX CORPORATION OR CONTRIBUTORS
! 27: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 28: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 29: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
! 30: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! 31: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
! 32: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
! 33: * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 34: */
! 35:
! 36: #include <arpa/inet.h>
! 37: #include <err.h>
! 38: #include <netdb.h>
! 39: #include <stdarg.h>
! 40: #include <string.h>
! 41: #include <sys/time.h>
! 42:
! 43: #include "defs.h"
! 44:
! 45: #define DEFAULT_TIMEOUT 2 /* How long to wait before retrying requests */
! 46: #define DEFAULT_RETRIES 1 /* How many times to ask each router */
! 47:
! 48:
! 49: /* All IP addresses are stored in the data structure in NET order. */
! 50:
! 51: typedef struct neighbor {
! 52: struct neighbor *next;
! 53: u_int32_t addr; /* IP address in NET order */
! 54: u_char metric; /* TTL cost of forwarding */
! 55: u_char threshold; /* TTL threshold to forward */
! 56: u_int16_t flags; /* flags on connection */
! 57: #define NF_PRESENT 0x8000 /* True if flags are meaningful */
! 58: } Neighbor;
! 59:
! 60: typedef struct interface {
! 61: struct interface *next;
! 62: u_int32_t addr; /* IP address of the interface in NET order */
! 63: Neighbor *neighbors; /* List of neighbors' IP addresses */
! 64: } Interface;
! 65:
! 66: typedef struct node {
! 67: u_int32_t addr; /* IP address of this entry in NET order
! 68: */
! 69: u_int32_t version; /* which mrouted version is running */
! 70: int tries; /* How many requests sent? -1 for aliases */
! 71: union {
! 72: struct node *alias; /* If alias, to what? */
! 73: struct interface *interfaces; /* Else, neighbor data */
! 74: } u;
! 75: struct node *left, *right;
! 76: } Node;
! 77:
! 78:
! 79: Node *routers = 0;
! 80: u_int32_t our_addr, target_addr = 0; /* in NET order */
! 81: int debug = 0;
! 82: int retries = DEFAULT_RETRIES;
! 83: int timeout = DEFAULT_TIMEOUT;
! 84: int show_names = TRUE;
! 85: vifi_t numvifs; /* to keep loader happy */
! 86: /* (see COPY_TABLES macro called in kern.c) */
! 87:
! 88: Node * find_node(u_int32_t addr, Node **ptr);
! 89: Interface * find_interface(u_int32_t addr, Node *node);
! 90: Neighbor * find_neighbor(u_int32_t addr, Node *node);
! 91: int main(int argc, char *argv[]);
! 92: void ask(u_int32_t dst);
! 93: void ask2(u_int32_t dst);
! 94: int retry_requests(Node *node);
! 95: char * inet_name(u_int32_t addr);
! 96: void print_map(Node *node);
! 97: char * graph_name(u_int32_t addr, char *buf, size_t len);
! 98: void graph_edges(Node *node);
! 99: void elide_aliases(Node *node);
! 100: void graph_map(void);
! 101: u_int32_t host_addr(char *name);
! 102: void usage(void);
! 103:
! 104: Node *find_node(u_int32_t addr, Node **ptr)
! 105: {
! 106: Node *n = *ptr;
! 107:
! 108: if (!n) {
! 109: *ptr = n = (Node *) malloc(sizeof(Node));
! 110: n->addr = addr;
! 111: n->version = 0;
! 112: n->tries = 0;
! 113: n->u.interfaces = 0;
! 114: n->left = n->right = 0;
! 115: return n;
! 116: } else if (addr == n->addr)
! 117: return n;
! 118: else if (addr < n->addr)
! 119: return find_node(addr, &(n->left));
! 120: else
! 121: return find_node(addr, &(n->right));
! 122: }
! 123:
! 124:
! 125: Interface *find_interface(u_int32_t addr, Node *node)
! 126: {
! 127: Interface *ifc;
! 128:
! 129: for (ifc = node->u.interfaces; ifc; ifc = ifc->next)
! 130: if (ifc->addr == addr)
! 131: return ifc;
! 132:
! 133: ifc = (Interface *) malloc(sizeof(Interface));
! 134: ifc->addr = addr;
! 135: ifc->next = node->u.interfaces;
! 136: node->u.interfaces = ifc;
! 137: ifc->neighbors = 0;
! 138:
! 139: return ifc;
! 140: }
! 141:
! 142:
! 143: Neighbor *find_neighbor(u_int32_t addr, Node *node)
! 144: {
! 145: Interface *ifc;
! 146:
! 147: for (ifc = node->u.interfaces; ifc; ifc = ifc->next) {
! 148: Neighbor *nb;
! 149:
! 150: for (nb = ifc->neighbors; nb; nb = nb->next)
! 151: if (nb->addr == addr)
! 152: return nb;
! 153: }
! 154:
! 155: return 0;
! 156: }
! 157:
! 158:
! 159: /*
! 160: * Log errors and other messages to stderr, according to the severity of the
! 161: * message and the current debug level. For errors of severity LOG_ERR or
! 162: * worse, terminate the program.
! 163: */
! 164: void logit(int severity, int syserr, const char *format, ...)
! 165: {
! 166: va_list ap;
! 167:
! 168: switch (debug) {
! 169: case 0:
! 170: if (severity > LOG_WARNING)
! 171: return;
! 172: case 1:
! 173: if (severity > LOG_NOTICE)
! 174: return;
! 175: case 2:
! 176: if (severity > LOG_INFO)
! 177: return;
! 178: default:
! 179: if (severity == LOG_WARNING)
! 180: fprintf(stderr, "warning - ");
! 181: va_start(ap, format);
! 182: vfprintf(stderr, format, ap);
! 183: va_end(ap);
! 184: if (syserr == 0)
! 185: fprintf(stderr, "\n");
! 186: else
! 187: fprintf(stderr, ": %s\n", strerror(syserr));
! 188: }
! 189:
! 190: if (severity <= LOG_ERR)
! 191: exit(1);
! 192: }
! 193:
! 194: /*
! 195: * Send a neighbors-list request.
! 196: */
! 197: void ask(u_int32_t dst)
! 198: {
! 199: send_igmp(our_addr, dst, IGMP_DVMRP, DVMRP_ASK_NEIGHBORS,
! 200: htonl(MROUTED_LEVEL), 0);
! 201: }
! 202:
! 203: void ask2(u_int32_t dst)
! 204: {
! 205: send_igmp(our_addr, dst, IGMP_DVMRP, DVMRP_ASK_NEIGHBORS2,
! 206: htonl(MROUTED_LEVEL), 0);
! 207: }
! 208:
! 209:
! 210: /*
! 211: * Process an incoming group membership report.
! 212: */
! 213: void accept_group_report(u_int32 src, u_int32 dst, u_int32 UNUSED group, int UNUSED r_type)
! 214: {
! 215: logit(LOG_INFO, 0, "ignoring IGMP group membership report from %s to %s",
! 216: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
! 217: }
! 218:
! 219:
! 220: /*
! 221: * Process an incoming neighbor probe message.
! 222: */
! 223: void accept_probe(u_int32_t src, u_int32_t dst, char UNUSED *p, size_t UNUSED datalen, u_int32_t UNUSED level)
! 224: {
! 225: logit(LOG_INFO, 0, "ignoring DVMRP probe from %s to %s",
! 226: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
! 227: }
! 228:
! 229:
! 230: /*
! 231: * Process an incoming route report message.
! 232: */
! 233: void accept_report(u_int32 src, u_int32 dst, char UNUSED *p, size_t UNUSED datalen, u_int32 UNUSED level)
! 234: {
! 235: logit(LOG_INFO, 0, "ignoring DVMRP routing report from %s to %s",
! 236: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
! 237: }
! 238:
! 239:
! 240: /*
! 241: * Process an incoming neighbor-list request message.
! 242: */
! 243: void accept_neighbor_request(u_int32 src, u_int32 dst)
! 244: {
! 245: if (src != our_addr)
! 246: logit(LOG_INFO, 0,
! 247: "ignoring spurious DVMRP neighbor request from %s to %s",
! 248: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
! 249: }
! 250:
! 251: void accept_neighbor_request2(u_int32 src, u_int32 dst)
! 252: {
! 253: if (src != our_addr)
! 254: logit(LOG_INFO, 0,
! 255: "ignoring spurious DVMRP neighbor request2 from %s to %s",
! 256: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
! 257: }
! 258:
! 259:
! 260: /*
! 261: * Process an incoming neighbor-list message.
! 262: */
! 263: void accept_neighbors(u_int32_t src, u_int32_t UNUSED dst, u_char *p, size_t datalen, u_int32_t level)
! 264: {
! 265: Node *node = find_node(src, &routers);
! 266:
! 267: if (node->tries == 0) /* Never heard of 'em; must have hit them at */
! 268: node->tries = 1; /* least once, though...*/
! 269: else if (node->tries == -1) /* follow alias link */
! 270: node = node->u.alias;
! 271:
! 272: #define GET_ADDR(a) (a = ((u_int32_t)*p++ << 24), a += ((u_int32_t)*p++ << 16),\
! 273: a += ((u_int32_t)*p++ << 8), a += *p++)
! 274:
! 275: /* if node is running a recent mrouted, ask for additional info */
! 276: if (level != 0) {
! 277: node->version = level;
! 278: node->tries = 1;
! 279: ask2(src);
! 280: return;
! 281: }
! 282:
! 283: if (debug > 3) {
! 284: size_t i;
! 285:
! 286: fprintf(stderr, " datalen = %zu\n", datalen);
! 287: for (i = 0; i < datalen; i++) {
! 288: if ((i & 0xF) == 0)
! 289: fprintf(stderr, " ");
! 290: fprintf(stderr, " %02x", p[i]);
! 291: if ((i & 0xF) == 0xF)
! 292: fprintf(stderr, "\n");
! 293: }
! 294: if ((datalen & 0xF) != 0xF)
! 295: fprintf(stderr, "\n");
! 296: }
! 297:
! 298: while (datalen > 0) { /* loop through interfaces */
! 299: u_int32_t ifc_addr;
! 300: u_char metric, threshold, ncount;
! 301: Node *ifc_node;
! 302: Interface *ifc;
! 303: Neighbor *old_neighbors;
! 304:
! 305: if (datalen < 4 + 3) {
! 306: logit(LOG_WARNING, 0, "received truncated interface record from %s",
! 307: inet_fmt(src, s1, sizeof(s1)));
! 308: return;
! 309: }
! 310:
! 311: GET_ADDR(ifc_addr);
! 312: ifc_addr = htonl(ifc_addr);
! 313: metric = *p++;
! 314: threshold = *p++;
! 315: ncount = *p++;
! 316: datalen -= 4 + 3;
! 317:
! 318: /* Fix up any alias information */
! 319: ifc_node = find_node(ifc_addr, &routers);
! 320: if (ifc_node->tries == 0) { /* new node */
! 321: ifc_node->tries = -1;
! 322: ifc_node->u.alias = node;
! 323: } else if (ifc_node != node
! 324: && (ifc_node->tries > 0 || ifc_node->u.alias != node)) {
! 325: /* must merge two hosts' nodes */
! 326: Interface *ifc_i, *next_ifc_i;
! 327:
! 328: if (ifc_node->tries == -1) {
! 329: Node *tmp = ifc_node->u.alias;
! 330:
! 331: ifc_node->u.alias = node;
! 332: ifc_node = tmp;
! 333: }
! 334:
! 335: /* Merge ifc_node (foo_i) into node (foo_n) */
! 336:
! 337: if (ifc_node->tries > node->tries)
! 338: node->tries = ifc_node->tries;
! 339:
! 340: for (ifc_i = ifc_node->u.interfaces; ifc_i; ifc_i = next_ifc_i) {
! 341: Neighbor *nb_i, *next_nb_i, *nb_n;
! 342: Interface *ifc_n = find_interface(ifc_i->addr, node);
! 343:
! 344: old_neighbors = ifc_n->neighbors;
! 345: for (nb_i = ifc_i->neighbors; nb_i; nb_i = next_nb_i) {
! 346: next_nb_i = nb_i->next;
! 347: for (nb_n = old_neighbors; nb_n; nb_n = nb_n->next)
! 348: if (nb_i->addr == nb_n->addr) {
! 349: if (nb_i->metric != nb_n->metric
! 350: || nb_i->threshold != nb_n->threshold)
! 351: logit(LOG_WARNING, 0,
! 352: "inconsistent %s for neighbor %s of %s",
! 353: "metric/threshold",
! 354: inet_fmt(nb_i->addr, s1, sizeof(s1)),
! 355: inet_fmt(node->addr, s2, sizeof(s2)));
! 356: free(nb_i);
! 357: break;
! 358: }
! 359: if (!nb_n) { /* no match for this neighbor yet */
! 360: nb_i->next = ifc_n->neighbors;
! 361: ifc_n->neighbors = nb_i;
! 362: }
! 363: }
! 364:
! 365: next_ifc_i = ifc_i->next;
! 366: free(ifc_i);
! 367: }
! 368:
! 369: ifc_node->tries = -1;
! 370: ifc_node->u.alias = node;
! 371: }
! 372:
! 373: ifc = find_interface(ifc_addr, node);
! 374: old_neighbors = ifc->neighbors;
! 375:
! 376: /* Add the neighbors for this interface */
! 377: while (ncount--) {
! 378: u_int32_t neighbor;
! 379: Neighbor *nb;
! 380: Node *n_node;
! 381:
! 382: if (datalen < 4) {
! 383: logit(LOG_WARNING, 0, "received truncated neighbor list from %s",
! 384: inet_fmt(src, s1, sizeof(s1)));
! 385: return;
! 386: }
! 387:
! 388: GET_ADDR(neighbor);
! 389: neighbor = htonl(neighbor);
! 390: datalen -= 4;
! 391:
! 392: for (nb = old_neighbors; nb; nb = nb->next)
! 393: if (nb->addr == neighbor) {
! 394: if (metric != nb->metric || threshold != nb->threshold)
! 395: logit(LOG_WARNING, 0,
! 396: "inconsistent %s for neighbor %s of %s",
! 397: "metric/threshold",
! 398: inet_fmt(nb->addr, s1, sizeof(s1)), inet_fmt(node->addr, s2, sizeof(s2)));
! 399: goto next_neighbor;
! 400: }
! 401:
! 402: nb = (Neighbor *) malloc(sizeof(Neighbor));
! 403: nb->next = ifc->neighbors;
! 404: ifc->neighbors = nb;
! 405: nb->addr = neighbor;
! 406: nb->metric = metric;
! 407: nb->threshold = threshold;
! 408: nb->flags = 0;
! 409:
! 410: n_node = find_node(neighbor, &routers);
! 411: if (n_node->tries == 0 && !target_addr) { /* it's a new router */
! 412: ask(neighbor);
! 413: n_node->tries = 1;
! 414: }
! 415:
! 416: next_neighbor: ;
! 417: }
! 418: }
! 419: }
! 420:
! 421: void accept_neighbors2(u_int32 src, u_int32 UNUSED dst, u_char *p, size_t datalen, u_int32 level)
! 422: {
! 423: Node *node = find_node(src, &routers);
! 424: u_int broken_cisco = ((level & 0xffff) == 0x020a); /* 10.2 */
! 425: /* well, only possibly_broken_cisco, but that's too long to type. */
! 426:
! 427: if (node->tries == 0) /* Never heard of 'em; must have hit them at */
! 428: node->tries = 1; /* least once, though...*/
! 429: else if (node->tries == -1) /* follow alias link */
! 430: node = node->u.alias;
! 431:
! 432: while (datalen > 0) { /* loop through interfaces */
! 433: u_int32_t ifc_addr;
! 434: u_char metric, threshold, ncount, flags;
! 435: Node *ifc_node;
! 436: Interface *ifc;
! 437: Neighbor *old_neighbors;
! 438:
! 439: if (datalen < 4 + 4) {
! 440: logit(LOG_WARNING, 0, "received truncated interface record from %s",
! 441: inet_fmt(src, s1, sizeof(s1)));
! 442: return;
! 443: }
! 444:
! 445: ifc_addr = *(u_int32_t*)p;
! 446: p += 4;
! 447: metric = *p++;
! 448: threshold = *p++;
! 449: flags = *p++;
! 450: ncount = *p++;
! 451: datalen -= 4 + 4;
! 452:
! 453: if (broken_cisco && ncount == 0) /* dumb Ciscos */
! 454: ncount = 1;
! 455: if (broken_cisco && ncount > 15) /* dumb Ciscos */
! 456: ncount = ncount & 0xf;
! 457:
! 458: /* Fix up any alias information */
! 459: ifc_node = find_node(ifc_addr, &routers);
! 460: if (ifc_node->tries == 0) { /* new node */
! 461: ifc_node->tries = -1;
! 462: ifc_node->u.alias = node;
! 463: } else if (ifc_node != node
! 464: && (ifc_node->tries > 0 || ifc_node->u.alias != node)) {
! 465: /* must merge two hosts' nodes */
! 466: Interface *ifc_i, *next_ifc_i;
! 467:
! 468: if (ifc_node->tries == -1) {
! 469: Node *tmp = ifc_node->u.alias;
! 470:
! 471: ifc_node->u.alias = node;
! 472: ifc_node = tmp;
! 473: }
! 474:
! 475: /* Merge ifc_node (foo_i) into node (foo_n) */
! 476:
! 477: if (ifc_node->tries > node->tries)
! 478: node->tries = ifc_node->tries;
! 479:
! 480: for (ifc_i = ifc_node->u.interfaces; ifc_i; ifc_i = next_ifc_i) {
! 481: Neighbor *nb_i, *next_nb_i, *nb_n;
! 482: Interface *ifc_n = find_interface(ifc_i->addr, node);
! 483:
! 484: old_neighbors = ifc_n->neighbors;
! 485: for (nb_i = ifc_i->neighbors; nb_i; nb_i = next_nb_i) {
! 486: next_nb_i = nb_i->next;
! 487: for (nb_n = old_neighbors; nb_n; nb_n = nb_n->next)
! 488: if (nb_i->addr == nb_n->addr) {
! 489: if (nb_i->metric != nb_n->metric
! 490: || nb_i->threshold != nb_i->threshold)
! 491: logit(LOG_WARNING, 0,
! 492: "inconsistent %s for neighbor %s of %s",
! 493: "metric/threshold",
! 494: inet_fmt(nb_i->addr, s1, sizeof(s1)),
! 495: inet_fmt(node->addr, s2, sizeof(s2)));
! 496: free(nb_i);
! 497: break;
! 498: }
! 499: if (!nb_n) { /* no match for this neighbor yet */
! 500: nb_i->next = ifc_n->neighbors;
! 501: ifc_n->neighbors = nb_i;
! 502: }
! 503: }
! 504:
! 505: next_ifc_i = ifc_i->next;
! 506: free(ifc_i);
! 507: }
! 508:
! 509: ifc_node->tries = -1;
! 510: ifc_node->u.alias = node;
! 511: }
! 512:
! 513: ifc = find_interface(ifc_addr, node);
! 514: old_neighbors = ifc->neighbors;
! 515:
! 516: /* Add the neighbors for this interface */
! 517: while (ncount-- && datalen > 0) {
! 518: u_int32_t neighbor;
! 519: Neighbor *nb;
! 520: Node *n_node;
! 521:
! 522: if (datalen < 4) {
! 523: logit(LOG_WARNING, 0, "received truncated neighbor list from %s",
! 524: inet_fmt(src, s1, sizeof(s1)));
! 525: return;
! 526: }
! 527:
! 528: neighbor = *(u_int32_t*)p;
! 529: p += 4;
! 530: datalen -= 4;
! 531: if (neighbor == 0)
! 532: /* make leaf nets point to themselves */
! 533: neighbor = ifc_addr;
! 534:
! 535: for (nb = old_neighbors; nb; nb = nb->next)
! 536: if (nb->addr == neighbor) {
! 537: if (metric != nb->metric || threshold != nb->threshold)
! 538: logit(LOG_WARNING, 0,
! 539: "inconsistent %s for neighbor %s of %s",
! 540: "metric/threshold",
! 541: inet_fmt(nb->addr, s1, sizeof(s1)), inet_fmt(node->addr, s2, sizeof(s2)));
! 542: goto next_neighbor;
! 543: }
! 544:
! 545: nb = (Neighbor *) malloc(sizeof(Neighbor));
! 546: nb->next = ifc->neighbors;
! 547: ifc->neighbors = nb;
! 548: nb->addr = neighbor;
! 549: nb->metric = metric;
! 550: nb->threshold = threshold;
! 551: nb->flags = flags | NF_PRESENT;
! 552:
! 553: n_node = find_node(neighbor, &routers);
! 554: if (n_node->tries == 0 && !target_addr) { /* it's a new router */
! 555: ask(neighbor);
! 556: n_node->tries = 1;
! 557: }
! 558:
! 559: next_neighbor: ;
! 560: }
! 561: }
! 562: }
! 563:
! 564:
! 565: void check_vif_state(void)
! 566: {
! 567: logit(LOG_NOTICE, 0, "network marked down...");
! 568: }
! 569:
! 570:
! 571: int retry_requests(Node *node)
! 572: {
! 573: int result;
! 574:
! 575: if (node) {
! 576: result = retry_requests(node->left);
! 577: if (node->tries > 0 && node->tries < retries) {
! 578: if (node->version)
! 579: ask2(node->addr);
! 580: else
! 581: ask(node->addr);
! 582: node->tries++;
! 583: result = 1;
! 584: }
! 585: return retry_requests(node->right) || result;
! 586: } else
! 587: return 0;
! 588: }
! 589:
! 590:
! 591: char *inet_name(u_int32_t addr)
! 592: {
! 593: struct hostent *e;
! 594:
! 595: e = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET);
! 596:
! 597: return e ? e->h_name : 0;
! 598: }
! 599:
! 600:
! 601: void print_map(Node *node)
! 602: {
! 603: if (node) {
! 604: char *name, *addr;
! 605:
! 606: print_map(node->left);
! 607:
! 608: addr = inet_fmt(node->addr, s1, sizeof(s1));
! 609: if (!target_addr
! 610: || (node->tries >= 0 && node->u.interfaces)
! 611: || (node->tries == -1
! 612: && node->u.alias->tries >= 0
! 613: && node->u.alias->u.interfaces)) {
! 614: if (show_names && (name = inet_name(node->addr)))
! 615: printf("%s (%s):", addr, name);
! 616: else
! 617: printf("%s:", addr);
! 618: if (node->tries < 0)
! 619: printf(" alias for %s\n\n", inet_fmt(node->u.alias->addr, s1, sizeof(s1)));
! 620: else if (!node->u.interfaces)
! 621: printf(" no response to query\n\n");
! 622: else {
! 623: Interface *ifc;
! 624:
! 625: if (node->version)
! 626: printf(" <v%d.%d>", node->version & 0xff,
! 627: (node->version >> 8) & 0xff);
! 628: printf("\n");
! 629: for (ifc = node->u.interfaces; ifc; ifc = ifc->next) {
! 630: Neighbor *nb;
! 631: char *ifc_name = inet_fmt(ifc->addr, s1, sizeof(s1));
! 632: int ifc_len = strlen(ifc_name);
! 633: int count = 0;
! 634:
! 635: printf(" %s:", ifc_name);
! 636: for (nb = ifc->neighbors; nb; nb = nb->next) {
! 637: if (count > 0)
! 638: printf("%*s", ifc_len + 5, "");
! 639: printf(" %s", inet_fmt(nb->addr, s1, sizeof(s1)));
! 640: if (show_names && (name = inet_name(nb->addr)))
! 641: printf(" (%s)", name);
! 642: printf(" [%d/%d", nb->metric, nb->threshold);
! 643: if (nb->flags) {
! 644: u_int16_t flags = nb->flags;
! 645: if (flags & DVMRP_NF_TUNNEL)
! 646: printf("/tunnel");
! 647: if (flags & DVMRP_NF_SRCRT)
! 648: printf("/srcrt");
! 649: if (flags & DVMRP_NF_QUERIER)
! 650: printf("/querier");
! 651: if (flags & DVMRP_NF_DISABLED)
! 652: printf("/disabled");
! 653: if (flags & DVMRP_NF_DOWN)
! 654: printf("/down");
! 655: }
! 656: printf("]\n");
! 657: count++;
! 658: }
! 659: }
! 660: printf("\n");
! 661: }
! 662: }
! 663: print_map(node->right);
! 664: }
! 665: }
! 666:
! 667:
! 668: char *graph_name(u_int32_t addr, char *buf, size_t len)
! 669: {
! 670: char *name;
! 671:
! 672: if (show_names && (name = inet_name(addr)))
! 673: strlcpy(buf, name, len);
! 674: else
! 675: inet_fmt(addr, buf, sizeof(buf));
! 676:
! 677: return buf;
! 678: }
! 679:
! 680:
! 681: void graph_edges(Node *node)
! 682: {
! 683: Interface *ifc;
! 684: Neighbor *nb;
! 685: char name[MAXHOSTNAMELEN];
! 686:
! 687: if (node) {
! 688: graph_edges(node->left);
! 689: if (node->tries >= 0) {
! 690: printf(" %d {$ NP %d0 %d0 $} \"%s%s\" \n",
! 691: (int) node->addr,
! 692: node->addr & 0xFF, (node->addr >> 8) & 0xFF,
! 693: graph_name(node->addr, name, sizeof(name)),
! 694: node->u.interfaces ? "" : "*");
! 695: for (ifc = node->u.interfaces; ifc; ifc = ifc->next)
! 696: for (nb = ifc->neighbors; nb; nb = nb->next) {
! 697: Node *nb_node = find_node(nb->addr, &routers);
! 698: Neighbor *nb2;
! 699:
! 700: if (nb_node->tries < 0)
! 701: nb_node = nb_node->u.alias;
! 702:
! 703: if (node != nb_node &&
! 704: (!(nb2 = find_neighbor(node->addr, nb_node))
! 705: || node->addr < nb_node->addr)) {
! 706: printf(" %d \"%d/%d",
! 707: nb_node->addr, nb->metric, nb->threshold);
! 708: if (nb2 && (nb2->metric != nb->metric
! 709: || nb2->threshold != nb->threshold))
! 710: printf(",%d/%d", nb2->metric, nb2->threshold);
! 711: if (nb->flags & NF_PRESENT)
! 712: printf("%s%s",
! 713: nb->flags & DVMRP_NF_SRCRT ? "" :
! 714: nb->flags & DVMRP_NF_TUNNEL ? "E" : "P",
! 715: nb->flags & DVMRP_NF_DOWN ? "D" : "");
! 716: printf("\"\n");
! 717: }
! 718: }
! 719: printf(" ;\n");
! 720: }
! 721: graph_edges(node->right);
! 722: }
! 723: }
! 724:
! 725: void elide_aliases(Node *node)
! 726: {
! 727: if (node) {
! 728: elide_aliases(node->left);
! 729: if (node->tries >= 0) {
! 730: Interface *ifc;
! 731:
! 732: for (ifc = node->u.interfaces; ifc; ifc = ifc->next) {
! 733: Neighbor *nb;
! 734:
! 735: for (nb = ifc->neighbors; nb; nb = nb->next) {
! 736: Node *nb_node = find_node(nb->addr, &routers);
! 737:
! 738: if (nb_node->tries < 0)
! 739: nb->addr = nb_node->u.alias->addr;
! 740: }
! 741: }
! 742: }
! 743: elide_aliases(node->right);
! 744: }
! 745: }
! 746:
! 747: void graph_map(void)
! 748: {
! 749: time_t now = time(0);
! 750: char *nowstr = ctime(&now);
! 751:
! 752: nowstr[24] = '\0'; /* Kill the newline at the end */
! 753: elide_aliases(routers);
! 754: printf("GRAPH \"Multicast Router Connectivity: %s\" = UNDIRECTED\n",
! 755: nowstr);
! 756: graph_edges(routers);
! 757: printf("END\n");
! 758: }
! 759:
! 760:
! 761: u_int32_t host_addr(char *name)
! 762: {
! 763: struct hostent *e = gethostbyname(name);
! 764: int addr;
! 765:
! 766: if (e)
! 767: memcpy(&addr, e->h_addr_list[0], e->h_length);
! 768: else {
! 769: addr = inet_addr(name);
! 770: if (addr == -1)
! 771: addr = 0;
! 772: }
! 773:
! 774: return addr;
! 775: }
! 776:
! 777: void usage(void)
! 778: {
! 779: extern char *__progname;
! 780:
! 781: fprintf(stderr,
! 782: "Usage: %s [-fghn] [-d level] [-r count] [-t seconds] [starting_router]\n\n", __progname);
! 783: fprintf(stderr, "\t-f Flood the routing graph with queries\n");
! 784: fprintf(stderr, "\t (True by default unless `router' is given)\n");
! 785: fprintf(stderr, "\t-g Generate output in GraphEd format\n");
! 786: fprintf(stderr, "\t-h Show this help text\n");
! 787: fprintf(stderr, "\t-n Don't look up DNS names for routers\n");
! 788: fprintf(stderr, "\t-d Set debug level\n");
! 789: fprintf(stderr, "\t-r Set retry count\n");
! 790: fprintf(stderr, "\t-t Set timeout in seconds\n");
! 791:
! 792: exit(1);
! 793: }
! 794:
! 795: int main(int argc, char *argv[])
! 796: {
! 797: int flood = FALSE, graph = FALSE;
! 798: int ch;
! 799: uid_t uid;
! 800: const char *errstr;
! 801:
! 802: while ((ch = getopt(argc, argv, "d::fghnr:t:")) != -1) {
! 803: switch (ch) {
! 804: case 'd':
! 805: if (!optarg)
! 806: debug = DEFAULT_DEBUG;
! 807: else {
! 808: debug = strtonum(optarg, 0, 3, &errstr);
! 809: if (errstr) {
! 810: warnx("debug level %s", errstr);
! 811: debug = DEFAULT_DEBUG;
! 812: }
! 813: }
! 814: break;
! 815: case 'f':
! 816: flood = TRUE;
! 817: break;
! 818: case 'g':
! 819: graph = TRUE;
! 820: break;
! 821: case 'h':
! 822: usage();
! 823: break;
! 824: case 'n':
! 825: show_names = FALSE;
! 826: break;
! 827: case 'r':
! 828: retries = strtonum(optarg, 0, INT_MAX, &errstr);
! 829: if (errstr) {
! 830: warnx("retries %s", errstr);
! 831: usage();
! 832: }
! 833: break;
! 834: case 't':
! 835: timeout = strtonum(optarg, 0, INT_MAX, &errstr);
! 836: if (errstr) {
! 837: warnx("timeout %s", errstr);
! 838: usage();
! 839: }
! 840: break;
! 841: default:
! 842: usage();
! 843: }
! 844: }
! 845:
! 846: argc -= optind;
! 847: argv += optind;
! 848:
! 849: setlinebuf(stderr);
! 850:
! 851: if (geteuid() != 0) {
! 852: fprintf(stderr, "must be root\n");
! 853: exit(1);
! 854: }
! 855:
! 856: if (argc > 1)
! 857: usage();
! 858: else if (argc == 1 && !(target_addr = host_addr(argv[0]))) {
! 859: fprintf(stderr, "Unknown host: %s\n", argv[0]);
! 860: exit(2);
! 861: }
! 862:
! 863: if (debug)
! 864: fprintf(stderr, "Debug level %u\n", debug);
! 865:
! 866: init_igmp();
! 867:
! 868: uid = getuid();
! 869: if (setuid(uid) == -1)
! 870: err(1, "setuid");
! 871:
! 872: { /* Find a good local address for us. */
! 873: int udp;
! 874: struct sockaddr_in addr;
! 875: socklen_t addrlen = sizeof(addr);
! 876:
! 877: memset(&addr, 0, sizeof addr);
! 878: addr.sin_family = AF_INET;
! 879: #ifdef HAVE_SA_LEN
! 880: addr.sin_len = sizeof(addr);
! 881: #endif
! 882: addr.sin_addr.s_addr = dvmrp_group;
! 883: addr.sin_port = htons(2000); /* any port over 1024 will do... */
! 884: if ((udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0
! 885: || connect(udp, (struct sockaddr *) &addr, sizeof(addr)) < 0
! 886: || getsockname(udp, (struct sockaddr *) &addr, &addrlen) < 0) {
! 887: perror("Determining local address");
! 888: exit(1);
! 889: }
! 890: close(udp);
! 891: our_addr = addr.sin_addr.s_addr;
! 892: }
! 893:
! 894: /* Send initial seed message to all local routers */
! 895: ask(target_addr ? target_addr : allhosts_group);
! 896:
! 897: if (target_addr) {
! 898: Node *n = find_node(target_addr, &routers);
! 899:
! 900: n->tries = 1;
! 901:
! 902: if (flood)
! 903: target_addr = 0;
! 904: }
! 905:
! 906: /* Main receive loop */
! 907: for(;;) {
! 908: fd_set fds;
! 909: struct timeval tv;
! 910: int count;
! 911: ssize_t recvlen;
! 912: socklen_t dummy = 0;
! 913:
! 914: FD_ZERO(&fds);
! 915: if (igmp_socket >= (int)FD_SETSIZE)
! 916: logit(LOG_ERR, 0, "Descriptor too big");
! 917: FD_SET(igmp_socket, &fds);
! 918:
! 919: tv.tv_sec = timeout;
! 920: tv.tv_usec = 0;
! 921:
! 922: count = select(igmp_socket + 1, &fds, 0, 0, &tv);
! 923:
! 924: if (count < 0) {
! 925: if (errno != EINTR)
! 926: perror("select");
! 927: continue;
! 928: } else if (count == 0) {
! 929: logit(LOG_DEBUG, 0, "Timed out receiving neighbor lists");
! 930: if (retry_requests(routers))
! 931: continue;
! 932: else
! 933: break;
! 934: }
! 935:
! 936: recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE, 0, NULL, &dummy);
! 937: if (recvlen >= 0)
! 938: accept_igmp(recvlen);
! 939: else if (errno != EINTR)
! 940: perror("recvfrom");
! 941: }
! 942:
! 943: printf("\n");
! 944:
! 945: if (graph)
! 946: graph_map();
! 947: else {
! 948: if (!target_addr)
! 949: printf("Multicast Router Connectivity:\n\n");
! 950: print_map(routers);
! 951: }
! 952:
! 953: exit(0);
! 954: }
! 955:
! 956: /* dummies */
! 957: void accept_prune(u_int32 UNUSED src, u_int32 UNUSED dst, char UNUSED *p, size_t UNUSED datalen)
! 958: {
! 959: }
! 960: void accept_graft(u_int32 UNUSED src, u_int32 UNUSED dst, char UNUSED *p, size_t UNUSED datalen)
! 961: {
! 962: }
! 963: void accept_g_ack(u_int32 UNUSED src, u_int32 UNUSED dst, char UNUSED *p, size_t UNUSED datalen)
! 964: {
! 965: }
! 966: void add_table_entry(u_int32 UNUSED origin, u_int32 UNUSED mcastgrp)
! 967: {
! 968: }
! 969: void accept_leave_message(u_int32 UNUSED src, u_int32 UNUSED dst, u_int32 UNUSED group)
! 970: {
! 971: }
! 972: void accept_mtrace(u_int32 UNUSED src, u_int32 UNUSED dst, u_int32 UNUSED group, char UNUSED *data, u_int8_t UNUSED no, size_t UNUSED datalen)
! 973: {
! 974: }
! 975: void accept_membership_query(u_int32 UNUSED src, u_int32 UNUSED dst, u_int32 UNUSED group, int UNUSED tmo)
! 976: {
! 977: }
! 978: void accept_info_request(u_int32 UNUSED src, u_int32 UNUSED dst, u_char UNUSED *p, size_t UNUSED datalen)
! 979: {
! 980: }
! 981: void accept_info_reply(u_int32 UNUSED src, u_int32 UNUSED dst, u_char UNUSED *p, size_t UNUSED datalen)
! 982: {
! 983: }
! 984:
! 985: /**
! 986: * Local Variables:
! 987: * version-control: t
! 988: * indent-tabs-mode: t
! 989: * c-file-style: "ellemtel"
! 990: * c-basic-offset: 4
! 991: * End:
! 992: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mapper.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mrouted