The multicast router. Stick it next to routed and XNSrouted since that

[unix-history] / sbin / mrouted / mapper.c

/* Mapper for connections between MRouteD multicast routers.
* Written by Pavel Curtis <Pavel@PARC.Xerox.Com>
*
* $Id: mapper.c,v 1.4 1993/06/24 05:11:16 deering Exp $
*/

/*
* Copyright (c) Xerox Corporation 1992. All rights reserved.
*  
* License is granted to copy, to use, and to make and to use derivative
* works for research and evaluation purposes, provided that Xerox is
* acknowledged in all documentation pertaining to any such copy or derivative
* work. Xerox grants no other licenses expressed or implied. The Xerox trade
* name should not be used in any advertising without its written permission.
*  
* XEROX CORPORATION MAKES NO REPRESENTATIONS CONCERNING EITHER THE
* MERCHANTABILITY OF THIS SOFTWARE OR THE SUITABILITY OF THIS SOFTWARE
* FOR ANY PARTICULAR PURPOSE.  The software is provided "as is" without
* express or implied warranty of any kind.
*  
* These notices must be retained in any copies of any part of this software.
*/

#include <netdb.h>
#include <sys/time.h>
#include "defs.h"

#define DEFAULT_TIMEOUT 2       /* How long to wait before retrying requests */
#define DEFAULT_RETRIES 1       /* How many times to ask each router */


/* All IP addresses are stored in the data structure in NET order. */

typedef struct neighbor {
   struct neighbor    *next;
   u_long              addr;           /* IP address in NET order */
   u_char              metric;         /* TTL cost of forwarding */
   u_char              threshold;      /* TTL threshold to forward */
   u_short             flags;          /* flags on connection */
#define NF_PRESENT 0x8000       /* True if flags are meaningful */
} Neighbor;

typedef struct interface {
   struct interface *next;
   u_long      addr;           /* IP address of the interface in NET order */
   Neighbor   *neighbors;      /* List of neighbors' IP addresses */
} Interface;

typedef struct node {
   u_long      addr;           /* IP address of this entry in NET order */
   u_long      version;        /* which mrouted version is running */
   int         tries;          /* How many requests sent?  -1 for aliases */
   union {
       struct node *alias;             /* If alias, to what? */
       struct interface *interfaces;   /* Else, neighbor data */
   } u;
   struct node *left, *right;
} Node;


Node   *routers = 0;
u_long  our_addr, target_addr = 0;              /* in NET order */
int     debug = 0;
int     retries = DEFAULT_RETRIES;
int     timeout = DEFAULT_TIMEOUT;
int     show_names = TRUE;


Node *find_node(addr, ptr)
   u_long addr;
   Node **ptr;
{
   Node *n = *ptr;

   if (!n) {
       *ptr = n = (Node *) malloc(sizeof(Node));
       n->addr = addr;
       n->version = 0;
       n->tries = 0;
       n->u.interfaces = 0;
       n->left = n->right = 0;
       return n;
   } else if (addr == n->addr)
       return n;
   else if (addr < n->addr)
       return find_node(addr, &(n->left));
   else
       return find_node(addr, &(n->right));
}


Interface *find_interface(addr, node)
   u_long addr;
   Node *node;
{
   Interface *ifc;

   for (ifc = node->u.interfaces; ifc; ifc = ifc->next)
       if (ifc->addr == addr)
           return ifc;

   ifc = (Interface *) malloc(sizeof(Interface));
   ifc->addr = addr;
   ifc->next = node->u.interfaces;
   node->u.interfaces = ifc;
   ifc->neighbors = 0;

   return ifc;
}


Neighbor *find_neighbor(addr, node)
   u_long addr;
   Node *node;
{
   Interface *ifc;

   for (ifc = node->u.interfaces; ifc; ifc = ifc->next) {
       Neighbor *nb;

       for (nb = ifc->neighbors; nb; nb = nb->next)
           if (nb->addr == addr)
               return nb;
   }

   return 0;
}


/*
* Log errors and other messages to stderr, according to the severity of the
* message and the current debug level.  For errors of severity LOG_ERR or
* worse, terminate the program.
*/
void log(severity, syserr, format, a, b, c, d, e)
   int severity, syserr;
   char *format;
   int a, b, c, d, e;
{
   char fmt[100];

   switch (debug) {
       case 0: if (severity > LOG_WARNING) return;
       case 1: if (severity > LOG_NOTICE ) return;
       case 2: if (severity > LOG_INFO   ) return;
       default:
           fmt[0] = '\0';
           if (severity == LOG_WARNING)
               strcat(fmt, "warning - ");
           strncat(fmt, format, 80);
           fprintf(stderr, fmt, a, b, c, d, e);
           if (syserr == 0)
               fprintf(stderr, "\n");
           else if (syserr < sys_nerr)
               fprintf(stderr, ": %s\n", sys_errlist[syserr]);
           else
               fprintf(stderr, ": errno %d\n", syserr);
   }

   if (severity <= LOG_ERR)
       exit(-1);
}


/*
* Send a neighbors-list request.
*/
void ask(dst)
   u_long dst;
{
   send_igmp(our_addr, dst, IGMP_DVMRP, DVMRP_ASK_NEIGHBORS,
               htonl(MROUTED_LEVEL), 0);
}

void ask2(dst)
   u_long dst;
{
   send_igmp(our_addr, dst, IGMP_DVMRP, DVMRP_ASK_NEIGHBORS2,
               htonl(MROUTED_LEVEL), 0);
}


/*
* Process an incoming group membership report.
*/
void accept_group_report(src, dst, group)
   u_long src, dst, group;
{
   log(LOG_INFO, 0, "ignoring IGMP group membership report from %s to %s",
       inet_fmt(src, s1), inet_fmt(dst, s2));
}


/*
* Process an incoming neighbor probe message.
*/
void accept_probe(src, dst)
   u_long src, dst;
{
   log(LOG_INFO, 0, "ignoring DVMRP probe from %s to %s",
       inet_fmt(src, s1), inet_fmt(dst, s2));
}


/*
* Process an incoming route report message.
*/
void accept_report(src, dst, p, datalen)
   u_long src, dst;
   char *p;
   int datalen;
{
   log(LOG_INFO, 0, "ignoring DVMRP routing report from %s to %s",
       inet_fmt(src, s1), inet_fmt(dst, s2));
}


/*
* Process an incoming neighbor-list request message.
*/
void accept_neighbor_request(src, dst)
   u_long src, dst;
{
   if (src != our_addr)
       log(LOG_INFO, 0,
           "ignoring spurious DVMRP neighbor request from %s to %s",
           inet_fmt(src, s1), inet_fmt(dst, s2));
}

void accept_neighbor_request2(src, dst)
   u_long src, dst;
{
   if (src != our_addr)
       log(LOG_INFO, 0,
           "ignoring spurious DVMRP neighbor request2 from %s to %s",
           inet_fmt(src, s1), inet_fmt(dst, s2));
}


/*
* Process an incoming neighbor-list message.
*/
void accept_neighbors(src, dst, p, datalen, level)
   u_long src, dst, level;
   u_char *p;
   int datalen;
{
   Node       *node = find_node(src, &routers);

   if (node->tries == 0)       /* Never heard of 'em; must have hit them at */
       node->tries = 1;        /* least once, though...*/
   else if (node->tries == -1) /* follow alias link */
       node = node->u.alias;

#define GET_ADDR(a) (a = ((u_long)*p++ << 24), a += ((u_long)*p++ << 16),\
                    a += ((u_long)*p++ << 8), a += *p++)

   /* if node is running a recent mrouted, ask for additional info */
   if (level != 0) {
       node->version = ntohl(level);
       node->tries = 0;
       ask2(src);
       return;
   }

   if (debug > 3) {
       int i;

       fprintf(stderr, "    datalen = %d\n", datalen);
       for (i = 0; i < datalen; i++) {
           if ((i & 0xF) == 0)
               fprintf(stderr, "   ");
           fprintf(stderr, " %02x", p[i]);
           if ((i & 0xF) == 0xF)
               fprintf(stderr, "\n");
       }
       if ((datalen & 0xF) != 0xF)
           fprintf(stderr, "\n");
   }

   while (datalen > 0) {       /* loop through interfaces */
       u_long          ifc_addr;
       u_char          metric, threshold, ncount;
       Node           *ifc_node;
       Interface      *ifc;
       Neighbor       *old_neighbors;

       if (datalen < 4 + 3) {
           log(LOG_WARNING, 0, "received truncated interface record from %s",
               inet_fmt(src, s1));
           return;
       }

       GET_ADDR(ifc_addr);
       ifc_addr = htonl(ifc_addr);
       metric = *p++;
       threshold = *p++;
       ncount = *p++;
       datalen -= 4 + 3;

       /* Fix up any alias information */
       ifc_node = find_node(ifc_addr, &routers);
       if (ifc_node->tries == 0) { /* new node */
           ifc_node->tries = -1;
           ifc_node->u.alias = node;
       } else if (ifc_node != node
                  && (ifc_node->tries > 0  ||  ifc_node->u.alias != node)) {
           /* must merge two hosts' nodes */
           Interface  *ifc_i, *next_ifc_i;

           if (ifc_node->tries == -1) {
               Node *tmp = ifc_node->u.alias;

               ifc_node->u.alias = node;
               ifc_node = tmp;
           }

           /* Merge ifc_node (foo_i) into node (foo_n) */

           if (ifc_node->tries > node->tries)
               node->tries = ifc_node->tries;

           for (ifc_i = ifc_node->u.interfaces; ifc_i; ifc_i = next_ifc_i) {
               Neighbor *nb_i, *next_nb_i, *nb_n;
               Interface *ifc_n = find_interface(ifc_i->addr, node);

               old_neighbors = ifc_n->neighbors;
               for (nb_i = ifc_i->neighbors; nb_i; nb_i = next_nb_i) {
                   next_nb_i = nb_i->next;
                   for (nb_n = old_neighbors; nb_n; nb_n = nb_n->next)
                       if (nb_i->addr == nb_n->addr) {
                           if (nb_i->metric != nb_n->metric
                               || nb_i->threshold != nb_i->threshold)
                               log(LOG_WARNING, 0,
                                   "inconsistent %s for neighbor %s of %s",
                                   "metric/threshold",
                                   inet_fmt(nb_i->addr, s1),
                                   inet_fmt(node->addr, s2));
                           free(nb_i);
                           break;
                       }
                   if (!nb_n) { /* no match for this neighbor yet */
                       nb_i->next = ifc_n->neighbors;
                       ifc_n->neighbors = nb_i;
                   }
               }

               next_ifc_i = ifc_i->next;
               free(ifc_i);
           }

           ifc_node->tries = -1;
           ifc_node->u.alias = node;
       }
       
       ifc = find_interface(ifc_addr, node);
       old_neighbors = ifc->neighbors;
       
       /* Add the neighbors for this interface */
       while (ncount--) {
           u_long      neighbor;
           Neighbor   *nb;
           Node       *n_node;

           if (datalen < 4) {
               log(LOG_WARNING, 0, "received truncated neighbor list from %s",
                   inet_fmt(src, s1));
               return;
           }

           GET_ADDR(neighbor);
           neighbor = htonl(neighbor);
           datalen -= 4;

           for (nb = old_neighbors; nb; nb = nb->next)
               if (nb->addr == neighbor) {
                   if (metric != nb->metric || threshold != nb->threshold)
                       log(LOG_WARNING, 0,
                           "inconsistent %s for neighbor %s of %s",
                           "metric/threshold",
                           inet_fmt(nb->addr, s1), inet_fmt(node->addr, s2));
                   goto next_neighbor;
               }

           nb = (Neighbor *) malloc(sizeof(Neighbor));
           nb->next = ifc->neighbors;
           ifc->neighbors = nb;
           nb->addr = neighbor;
           nb->metric = metric;
           nb->threshold = threshold;
           nb->flags = 0;

           n_node = find_node(neighbor, &routers);
           if (n_node->tries == 0  &&  !target_addr) { /* it's a new router */
               ask(neighbor);
               n_node->tries = 1;
           }

         next_neighbor: ;
       }
   }
}

void accept_neighbors2(src, dst, p, datalen)
   u_long src, dst;
   u_char *p;
   int datalen;
{
   Node       *node = find_node(src, &routers);

   if (node->tries == 0)       /* Never heard of 'em; must have hit them at */
       node->tries = 1;        /* least once, though...*/
   else if (node->tries == -1) /* follow alias link */
       node = node->u.alias;

   while (datalen > 0) {       /* loop through interfaces */
       u_long          ifc_addr;
       u_char          metric, threshold, ncount, flags;
       Node           *ifc_node;
       Interface      *ifc;
       Neighbor       *old_neighbors;

       if (datalen < 4 + 4) {
           log(LOG_WARNING, 0, "received truncated interface record from %s",
               inet_fmt(src, s1));
           return;
       }

       ifc_addr = *(u_long*)p;
       p += 4;
       metric = *p++;
       threshold = *p++;
       flags = *p++;
       ncount = *p++;
       datalen -= 4 + 4;

       /* Fix up any alias information */
       ifc_node = find_node(ifc_addr, &routers);
       if (ifc_node->tries == 0) { /* new node */
           ifc_node->tries = -1;
           ifc_node->u.alias = node;
       } else if (ifc_node != node
                  && (ifc_node->tries > 0  ||  ifc_node->u.alias != node)) {
           /* must merge two hosts' nodes */
           Interface  *ifc_i, *next_ifc_i;

           if (ifc_node->tries == -1) {
               Node *tmp = ifc_node->u.alias;

               ifc_node->u.alias = node;
               ifc_node = tmp;
           }

           /* Merge ifc_node (foo_i) into node (foo_n) */

           if (ifc_node->tries > node->tries)
               node->tries = ifc_node->tries;

           for (ifc_i = ifc_node->u.interfaces; ifc_i; ifc_i = next_ifc_i) {
               Neighbor *nb_i, *next_nb_i, *nb_n;
               Interface *ifc_n = find_interface(ifc_i->addr, node);

               old_neighbors = ifc_n->neighbors;
               for (nb_i = ifc_i->neighbors; nb_i; nb_i = next_nb_i) {
                   next_nb_i = nb_i->next;
                   for (nb_n = old_neighbors; nb_n; nb_n = nb_n->next)
                       if (nb_i->addr == nb_n->addr) {
                           if (nb_i->metric != nb_n->metric
                               || nb_i->threshold != nb_i->threshold)
                               log(LOG_WARNING, 0,
                                   "inconsistent %s for neighbor %s of %s",
                                   "metric/threshold",
                                   inet_fmt(nb_i->addr, s1),
                                   inet_fmt(node->addr, s2));
                           free(nb_i);
                           break;
                       }
                   if (!nb_n) { /* no match for this neighbor yet */
                       nb_i->next = ifc_n->neighbors;
                       ifc_n->neighbors = nb_i;
                   }
               }

               next_ifc_i = ifc_i->next;
               free(ifc_i);
           }

           ifc_node->tries = -1;
           ifc_node->u.alias = node;
       }
       
       ifc = find_interface(ifc_addr, node);
       old_neighbors = ifc->neighbors;
       
       /* Add the neighbors for this interface */
       while (ncount--) {
           u_long      neighbor;
           Neighbor   *nb;
           Node       *n_node;

           if (datalen < 4) {
               log(LOG_WARNING, 0, "received truncated neighbor list from %s",
                   inet_fmt(src, s1));
               return;
           }

           neighbor = *(u_long*)p;
           p += 4;
           datalen -= 4;
           if (neighbor == 0)
               /* make leaf nets point to themselves */
               neighbor = ifc_addr;

           for (nb = old_neighbors; nb; nb = nb->next)
               if (nb->addr == neighbor) {
                   if (metric != nb->metric || threshold != nb->threshold)
                       log(LOG_WARNING, 0,
                           "inconsistent %s for neighbor %s of %s",
                           "metric/threshold",
                           inet_fmt(nb->addr, s1), inet_fmt(node->addr, s2));
                   goto next_neighbor;
               }

           nb = (Neighbor *) malloc(sizeof(Neighbor));
           nb->next = ifc->neighbors;
           ifc->neighbors = nb;
           nb->addr = neighbor;
           nb->metric = metric;
           nb->threshold = threshold;
           nb->flags = flags | NF_PRESENT;

           n_node = find_node(neighbor, &routers);
           if (n_node->tries == 0  &&  !target_addr) { /* it's a new router */
               ask(neighbor);
               n_node->tries = 1;
           }

         next_neighbor: ;
       }
   }
}


void check_vif_state()
{
   log(LOG_NOTICE, 0, "network marked down...");
}


int retry_requests(node)
   Node *node;
{
   int result;

   if (node) {
       result = retry_requests(node->left);
       if (node->tries > 0  &&  node->tries < retries) {
           if (node->version)
               ask2(node->addr);
           else
               ask(node->addr);
           node->tries++;
           result = 1;
       }
       return retry_requests(node->right) || result;
   } else
       return 0;
}


char *inet_name(addr)
   u_long addr;
{
   struct hostent *e;

   e = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET);

   return e ? e->h_name : 0;
}


void print_map(node)
   Node *node;
{
   if (node) {
       char *name, *addr;
       
       print_map(node->left);

       addr = inet_fmt(node->addr, s1);
       if (!target_addr
           || (node->tries >= 0 && node->u.interfaces)
           || (node->tries == -1
               && node->u.alias->tries >= 0
               && node->u.alias->u.interfaces)) {
           if (show_names && (name = inet_name(node->addr)))
               printf("%s (%s):", addr, name);
           else
               printf("%s:", addr);
           if (node->tries < 0)
               printf(" alias for %s\n\n", inet_fmt(node->u.alias->addr, s1));
           else if (!node->u.interfaces)
               printf(" no response to query\n\n");
           else {
               Interface *ifc;

               if (node->version)
                   printf(" <v%d.%d>", node->version & 0xff,
                                       (node->version >> 8) & 0xff);
               printf("\n");
               for (ifc = node->u.interfaces; ifc; ifc = ifc->next) {
                   Neighbor *nb;
                   char *ifc_name = inet_fmt(ifc->addr, s1);
                   int ifc_len = strlen(ifc_name);
                   int count = 0;

                   printf("    %s:", ifc_name);
                   for (nb = ifc->neighbors; nb; nb = nb->next) {
                       if (count > 0)
                           printf("%*s", ifc_len + 5, "");
                       printf("  %s", inet_fmt(nb->addr, s1));
                       if (show_names  &&  (name = inet_name(nb->addr)))
                           printf(" (%s)", name);
                       printf(" [%d/%d", nb->metric, nb->threshold);
                       if (nb->flags) {
                           u_short flags = nb->flags;
                           if (flags & DVMRP_NF_TUNNEL)
                                   printf("/tunnel");
                           if (flags & DVMRP_NF_SRCRT)
                                   printf("/srcrt");
                           if (flags & DVMRP_NF_QUERIER)
                                   printf("/querier");
                           if (flags & DVMRP_NF_DISABLED)
                                   printf("/disabled");
                           if (flags & DVMRP_NF_DOWN)
                                   printf("/down");
                       }
                       printf("]\n");
                       count++;
                   }
               }
               printf("\n");
           }
       }
       print_map(node->right);
   }
}


char *graph_name(addr, buf)
   u_long addr;
   char *buf;
{
   char *name;

   if (show_names  &&  (name = inet_name(addr)))
       strcpy(buf, name);
   else
       inet_fmt(addr, buf);

   return buf;
}


void graph_edges(node)
   Node *node;
{
   Interface *ifc;
   Neighbor *nb;
   char name[100];

   if (node) {
       graph_edges(node->left);
       if (node->tries >= 0) {
           printf("  %d {$ NP %d0 %d0 $} \"%s%s\" \n",
                  (int) node->addr,
                  node->addr & 0xFF, (node->addr >> 8) & 0xFF,
                  graph_name(node->addr, name),
                  node->u.interfaces ? "" : "*");
           for (ifc = node->u.interfaces; ifc; ifc = ifc->next)
               for (nb = ifc->neighbors; nb; nb = nb->next) {
                   Node *nb_node = find_node(nb->addr, &routers);
                   Neighbor *nb2;

                   if (nb_node->tries < 0)
                       nb_node = nb_node->u.alias;

                   if (node != nb_node &&
                       (!(nb2 = find_neighbor(node->addr, nb_node))
                        || node->addr < nb_node->addr)) {
                       printf("    %d \"%d/%d",
                              nb_node->addr, nb->metric, nb->threshold);
                       if (nb2 && (nb2->metric != nb->metric
                                   || nb2->threshold != nb->threshold))
                           printf(",%d/%d", nb2->metric, nb2->threshold);
                       if (nb->flags & NF_PRESENT)
                           printf("%s%s",
                                  nb->flags & DVMRP_NF_SRCRT ? "" :
                                  nb->flags & DVMRP_NF_TUNNEL ? "E" : "P",
                                  nb->flags & DVMRP_NF_DOWN ? "D" : "");
                       printf("\"\n");
                   }
               }
           printf("    ;\n");
       }
       graph_edges(node->right);
   }
}

void elide_aliases(node)
   Node *node;
{
   if (node) {
       elide_aliases(node->left);
       if (node->tries >= 0) {
           Interface *ifc;

           for (ifc = node->u.interfaces; ifc; ifc = ifc->next) {
               Neighbor *nb;

               for (nb = ifc->neighbors; nb; nb = nb->next) {
                   Node *nb_node = find_node(nb->addr, &routers);

                   if (nb_node->tries < 0)
                       nb->addr = nb_node->u.alias->addr;
               }
           }
       }
       elide_aliases(node->right);
   }
}

void graph_map()
{
   time_t now = time(0);
   char *nowstr = ctime(&now);

   nowstr[24] = '\0';          /* Kill the newline at the end */
   elide_aliases(routers);
   printf("GRAPH \"Multicast Router Connectivity: %s\" = UNDIRECTED\n",
          nowstr);
   graph_edges(routers);
   printf("END\n");
}


int get_number(var, deflt, pargv, pargc)
   int *var, *pargc, deflt;
   char ***pargv;
{
   if ((*pargv)[0][2] == '\0') { /* Get the value from the next argument */
       if (*pargc > 1  &&  isdigit((*pargv)[1][0])) {
           (*pargv)++, (*pargc)--;
           *var = atoi((*pargv)[0]);
           return 1;
       } else if (deflt >= 0) {
           *var = deflt;
           return 1;
       } else
           return 0;
   } else {                    /* Get value from the rest of this argument */
       if (isdigit((*pargv)[0][2])) {
           *var = atoi((*pargv)[0] + 2);
           return 1;
       } else {
           return 0;
       }
   }
}


u_long host_addr(name)
   char *name;
{
   struct hostent *e = gethostbyname(name);
   int addr;

   if (e)
       memcpy(&addr, e->h_addr_list[0], e->h_length);
   else {
       addr = inet_addr(name);
       if (addr == -1)
           addr = 0;
   }

   return addr;
}


main(argc, argv)
   int argc;
   char *argv[];
{
   int flood = FALSE, graph = FALSE;
   
#ifdef SYSV
   setvbuf(stderr, NULL, _IOLBF, 0);
#else
   setlinebuf(stderr);
#endif

   if (geteuid() != 0) {
       fprintf(stderr, "must be root\n");
       exit(1);
   }

   argv++, argc--;
   while (argc > 0 && argv[0][0] == '-') {
       switch (argv[0][1]) {
         case 'd':
           if (!get_number(&debug, DEFAULT_DEBUG, &argv, &argc))
               goto usage;
           break;
         case 'f':
           flood = TRUE;
           break;
         case 'g':
           graph = TRUE;
           break;
         case 'n':
           show_names = FALSE;
           break;
         case 'r':
           if (!get_number(&retries, -1, &argv, &argc))
               goto usage;
           break;
         case 't':
           if (!get_number(&timeout, -1, &argv, &argc))
               goto usage;
           break;
         default:
           goto usage;
       }
       argv++, argc--;
   }

   if (argc > 1) {
     usage:    
       fprintf(stderr,
               "Usage: map-mbone [-f] [-g] [-n] [-t timeout] %s\n\n",
               "[-r retries] [-d [debug-level]] [router]");
       fprintf(stderr, "\t-f  Flood the routing graph with queries\n");
       fprintf(stderr, "\t    (True by default unless `router' is given)\n");
       fprintf(stderr, "\t-g  Generate output in GraphEd format\n");
       fprintf(stderr, "\t-n  Don't look up DNS names for routers\n");
       exit(1);
   } else if (argc == 1 && !(target_addr = host_addr(argv[0]))) {
       fprintf(stderr, "Unknown host: %s\n", argv[0]);
       exit(2);
   }

   if (debug)
       fprintf(stderr, "Debug level %u\n", debug);

   init_igmp();

   {                           /* Find a good local address for us. */
       int udp;
       struct sockaddr_in addr;
       int addrlen = sizeof(addr);

       addr.sin_family = AF_INET;
       addr.sin_addr.s_addr = dvmrp_group;
       addr.sin_port = htons(2000); /* any port over 1024 will do... */
       if ((udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0
           || connect(udp, (struct sockaddr *) &addr, sizeof(addr)) < 0
           || getsockname(udp, (struct sockaddr *) &addr, &addrlen) < 0) {
           perror("Determining local address");
           exit(-1);
       }
       close(udp);
       our_addr = addr.sin_addr.s_addr;
   }

   /* Send initial seed message to all local routers */
   ask(target_addr ? target_addr : allhosts_group);

   if (target_addr) {
       Node *n = find_node(target_addr, &routers);

       n->tries = 1;

       if (flood)
           target_addr = 0;
   }

   /* Main receive loop */
   for(;;) {
       fd_set          fds;
       struct timeval  tv;
       int             count, recvlen, dummy = 0;

       FD_ZERO(&fds);
       FD_SET(igmp_socket, &fds);

       tv.tv_sec = timeout;
       tv.tv_usec = 0;

       count = select(igmp_socket + 1, &fds, 0, 0, &tv);

       if (count < 0) {
           if (errno != EINTR)
               perror("select");
           continue;
       } else if (count == 0) {
           log(LOG_DEBUG, 0, "Timed out receiving neighbor lists");
           if (retry_requests(routers))
               continue;
           else
               break;
       }

       recvlen = recvfrom(igmp_socket, recv_buf, sizeof(recv_buf),
                          0, NULL, &dummy);
       if (recvlen >= 0)
           accept_igmp(recvlen);
       else if (errno != EINTR)
           perror("recvfrom");
   }

   printf("\n");

   if (graph)
       graph_map();
   else {
       if (!target_addr)
           printf("Multicast Router Connectivity:\n\n");
       print_map(routers);
   }

   exit(0);
}