freebsd-dev/usr.sbin/mrouted/mtrace.c

/*
 * mtrace.c
 *
 * This tool traces the branch of a multicast tree from a source to a
 * receiver for a particular multicast group and gives statistics
 * about packet rate and loss for each hop along the path.  It can
 * usually be invoked just as
 *
 * 	mtrace source
 *
 * to trace the route from that source to the local host for a default
 * group when only the route is desired and not group-specific packet
 * counts.  See the usage line for more complex forms.
 *
 *
 * Released 4 Apr 1995.  This program was adapted by Steve Casner
 * (USC/ISI) from a prototype written by Ajit Thyagarajan (UDel and
 * Xerox PARC).  It attempts to parallel in command syntax and output
 * format the unicast traceroute program written by Van Jacobson (LBL)
 * for the parts where that makes sense.
 * 
 * Copyright (c) 1995 by the University of Southern California
 * All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation in source and binary forms for any purposes and without
 * fee is hereby granted, provided that the above copyright notice
 * appear in all copies and that both the copyright notice and this
 * permission notice appear in supporting documentation, and that any
 * documentation, advertising materials, and other materials related to
 * such distribution and use acknowledge that the software was developed
 * by the University of Southern California, Information Sciences
 * Institute.  The name of the University may not be used to endorse or
 * promote products derived from this software without specific prior
 * written permission.
 *
 * THE UNIVERSITY OF SOUTHERN CALIFORNIA makes no representations about
 * the suitability of this software for any purpose.  THIS SOFTWARE IS
 * PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Other copyrights might apply to parts of this software and are so
 * noted when applicable.
 *
 * Parts of this software are derived from mrouted, which has the
 * following license:
 * 
 * The mrouted program is covered by the following license.  Use of the
 * mrouted program represents acceptance of these terms and conditions.
 * 
 * 1. STANFORD grants to LICENSEE a nonexclusive and nontransferable
 * license to use, copy and modify the computer software ``mrouted''
 * (hereinafter called the ``Program''), upon the terms and conditions
 * hereinafter set out and until Licensee discontinues use of the Licensed
 * Program.
 * 
 * 2. LICENSEE acknowledges that the Program is a research tool still in
 * the development state, that it is being supplied ``as is,'' without any
 * accompanying services from STANFORD, and that this license is entered
 * into in order to encourage scientific collaboration aimed at further
 * development and application of the Program.
 * 
 * 3. LICENSEE may copy the Program and may sublicense others to use
 * object code copies of the Program or any derivative version of the
 * Program.  All copies must contain all copyright and other proprietary
 * notices found in the Program as provided by STANFORD.  Title to
 * copyright to the Program remains with STANFORD.
 * 
 * 4. LICENSEE may create derivative versions of the Program.  LICENSEE
 * hereby grants STANFORD a royalty-free license to use, copy, modify,
 * distribute and sublicense any such derivative works.  At the time
 * LICENSEE provides a copy of a derivative version of the Program to a
 * third party, LICENSEE shall provide STANFORD with one copy of the
 * source code of the derivative version at no charge to STANFORD.
 * 
 * 5. STANFORD MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
 * IMPLIED.  By way of example, but not limitation, STANFORD MAKES NO
 * REPRESENTATION OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY
 * PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED PROGRAM WILL NOT
 * INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. STANFORD
 * shall not be held liable for any liability nor for any direct, indirect
 * or consequential damages with respect to any claim by LICENSEE or any
 * third party on account of or arising from this Agreement or use of the
 * Program.
 * 
 * 6. This agreement shall be construed, interpreted and applied in
 * accordance with the State of California and any legal action arising
 * out of this Agreement or use of the Program shall be filed in a court
 * in the State of California.
 * 
 * 7. Nothing in this Agreement shall be construed as conferring rights to
 * use in advertising, publicity or otherwise any trademark or the name
 * of ``Stanford''.
 * 
 * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
 * Leland Stanford Junior University.
 *
 *
 * The mtrace program has been modified and improved by Xerox
 * Corporation.  Xerox grants to LICENSEE a non-exclusive and
 * non-transferable license to use, copy, and modify the Xerox modified
 * and improved mrouted software on the same terms and conditions which
 * govern the license Stanford and ISI grant with respect to the mtrace
 * program.  These terms and conditions are incorporated in this grant
 * by reference and shall be deemed to have been accepted by LICENSEE
 * to cover its relationship with Xerox Corporation with respect to any
 * use of the Xerox improved program.
 * 
 * The mtrace program is COPYRIGHT 1998 by Xerox Corporation.
 *
 */

#ifndef lint
static const char rcsid[] =
  "$FreeBSD$";
#endif

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <memory.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/igmp.h>
#include <sys/ioctl.h>
#ifdef SYSV
#include <sys/sockio.h>
#endif
#include <arpa/inet.h>
#ifdef __STDC__
#include <stdarg.h>
#else
#include <varargs.h>
#endif
#ifdef SUNOS5
#include <sys/systeminfo.h>
#endif

typedef unsigned int u_int32;	/* XXX */
#include "mtrace.h"

#define DEFAULT_TIMEOUT	3	/* How long to wait before retrying requests */
#define DEFAULT_RETRIES 3	/* How many times to try */
#define DEFAULT_EXTRAHOPS 3	/* How many hops past a non-responding rtr */
#define MAXHOPS 60		/* Don't need more hops than this */
#define UNICAST_TTL 255		/* TTL for unicast response */
#define MULTICAST_TTL1 127	/* Default TTL for multicast query/response */
#define MULTICAST_TTL_INC 32	/* TTL increment for increase after timeout */
#define MULTICAST_TTL_MAX 192	/* Maximum TTL allowed (protect low-BW links */

#define TRUE 1
#define FALSE 0
#define DVMRP_ASK_NEIGHBORS2	5	/* DVMRP msg requesting neighbors */
#define DVMRP_NEIGHBORS2	6	/* reply to above */
#define DVMRP_NF_DOWN		0x10	/* kernel state of interface */
#define DVMRP_NF_DISABLED	0x20	/* administratively disabled */
#define MAX_IP_PACKET_LEN	576
#define MIN_IP_HEADER_LEN	20
#define MAX_IP_HEADER_LEN	60
#define MAX_DVMRP_DATA_LEN \
		( MAX_IP_PACKET_LEN - MAX_IP_HEADER_LEN - IGMP_MINLEN )

struct resp_buf {
    u_long qtime;		/* Time query was issued */
    u_long rtime;		/* Time response was received */
    int	len;			/* Number of reports or length of data */
    struct igmp igmp;		/* IGMP header */
    union {
	struct {
	    struct tr_query q;		/* Query/response header */
	    struct tr_resp r[MAXHOPS];	/* Per-hop reports */
	} t;
	char d[MAX_DVMRP_DATA_LEN];	/* Neighbor data */
    } u;
} base, incr[2];

#define qhdr u.t.q
#define resps u.t.r
#define ndata u.d

char *names[MAXHOPS];

/*
 * In mrouted 3.3 and 3.4 (and in some Cisco IOS releases),
 * cache entries can get deleted even if there is traffic
 * flowing, which will reset the per-source/group counters.
 */
#define		BUG_RESET	0x01

/*
 * Also in mrouted 3.3 and 3.4, there's a bug in neighbor
 * version processing which can cause them to believe that
 * the neighbor is constantly resetting.  This causes them
 * to constantly delete all their state.
 */
#define		BUG_RESET2X	0x02

/*
 * Pre-3.7 mrouted's forget to byte-swap their reports.
 */
#define		BUG_SWAP	0x04

/*
 * Pre-3.9 mrouted's forgot a parenthesis in the htonl()
 * on the time calculation so supply bogus times.
 */
#define		BUG_BOGUSTIME	0x08

#define BUG_NOPRINT	(BUG_RESET | BUG_RESET2X)

int bugs[MAXHOPS];			/* List of bugs noticed at each hop */

struct mtrace {
	struct mtrace	*next;
	struct resp_buf	 base, incr[2];
	struct resp_buf	*new, *prev;
	int		 nresp;
	struct timeval	 last;
	int		 bugs[MAXHOPS];
	char		*names[MAXHOPS];
	int		 lastqid;
};

int timeout = DEFAULT_TIMEOUT;
int nqueries = DEFAULT_RETRIES;
int numeric = FALSE;
int debug = 0;
int passive = FALSE;
int multicast = FALSE;
int unicast = FALSE;
int statint = 10;
int verbose = FALSE;
int tunstats = FALSE;
int weak = FALSE;
int extrahops = DEFAULT_EXTRAHOPS;
int printstats = TRUE;
int sendopts = TRUE;
int lossthresh = 0;
int fflag = FALSE;
int staticqid = 0;

u_int32 defgrp;				/* Default group if not specified */
u_int32 query_cast;			/* All routers multicast addr */
u_int32 resp_cast;			/* Mtrace response multicast addr */

u_int32 lcl_addr = 0;			/* This host address, in NET order */
u_int32 dst_netmask = 0;		/* netmask to go with qdst */

/*
 * Query/response parameters, all initialized to zero and set later
 * to default values or from options.
 */
u_int32 qsrc = 0;		/* Source address in the query */
u_int32 qgrp = 0;		/* Group address in the query */
u_int32 qdst = 0;		/* Destination (receiver) address in query */
u_char qno  = 0;		/* Max number of hops to query */
u_int32 raddr = 0;		/* Address where response should be sent */
int    qttl = 0;		/* TTL for the query packet */
u_char rttl = 0;		/* TTL for the response packet */
u_int32 gwy = 0;		/* User-supplied last-hop router address */
u_int32 tdst = 0;		/* Address where trace is sent (last-hop) */

char s1[19];		/* buffers to hold the string representations  */
char s2[19];		/* of IP addresses, to be passed to inet_fmt() */
char s3[19];		/* or inet_fmts().                             */

#if !(defined(BSD) && (BSD >= 199103))
extern int		errno;
extern int		sys_nerr;
extern char *		sys_errlist[];
#endif

#define RECV_BUF_SIZE 8192
char	*send_buf, *recv_buf;
int	igmp_socket;
u_int32	allrtrs_group;
char	router_alert[4];	     	/* Router Alert IP Option	    */
#ifndef	IPOPT_RA
#define	IPOPT_RA		148
#endif
#ifdef SUNOS5
char	eol[4];		     		/* EOL IP Option		    */
int ip_addlen = 0;		     	/* Workaround for Option bug #2     */
#endif

/*
 * max macro, with weird case to avoid conflicts
 */
#define	MaX(a,b)	((a) > (b) ? (a) : (b))

#ifndef __P
#ifdef __STDC__
#define __P(x)	x
#else
#define __P(x)	()
#endif
#endif

typedef int (*callback_t) __P((int, u_char *, int, struct igmp *, int,
			struct sockaddr *, int *, struct timeval *));

void			init_igmp __P((void));
void			send_igmp __P((u_int32 src, u_int32 dst, int type,
						int code, u_int32 group,
						int datalen));
int			inet_cksum __P((u_short *addr, u_int len));
void			k_set_rcvbuf __P((int bufsize));
void			k_hdr_include __P((int bool));
void			k_set_ttl __P((int t));
void			k_set_loop __P((int l));
void			k_set_if __P((u_int32 ifa));
void			k_join __P((u_int32 grp, u_int32 ifa));
void			k_leave __P((u_int32 grp, u_int32 ifa));
char *			inet_fmt __P((u_int32 addr, char *s));
char *			inet_fmts __P((u_int32 addr, u_int32 mask, char *s));
char *			inet_name __P((u_int32 addr));
u_int32			host_addr __P((char *name));
/* u_int is promoted u_char */
char *			proto_type __P((u_int type));
char *			flag_type __P((u_int type));

u_int32			get_netmask __P((int s, u_int32 *dst));
int			get_ttl __P((struct resp_buf *buf));
int			t_diff __P((u_long a, u_long b));
u_long			byteswap __P((u_long v));
int			mtrace_callback __P((int, u_char *, int, struct igmp *,
					int, struct sockaddr *, int *,
					struct timeval *));
int			send_recv __P((u_int32 dst, int type, int code,
					int tries, struct resp_buf *save,
					callback_t callback));
void			passive_mode __P((void));
char *			print_host __P((u_int32 addr));
char *			print_host2 __P((u_int32 addr1, u_int32 addr2));
void			print_trace __P((int idx, struct resp_buf *buf,
					char **names));
int			what_kind __P((struct resp_buf *buf, char *why));
char *			scale __P((int *hop));
void			stat_line __P((struct tr_resp *r, struct tr_resp *s,
					int have_next, int *res));
void			fixup_stats __P((struct resp_buf *base,
					struct resp_buf *prev,
					struct resp_buf *new,
					int *bugs));
int			check_thresh __P((int thresh,
					struct resp_buf *base,
					struct resp_buf *prev,
					struct resp_buf *new));
int			print_stats __P((struct resp_buf *base,
					struct resp_buf *prev,
					struct resp_buf *new,
					int *bugs,
					char **names));
int			path_changed __P((struct resp_buf *base,
					struct resp_buf *new));
void			check_vif_state __P((void));

int			main __P((int argc, char *argv[]));
void			log __P((int, int, char *, ...));
static void		usage __P((void));


/*
 * Open and initialize the igmp socket, and fill in the non-changing
 * IP header fields in the output packet buffer.
 */
void
init_igmp()
{
    struct ip *ip;

    recv_buf = (char *)malloc(RECV_BUF_SIZE);
    if (recv_buf == 0)
	log(LOG_ERR, 0, "Out of memory allocating recv_buf!");
    send_buf = (char *)malloc(RECV_BUF_SIZE);
    if (send_buf == 0)
	log(LOG_ERR, 0, "Out of memory allocating send_buf!");

    if ((igmp_socket = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP)) < 0) 
	log(LOG_ERR, errno, "IGMP socket");

    k_hdr_include(TRUE);	/* include IP header when sending */
    k_set_rcvbuf(48*1024);	/* lots of input buffering        */
    k_set_ttl(1);		/* restrict multicasts to one hop */
    k_set_loop(FALSE);		/* disable multicast loopback     */

    ip         = (struct ip *)send_buf;
    ip->ip_hl  = sizeof(struct ip) >> 2;
    ip->ip_v   = IPVERSION;
    ip->ip_tos = 0;
    ip->ip_off = 0;
    ip->ip_p   = IPPROTO_IGMP;
    ip->ip_ttl = MAXTTL;	/* applies to unicasts only */

#ifndef INADDR_ALLRTRS_GROUP
#define	INADDR_ALLRTRS_GROUP	0xe0000002	/* 224.0.0.2 */
#endif
    allrtrs_group  = htonl(INADDR_ALLRTRS_GROUP);

    router_alert[0] = IPOPT_RA;	/* Router Alert */
    router_alert[1] = 4;	/* 4 bytes */
    router_alert[2] = 0;
    router_alert[3] = 0;
}

#ifdef SUNOS5
void
checkforsolarisbug()
{
    u_int32 localhost = htonl(0x7f000001);

    eol[0] = IPOPT_EOL;
    eol[1] = IPOPT_EOL;
    eol[2] = IPOPT_EOL;
    eol[3] = IPOPT_EOL;

    setsockopt(igmp_socket, IPPROTO_IP, IP_OPTIONS, eol, sizeof(eol));
    /*
     * Check if the kernel adds the options length to the packet
     * length.  Send myself an IGMP packet of type 0 (illegal),
     * with 4 IPOPT_EOL options, my PID (for collision detection)
     * and 4 bytes of zero (so that the checksum works whether
     * the 4 bytes of zero get truncated or not).
     */
    bzero(send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN, 8);
    *(int *)(send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN) = getpid();
    send_igmp(localhost, localhost, 0, 0, 0, 8);
    while (1) {
	int recvlen, dummy = 0;

	recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE,
				0, NULL, &dummy);
	/* 8 == 4 bytes of options and 4 bytes of PID */
	if (recvlen >= MIN_IP_HEADER_LEN + IGMP_MINLEN + 8) {
	    struct ip *ip = (struct ip *)recv_buf;
	    struct igmp *igmp;
	    int *p;

	    if (ip->ip_hl != 6 ||
		ip->ip_p != IPPROTO_IGMP ||
	        ip->ip_src.s_addr != localhost ||
		ip->ip_dst.s_addr != localhost)
		continue;

	    igmp = (struct igmp *)(recv_buf + (ip->ip_hl << 2));
	    if (igmp->igmp_group.s_addr != 0)
		continue;
	    if (igmp->igmp_type != 0 || igmp->igmp_code != 0)
		continue;

	    p = (int *)((char *)igmp + IGMP_MINLEN);
	    if (*p != getpid())
		continue;

#ifdef RAW_INPUT_IS_RAW
	    ip->ip_len = ntohs(ip->ip_len);
#endif
	    if (ip->ip_len == IGMP_MINLEN + 4)
		ip_addlen = 4;
	    else if (ip->ip_len == IGMP_MINLEN + 8)
		ip_addlen = 0;
	    else
		log(LOG_ERR, 0, "while checking for Solaris bug: Sent %d bytes and got back %d!", IGMP_MINLEN + 8, ip->ip_len);

	    break;
	}
    }
}
#endif

/*
 * Construct an IGMP message in the output packet buffer.  The caller may
 * have already placed data in that buffer, of length 'datalen'.  Then send
 * the message from the interface with IP address 'src' to destination 'dst'.
 */
void
send_igmp(src, dst, type, code, group, datalen)
    u_int32 src, dst;
    int type, code;
    u_int32 group;
    int datalen;
{
    struct sockaddr_in sdst;
    struct ip *ip;
    struct igmp *igmp;
    int setloop = 0;
    static int raset = 0;
    int sendra = 0;
    int sendlen;

    ip                      = (struct ip *)send_buf;
    ip->ip_src.s_addr       = src;
    ip->ip_dst.s_addr       = dst;
    ip->ip_len              = MIN_IP_HEADER_LEN + IGMP_MINLEN + datalen;
    sendlen		    = ip->ip_len;
#ifdef SUNOS5
    ip->ip_len		   += ip_addlen;
#endif
#ifdef RAW_OUTPUT_IS_RAW
    ip->ip_len		    = htons(ip->ip_len);
#endif

    igmp                    = (struct igmp *)(send_buf + MIN_IP_HEADER_LEN);
    igmp->igmp_type         = type;
    igmp->igmp_code         = code;
    igmp->igmp_group.s_addr = group;
    igmp->igmp_cksum        = 0;
    igmp->igmp_cksum        = inet_cksum((u_short *)igmp,
					 IGMP_MINLEN + datalen);

    if (IN_MULTICAST(ntohl(dst))) {
	k_set_if(src);
	setloop = 1;
	k_set_loop(TRUE);
	if (dst != allrtrs_group)
	    sendra = 1;
    }

    if (sendopts && sendra && !raset) {
	setsockopt(igmp_socket, IPPROTO_IP, IP_OPTIONS,
			router_alert, sizeof(router_alert));
	raset = 1;
    } else if (!sendra && raset) {
#ifdef SUNOS5
	/*
	 * SunOS5 < 5.6 cannot properly reset the IP_OPTIONS "socket"
	 * option.  Instead, set up a string of 4 EOL's.
	 */
	setsockopt(igmp_socket, IPPROTO_IP, IP_OPTIONS,
			eol, sizeof(eol));
#else
	setsockopt(igmp_socket, IPPROTO_IP, IP_OPTIONS,
			NULL, 0);
#endif
	raset = 0;
    }

    bzero(&sdst, sizeof(sdst));
    sdst.sin_family = AF_INET;
#if (defined(BSD) && (BSD >= 199103))
    sdst.sin_len = sizeof(sdst);
#endif
    sdst.sin_addr.s_addr = dst;
    if (sendto(igmp_socket, send_buf, sendlen, 0,
			(struct sockaddr *)&sdst, sizeof(sdst)) < 0) {
	    log(LOG_WARNING, errno, "sendto to %s on %s",
		inet_fmt(dst, s1), inet_fmt(src, s2));
    }

    if (setloop)
	    k_set_loop(FALSE);

    log(LOG_DEBUG, 0, "SENT %s from %-15s to %s",
	type == IGMP_MTRACE ? "mtrace request" : "ask_neighbors",
	src == INADDR_ANY ? "INADDR_ANY" : inet_fmt(src, s1),
	inet_fmt(dst, s2));
}

/*
 * inet_cksum extracted from:
 *			P I N G . C
 *
 * Author -
 *	Mike Muuss
 *	U. S. Army Ballistic Research Laboratory
 *	December, 1983
 * Modified at Uc Berkeley
 *
 * (ping.c) Status -
 *	Public Domain.  Distribution Unlimited.
 *
 *			I N _ C K S U M
 *
 * Checksum routine for Internet Protocol family headers (C Version)
 *
 */
int
inet_cksum(addr, len)
	u_short *addr;
	u_int len;
{
	register int nleft = (int)len;
	register u_short *w = addr;
	u_short answer = 0;
	register int sum = 0;

	/*
	 *  Our algorithm is simple, using a 32 bit accumulator (sum),
	 *  we add sequential 16 bit words to it, and at the end, fold
	 *  back all the carry bits from the top 16 bits into the lower
	 *  16 bits.
	 */
	while (nleft > 1)  {
		sum += *w++;
		nleft -= 2;
	}

	/* mop up an odd byte, if necessary */
	if (nleft == 1) {
		*(u_char *) (&answer) = *(u_char *)w ;
		sum += answer;
	}

	/*
	 * add back carry outs from top 16 bits to low 16 bits
	 */
	sum = (sum >> 16) + (sum & 0xffff);	/* add hi 16 to low 16 */
	sum += (sum >> 16);			/* add carry */
	answer = ~sum;				/* truncate to 16 bits */
	return (answer);
}

void
k_set_rcvbuf(bufsize)
    int bufsize;
{
    if (setsockopt(igmp_socket, SOL_SOCKET, SO_RCVBUF,
		   (char *)&bufsize, sizeof(bufsize)) < 0)
	log(LOG_ERR, errno, "setsockopt SO_RCVBUF %u", bufsize);
}


void
k_hdr_include(bool)
    int bool;
{
#ifdef IP_HDRINCL
    if (setsockopt(igmp_socket, IPPROTO_IP, IP_HDRINCL,
		   (char *)&bool, sizeof(bool)) < 0)
	log(LOG_ERR, errno, "setsockopt IP_HDRINCL %u", bool);
#endif
}

void
k_set_ttl(t)
    int t;
{
    u_char ttl;

    ttl = t;
    if (setsockopt(igmp_socket, IPPROTO_IP, IP_MULTICAST_TTL,
		   (char *)&ttl, sizeof(ttl)) < 0)
	log(LOG_ERR, errno, "setsockopt IP_MULTICAST_TTL %u", ttl);
}


void
k_set_loop(l)
    int l;
{
    u_char loop;

    loop = l;
    if (setsockopt(igmp_socket, IPPROTO_IP, IP_MULTICAST_LOOP,
		   (char *)&loop, sizeof(loop)) < 0)
	log(LOG_ERR, errno, "setsockopt IP_MULTICAST_LOOP %u", loop);
}

void
k_set_if(ifa)
    u_int32 ifa;
{
    struct in_addr adr;

    adr.s_addr = ifa;
    if (setsockopt(igmp_socket, IPPROTO_IP, IP_MULTICAST_IF,
		   (char *)&adr, sizeof(adr)) < 0)
	log(LOG_ERR, errno, "setsockopt IP_MULTICAST_IF %s",
	    		    inet_fmt(ifa, s1));
}

void
k_join(grp, ifa)
    u_int32 grp;
    u_int32 ifa;
{
    struct ip_mreq mreq;

    mreq.imr_multiaddr.s_addr = grp;
    mreq.imr_interface.s_addr = ifa;

    if (setsockopt(igmp_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
		   (char *)&mreq, sizeof(mreq)) < 0)
	log(LOG_WARNING, errno, "can't join group %s on interface %s",
				inet_fmt(grp, s1), inet_fmt(ifa, s2));
}


void
k_leave(grp, ifa)
    u_int32 grp;
    u_int32 ifa;
{
    struct ip_mreq mreq;

    mreq.imr_multiaddr.s_addr = grp;
    mreq.imr_interface.s_addr = ifa;

    if (setsockopt(igmp_socket, IPPROTO_IP, IP_DROP_MEMBERSHIP,
		   (char *)&mreq, sizeof(mreq)) < 0)
	log(LOG_WARNING, errno, "can't leave group %s on interface %s",
				inet_fmt(grp, s1), inet_fmt(ifa, s2));
}

/*
 * Convert an IP address in u_long (network) format into a printable string.
 */
char *
inet_fmt(addr, s)
    u_int32 addr;
    char *s;
{
    register u_char *a;

    a = (u_char *)&addr;
    sprintf(s, "%u.%u.%u.%u", a[0], a[1], a[2], a[3]);
    return (s);
}


/*
 * Convert an IP subnet number in u_long (network) format into a printable
 * string including the netmask as a number of bits.
 */
char *
inet_fmts(addr, mask, s)
    u_int32 addr, mask;
    char *s;
{
    register u_char *a, *m;
    int bits;

    if ((addr == 0) && (mask == 0)) {
	sprintf(s, "default");
	return (s);
    }
    a = (u_char *)&addr;
    m = (u_char *)&mask;
    bits = 33 - ffs(ntohl(mask));

    if      (m[3] != 0) sprintf(s, "%u.%u.%u.%u/%d", a[0], a[1], a[2], a[3],
						bits);
    else if (m[2] != 0) sprintf(s, "%u.%u.%u/%d",    a[0], a[1], a[2], bits);
    else if (m[1] != 0) sprintf(s, "%u.%u/%d",       a[0], a[1], bits);
    else                sprintf(s, "%u/%d",          a[0], bits);

    return (s);
}

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

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

    return e ? e->h_name : "?";
}


u_int32 
host_addr(name)
    char   *name;
{
    struct hostent *e = (struct hostent *)0;
    u_int32  addr;
    int	i, dots = 3;
    char	buf[40];
    char	*ip = name;
    char	*op = buf;

    /*
     * Undo BSD's favor -- take fewer than 4 octets as net/subnet address
     * if the name is all numeric.
     */
    for (i = sizeof(buf) - 7; i > 0; --i) {
	if (*ip == '.') --dots;
	else if (*ip == '\0') break;
	else if (!isdigit(*ip)) dots = 0;  /* Not numeric, don't add zeroes */
	*op++ = *ip++;
    }
    for (i = 0; i < dots; ++i) {
	*op++ = '.';
	*op++ = '0';
    }
    *op = '\0';

    if (dots <= 0)
	e = gethostbyname(name);
    if (e && (e->h_length == sizeof(addr))) {
	memcpy((char *)&addr, e->h_addr_list[0], e->h_length);
	if (e->h_addr_list[1])
	    fprintf(stderr, "Warning: %s has multiple addresses, using %s\n",
			name, inet_fmt(addr, s1));
    } else {
	addr = inet_addr(buf);
	if (addr == -1 || (IN_MULTICAST(addr) && dots)) {
	    addr = 0;
	    printf("Could not parse %s as host name or address\n", name);
	}
    }
    return addr;
}


char *
proto_type(type)
    u_int type;
{
    static char buf[80];

    switch (type) {
      case PROTO_DVMRP:
	return ("DVMRP");
      case PROTO_MOSPF:
	return ("MOSPF");
      case PROTO_PIM:
	return ("PIM");
      case PROTO_CBT:
	return ("CBT");
      case PROTO_PIM_SPECIAL:
	return ("PIM/Special");
      case PROTO_PIM_STATIC:
	return ("PIM/Static");
      case PROTO_DVMRP_STATIC:
	return ("DVMRP/Static");
      case PROTO_PIM_BGP4PLUS:
	return ("PIM/BGP4+");
      case PROTO_CBT_SPECIAL:
	return ("CBT/Special");
      case PROTO_CBT_STATIC:
	return ("CBT/Static");
      case PROTO_PIM_ASSERT:
	return ("PIM/Assert");
      case 0:
	return ("None");
      default:
	(void) sprintf(buf, "Unknown protocol code %d", type);
	return (buf);
    }
}


char *
flag_type(type)
    u_int type;
{
    static char buf[80];

    switch (type) {
      case TR_NO_ERR:
	return ("");
      case TR_WRONG_IF:
	return ("Wrong interface");
      case TR_PRUNED:
	return ("Prune sent upstream");
      case TR_OPRUNED:
	return ("Output pruned");
      case TR_SCOPED:
	return ("Hit scope boundary");
      case TR_NO_RTE:
	return ("No route");
      case TR_NO_FWD:
	return ("Not forwarding");
      case TR_HIT_RP:
	return ("Reached RP/Core");
      case TR_RPF_IF:
	return ("RPF Interface");
      case TR_NO_MULTI:
	return ("Multicast disabled");
      case TR_OLD_ROUTER:
	return ("Next router no mtrace");
      case TR_NO_SPACE:
	return ("No space in packet");
      case TR_ADMIN_PROHIB:
	return ("Admin. Prohibited");
      default:
	(void) sprintf(buf, "Unknown error code %d", type);
	return (buf);
    }
}    

/*
 * If destination is on a local net, get the netmask, else set the
 * netmask to all ones.  There are two side effects: if the local
 * address was not explicitly set, and if the destination is on a
 * local net, use that one; in either case, verify that the local
 * address is valid.
 */
u_int32
get_netmask(s, dst)
    int s;
    u_int32 *dst;
{
    unsigned int n;
    struct ifconf ifc;
    struct ifreq *ifrp, *ifend;
    u_int32 if_addr, if_mask;
    u_int32 retval = 0xFFFFFFFF;
    int found = FALSE;
    int num_ifreq = 32;

    ifc.ifc_len = num_ifreq * sizeof(struct ifreq);
    ifc.ifc_buf = malloc(ifc.ifc_len);
    while (ifc.ifc_buf) {
	if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) {
	    perror("ioctl SIOCGIFCONF");
	    return retval;
	}

	/*
	 * If the buffer was large enough to hold all the addresses
	 * then break out, otherwise increase the buffer size and
	 * try again.
	 *
	 * The only way to know that we definitely had enough space
	 * is to know that there was enough space for at least one
	 * more struct ifreq. ???
	 */
	if ((num_ifreq * sizeof(struct ifreq)) >=
	     ifc.ifc_len + sizeof(struct ifreq))
	     break;

	num_ifreq *= 2;
	ifc.ifc_len = num_ifreq * sizeof(struct ifreq);
	ifc.ifc_buf = realloc(ifc.ifc_buf, ifc.ifc_len);
    }
    if (ifc.ifc_buf == NULL) {
	fprintf(stderr, "getting interface list: ran out of memory");
	exit(1);
    }

    ifrp = (struct ifreq *)ifc.ifc_buf;
    ifend = (struct ifreq *)(ifc.ifc_buf + ifc.ifc_len);
    /*
     * Loop through all of the interfaces.
     */
    for (; ifrp < ifend && !found; ifrp = (struct ifreq *)((char *)ifrp + n)) {
#if BSD >= 199006
	n = ifrp->ifr_addr.sa_len + sizeof(ifrp->ifr_name);
	if (n < sizeof(*ifrp))
	    n = sizeof(*ifrp);
#else
	n = sizeof(*ifrp);
#endif
	/*
	 * Ignore any interface for an address family other than IP.
	 */
	if (ifrp->ifr_addr.sa_family != AF_INET)
	    continue;

	if_addr = ((struct sockaddr_in *)&(ifrp->ifr_addr))->sin_addr.s_addr;
	if (ioctl(s, SIOCGIFFLAGS, (char *)ifrp) < 0) {
	    fprintf(stderr, "SIOCGIFFLAGS on ");
	    perror(ifrp->ifr_name);
	    continue;
	}
	if ((ifrp->ifr_flags & (IFF_MULTICAST|IFF_UP|IFF_LOOPBACK)) !=
				(IFF_MULTICAST|IFF_UP))
	    continue;
	if (*dst == 0)
	    *dst = if_addr;
	if (ioctl(s, SIOCGIFNETMASK, (char *)ifrp) >= 0) {
	    if_mask = ((struct sockaddr_in *)&(ifrp->ifr_addr))->sin_addr.s_addr;
	    if (if_mask != 0 && (*dst & if_mask) == (if_addr & if_mask)) {
		retval = if_mask;
		if (lcl_addr == 0) lcl_addr = if_addr;	/* XXX what about aliases? */
	    }
	}
	if (lcl_addr == if_addr) found = TRUE;
    }
    if (!found && lcl_addr != 0) {
	printf("Interface address is not valid\n");
	exit(1);
    }
    return (retval);
}


/*
 * Try to pick a TTL that will get past all the thresholds in the path.
 */
int
get_ttl(buf)
    struct resp_buf *buf;
{
    int rno;
    struct tr_resp *b;
    u_int ttl;

    if (buf && (rno = buf->len) > 0) {
	b = buf->resps + rno - 1;
	ttl = b->tr_fttl;

	while (--rno > 0) {
	    --b;
	    if (ttl < b->tr_fttl) ttl = b->tr_fttl;
	    else ++ttl;
	}
	ttl += MULTICAST_TTL_INC;
	if (ttl < MULTICAST_TTL1) ttl = MULTICAST_TTL1;
	if (ttl > MULTICAST_TTL_MAX) ttl = MULTICAST_TTL_MAX;
	return (ttl);
    } else return(MULTICAST_TTL1);
}

/*
 * Calculate the difference between two 32-bit NTP timestamps and return
 * the result in milliseconds.
 */
int
t_diff(a, b)
    u_long a, b;
{
    int d = a - b;

    return ((d * 125) >> 13);
}

/*
 * Swap bytes for poor little-endian machines that don't byte-swap
 */
u_long
byteswap(v)
    u_long v;
{
    return ((v << 24) | ((v & 0xff00) << 8) |
	    ((v >> 8) & 0xff00) | (v >> 24));
}

#if 0
/*
 * XXX incomplete - need private callback data, too?
 * XXX since dst doesn't get passed through?
 */
int
neighbors_callback(tmo, buf, buflen, igmp, igmplen, addr, addrlen, ts)
    int tmo;
    u_char *buf;
    int buflen;
    struct igmp *igmp;
    int igmplen;
    struct sockaddr *addr;
    int *addrlen;
    struct timeval *ts;
{
    int len;
    u_int32 dst;
    struct ip *ip = (struct ip *)buf;

    if (tmo)
	return 0;

    if (igmp->igmp_code != DVMRP_NEIGHBORS2)
	return 0;
    len = igmplen;
    /*
     * Accept DVMRP_NEIGHBORS2 response if it comes from the
     * address queried or if that address is one of the local
     * addresses in the response.
     */
    if (ip->ip_src.s_addr != dst) {
	u_int32 *p = (u_int32 *)(igmp + 1);
	u_int32 *ep = p + (len >> 2);
	while (p < ep) {
	    u_int32 laddr = *p++;
	    int n = ntohl(*p++) & 0xFF;
	    if (laddr == dst) {
		ep = p + 1;		/* ensure p < ep after loop */
		break;
	    }
	    p += n;
	}
	if (p >= ep)
	    return 0;
    }
    return buflen;
}
#endif

int
mtrace_callback(tmo, buf, buflen, igmp, igmplen, addr, addrlen, ts)
    int tmo;
    u_char *buf;
    int buflen;
    struct igmp *igmp;
    int igmplen;
    struct sockaddr *addr;
    int *addrlen;
    struct timeval *ts;
{
    static u_char *savbuf = NULL;
    static int savbuflen;
    static struct sockaddr *savaddr;
    static int savaddrlen;
    static struct timeval savts;

    int len = (igmplen - QLEN) / RLEN;
    struct tr_resp *r = (struct tr_resp *)((struct tr_query *)(igmp + 1) + 1);

    if (tmo == 1) {
	/*
	 * If we timed out with a packet saved, then return that packet.
	 * send_recv won't send this same packet to the callback again.
	 */
	if (savbuf) {
	    bcopy(savbuf, buf, savbuflen);
	    free(savbuf);
	    savbuf = NULL;
	    bcopy(savaddr, addr, savaddrlen);
	    free(savaddr);
	    *addrlen = savaddrlen;
	    bcopy(&savts, ts, sizeof(savts));
	    return savbuflen;
	}
	return 0;
    }
    if (savbuf) {
	free(savbuf);
	savbuf = NULL;
	free(savaddr);
    }
    /*
     * Check for IOS bug described in CSCdi68628, where a router that does
     *  not have multicast enabled responds to an mtrace request with a 1-hop
     *  error packet.
     * Heuristic is:
     *  If there is only one hop reported in the packet,
     *	And the protocol code is 0,
     *  And there is no previous hop,
     *	And the forwarding information is "Not Forwarding",
     *	And the router is not on the same subnet as the destination of the
     *		trace,
     *  then drop this packet.  The "#if 0"'d code saves it and returns
     *   it on timeout, but timeouts are too common (e.g. routers with
     *   limited unicast routing tables, etc).
     */
    if (len == 1 && r->tr_rproto == 0 && r->tr_rmtaddr == 0 &&
					r->tr_rflags == TR_NO_FWD) {
	u_int32 smask;

	VAL_TO_MASK(smask, r->tr_smask);
	if ((r->tr_outaddr & smask) != (qdst & smask)) {
#if 0
	    /* XXX should do this silently? */
	    fprintf(stderr, "mtrace: probably IOS-buggy packet from %s\n",
		inet_fmt(((struct sockaddr_in *)addr)->sin_addr.s_addr, s1));
	    /* Save the packet to return if a timeout occurs. */
	    savbuf = (u_char *)malloc(buflen);
	    if (savbuf != NULL) {
		bcopy(buf, savbuf, buflen);
		savbuflen = buflen;
		savaddr = (struct sockaddr *)malloc(*addrlen);
		if (savaddr != NULL) {
		    bcopy(addr, savaddr, *addrlen);
		    savaddrlen = *addrlen;
		    bcopy(ts, &savts, sizeof(savts));
		} else {
		    free(savbuf);
		    savbuf = NULL;
		}
	    }
#endif
	    return 0;
	}
    }
    return buflen;
}

int
send_recv(dst, type, code, tries, save, callback)
    u_int32 dst;
    int type, code, tries;
    struct resp_buf *save;
    callback_t callback;
{
    fd_set  fds;
    struct timeval tq, tr, tv;
    struct ip *ip;
    struct igmp *igmp;
    struct tr_query *query, *rquery;
    struct tr_resp *r;
    struct sockaddr_in recvaddr;
    u_int32 local, group;
    int ipdatalen, iphdrlen, igmpdatalen;
    int datalen;
    int count, recvlen, socklen = sizeof(recvaddr);
    int len;
    int i;

    if (type == IGMP_MTRACE) {
	group = qgrp;
	datalen = sizeof(struct tr_query);
    } else {
	group = htonl(0xff03);
	datalen = 0;
    }
    if (IN_MULTICAST(ntohl(dst))) local = lcl_addr;
    else local = INADDR_ANY;

    /*
     * If the reply address was not explictly specified, start off
     * with the standard multicast reply address, or the unicast
     * address of this host if the unicast flag was specified.
     * Then, if there is no response after trying half the tries
     * with multicast, switch to the unicast address of this host
     * if the multicast flag was not specified.  If the TTL was
     * also not specified, set a multicast TTL and increase it
     * for every try.
     */
    query = (struct tr_query *)(send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
    query->tr_raddr = raddr ? raddr : unicast ? lcl_addr : resp_cast;
    TR_SETTTL(query->tr_rttlqid, rttl ? rttl :
      IN_MULTICAST(ntohl(query->tr_raddr)) ? get_ttl(save) : UNICAST_TTL);
    query->tr_src   = qsrc;
    query->tr_dst   = qdst;

    for (i = tries ; i > 0; --i) {
	int oqid;

	if (tries == nqueries && raddr == 0) {
	    if (i == (nqueries >> 1)) {
		if (multicast && unicast) {
		    query->tr_raddr = resp_cast;
		    if (!rttl)
			TR_SETTTL(query->tr_rttlqid, get_ttl(save));
		} else if (!multicast) {
		    query->tr_raddr = lcl_addr;
		    TR_SETTTL(query->tr_rttlqid, UNICAST_TTL);
		}
	    }
	    if (i < tries && IN_MULTICAST(ntohl(query->tr_raddr)) &&
								rttl == 0) {
		TR_SETTTL(query->tr_rttlqid,
			TR_GETTTL(query->tr_rttlqid) + MULTICAST_TTL_INC);
		if (TR_GETTTL(query->tr_rttlqid) > MULTICAST_TTL_MAX)
		  TR_SETTTL(query->tr_rttlqid, MULTICAST_TTL_MAX);
	    }
	}

	/*
	 * Change the qid for each request sent to avoid being confused
	 * by duplicate responses
	 */
	oqid = TR_GETQID(query->tr_rttlqid);
	if (staticqid)
	    TR_SETQID(query->tr_rttlqid, staticqid);
	else
#ifdef SYSV    
	    TR_SETQID(query->tr_rttlqid, ((u_int32)lrand48() >> 8));
#else
	    TR_SETQID(query->tr_rttlqid, ((u_int32)random() >> 8));
#endif

	/*
	 * Set timer to calculate delays, then send query
	 */
	gettimeofday(&tq, 0);
	send_igmp(local, dst, type, code, group, datalen);

	/*
	 * Wait for response, discarding false alarms
	 */
	while (TRUE) {
	    FD_ZERO(&fds);
	    FD_SET(igmp_socket, &fds);
	    gettimeofday(&tv, 0);
	    tv.tv_sec = tq.tv_sec + timeout - tv.tv_sec;
	    tv.tv_usec = tq.tv_usec - tv.tv_usec;
	    if (tv.tv_usec < 0) tv.tv_usec += 1000000L, --tv.tv_sec;
	    if (tv.tv_sec < 0) tv.tv_sec = tv.tv_usec = 0;

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

	    if (count < 0) {
		if (errno != EINTR) warn("select");
		continue;
	    } else if (count == 0) {
		/*
		 * Timed out.  Notify the callback.
		 */
		if (!callback || (recvlen = (callback)(1, recv_buf, 0, NULL, 0, (struct sockaddr *)&recvaddr, &socklen, &tr)) == 0) {
		    printf("* ");
		    fflush(stdout);
		    break;
		}
	    } else {
		/*
		 * Data is available on the socket, so read it.
		 */
		gettimeofday(&tr, 0);
		recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE,
				   0, (struct sockaddr *)&recvaddr, &socklen);
	    }

	    if (recvlen <= 0) {
		if (recvlen && errno != EINTR) warn("recvfrom");
		continue;
	    }

	    if (recvlen < sizeof(struct ip)) {
		warnx("packet too short (%u bytes) for IP header", recvlen);
		continue;
	    }
	    ip = (struct ip *) recv_buf;
	    if (ip->ip_p == 0)	/* ignore cache creation requests */
		continue;

	    iphdrlen = ip->ip_hl << 2;
#ifdef RAW_INPUT_IS_RAW
	    ipdatalen = ntohs(ip->ip_len);
#else
	    ipdatalen = ip->ip_len;
#endif
	    if (iphdrlen + ipdatalen != recvlen) {
		warnx("packet shorter (%u bytes) than hdr+data len (%u+%u)",
			recvlen, iphdrlen, ipdatalen);
		continue;
	    }

	    igmp = (struct igmp *) (recv_buf + iphdrlen);
	    igmpdatalen = ipdatalen - IGMP_MINLEN;
	    if (igmpdatalen < 0) {
		warnx("IP data field too short (%u bytes) for IGMP from %s",
			ipdatalen, inet_fmt(ip->ip_src.s_addr, s1));
		continue;
	    }

	    switch (igmp->igmp_type) {

	      case IGMP_DVMRP:
		if (type != IGMP_DVMRP || code != DVMRP_ASK_NEIGHBORS2)
			continue;
		if (igmp->igmp_code != DVMRP_NEIGHBORS2) continue;
		len = igmpdatalen;
		/*
		 * Accept DVMRP_NEIGHBORS2 response if it comes from the
		 * address queried or if that address is one of the local
		 * addresses in the response.
		 */
		if (ip->ip_src.s_addr != dst) {
		    u_int32 *p = (u_int32 *)(igmp + 1);
		    u_int32 *ep = p + (len >> 2);
		    while (p < ep) {
			u_int32 laddr = *p++;
			int n = ntohl(*p++) & 0xFF;
			if (laddr == dst) {
			    ep = p + 1;		/* ensure p < ep after loop */
			    break;
			}
			p += n;
		    }
		    if (p >= ep) continue;
		}
		break;

	      case IGMP_MTRACE:	    /* For backward compatibility with 3.3 */
	      case IGMP_MTRACE_RESP:
		if (type != IGMP_MTRACE) continue;
		if (igmpdatalen <= QLEN) continue;
		if ((igmpdatalen - QLEN)%RLEN) {
		    printf("packet with incomplete responses (%d bytes)\n",
			igmpdatalen);
		    continue;
		}

		/*
		 * Ignore responses that don't match query.
		 */
		rquery = (struct tr_query *)(igmp + 1);
		if (rquery->tr_src != qsrc || rquery->tr_dst != qdst)
		    continue;
		if (TR_GETQID(rquery->tr_rttlqid) !=
			TR_GETQID(query->tr_rttlqid)) {
		    if (verbose && TR_GETQID(rquery->tr_rttlqid) == oqid)
			printf("[D]");
		    continue;
		}
		len = (igmpdatalen - QLEN)/RLEN;
		r = (struct tr_resp *)(rquery+1) + len - 1;

		/*
		 * Ignore trace queries passing through this node when
		 * mtrace is run on an mrouter that is in the path
		 * (needed only because IGMP_MTRACE is accepted above
		 * for backward compatibility with multicast release 3.3).
		 */
		if (igmp->igmp_type == IGMP_MTRACE) {
		    u_int32 smask;

		    VAL_TO_MASK(smask, r->tr_smask);
		    if (len < code && (r->tr_inaddr & smask) != (qsrc & smask)
			&& r->tr_rmtaddr != 0 && !(r->tr_rflags & 0x80))
		      continue;
		}
		/*
		 * Some routers will return error messages without
		 * filling in their addresses.  We fill in the address
		 * for them.
		 */
		if (r->tr_outaddr == 0)
		    r->tr_outaddr = recvaddr.sin_addr.s_addr;

		/*
		 * A match, we'll keep this one.
		 */
		if (len > code) {
		    warnx("num hops received (%d) exceeds request (%d)",
			    len, code);
		}
		rquery->tr_raddr = query->tr_raddr;	/* Insure these are */
		TR_SETTTL(rquery->tr_rttlqid, TR_GETTTL(query->tr_rttlqid));
							/* as we sent them */
		break;

	      default:
		continue;
	    }

	    /*
	     * We're pretty sure we want to use this packet now,
	     * but if the caller gave a callback function, it might
	     * want to handle it instead.  Give the callback a chance,
	     * unless the select timed out (in which case the only way
	     * to get here is because the callback returned a packet).
	     */
	    if (callback && (count != 0) && ((callback)(0, recv_buf, recvlen, igmp, igmpdatalen, (struct sockaddr*)&recvaddr, &socklen, &tr)) == 0) {
		/*
		 * The callback function didn't like this packet.
		 * Go try receiving another one.
		 */
		continue;
	    }

	    /*
	     * Most of the sanity checking done at this point.
	     * Return this packet we have been waiting for.
	     */
	    if (save) {
		save->qtime = ((tq.tv_sec + JAN_1970) << 16) +
			      (tq.tv_usec << 10) / 15625;
		save->rtime = ((tr.tv_sec + JAN_1970) << 16) +
			      (tr.tv_usec << 10) / 15625;
		save->len = len;
		bcopy((char *)igmp, (char *)&save->igmp, ipdatalen);
	    }
	    return (recvlen);
	}
    }
    return (0);
}

/*
 * Most of this code is duplicated elsewhere.  I'm not sure if
 * the duplication is absolutely required or not.
 *
 * Ideally, this would keep track of ongoing statistics
 * collection and print out statistics.  (& keep track
 * of h-b-h traces and only print the longest)  For now,
 * it just snoops on what traces it can.
 */
void
passive_mode()
{
    struct timeval tr;
    time_t tr_sec;
    struct ip *ip;
    struct igmp *igmp;
    struct tr_resp *r;
    struct sockaddr_in recvaddr;
    struct tm *now;
    char timebuf[32];
    int socklen;
    int ipdatalen, iphdrlen, igmpdatalen;
    int len, recvlen;
    int qid;
    u_int32 smask;
    struct mtrace *remembered = NULL, *m, *n, **nn;
    int pc = 0;

    if (raddr) {
	if (IN_MULTICAST(ntohl(raddr))) k_join(raddr, lcl_addr);
    } else k_join(htonl(0xE0000120), lcl_addr);

    while (1) {
	fflush(stdout);		/* make sure previous trace is flushed */

	socklen = sizeof(recvaddr);
	recvlen = recvfrom(igmp_socket, recv_buf, RECV_BUF_SIZE,
			   0, (struct sockaddr *)&recvaddr, &socklen);
	gettimeofday(&tr,0);

	if (recvlen <= 0) {
	    if (recvlen && errno != EINTR) warn("recvfrom");
	    continue;
	}

	if (recvlen < sizeof(struct ip)) {
	    warnx("packet too short (%u bytes) for IP header", recvlen);
	    continue;
	}
	ip = (struct ip *) recv_buf;
	if (ip->ip_p == 0)	/* ignore cache creation requests */
	    continue;

	iphdrlen = ip->ip_hl << 2;
#ifdef RAW_INPUT_IS_RAW
	ipdatalen = ntohs(ip->ip_len);
#else
	ipdatalen = ip->ip_len;
#endif
	if (iphdrlen + ipdatalen != recvlen) {
	    warnx("packet shorter (%u bytes) than hdr+data len (%u+%u)",
		    recvlen, iphdrlen, ipdatalen);
	    continue;
	}

	igmp = (struct igmp *) (recv_buf + iphdrlen);
	igmpdatalen = ipdatalen - IGMP_MINLEN;
	if (igmpdatalen < 0) {
	    warnx("IP data field too short (%u bytes) for IGMP from %s",
		    ipdatalen, inet_fmt(ip->ip_src.s_addr, s1));
	    continue;
	}

	switch (igmp->igmp_type) {

	  case IGMP_MTRACE:	    /* For backward compatibility with 3.3 */
	  case IGMP_MTRACE_RESP:
	    if (igmpdatalen < QLEN) continue;
	    if ((igmpdatalen - QLEN)%RLEN) {
		printf("packet with incorrect datalen\n");
		continue;
	    }

	    len = (igmpdatalen - QLEN)/RLEN;

	    break;

	  default:
	    continue;
	}

	base.qtime = ((tr.tv_sec + JAN_1970) << 16) +
		      (tr.tv_usec << 10) / 15625;
	base.rtime = ((tr.tv_sec + JAN_1970) << 16) +
		      (tr.tv_usec << 10) / 15625;
	base.len = len;
	bcopy((char *)igmp, (char *)&base.igmp, ipdatalen);
	/*
	 * If the user specified which traces to monitor,
	 * only accept traces that correspond to the
	 * request
	 */
	if ((qsrc != 0 && qsrc != base.qhdr.tr_src) ||
	    (qdst != 0 && qdst != base.qhdr.tr_dst) ||
	    (qgrp != 0 && qgrp != igmp->igmp_group.s_addr))
	    continue;

	/* XXX This should be a hash table */
	/* XXX garbage-collection should be more efficient */
	for (nn = &remembered, n = *nn, m = 0; n; n = *nn) {
	    if ((n->base.qhdr.tr_src == base.qhdr.tr_src) &&
		(n->base.qhdr.tr_dst == base.qhdr.tr_dst) &&
		(n->base.igmp.igmp_group.s_addr == igmp->igmp_group.s_addr)) {
		m = n;
		m->last = tr;
	    }
	    if (tr.tv_sec - n->last.tv_sec > 500) { /* XXX don't hardcode */
		*nn = n->next;
		free(n);
	    } else {
		nn = &n->next;
	    }
	}

	tr_sec = tr.tv_sec;
	now = localtime(&tr_sec);
	strftime(timebuf, sizeof(timebuf) - 1, "%b %e %k:%M:%S", now);
	printf("Mtrace %s at %s",
		len == 0 ? "query" :
			   igmp->igmp_type == IGMP_MTRACE_RESP ? "response" :
								 "in transit",
		timebuf);
	if (len == 0)
		printf(" by %s", inet_fmt(recvaddr.sin_addr.s_addr, s1));
	if (!IN_MULTICAST(base.qhdr.tr_raddr))
		printf(", resp to %s", (len == 0 && recvaddr.sin_addr.s_addr == base.qhdr.tr_raddr) ? "same" : inet_fmt(base.qhdr.tr_raddr, s1));
	else
		printf(", respttl %d", TR_GETTTL(base.qhdr.tr_rttlqid));
	printf(", qid %06x\n", qid = TR_GETQID(base.qhdr.tr_rttlqid));
	printf("packet from %s to %s\n",
		inet_fmt(ip->ip_src.s_addr, s1),
		inet_fmt(ip->ip_dst.s_addr, s2));

	printf("from %s to %s via group %s (mxhop=%d)\n",
		inet_fmt(base.qhdr.tr_dst, s1), inet_fmt(base.qhdr.tr_src, s2),
		inet_fmt(igmp->igmp_group.s_addr, s3), igmp->igmp_code);
	if (len == 0) {
	    printf("\n");
	    continue;
	}
	r = base.resps + base.len - 1;
	/*
	 * Some routers will return error messages without
	 * filling in their addresses.  We fill in the address
	 * for them.
	 */
	if (r->tr_outaddr == 0)
	    r->tr_outaddr = recvaddr.sin_addr.s_addr;

	/*
	 * If there was a previous trace, it see if this is a
	 * statistics candidate.
	 */
	if (m && base.len == m->base.len &&
		!(pc = path_changed(&m->base, &base))) {
	    /*
	     * Some mtrace responders send multiple copies of the same
	     * reply.  Skip this packet if it's got the same query-id
	     * as the last one.
	     */
	    if (m->lastqid == qid) {
		printf("Skipping duplicate reply\n");
		continue;
	    }

	    m->lastqid = qid;

	    ++m->nresp;

	    bcopy(&base, m->new, sizeof(base));

	    printf("Results after %d seconds:\n\n",
		   (int)((m->new->qtime - m->base.qtime) >> 16));
	    fixup_stats(&m->base, m->prev, m->new, m->bugs);
	    print_stats(&m->base, m->prev, m->new, m->bugs, m->names);
	    m->prev = m->new;
	    m->new = &m->incr[(m->nresp & 1)];

	    continue;
	}

	if (m == NULL) {
	    m = (struct mtrace *)malloc(sizeof(struct mtrace));
	    if (m == NULL) {
		fprintf(stderr, "Out of memory!\n");
		continue;
	    }
	    bzero(m, sizeof(struct mtrace));
	    m->next = remembered;
	    remembered = m;
	    bcopy(&tr, &m->last, sizeof(tr));
	}

	/* Either it's a hop-by-hop in progress, or the path changed. */
	if (pc) {
	    printf("[Path Changed...]\n");
	    bzero(m->bugs, sizeof(m->bugs));
	}
	bcopy(&base, &m->base, sizeof(base));
	m->prev = &m->base;
	m->new = &m->incr[0];
	m->nresp = 0;

	printf("  0  ");
	print_host(base.qhdr.tr_dst);
	printf("\n");
	print_trace(1, &base, m->names);
	VAL_TO_MASK(smask, r->tr_smask);
	if ((r->tr_inaddr & smask) == (base.qhdr.tr_src & smask)) {
	    printf("%3d  ", -(base.len+1));
	    print_host(base.qhdr.tr_src);
	    printf("\n");
	} else if (r->tr_rmtaddr != 0) {
	    printf("%3d  ", -(base.len+1));
	    print_host(r->tr_rmtaddr);
	    printf(" %s\n", r->tr_rflags == TR_OLD_ROUTER ?
				   "doesn't support mtrace"
				 : "is the next hop");
	}
	printf("\n");
    }
}

char *
print_host(addr)
    u_int32 addr;
{
    return print_host2(addr, 0);
}

/*
 * On some routers, one interface has a name and the other doesn't.
 * We always print the address of the outgoing interface, but can
 * sometimes get the name from the incoming interface.  This might be
 * confusing but should be slightly more helpful than just a "?".
 */
char *
print_host2(addr1, addr2)
    u_int32 addr1, addr2;
{
    char *name;

    if (numeric) {
	printf("%s", inet_fmt(addr1, s1));
	return ("");
    }
    name = inet_name(addr1);
    if (*name == '?' && *(name + 1) == '\0' && addr2 != 0)
	name = inet_name(addr2);
    printf("%s (%s)", name, inet_fmt(addr1, s1));
    return (name);
}

/*
 * Print responses as received (reverse path from dst to src)
 */
void
print_trace(idx, buf, names)
    int idx;
    struct resp_buf *buf;
    char **names;
{
    struct tr_resp *r;
    char *name;
    int i;
    int hop;
    char *ms;

    i = abs(idx);
    r = buf->resps + i - 1;

    for (; i <= buf->len; ++i, ++r) {
	if (idx > 0) printf("%3d  ", -i);
	name = print_host2(r->tr_outaddr, r->tr_inaddr);
	if (r->tr_rflags != TR_NO_RTE)
	    printf("  %s  thresh^ %d", proto_type(r->tr_rproto), r->tr_fttl);
	if (verbose) {
	    hop = t_diff(ntohl(r->tr_qarr), buf->qtime);
	    ms = scale(&hop);
	    printf("  %d%s", hop, ms);
	}
	printf("  %s", flag_type(r->tr_rflags));
	if (i > 1 && r->tr_outaddr != (r-1)->tr_rmtaddr) {
	    printf(" !RPF!");
	    print_host((r-1)->tr_rmtaddr);
	}
	if (r->tr_rflags != TR_NO_RTE) {
	    if (r->tr_smask <= 1)    /* MASK_TO_VAL() returns 1 for default */
		printf(" [default]");
	    else if (verbose) {
		u_int32 smask;

		VAL_TO_MASK(smask, r->tr_smask);
		printf(" [%s]", inet_fmts(buf->qhdr.tr_src & smask,
							smask, s1));
	    }
	}
	printf("\n");
	if (names[i-1])
	    free(names[i-1]);
	names[i-1]=malloc(strlen(name) + 1);
	strcpy(names[i-1], name);
    }
}

/*
 * See what kind of router is the next hop
 */
int
what_kind(buf, why)
    struct resp_buf *buf;
    char *why;
{
    u_int32 smask;
    int retval;
    int hops = buf->len;
    struct tr_resp *r = buf->resps + hops - 1;
    u_int32 next = r->tr_rmtaddr;

    retval = send_recv(next, IGMP_DVMRP, DVMRP_ASK_NEIGHBORS2, 1, &incr[0], NULL);
    print_host(next);
    if (retval) {
	u_int32 version = ntohl(incr[0].igmp.igmp_group.s_addr);
	u_int32 *p = (u_int32 *)incr[0].ndata;
	u_int32 *ep = p + (incr[0].len >> 2);
	char *type = "version ";

	retval = 0;
	switch (version & 0xFF) {
	  case 1:
	    type = "proteon/mrouted ";
	    retval = 1;
	    break;

	  case 10:
	  case 11:
	    type = "cisco ";
	}
	printf(" [%s%d.%d] %s\n",
	       type, version & 0xFF, (version >> 8) & 0xFF,
	       why);
	VAL_TO_MASK(smask, r->tr_smask);
	while (p < ep) {
	    u_int32 laddr = *p++;
	    int flags = (ntohl(*p) & 0xFF00) >> 8;
	    int n = ntohl(*p++) & 0xFF;
	    if (!(flags & (DVMRP_NF_DOWN | DVMRP_NF_DISABLED)) &&
		 (laddr & smask) == (qsrc & smask)) {
		printf("%3d  ", -(hops+2));
		print_host(qsrc);
		printf("\n");
		return 1;
	    }
	    p += n;
	}
	return retval;
    }
    printf(" %s\n", why);
    return 0;
}


char *
scale(hop)
    int *hop;
{
    if (*hop > -1000 && *hop < 10000) return (" ms");
    *hop /= 1000;
    if (*hop > -1000 && *hop < 10000) return (" s ");
    return ("s ");
}

/*
 * Calculate and print one line of packet loss and packet rate statistics.
 * Checks for count of all ones from mrouted 2.3 that doesn't have counters.
 */
#define NEITHER 0
#define INS     1
#define OUTS    2
#define BOTH    3
void
stat_line(r, s, have_next, rst)
    struct tr_resp *r, *s;
    int have_next;
    int *rst;
{
    int timediff = (ntohl(s->tr_qarr) - ntohl(r->tr_qarr)) >> 16;
    int v_lost, v_pct;
    int g_lost, g_pct;
    int v_out = ntohl(s->tr_vifout) - ntohl(r->tr_vifout);
    int g_out = ntohl(s->tr_pktcnt) - ntohl(r->tr_pktcnt);
    int v_pps, g_pps;
    char v_str[8], g_str[8];
    int vhave = NEITHER;
    int ghave = NEITHER;
    int gmissing = NEITHER;
    char whochar;
    int badtime = 0;

    if (timediff == 0) {
	badtime = 1;
	/* Might be 32 bits of int seconds instead of 16int+16frac */
	timediff = ntohl(s->tr_qarr) - ntohl(r->tr_qarr);
	if (timediff == 0 || abs(timediff - statint) > statint)
	    timediff = 1;
    }
    v_pps = v_out / timediff;
    g_pps = g_out / timediff;

#define STATS_MISSING(x)	((x) == 0xFFFFFFFF)

    if (!STATS_MISSING(s->tr_vifout) && !STATS_MISSING(r->tr_vifout))
	    vhave |= OUTS;
    if (STATS_MISSING(s->tr_pktcnt) || STATS_MISSING(r->tr_pktcnt))
	    gmissing |= OUTS;
    if (!(*rst & BUG_NOPRINT))
	    ghave |= OUTS;

    if (have_next) {
	--r,  --s,  --rst;
	if (!STATS_MISSING(s->tr_vifin) && !STATS_MISSING(r->tr_vifin))
	    vhave |= INS;
	if (STATS_MISSING(s->tr_pktcnt) || STATS_MISSING(r->tr_pktcnt))
	    gmissing |= INS;
	if (!(*rst & BUG_NOPRINT))
	    ghave |= INS;
    }

    /*
     * Stats can be missing for any number of reasons:
     * - The hop may not be capable of collecting stats
     * - Traffic may be getting dropped at the previous hop
     *   and so this hop may not have any state
     *
     * We need a stronger heuristic to tell between these
     * two cases; in case 1 we don't want to print the stats
     * and in case 2 we want to print 100% loss.  We used to
     * err on the side of not printing, which is less useful
     * than printing 100% loss and dealing with it.
     */
#if 0
    /*
     * If both hops report as missing, then it's likely that there's just
     * no traffic flowing.
     *
     * If just one hop is missing, then we really don't have it.
     */
    if (gmissing != BOTH)
	ghave &= ~gmissing;
#endif

    whochar = have_next ? '^' : ' ';
    switch (vhave) {
      case BOTH:
	v_lost = v_out - (ntohl(s->tr_vifin) - ntohl(r->tr_vifin));
	if (v_out) v_pct = v_lost * 100 / v_out;
	else v_pct = 0;
	if (-20 < v_pct && v_pct < 101 && v_out > 10)
	  sprintf(v_str, "%3d%%", v_pct);
	else if (v_pct < -900 && v_out > 10)
	  sprintf(v_str, "%3dx", (int)(-v_pct / 100. + 1.));
	else if (v_pct <= -20 && v_out > 10)
	  sprintf(v_str, "%1.1fx", -v_pct / 100. + 1.);
	else
	  memcpy(v_str, " -- ", 5);

	if (tunstats)
	    printf("%6d/%-5d=%s", v_lost, v_out, v_str);
	else
	    printf("   ");
	printf("%4d pps", v_pps);
	if (v_pps && badtime)
	    printf("?");

	break;

      case INS:
	v_out = ntohl(s->tr_vifin) - ntohl(r->tr_vifin);
	v_pps = v_out / timediff;
	whochar = 'v';
	/* Fall through */

      case OUTS:
	if (tunstats)
	    printf("      %c%-5d     ", whochar, v_out);
	else
	    printf("  %c", whochar);
	printf("%4d pps", v_pps);
	if (v_pps && badtime)
	    printf("?");

	break;

      case NEITHER:
	if (ghave != NEITHER)
	    if (tunstats)
		printf("                         ");
	    else
		printf("           ");

	break;
    }

    whochar = have_next ? '^' : ' ';
    switch (ghave) {
      case BOTH:
	g_lost = g_out - (ntohl(s->tr_pktcnt) - ntohl(r->tr_pktcnt));
	if (g_out) g_pct = g_lost * 100 / g_out;
	else g_pct = 0;
	if (-20 < g_pct && g_pct < 101 && g_out > 10)
	  sprintf(g_str, "%3d%%", g_pct);
	else if (g_pct < -900 && g_out > 10)
	  sprintf(g_str, "%3dx", (int)(-g_pct / 100. + 1.));
	else if (g_pct <= -20 && g_out > 10)
	  sprintf(g_str, "%1.1fx", -g_pct / 100. + 1.);
	else
	  memcpy(g_str, " -- ", 5);

	printf("%s%6d/%-5d=%s%4d pps",
	       tunstats ? "" : "   ", g_lost, g_out, g_str, g_pps);
	if (g_pps && badtime)
	    printf("?");
	printf("\n");
	break;

#if 0
      case INS:
	g_out = ntohl(s->tr_pktcnt) - ntohl(r->tr_pktcnt);
	g_pps = g_out / timediff;
	whochar = 'v';
	/* Fall through */
#endif

      case OUTS:
	printf("%s     ?/%-5d     %4d pps",
	       tunstats ? "" : "   ", g_out, g_pps);
	if (badtime)
	    printf("?");
	printf("\n");
	break;

      case INS:
      case NEITHER:
	printf("\n");
	break;
    }


    if (debug > 2) {
	printf("\t\t\t\tv_in: %ld ", (long)ntohl(s->tr_vifin));
	printf("v_out: %ld ", (long)ntohl(s->tr_vifout));
	printf("pkts: %ld\n", (long)ntohl(s->tr_pktcnt));
	printf("\t\t\t\tv_in: %ld ", (long)ntohl(r->tr_vifin));
	printf("v_out: %ld ", (long)ntohl(r->tr_vifout));
	printf("pkts: %ld\n", (long)ntohl(r->tr_pktcnt));
	printf("\t\t\t\tv_in: %ld ",
	    (long)(ntohl(s->tr_vifin) - ntohl(r->tr_vifin)));
	printf("v_out: %ld ",
	    (long)(ntohl(s->tr_vifout) - ntohl(r->tr_vifout)));
	printf("pkts: %ld ", (long)(ntohl(s->tr_pktcnt) - ntohl(r->tr_pktcnt)));
	printf("time: %d\n", timediff);
	printf("\t\t\t\treset: %x hoptime: %lx\n", *rst, ntohl(s->tr_qarr));
    }
}

/*
 * A fixup to check if any pktcnt has been reset, and to fix the
 * byteorder bugs in mrouted 3.6 on little-endian machines.
 *
 * XXX Since periodic traffic sources are likely to have their
 *     pktcnt periodically reset, should we save old values when
 *     the reset occurs to keep slightly better statistics over
 *     the long term?  (e.g. SAP)
 */
void
fixup_stats(base, prev, new, bugs)
    struct resp_buf *base, *prev, *new;
    int *bugs;
{
    int rno = base->len;
    struct tr_resp *b = base->resps + rno;
    struct tr_resp *p = prev->resps + rno;
    struct tr_resp *n = new->resps + rno;
    int *r = bugs + rno;
    int res;
    int cleanup = 0;

    /* Check for byte-swappers.  Only check on the first trace,
     * since long-running traces can wrap around and falsely trigger. */
    while (--rno >= 0) {
#ifdef TEST_ONLY
	u_int32 nvifout = ntohl(n->tr_vifout);
	u_int32 pvifout = ntohl(p->tr_vifout);
#endif
	--n; --p; --b;
#ifdef TEST_ONLY	/*XXX this is still buggy, so disable it for release */
	if ((*r & BUG_SWAP) ||
	    ((base == prev) &&
	     (nvifout - pvifout) > (byteswap(nvifout) - byteswap(pvifout)))) {
	    if (1 || debug > 2) {
		printf("ip %s swaps; b %08x p %08x n %08x\n",
			inet_fmt(n->tr_inaddr, s1),
			ntohl(b->tr_vifout), pvifout, nvifout);
	    }
	    /* This host sends byteswapped reports; swap 'em */
	    if (!(*r & BUG_SWAP)) {
		*r |= BUG_SWAP;
		b->tr_qarr = byteswap(b->tr_qarr);
		b->tr_vifin = byteswap(b->tr_vifin);
		b->tr_vifout = byteswap(b->tr_vifout);
		b->tr_pktcnt = byteswap(b->tr_pktcnt);
	    }

	    n->tr_qarr = byteswap(n->tr_qarr);
	    n->tr_vifin = byteswap(n->tr_vifin);
	    n->tr_vifout = byteswap(n->tr_vifout);
	    n->tr_pktcnt = byteswap(n->tr_pktcnt);
	}
#endif
	/*
	 * A missing parenthesis in mrouted 3.5-3.8's prune.c
	 * causes extremely bogus time diff's.
	 * One half of the time calculation was
	 * inside an htonl() and one half wasn't.  Therefore, on
	 * a little-endian machine, both halves of the calculation
	 * would get added together in the little end.  Thus, the
	 * low-order 2 bytes are either 0000 (no overflow) or
	 * 0100 (overflow from the addition).
	 *
	 * Odds are against these particular bit patterns
	 * happening in both prev and new for actual time values.
	 */
	if ((*r & BUG_BOGUSTIME) || (((ntohl(n->tr_qarr) & 0xfeff) == 0x0000) &&
	    ((ntohl(p->tr_qarr) & 0xfeff) == 0x0000))) {
	    *r |= BUG_BOGUSTIME;
	    n->tr_qarr = new->rtime;
	    p->tr_qarr = prev->rtime;
	    b->tr_qarr = base->rtime;
	}
    }

    rno = base->len;
    b = base->resps + rno;
    p = prev->resps + rno;
    n = new->resps + rno;
    r = bugs + rno;

    while (--rno >= 0) {
	--n; --p; --b; --r;
	/*
	 * This hop has reset if:
	 * - There were statistics in the base AND previous pass, AND
	 *   - There are less packets this time than the first time and
	 *     we didn't reset last time, OR
	 *   - There are less packets this time than last time, OR
	 *   - There are no statistics on this pass.
	 *
	 * The "and we didn't reset last time" is necessary in the
	 * first branch of the OR because if the base is large and
	 * we reset last time but the constant-resetter-avoidance
	 * code kicked in so we delayed the copy of prev to base,
	 * new could still be below base so we trigger the
	 * constant-resetter code even though it was really only
	 * a single reset.
	 */
	res = ((b->tr_pktcnt != 0xFFFFFFFF) && (p->tr_pktcnt != 0xFFFFFFFF) &&
	       ((!(*r & BUG_RESET) && ntohl(n->tr_pktcnt) < ntohl(b->tr_pktcnt)) ||
	        (ntohl(n->tr_pktcnt) < ntohl(p->tr_pktcnt)) ||
		(n->tr_pktcnt == 0xFFFFFFFF)));
	if (debug > 2) {
    	    printf("\t\tip=%s, r=%d, res=%d\n", inet_fmt(b->tr_inaddr, s1), *r, res);
	    if (res)
		printf("\t\tbase=%ld, prev=%ld, new=%ld\n", ntohl(b->tr_pktcnt),
			    ntohl(p->tr_pktcnt), ntohl(n->tr_pktcnt));
	}
	if (*r & BUG_RESET) {
	    if (res || (*r & BUG_RESET2X)) {
		/*
		 * This router appears to be a 3.4 with that nasty ol'
		 * neighbor version bug, which causes it to constantly
		 * reset.  Just nuke the statistics for this node, and
		 * don't even bother giving it the benefit of the
		 * doubt from now on.
		 */
		p->tr_pktcnt = b->tr_pktcnt = n->tr_pktcnt;
		*r |= BUG_RESET2X;
	    } else {
		/*
		 * This is simply the situation that the original
		 * fixup_stats was meant to deal with -- that a
		 * 3.3 or 3.4 router deleted a cache entry while
		 * traffic was still active.
		 */
		*r &= ~BUG_RESET;
		cleanup = 1;
	    }
	} else
	    if (res)
		*r |= BUG_RESET;
    }

    if (cleanup == 0) return;

    /*
     * If some hop reset its counters and didn't continue to
     * reset, then we pretend that the previous
     * trace was the first one.
     */
    rno = base->len;
    b = base->resps + rno;
    p = prev->resps + rno;

    while (--rno >= 0) (--b)->tr_pktcnt = (--p)->tr_pktcnt;
    base->qtime = prev->qtime;
    base->rtime = prev->rtime;
}

/*
 * Check per-source losses along path and compare with threshold.
 */
int
check_thresh(thresh, base, prev, new)
    int thresh;
    struct resp_buf *base, *prev, *new;
{
    int rno = base->len - 1;
    struct tr_resp *b = base->resps + rno;
    struct tr_resp *p = prev->resps + rno;
    struct tr_resp *n = new->resps + rno;
    int g_out, g_lost;

    while (TRUE) {
	if ((n->tr_inaddr != b->tr_inaddr) ||
	    (n->tr_outaddr != b->tr_outaddr) ||
	    (n->tr_rmtaddr != b->tr_rmtaddr))
	  return 1;		/* Route changed */

	if (rno-- < 1) break;
    	g_out = ntohl(n->tr_pktcnt) - ntohl(p->tr_pktcnt);
	b--; n--; p--;
	g_lost = g_out - (ntohl(n->tr_pktcnt) - ntohl(p->tr_pktcnt));
	if (g_out && ((g_lost * 100 + (g_out >> 1))/ g_out) > thresh) {
	    return TRUE;
	}
    }
    return FALSE;
}

/*
 * Print responses with statistics for forward path (from src to dst)
 */
int
print_stats(base, prev, new, bugs, names)
    struct resp_buf *base, *prev, *new;
    int *bugs;
    char **names;
{
    int rtt, hop;
    char *ms;
    u_int32 smask;
    int rno = base->len - 1;
    struct tr_resp *b = base->resps + rno;
    struct tr_resp *p = prev->resps + rno;
    struct tr_resp *n = new->resps + rno;
    int *r = bugs + rno;
    u_long resptime = new->rtime;
    u_long qarrtime = ntohl(n->tr_qarr);
    u_int ttl = MaX(1, n->tr_fttl) + 1;
    int first = (base == prev);

    VAL_TO_MASK(smask, b->tr_smask);
    printf("  Source        Response Dest    ");
    if (tunstats)
	printf("Packet Statistics For     Only For Traffic\n");
    else
	printf("Overall     Packet Statistics For Traffic From\n");
    (void)inet_fmt(base->qhdr.tr_src, s1);
    printf("%-15s %-15s  ",
	   ((b->tr_inaddr & smask) == (base->qhdr.tr_src & smask)) ?
		s1 : "   * * *       ",
	   inet_fmt(base->qhdr.tr_raddr, s2));
    (void)inet_fmt(base->igmp.igmp_group.s_addr, s2);
    if (tunstats)
	printf("All Multicast Traffic     From %s\n", s1);
    else
	printf("Packet      %s To %s\n", s1, s2);
    rtt = t_diff(resptime, new->qtime);
    ms = scale(&rtt);
    printf("     %c       __/  rtt%5d%s    ",
	   (first && !verbose) ? 'v' : '|', rtt, ms);
    if (tunstats)
	printf("Lost/Sent = Pct  Rate       To %s\n", s2);
    else
	printf(" Rate       Lost/Sent = Pct  Rate\n");
    if (!first || verbose) {
	hop = t_diff(resptime, qarrtime);
	ms = scale(&hop);
	printf("     v      /     hop%5d%s    ", hop, ms);
	if (tunstats)
	    printf("---------------------     --------------------\n");
	else
	    printf("-------     ---------------------\n");
    }
    if ((b->tr_inaddr & smask) != (base->qhdr.tr_src & smask) &&
	    b->tr_rmtaddr != 0) {
	printf("%-15s %-14s is the previous hop\n", inet_fmt(b->tr_rmtaddr, s1),
		inet_name(b->tr_rmtaddr));
	printf("     v     ^\n");
    }
    if (debug > 2) {
	printf("\t\t\t\tv_in: %ld ", (long)ntohl(n->tr_vifin));
	printf("v_out: %ld ", (long)ntohl(n->tr_vifout));
	printf("pkts: %ld\n", (long)ntohl(n->tr_pktcnt));
	printf("\t\t\t\tv_in: %ld ", (long)ntohl(b->tr_vifin));
	printf("v_out: %ld ", (long)ntohl(b->tr_vifout));
	printf("pkts: %ld\n", (long)ntohl(b->tr_pktcnt));
	printf("\t\t\t\tv_in: %ld ",
	    (long)(ntohl(n->tr_vifin) - ntohl(b->tr_vifin)));
	printf("v_out: %ld ",
	    (long)(ntohl(n->tr_vifout) - ntohl(b->tr_vifout)));
	printf("pkts: %ld\n",
	    (long)(ntohl(n->tr_pktcnt) - ntohl(b->tr_pktcnt)));
	printf("\t\t\t\treset: %x hoptime: %lx\n", *r, (long)ntohl(n->tr_qarr));
    }

    while (TRUE) {
	if ((n->tr_inaddr != b->tr_inaddr) ||
	    (n->tr_outaddr != b->tr_outaddr) ||
	    (n->tr_rmtaddr != b->tr_rmtaddr))
	  return 1;		/* Route changed */

	if ((n->tr_inaddr != n->tr_outaddr) && n->tr_inaddr)
	  printf("%-15s\n", inet_fmt(n->tr_inaddr, s1));
	printf("%-15s %-14s %s%s\n", inet_fmt(n->tr_outaddr, s1), names[rno],
		 flag_type(n->tr_rflags),
		 (*r & BUG_NOPRINT) ? " [reset counters]" : "");

	if (rno-- < 1) break;

	printf("     %c     ^      ttl%5d   ", (first && !verbose) ? 'v' : '|',
								ttl);
	stat_line(p, n, TRUE, r);
	if (!first || verbose) {
	    resptime = qarrtime;
	    qarrtime = ntohl((n-1)->tr_qarr);
	    hop = t_diff(resptime, qarrtime);
	    ms = scale(&hop);
	    printf("     v     |      hop%5d%s", hop, ms);
	    if (first)
		printf("\n");
	    else
		stat_line(b, n, TRUE, r);
	}

	--b, --p, --n, --r;
	ttl = MaX(ttl, MaX(1, n->tr_fttl) + base->len - rno);
    }
	   
    printf("     %c      \\__   ttl%5d   ", (first && !verbose) ? 'v' : '|',
							ttl);
    stat_line(p, n, FALSE, r);
    if (!first || verbose) {
	hop = t_diff(qarrtime, new->qtime);
	ms = scale(&hop);
	printf("     v         \\  hop%5d%s", hop, ms);
	if (first)
	    printf("\n");
	else
	    stat_line(b, n, FALSE, r);
    }
    printf("%-15s %s\n", inet_fmt(base->qhdr.tr_dst, s1),
			!passive ? inet_fmt(lcl_addr, s2) : "   * * *       ");
    printf("  Receiver      Query Source\n\n");
    return 0;
}

/*
 * Determine whether or not the path has changed.
 */
int
path_changed(base, new)
    struct resp_buf *base, *new;
{
    int rno = base->len - 1;
    struct tr_resp *b = base->resps + rno;
    struct tr_resp *n = new->resps + rno;

    while (rno-- >= 0) {
	if ((n->tr_inaddr != b->tr_inaddr) ||
	    (n->tr_outaddr != b->tr_outaddr) ||
	    (n->tr_rmtaddr != b->tr_rmtaddr))
	  return 1;		/* Route changed */
	if ((b->tr_rflags == TR_NO_RTE) &&
	    (n->tr_rflags != TR_NO_RTE))
	  return 1;		/* Route got longer? */
	--n;
	--b;
    }
    return 0;
}


/***************************************************************************
 *	main
 ***************************************************************************/

int
main(argc, argv)
int argc;
char *argv[];
{
    int udp;
    struct sockaddr_in addr;
    int addrlen = sizeof(addr);
    int recvlen;
    struct timeval tv;
    struct resp_buf *prev, *new;
    struct tr_resp *r;
    u_int32 smask;
    int rno;
    int hops, nexthop, tries;
    u_int32 lastout = 0;
    int numstats = 1;
    int waittime;
    int seed;
    int hopbyhop;
    int i;
    int printed = 1;

    if (geteuid() != 0)
	errx(1, "must be root");

    /*
     * We might get spawned by vat with the audio device open.
     * Close everything but stdin, stdout, stderr.
     */
    for (i = 3; i < 255; i++)
	close(i);

    init_igmp();
    setuid(getuid());

    argv++, argc--;
    if (argc == 0) usage();

    while (argc > 0 && *argv[0] == '-') {
	char *p = *argv++;  argc--;
	p++;
	do {
	    char c = *p++;
	    char *arg = (char *) 0;
	    if (isdigit(*p)) {
		arg = p;
		p = "";
	    } else if (argc > 0) arg = argv[0];
	    switch (c) {
	      case 'd':			/* Unlisted debug print option */
		if (arg && isdigit(*arg)) {
		    debug = atoi(arg);
		    if (debug < 0) debug = 0;
		    if (debug > 3) debug = 3;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 'M':			/* Use multicast for reponse */
		multicast = TRUE;
		break;
	      case 'U':			/* Use unicast for response */
		unicast = TRUE;
		break;
	      case 'L':			/* Trace w/ loss threshold */
		if (arg && isdigit(*arg)) {
		    lossthresh = atoi(arg);
		    if (lossthresh < 0)
			lossthresh = 0;
		    numstats = 3153600;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
		break;
	      case 'O':			/* Don't use IP options */
		sendopts = FALSE;
		break;
	      case 'P':			/* Just watch the path */
		printstats = FALSE;
		numstats = 3153600;
		break;
	      case 'Q':			/* (undoc.) always use this QID */
		if (arg && isdigit(*arg)) {
		    staticqid = atoi(arg);
		    if (staticqid < 0)
			staticqid = 0;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
		break;
	      case 'T':			/* Print confusing tunnel stats */
		tunstats = TRUE;
		break;
	      case 'W':			/* Cisco's "weak" mtrace */
		weak = TRUE;
		break;
	      case 'V':			/* Print version and exit */
		/*
		 * FreeBSD wants to have its own Id string, so
		 * determination of the version number has to change.
		 * XXX Note that this must be changed by hand on importing
		 * XXX new versions!
		 */
		{
		    char *r = strdup(rcsid);
		    char *s = strchr(r, ',');

		    while (s && *(s+1) != 'v')
			s = strchr(s + 1, ',');

		    if (s) {
			char *q;

			s += 3;		/* , v sp */
			q = strchr(s, ' ');
			if (q)
				*q = '\0';
			fprintf(stderr, "mtrace version 5.2/%s\n", s);
		    } else {
			fprintf(stderr, "mtrace could not determine version number!?\n");
		    }
		    exit(1);
		}
		break;
	      case 'l':			/* Loop updating stats indefinitely */
		numstats = 3153600;
		break;
	      case 'n':			/* Don't reverse map host addresses */
		numeric = TRUE;
		break;
	      case 'p':			/* Passive listen for traces */
		passive = TRUE;
		break;
	      case 'v':			/* Verbosity */
		verbose = TRUE;
		break;
	      case 's':			/* Short form, don't wait for stats */
		numstats = 0;
		break;
	      case 'w':			/* Time to wait for packet arrival */
		if (arg && isdigit(*arg)) {
		    timeout = atoi(arg);
		    if (timeout < 1) timeout = 1;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 'f':			/* first hop */
		if (arg && isdigit(*arg)) {
		    qno = atoi(arg);
		    if (qno > MAXHOPS) qno = MAXHOPS;
		    else if (qno < 1) qno = 0;
		    if (arg == argv[0]) argv++, argc--;
		    fflag++;
		    break;
		} else
		    usage();
	      case 'm':			/* Max number of hops to trace */
		if (arg && isdigit(*arg)) {
		    qno = atoi(arg);
		    if (qno > MAXHOPS) qno = MAXHOPS;
		    else if (qno < 1) qno = 0;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 'q':			/* Number of query retries */
		if (arg && isdigit(*arg)) {
		    nqueries = atoi(arg);
		    if (nqueries < 1) nqueries = 1;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 'g':			/* Last-hop gateway (dest of query) */
		if (arg && (gwy = host_addr(arg))) {
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 't':			/* TTL for query packet */
		if (arg && isdigit(*arg)) {
		    qttl = atoi(arg);
		    if (qttl < 1) qttl = 1;
		    rttl = qttl;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 'e':			/* Extra hops past non-responder */
		if (arg && isdigit(*arg)) {
		    extrahops = atoi(arg);
		    if (extrahops < 0) extrahops = 0;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 'r':			/* Dest for response packet */
		if (arg && (raddr = host_addr(arg))) {
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 'i':			/* Local interface address */
		if (arg && (lcl_addr = host_addr(arg))) {
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      case 'S':			/* Stat accumulation interval */
		if (arg && isdigit(*arg)) {
		    statint = atoi(arg);
		    if (statint < 1) statint = 1;
		    if (arg == argv[0]) argv++, argc--;
		    break;
		} else
		    usage();
	      default:
		usage();
	    }
	} while (*p);
    }

    if (argc > 0 && (qsrc = host_addr(argv[0]))) {          /* Source of path */
	if (IN_MULTICAST(ntohl(qsrc))) {
	    if (gwy) {
		/* Should probably rewrite arg parsing at some point, as
		 * this makes "mtrace -g foo 224.1.2.3 224.2.3.4" valid!... */
		qgrp = qsrc;
		qsrc = 0;
	    } else {
		usage();
	    }
	}
	argv++, argc--;
	if (argc > 0 && (qdst = host_addr(argv[0]))) {      /* Dest of path */
	    argv++, argc--;
	    if (argc > 0 && (qgrp = host_addr(argv[0]))) {  /* Path via group */
		argv++, argc--;
	    }
	    if (IN_MULTICAST(ntohl(qdst))) {
		u_int32 temp = qdst;
		qdst = qgrp;
		qgrp = temp;
		if (IN_MULTICAST(ntohl(qdst))) usage();
	    } else if (qgrp && !IN_MULTICAST(ntohl(qgrp))) usage();
	}
    }

    if (passive) {
	passive_mode();
	return(0);
    }

    if (argc > 0) {
	usage();
    }

#ifdef SUNOS5
    if (sendopts)
	checkforsolarisbug();
#endif

    /*
     * Set useful defaults for as many parameters as possible.
     */

    defgrp = 0;				/* Default to no group */
    query_cast = htonl(0xE0000002);	/* All routers multicast addr */
    resp_cast = htonl(0xE0000120);	/* Mtrace response multicast addr */
    if (qgrp == 0) {
	if (!weak)
	    qgrp = defgrp;
	if (printstats && numstats != 0 && !tunstats) {
	    /* Stats are useless without a group */
	    warnx(
	"WARNING: no multicast group specified, so no statistics printed");
	    numstats = 0;
	}
    } else {
	if (weak)
	    warnx(
	"WARNING: group was specified so not performing \"weak\" mtrace");
    }

    /*
     * Get default local address for multicasts to use in setting defaults.
     */
    addr.sin_family = AF_INET;
#if (defined(BSD) && (BSD >= 199103))
    addr.sin_len = sizeof(addr);
#endif
    addr.sin_addr.s_addr = qgrp ? qgrp : query_cast;
    addr.sin_port = htons(2000);	/* Any port above 1024 will do */

    /*
     * Note that getsockname() can return 0 on some systems
     * (notably SunOS 5.x, x < 6).  This is taken care of in
     * get_netmask().  If the default multicast interface (set
     * with the route for 224.0.0.0) is not the same as the
     * hostname, mtrace -i [if_addr] will have to be used.
     */
    if (((udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0) ||
	(connect(udp, (struct sockaddr *) &addr, sizeof(addr)) < 0) ||
	getsockname(udp, (struct sockaddr *) &addr, &addrlen) < 0)
	err(-1, "determining local address");

#ifdef SUNOS5
    /*
     * SunOS 5.X prior to SunOS 2.6, getsockname returns 0 for udp socket.
     * This call to sysinfo will return the hostname.
     * If the default multicast interfface (set with the route
     * for 224.0.0.0) is not the same as the hostname,
     * mtrace -i [if_addr] will have to be used.
     */
    if (addr.sin_addr.s_addr == 0) {
	char myhostname[MAXHOSTNAMELEN];
	struct hostent *hp;
	int error;
    
	error = sysinfo(SI_HOSTNAME, myhostname, sizeof(myhostname));
	if (error == -1)
	    err(1, "getting my hostname");

	hp = gethostbyname(myhostname);
	if (hp == NULL || hp->h_addrtype != AF_INET ||
	    hp->h_length != sizeof(addr.sin_addr))
	    err(1, "finding IP address for my hostname");

	memcpy((char *)&addr.sin_addr.s_addr, hp->h_addr, hp->h_length);
    }
#endif

    /*
     * Default destination for path to be queried is the local host.
     * When gateway specified, default destination is that gateway
     *  and default source is local host.
     */
    if (qdst == 0) {
	qdst = lcl_addr ? lcl_addr : addr.sin_addr.s_addr;
	dst_netmask = get_netmask(udp, &qdst);
	if (gwy && (gwy & dst_netmask) != (qdst & dst_netmask) &&
		!IN_MULTICAST(ntohl(gwy)))
	    qdst = gwy;
    }
    if (qsrc == 0 && gwy)
	qsrc = lcl_addr ? lcl_addr : addr.sin_addr.s_addr;
    if (qsrc == 0)
	usage();
    if (!dst_netmask)
	dst_netmask = get_netmask(udp, &qdst);
    close(udp);
    if (lcl_addr == 0) lcl_addr = addr.sin_addr.s_addr;

    /*
     * Initialize the seed for random query identifiers.
     */
    gettimeofday(&tv, 0);
    seed = tv.tv_usec ^ lcl_addr;
#ifdef SYSV    
    srand48(seed);
#else
    srandom(seed);
#endif

    /*
     * Protect against unicast queries to mrouted versions that might crash.
     * Also use the obsolete "can mtrace" neighbor bit to warn about
     * older implementations.
     */
    if (gwy && !IN_MULTICAST(ntohl(gwy)))
      if (send_recv(gwy, IGMP_DVMRP, DVMRP_ASK_NEIGHBORS2, 1, &incr[0], NULL)) {
	int flags = ntohl(incr[0].igmp.igmp_group.s_addr);
	int version = flags & 0xFFFF;
	int info = (flags & 0xFF0000) >> 16;

	if (version == 0x0303 || version == 0x0503) {
	    printf("Don't use -g to address an mrouted 3.%d, it might crash\n",
		   (version >> 8) & 0xFF);
	    exit(0);
	}
	if ((info & 0x08) == 0) {
	    printf("mtrace: ");
	    print_host(gwy);
	    printf(" probably doesn't support mtrace, trying anyway...\n");
	}
      }

    printf("Mtrace from %s to %s via group %s\n",
	   inet_fmt(qsrc, s1), inet_fmt(qdst, s2), inet_fmt(qgrp, s3));

    if ((qdst & dst_netmask) == (qsrc & dst_netmask))
	fprintf(stderr, "mtrace: Source & receiver appear to be directly connected\n");

    /*
     * If the response is to be a multicast address, make sure we 
     * are listening on that multicast address.
     */
    if (raddr) {
	if (IN_MULTICAST(ntohl(raddr))) k_join(raddr, lcl_addr);
    } else k_join(resp_cast, lcl_addr);

    memset(&base, 0, sizeof(base));

    /*
     * If the destination is on the local net, the last-hop router can
     * be found by multicast to the all-routers multicast group.
     * Otherwise, use the group address that is the subject of the
     * query since by definition the last-hop router will be a member.
     * Set default TTLs for local remote multicasts.
     */
    if (gwy == 0)
      if ((qdst & dst_netmask) == (lcl_addr & dst_netmask)) tdst = query_cast;
      else tdst = qgrp;
    else tdst = gwy;
    if (tdst == 0 && qgrp == 0)
	errx(1, "mtrace: weak mtrace requires -g if destination is not local.\n");

    if (IN_MULTICAST(ntohl(tdst))) {
      k_set_loop(1);	/* If I am running on a router, I need to hear this */
      if (tdst == query_cast) k_set_ttl(qttl ? qttl : 1);
      else k_set_ttl(qttl ? qttl : MULTICAST_TTL1);
    }

    /*
     * Try a query at the requested number of hops or MAXHOPS if unspecified.
     */
    if (qno == 0) {
	hops = MAXHOPS;
	tries = 1;
	printf("Querying full reverse path... ");
	fflush(stdout);
    } else {
	hops = qno;
	tries = nqueries;
	if (fflag)
	    printf("Querying full reverse path, starting at hop %d...", qno);
	else
	    printf("Querying reverse path, maximum %d hops... ", qno);
	fflush(stdout); 
    }
    base.rtime = 0;
    base.len = 0;
    hopbyhop = FALSE;

    recvlen = send_recv(tdst, IGMP_MTRACE, hops, tries, &base, mtrace_callback);

    /*
     * If the initial query was successful, print it.  Otherwise, if
     * the query max hop count is the default of zero, loop starting
     * from one until there is no response for extrahops more hops.  The
     * extra hops allow getting past an mtrace-capable mrouter that can't
     * send multicast packets because all phyints are disabled.
     */
    if (recvlen) {
	printf("\n  0  ");
	print_host(qdst);
	printf("\n");
	print_trace(1, &base, names);
	r = base.resps + base.len - 1;
	if (r->tr_rflags == TR_OLD_ROUTER || r->tr_rflags == TR_NO_SPACE ||
		(qno != 0 && r->tr_rmtaddr != 0 && !fflag)) {
	    printf("%3d  ", -(base.len+1));
	    what_kind(&base, r->tr_rflags == TR_OLD_ROUTER ?
				   "doesn't support mtrace"
				 : "is the next hop");
	} else {
	    if (fflag) {
		nexthop = hops = qno;
		goto continuehop;
	    }
	    VAL_TO_MASK(smask, r->tr_smask);
	    if ((r->tr_inaddr & smask) == (qsrc & smask)) {
		printf("%3d  ", -(base.len+1));
		print_host(qsrc);
		printf("\n");
	    }
	}
    } else if (qno == 0) {
	hopbyhop = TRUE;
	printf("switching to hop-by-hop:\n  0  ");
	print_host(qdst);
	printf("\n");

	for (hops = 1, nexthop = 1; hops <= MAXHOPS; ++hops) {
	    printf("%3d  ", -hops);
	    fflush(stdout);

	    /*
	     * After a successful first hop, try switching to the unicast
	     * address of the last-hop router instead of multicasting the
	     * trace query.  This should be safe for mrouted versions 3.3
	     * and 3.5 because there is a long route timeout with metric
	     * infinity before a route disappears.  Switching to unicast
	     * reduces the amount of multicast traffic and avoids a bug
	     * with duplicate suppression in mrouted 3.5.
	     */
	    if (hops == 2 && gwy == 0 && lastout != 0 &&
		(recvlen = send_recv(lastout, IGMP_MTRACE, hops, 1, &base, mtrace_callback)))
	      tdst = lastout;
	    else recvlen = send_recv(tdst, IGMP_MTRACE, hops, nqueries, &base, mtrace_callback);

	    if (recvlen == 0) {
		/*if (hops == 1) break;*/
		if (hops == nexthop) {
		    if (hops == 1) {
			printf("\n");
		    } else if (what_kind(&base, "didn't respond")) {
			/* the ask_neighbors determined that the
			 * not-responding router is the first-hop. */
			break;
		    }
		    if (extrahops == 0)
			break;
		} else if (hops < nexthop + extrahops) {
		    printf("\n");
		} else {
		    printf("...giving up\n");
		    break;
		}
		continue;
	    }
	    if (base.len == hops &&
		(hops == 1 || (base.resps+nexthop-2)->tr_outaddr == lastout)) {
	    	if (hops == nexthop) {
		    print_trace(-hops, &base, names);
		} else {
		    printf("\nResuming...\n");
		    print_trace(nexthop, &base, names);
		}
	    } else {
		if (base.len < hops) {
		    /*
		     * A shorter trace than requested means a fatal error
		     * occurred along the path, or that the route changed
		     * to a shorter one.
		     *
		     * If the trace is longer than the last one we received,
		     * then we are resuming from a skipped router (but there
		     * is still probably a problem).
		     *
		     * If the trace is shorter than the last one we
		     * received, then the route must have changed (and
		     * there is still probably a problem).
		     */
		    if (nexthop <= base.len) {
			printf("\nResuming...\n");
			print_trace(nexthop, &base, names);
		    } else if (nexthop > base.len + 1) {
			hops = base.len;
			printf("\nRoute must have changed...\n");
			print_trace(1, &base, names);
		    }
		} else {
		    /*
		     * The last hop address is not the same as it was.
		     * If we didn't know the last hop then we just
		     * got the first response from a hop-by-hop trace;
		     * if we did know the last hop then
		     * the route probably changed underneath us.
		     */
		    hops = base.len;
		    if (lastout != 0)
			printf("\nRoute must have changed...\n");
		    else
			printf("\nResuming...\n");
		    print_trace(1, &base, names);
		}
	    }
continuehop:
	    r = base.resps + base.len - 1;
	    lastout = r->tr_outaddr;

	    if (base.len < hops ||
		r->tr_rmtaddr == 0 ||
		(r->tr_rflags & 0x80)) {
		VAL_TO_MASK(smask, r->tr_smask);
		if (r->tr_rmtaddr) {
		    if (hops != nexthop) {
			printf("\n%3d  ", -(base.len+1));
		    }
		    what_kind(&base, r->tr_rflags == TR_OLD_ROUTER ?
				"doesn't support mtrace" :
				"would be the next hop");
		    /* XXX could do segmented trace if TR_NO_SPACE */
		} else if (r->tr_rflags == TR_NO_ERR &&
			   (r->tr_inaddr & smask) == (qsrc & smask)) {
		    printf("%3d  ", -(hops + 1));
		    print_host(qsrc);
		    printf("\n");
		}
		break;
	    }

	    nexthop = hops + 1;
	}
    }

    if (base.rtime == 0) {
	printf("Timed out receiving responses\n");
	if (IN_MULTICAST(ntohl(tdst)))
	  if (tdst == query_cast)
	    printf("Perhaps no local router has a route for source %s\n",
		   inet_fmt(qsrc, s1));
	  else
	    printf("Perhaps receiver %s is not a member of group %s,\n\
or no router local to it has a route for source %s,\n\
or multicast at ttl %d doesn't reach its last-hop router for that source\n",
		   inet_fmt(qdst, s2), inet_fmt(qgrp, s3), inet_fmt(qsrc, s1),
		   qttl ? qttl : MULTICAST_TTL1);
	exit(1);
    }

    printf("Round trip time %d ms; ", t_diff(base.rtime, base.qtime));
    {
	struct tr_resp *n = base.resps + base.len - 1;
	u_int ttl = n->tr_fttl + 1;

	rno = base.len - 1;
	while (--rno > 0) {
	    --n;
	    ttl = MaX(ttl, MaX(1, n->tr_fttl) + base.len - rno);
	}
	printf("total ttl of %d required.\n\n",ttl);
    }

    /*
     * Use the saved response which was the longest one received,
     * and make additional probes after delay to measure loss.
     */
    raddr = base.qhdr.tr_raddr;
    rttl = TR_GETTTL(base.qhdr.tr_rttlqid);
    gettimeofday(&tv, 0);
    waittime = statint - (((tv.tv_sec + JAN_1970) & 0xFFFF) - (base.qtime >> 16));
    prev = &base;
    new = &incr[numstats&1];

    /*
     * Zero out bug-avoidance counters
     */
    memset(bugs, 0, sizeof(bugs));

    if (!printstats)
	printf("Monitoring path..");

    while (numstats--) {
	if (waittime < 1) printf("\n");
	else {
	    if (printstats && (lossthresh == 0 || printed)) {
		printf("Waiting to accumulate statistics...");
	    } else {
		printf(".");
	    }
	    fflush(stdout);
	    sleep((unsigned)waittime);
	}
	printed = 0;
	rno = hopbyhop ? base.len : qno ? qno : MAXHOPS;
	recvlen = send_recv(tdst, IGMP_MTRACE, rno, nqueries, new, mtrace_callback);

	if (recvlen == 0) {
	    printf("Timed out.\n");
	    if (numstats) {
		numstats++;
		continue;
	    } else
		exit(1);
	}

	if (base.len != new->len || path_changed(&base, new)) {
	    printf("%s", base.len == new->len ? "Route changed" :
					"Trace length doesn't match");
	    if (!printstats)
		printf(" after %d seconds",
		   (int)((new->qtime - base.qtime) >> 16));
	    printf(":\n");
printandcontinue:
	    print_trace(1, new, names);
	    numstats++;
	    bcopy(new, &base, sizeof(base));
	    nexthop = hops = new->len;
	    printf("Continuing with hop-by-hop...\n");
	    goto continuehop;
	}

	if (printstats) {
	    if (new->igmp.igmp_group.s_addr != qgrp ||
		new->qhdr.tr_src != qsrc || new->qhdr.tr_dst != qdst)
		printf("\nWARNING: trace modified en route; statistics may be incorrect\n");
	    fixup_stats(&base, prev, new, bugs);
	    if ((lossthresh == 0) || check_thresh(lossthresh, &base, prev, new)) {
		printf("Results after %d seconds",
		       (int)((new->qtime - base.qtime) >> 16));
		if (lossthresh)
		    printf(" (this trace %d seconds)",
			   (int)((new->qtime - prev->qtime) >> 16));
		if (verbose) {
		    time_t t = time(0);
		    struct tm *qr = localtime(&t);

		    printf(" qid 0x%06x at %2d:%02d:%02d",
				TR_GETQID(base.qhdr.tr_rttlqid),
				qr->tm_hour, qr->tm_min, qr->tm_sec);
		}
		printf(":\n\n");
		printed = 1;
		if (print_stats(&base, prev, new, bugs, names)) {
		    printf("This should have been detected earlier, but ");
		    printf("Route changed:\n");
		    goto printandcontinue;
		}
	    }
	}
	prev = new;
	new = &incr[numstats&1];
	waittime = statint;
    }

    /*
     * If the response was multicast back, leave the group
     */
    if (raddr) {
	if (IN_MULTICAST(ntohl(raddr)))	k_leave(raddr, lcl_addr);
    } else k_leave(resp_cast, lcl_addr);

    return (0);
}

static void
usage()
{
	fprintf(stderr, "%s\n%s\n%s\n",
	"usage: mtrace [-MUOPTWVlnpvs] [-e extra_hops] [-f first_hop] [-i if_addr]",
	"              [-g gateway] [-m max_hops] [-q nqueries] [-r resp_dest]",
	"              [-S statint] [-t ttl] [-w wait] source [receiver] [group]");
	exit(1);
}

void
check_vif_state()
{
    log(LOG_WARNING, errno, "sendto");
}

/*
 * 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.
 */
#ifdef __STDC__
void
log(int severity, int syserr, char *format, ...)
{
	va_list ap;
	char    fmt[100];

	va_start(ap, format);
#else
/*VARARGS3*/
void 
log(severity, syserr, format, va_alist)
	int     severity, syserr;
	char   *format;
	va_dcl
{
	va_list ap;
	char    fmt[100];

	va_start(ap);
#endif

    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) 
		strcpy(fmt, "warning - ");
	    strncat(fmt, format, sizeof(fmt)-strlen(fmt));
	    fmt[sizeof(fmt)-1]='\0';
	    vfprintf(stderr, fmt, ap);
	    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);
}