usr.sbin/in.routed/trace.c

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright (c) 1983, 1988, 1993
 *  The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgment:
 *  This product includes software developed by the University of
 *  California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD: src/sbin/routed/trace.c,v 1.6 2000/08/11 08:24:38 sheldonh Exp $
 */

#include "defs.h"
#include "pathnames.h"
#include <signal.h>
#include <sys/stat.h>
#include <sys/signal.h>
#include <strings.h>
#include <fcntl.h>
#include <protocols/routed.h>

#define NRECORDS    50      /* size of circular trace buffer */

int tracelevel, new_tracelevel;
FILE    *ftrace = stdout;       /* output trace file */
static const char *sigtrace_pat = "%s";
static char savetracename[MAXPATHLEN+1];
static char *ripcmds[RIPCMD_MAX] =
    {"#0", "REQUEST", "RESPONSE", "TRACEON", "TRACEOFF", "POLL",
    "POLLENTRY"};
char    inittracename[MAXPATHLEN+1];
static boolean_t file_trace;    /* 1=tracing to file, not stdout */

static void tmsg(const char *, ...);

const char *
rip_strerror(int err)
{
    const char *cp = strerror(err);
    static char msgbuf[64];

    if (cp == NULL) {
        if (err == 0) {
            cp = "success";
        } else {
            (void) snprintf(msgbuf, sizeof (msgbuf),
                "unknown error %d", err);
            cp = msgbuf;
        }
    }
    return (cp);
}

/* convert IP address to a string, but not into a single buffer */
char *
naddr_ntoa(in_addr_t a)
{
#define NUM_BUFS 4
    static int bufno;
    static struct {
        char    str[INET_ADDRSTRLEN];   /* xxx.xxx.xxx.xxx\0 */
    } bufs[NUM_BUFS];
    char *s;
    struct in_addr addr;

    addr.s_addr = a;
    s = strcpy(bufs[bufno].str, inet_ntoa(addr));
    bufno = (bufno+1) % NUM_BUFS;
    return (s);
#undef NUM_BUFS
}


const char *
saddr_ntoa(struct sockaddr_storage *ss)
{
    return (ss == NULL) ? "?" : naddr_ntoa(S_ADDR(ss));
}


static char *
ts(time_t secs)
{
    static char s[20];

    secs += epoch.tv_sec;
    (void) strftime(s, sizeof (s), "%T", localtime(&secs));
    return (s);
}

static char *
ts_full(struct timeval *tv)
{
    static char s[32];
    time_t secs;
    int len;

    secs = tv->tv_sec + epoch.tv_sec;
    (void) strftime(s, sizeof (s), "%Y/%m/%d %T", localtime(&secs));
    len = strlen(s);
    (void) snprintf(s + len, sizeof (s) - len, ".%06ld", tv->tv_usec);
    return (s);
}

/*
 * On each event, display a time stamp.
 * This assumes that 'now' is update once for each event, and
 * that at least now.tv_usec changes.
 */
static struct timeval lastlog_time;

void
lastlog(void)
{
    if (lastlog_time.tv_sec != now.tv_sec ||
        lastlog_time.tv_usec != now.tv_usec) {
        (void) fprintf(ftrace, "-- %s --\n", ts_full(&now));
        lastlog_time = now;
    }
}


static void
tmsg(const char *p, ...)
{
    va_list args;

    if (ftrace != NULL) {
        lastlog();
        va_start(args, p);
        (void) vfprintf(ftrace, p, args);
        (void) fputc('\n', ftrace);
        (void) fflush(ftrace);
        (void) va_end(args);
    }
}


void
trace_close(int zap_stdio)
{
    int fd;


    (void) fflush(stdout);
    (void) fflush(stderr);

    if (ftrace != NULL && zap_stdio) {
        if (ftrace != stdout)
            (void) fclose(ftrace);
        ftrace = NULL;
        fd = open("/dev/null", O_RDWR);
        if (isatty(STDIN_FILENO))
            (void) dup2(fd, STDIN_FILENO);
        if (isatty(STDOUT_FILENO))
            (void) dup2(fd, STDOUT_FILENO);
        if (isatty(STDERR_FILENO))
            (void) dup2(fd, STDERR_FILENO);
        (void) close(fd);
    }
    lastlog_time.tv_sec = 0;
}


void
trace_flush(void)
{
    if (ftrace != NULL) {
        (void) fflush(ftrace);
        if (ferror(ftrace))
            trace_off("tracing off: %s",
                rip_strerror(ferror(ftrace)));
    }
}


void
trace_off(const char *p, ...)
{
    va_list args;


    if (ftrace != NULL) {
        lastlog();
        va_start(args, p);
        (void) vfprintf(ftrace, p, args);
        (void) fputc('\n', ftrace);
        (void) va_end(args);
    }
    trace_close(file_trace);

    new_tracelevel = tracelevel = 0;
}


/* log a change in tracing */
void
tracelevel_msg(const char *pat,
    int dump)       /* -1=no dump, 0=default, 1=force */
{
    static const char *off_msgs[MAX_TRACELEVEL] = {
        "Tracing actions stopped",
        "Tracing packets stopped",
        "Tracing packet contents stopped",
        "Tracing kernel changes stopped",
        "Tracing routing socket messages stopped",
    };
    static const char *on_msgs[MAX_TRACELEVEL] = {
        "Tracing actions started",
        "Tracing packets started",
        "Tracing packet contents started",
        "Tracing kernel changes started",
        "Tracing routing socket messages started",
    };
    uint_t old_tracelevel = tracelevel;


    if (new_tracelevel < 0)
        new_tracelevel = 0;
    else if (new_tracelevel > MAX_TRACELEVEL)
        new_tracelevel = MAX_TRACELEVEL;

    if (new_tracelevel < tracelevel) {
        if (new_tracelevel <= 0) {
            trace_off(pat, off_msgs[0]);
        } else {
            do {
                tmsg(pat, off_msgs[tracelevel]);
            } while (--tracelevel != new_tracelevel);
        }

    } else if (new_tracelevel > tracelevel) {
        do {
            tmsg(pat, on_msgs[tracelevel++]);
        } while (tracelevel != new_tracelevel);
    }

    if (dump > 0 ||
        (dump == 0 && old_tracelevel == 0 && tracelevel != 0))
        trace_dump();
}

void
set_tracefile(const char *filename,
    const char *pat,
    int dump)           /* -1=no dump, 0=default, 1=force */
{
    struct stat stbuf;
    struct stat stbuf2;
    FILE *n_ftrace;
    const char *fn;
    int nfd;
    boolean_t allow_create;

    /*
     * main() calls this routine with "dump == -1".  All others
     * call it with 0, so we take dump == -1 to mean "can create
     * the file."
     */
    allow_create = (dump == -1);

    /*
     * Allow a null filename to increase the level if the trace file
     * is already open or if coming from a trusted source, such as
     * a signal or the command line.
     */
    if (filename == NULL || filename[0] == '\0') {
        filename = NULL;
        if (ftrace == NULL) {
            if (inittracename[0] == '\0') {
                msglog("missing trace file name");
                return;
            }
            fn = inittracename;
        } else {
            goto set_tracelevel;
        }

    } else if (strcmp(filename, "dump/../table") == 0) {
        trace_dump();
        return;

    } else {
        /*
         * Allow the file specified with "-T file" to be reopened,
         * but require all other names specified over the net to
         * match the official path.  The path can specify a directory
         * in which the file is to be created.
         */

        if (strcmp(filename, inittracename) != 0) {
            if (strncmp(filename, PATH_TRACE,
                sizeof (PATH_TRACE)-1) != 0 ||
                (strstr(filename, "../") != NULL)) {
                msglog("wrong trace file \"%s\"", filename);
                return;
            }
            if (stat(PATH_TRACE, &stbuf) == -1) {
                fn = PATH_TRACE;
                goto missing_file;
            }
            if (filename[sizeof (PATH_TRACE) - 1] != '\0' &&
                (filename[sizeof (PATH_TRACE) - 1] != '/' ||
                !S_ISDIR(stbuf.st_mode))) {
                goto bad_file_type;
            }
            if (S_ISDIR(stbuf.st_mode))
                allow_create = _B_TRUE;
        }

        fn = filename;
    }
    /* fn cannot be null here */

    /* If the new tracefile exists, it must be a regular file. */
    if (lstat(fn, &stbuf) == -1) {
        if (!allow_create)
            goto missing_file;
        nfd = open(fn, O_CREAT|O_EXCL|O_WRONLY, 0644);
        if (nfd != -1 && fstat(nfd, &stbuf) == -1) {
            (void) close(nfd);
            goto missing_file;
        }
    } else if (S_ISREG(stbuf.st_mode)) {
        nfd = open(fn, O_APPEND|O_WRONLY, 0644);
    } else {
        goto bad_file_type;
    }

    if (nfd == -1 || (n_ftrace = fdopen(nfd, "a")) == NULL) {
        msglog("failed to open trace file \"%s\" %s", fn,
            rip_strerror(errno));
        if (fn == inittracename)
            inittracename[0] = '\0';
        if (nfd != -1)
            (void) close(nfd);
        return;
    }

    if (fstat(nfd, &stbuf2) == -1 || !S_ISREG(stbuf2.st_mode) ||
        stbuf2.st_dev != stbuf.st_dev || stbuf2.st_ino != stbuf.st_ino) {
        msglog("trace file \"%s\" moved", fn);
        (void) fclose(n_ftrace);
        return;
    }

    tmsg("switch to trace file %s", fn);
    trace_close(file_trace = _B_TRUE);
    (void) dup2(nfd, STDOUT_FILENO);
    (void) dup2(nfd, STDERR_FILENO);

    if (fn != savetracename)
        (void) strlcpy(savetracename, fn, sizeof (savetracename) - 1);
    ftrace = n_ftrace;

set_tracelevel:
    if (new_tracelevel == 0 || filename == NULL)
        new_tracelevel++;
    tracelevel_msg(pat, dump != 0 ? dump : (filename != NULL));
    return;

missing_file:
    msglog("trace \"%s\" missing", fn);
    return;

bad_file_type:
    msglog("wrong type (%#x) of trace file \"%s\"", stbuf.st_mode, fn);
}


/* ARGSUSED */
void
sigtrace_more(int s)
{
    new_tracelevel++;
    sigtrace_pat = "SIGUSR1: %s";
    if (signal(s, sigtrace_more) == SIG_ERR)
        msglog("signal: %s", rip_strerror(errno));
}


/* ARGSUSED */
void
sigtrace_less(int s)
{
    new_tracelevel--;
    sigtrace_pat = "SIGUSR2: %s";
    if (signal(s, sigtrace_less) == SIG_ERR)
        msglog("signal: %s", rip_strerror(errno));
}

/* ARGSUSED */
void
sigtrace_dump(int s)
{
    trace_dump();
    if (signal(s, sigtrace_dump) == SIG_ERR)
        msglog("signal: %s", rip_strerror(errno));
}

/* Set tracing after a signal. */
void
set_tracelevel(void)
{
    if (new_tracelevel == tracelevel)
        return;

    /*
     * If tracing entirely off, and there was no tracefile specified
     * on the command line, then leave it off.
     */
    if (new_tracelevel > tracelevel && ftrace == NULL) {
        if (savetracename[0] != '\0') {
            set_tracefile(savetracename, sigtrace_pat, 0);
        } else if (inittracename[0] != '\0') {
            set_tracefile(inittracename, sigtrace_pat, 0);
        } else {
            new_tracelevel = 0;
            return;
        }
    } else {
        tracelevel_msg(sigtrace_pat, 0);
    }
}


/* display an address */
char *
addrname(in_addr_t addr,    /* in network byte order */
    in_addr_t   mask,
    int force)          /* 0=show mask if nonstandard, */
{                   /*  1=always show mask, 2=never */
#define NUM_BUFS 4
    static int bufno;
    static struct {
    /*
     * this array can hold either of the following strings terminated
     * by a null character:
     * "xxx.xxx.xxx.xxx/xx"
     * "xxx.xxx.xxx.xxx (mask xxx.xxx.xxx.xxx)"
     *
     */
        char    str[2*INET_ADDRSTRLEN + sizeof (" (mask )")];
    } bufs[NUM_BUFS];
    char *s, *sp;
    in_addr_t dmask;
    int i, len;
    struct in_addr tmp_addr;

    tmp_addr.s_addr = addr;
    len = strlcpy(bufs[bufno].str, inet_ntoa(tmp_addr),
        sizeof (bufs[bufno].str));
    s = bufs[bufno].str;
    bufno = (bufno+1) % NUM_BUFS;

    if (force == 1 || (force == 0 && mask != std_mask(addr))) {
        sp = &s[strlen(s)];

        dmask = mask & -mask;
        if (mask + dmask == 0) {
            i = ffs(mask);
            (void) snprintf(sp,
                (sizeof (bufs[bufno].str) - len), "/%d",
                (NBBY * sizeof (in_addr_t) + 1) - i);

        } else {
            (void) snprintf(sp,
                (sizeof (bufs[bufno].str) - len), " (mask %s)",
                naddr_ntoa(htonl(mask)));
        }
    }

    return (s);
#undef NUM_BUFS
}


/* display a bit-field */
struct or_bits {
    uint8_t origin;
    const char *origin_name;
};

static struct or_bits origin_bits[] = {
    { RO_RIP,       "RIP" },
    { RO_RDISC,     "RDISC" },
    { RO_STATIC,        "STATIC" },
    { RO_LOOPBCK,       "LOOPBCK" },
    { RO_PTOPT,     "PTOPT" },
    { RO_NET_SYN,       "NET_SYN" },
    { RO_IF,        "IF" },
    { RO_FILE,      "FILE" },
    { RO_NONE,      "     " },
    { 0,            NULL}
};

/* display a bit-field */
struct bits {
    uint64_t    bits_mask;
    uint64_t    bits_clear;
    const char  *bits_name;
};

static struct bits if_bits[] = {
    { IFF_BROADCAST,    0,      "BROADCAST" },
    { IFF_DEBUG,        0,      "DEBUG" },
    { IFF_LOOPBACK,     0,      "LOOPBACK" },
    { IFF_POINTOPOINT,  0,      "POINTOPOINT" },
    { IFF_NOTRAILERS,   0,      "NOTRAILERS" },
    { IFF_RUNNING,      0,      "RUNNING" },
    { IFF_NOARP,        0,      "NOARP" },
    { IFF_PROMISC,      0,      "PROMISC" },
    { IFF_ALLMULTI,     0,      "ALLMULTI" },
    { IFF_INTELLIGENT,  0,      "INTELLIGENT" },
    { IFF_MULTICAST,    0,      "MULTICAST" },
    { IFF_MULTI_BCAST,  0,      "MULTI_BCAST" },
    { IFF_UNNUMBERED,   0,      "UNNUMBERED" },
    { IFF_DHCPRUNNING,  0,      "DHCP" },
    { IFF_PRIVATE,      0,      "PRIVATE" },
    { IFF_NOXMIT,       0,      "NOXMIT" },
    { IFF_NOLOCAL,      0,      "NOLOCAL" },
    { IFF_DEPRECATED,   0,      "DEPRECATED" },
    { IFF_ADDRCONF,     0,      "ADDRCONF" },
    { IFF_ROUTER,       0,      "ROUTER" },
    { IFF_NONUD,        0,      "NONUD" },
    { IFF_ANYCAST,      0,      "ANYCAST" },
    { IFF_NORTEXCH,     0,      "NORTEXCH" },
    { IFF_IPV4,     0,      "IPv4" },
    { IFF_IPV6,     0,      "IPv6" },
    { IFF_NOFAILOVER,   0,      "NOFAILOVER" },
    { IFF_FAILED,       0,      "FAILED" },
    { IFF_STANDBY,      0,      "STANDBY" },
    { IFF_INACTIVE,     0,      "INACTIVE" },
    { IFF_OFFLINE,      0,      "OFFLINE" },
    { IFF_XRESOLV,      0,      "XRESOLV" },
    { IFF_COS_ENABLED,  0,      "CoS" },
    { IFF_PREFERRED,    0,      "PREFERRED" },
    { IFF_TEMPORARY,    0,      "TEMPORARY" },
    { IFF_FIXEDMTU,     0,      "FIXEDMTU" },
    { IFF_VIRTUAL,      0,      "VIRTUAL"},
    { IFF_IPMP,     0,      "IPMP"},
    { 0,            0,      NULL}
};

static struct bits is_bits[] = {
    { IS_ALIAS,     0,      "ALIAS" },
    { IS_SUBNET,        0,      "" },
    { IS_REMOTE,        (IS_NO_RDISC |
                IS_BCAST_RDISC), "REMOTE" },
    { IS_PASSIVE,       (IS_NO_RDISC |
                IS_NO_RIP |
                IS_NO_SUPER_AG |
                IS_PM_RDISC |
                IS_NO_AG),  "PASSIVE" },
    { IS_EXTERNAL,      0,      "EXTERNAL" },
    { IS_CHECKED,       0,      "" },
    { IS_ALL_HOSTS,     0,      "" },
    { IS_ALL_ROUTERS,   0,      "" },
    { IS_DISTRUST,      0,      "DISTRUST" },
    { IS_BROKE,     IS_SICK,    "BROKEN" },
    { IS_SICK,      0,      "SICK" },
    { IS_DUP,       0,      "DUPLICATE" },
    { IS_REDIRECT_OK,   0,      "REDIRECT_OK" },
    { IS_NEED_NET_SYN,  0,      "" },
    { IS_NO_AG,     IS_NO_SUPER_AG, "NO_AG" },
    { IS_NO_SUPER_AG,   0,      "NO_SUPER_AG" },
    { (IS_NO_RIPV1_IN |
        IS_NO_RIPV2_IN |
        IS_NO_RIPV1_OUT |
        IS_NO_RIPV2_OUT),   0,      "NO_RIP" },
    { (IS_NO_RIPV1_IN |
        IS_NO_RIPV1_OUT),   0,      "RIPV2" },
    { IS_NO_RIPV1_IN,   0,      "NO_RIPV1_IN" },
    { IS_NO_RIPV2_IN,   0,      "NO_RIPV2_IN" },
    { IS_NO_RIPV1_OUT,  0,      "NO_RIPV1_OUT" },
    { IS_NO_RIPV2_OUT,  0,      "NO_RIPV2_OUT" },
    { IS_NO_RIP_MCAST,  0,      "NO_RIP_MCAST" },
    { (IS_NO_ADV_IN |
        IS_NO_SOL_OUT |
        IS_NO_ADV_OUT), IS_BCAST_RDISC, "NO_RDISC" },
    { IS_NO_SOL_OUT,    0,      "NO_SOLICIT" },
    { IS_SOL_OUT,       0,      "SEND_SOLICIT" },
    { IS_NO_ADV_OUT,    IS_BCAST_RDISC, "NO_RDISC_ADV" },
    { IS_ADV_OUT,       0,      "RDISC_ADV" },
    { IS_BCAST_RDISC,   0,      "BCAST_RDISC" },
    { IS_PM_RDISC,      0,      "" },
    { IS_NO_HOST,       0,      "NO_HOST" },
    { IS_SUPPRESS_RDISC,    0,      "SUPPRESS_RDISC" },
    { IS_FLUSH_RDISC,   0,      "FLUSH_RDISC" },
    { 0,            0,      NULL}
};

static struct bits rs_bits[] = {
    { RS_IF,        0,      "IF" },
    { RS_NET_INT,       RS_NET_SYN, "NET_INT" },
    { RS_NET_SYN,       0,      "NET_SYN" },
    { RS_SUBNET,        0,      "" },
    { RS_LOCAL,     0,      "LOCAL" },
    { RS_MHOME,     0,      "MHOME" },
    { RS_STATIC,        0,      "STATIC" },
    { RS_NOPROPAGATE,   0,      "NOPROP" },
    { RS_BADIF,     0,      "BADIF" },
    { 0,            0,      NULL}
};

static struct bits ks_bits[] = {
    { KS_NEW,   0,      "NEW" },
    { KS_DELETE,    0,      "DELETE" },
    { KS_ADD,   0,      "ADD" },
    { KS_CHANGE,    0,      "CHANGE" },
    { KS_DEL_ADD,   0,      "DEL_ADD" },
    { KS_STATIC,    0,      "STATIC" },
    { KS_GATEWAY,   0,      "GATEWAY" },
    { KS_DYNAMIC,   0,      "DYNAMIC" },
    { KS_DELETED,   0,      "DELETED" },
    { KS_PRIVATE,   0,      "PRIVATE" },
    { KS_CHECK, 0,      "CHECK" },
    { KS_IF,    0,      "IF" },
    { KS_PASSIVE,   0,      "PASSIVE" },
    { KS_DEPRE_IF,  0,      "DEPRE_IF" },
    { KS_FILE,  0,      "FILE" },
    { 0,        0,      NULL}
};

static void
trace_bits(const struct bits *tbl,
    uint64_t field,
    boolean_t force)
{
    uint64_t b;
    char c;

    if (force) {
        (void) putc('<', ftrace);
        c = '\0';
    } else {
        c = '<';
    }

    while (field != 0 &&
        (b = tbl->bits_mask) != 0) {
        if ((b & field) == b) {
            if (tbl->bits_name[0] != '\0') {
                if (c != '\0')
                    (void) putc(c, ftrace);
                (void) fprintf(ftrace, "%s", tbl->bits_name);
                c = '|';
            }
            field &= ~(b | tbl->bits_clear);
        }
        tbl++;
    }
    if (field != 0) {
        if (c != '\0')
            (void) putc(c, ftrace);
        (void) fprintf(ftrace, "%#llx", field);
        c = '|';
    }

    if (c != '<' || force)
        (void) fputs("> ", ftrace);
}

static char *
trace_string(const struct bits *tbl, uint_t field, boolean_t force)
{
    const struct bits *tbp;
    char *sbuf, *cp, chr;
    size_t slen;

    /* minimum default string */
    slen = sizeof ("<0x12345678>");
    for (tbp = tbl; tbp->bits_mask != 0; tbp++)
        if (tbp->bits_name[0] != '\0')
            slen += strlen(tbp->bits_name) + 1;
    if ((sbuf = malloc(slen)) == NULL)
        return (NULL);
    cp = sbuf;

    if (force) {
        *cp++ = '<';
        chr = '\0';
    } else {
        chr = '<';
    }

    while (field != 0 && tbl->bits_mask != 0) {
        if ((tbl->bits_mask & field) == tbl->bits_mask) {
            if (tbl->bits_name[0] != '\0') {
                if (chr != '\0')
                    *cp++ = chr;
                (void) strcpy(cp, tbl->bits_name);
                cp += strlen(tbl->bits_name);
                chr = '|';
            }
            field &= ~(tbl->bits_mask | tbl->bits_clear);
        }
        tbl++;
    }
    if (field != 0) {
        if (chr != '\0')
            *cp++ = chr;
        cp += sprintf(cp, "%#x", field);
        chr = '|';
    }

    if (chr != '<' || force)
        *cp++ = '>';
    *cp = '\0';
    return (sbuf);
}

char *
if_bit_string(uint_t field, boolean_t force)
{
    return (trace_string(if_bits, field, force));
}

char *
rtname(in_addr_t dst,
    in_addr_t mask,
    in_addr_t gate)
{
    static char buf[sizeof ("xxx.xxx.xxx.xxx/xx-->xxx.xxx.xxx.xxx")];
    int i;

    (void) snprintf(buf, sizeof (buf), "%-16s-->", addrname(dst, mask, 0));
    i = strlen(buf);
    (void) snprintf(&buf[i], (sizeof (buf) -i), "%-*s", 15+24-MAX(24, i),
        naddr_ntoa(gate));
    return (buf);
}


static void
print_rts(struct rt_spare *rts,
    int force_metric,       /* -1=suppress, 0=default */
    int force_ifp,      /* -1=suppress, 0=default */
    int force_router,       /* -1=suppress, 0=default, 1=display */
    int force_tag,      /* -1=suppress, 0=default, 1=display */
    int force_time)     /* 0=suppress, 1=display */
{
    int i;

    if (force_metric >= 0)
        (void) fprintf(ftrace, "metric=%-2d ", rts->rts_metric);
    if (force_ifp >= 0)
        (void) fprintf(ftrace, "%s ", (rts->rts_ifp == 0 ?
            "if?" : rts->rts_ifp->int_name));
    if (force_router > 0 ||
        (force_router == 0 && rts->rts_router != rts->rts_gate))
        (void) fprintf(ftrace, "router=%s ",
            naddr_ntoa(rts->rts_router));
    if (force_time > 0)
        (void) fprintf(ftrace, "%s ", ts(rts->rts_time));
    if (force_tag > 0 ||
        (force_tag == 0 && rts->rts_tag != 0))
        (void) fprintf(ftrace, "tag=%#x ", ntohs(rts->rts_tag));
    if (rts->rts_de_ag != 0) {
        for (i = 1; (uint_t)(1 << i) <= rts->rts_de_ag; i++)
            continue;
        (void) fprintf(ftrace, "de_ag=%d ", i);
    }
    (void) fprintf(ftrace, "flags 0x%x ", rts->rts_flags);

}


static void
print_rtsorigin(const struct or_bits *tbl, uint8_t route_origin)
{

    uint8_t tblentry;
    while ((tblentry = tbl->origin) != 0) {
        if (tblentry == route_origin) {
            (void) fprintf(ftrace, "origin=%s ", tbl->origin_name);
        }
        tbl++;
    }
}


void
trace_if(const char *act, struct interface *ifp)
{
    if (!TRACEACTIONS || ftrace == NULL)
        return;

    lastlog();
    (void) fprintf(ftrace, "%-3s interface %-4s #%-3d ", act,
        ifp->int_name,
        ifp->int_phys != NULL ? ifp->int_phys->phyi_index : 0);
    (void) fprintf(ftrace, "%-15s-->%-15s",
        naddr_ntoa(ifp->int_addr),
        addrname(((ifp->int_if_flags & IFF_POINTOPOINT) ?
        ifp->int_dstaddr : htonl(ifp->int_net)),
        ifp->int_mask, 1));
    if (ifp->int_metric != 0)
        (void) fprintf(ftrace, " metric=%d", ifp->int_metric);
    if (!IS_RIP_OUT_OFF(ifp->int_state) &&
        ifp->int_d_metric != 0)
        (void) fprintf(ftrace, " fake_default=%d", ifp->int_d_metric);
    (void) fputs("\n    ", ftrace);
    trace_bits(if_bits, ifp->int_if_flags, _B_FALSE);
    trace_bits(is_bits, ifp->int_state, _B_FALSE);
    (void) fputc('\n', ftrace);
}

void
trace_khash(const struct khash *krt)
{
    if (ftrace == NULL)
        return;

    lastlog();
    (void) fprintf(ftrace, "  %-15s-->%-15s metric=%d ",
        addrname(krt->k_dst, krt->k_mask, 0),
        naddr_ntoa(krt->k_gate), krt->k_metric);
    if (krt->k_ifp != NULL)
        (void) fprintf(ftrace, "ifp %s ", krt->k_ifp->int_name);
    else
        (void) fprintf(ftrace, "ifp NULL ");
    (void) fprintf(ftrace, "%s ", ts(krt->k_keep));
    (void) fprintf(ftrace, "%s ", ts(krt->k_redirect_time));
    trace_bits(ks_bits, krt->k_state, _B_TRUE);
    (void) fputc('\n', ftrace);
}

void
trace_dr(const struct dr *drp)
{
    if (ftrace == NULL)
        return;

    lastlog();
    (void) fprintf(ftrace, "  %-4s %-15s %s ",
        drp->dr_ifp != NULL ? drp->dr_ifp->int_name : "?",
        naddr_ntoa(drp->dr_gate), ts(drp->dr_ts));
    (void) fprintf(ftrace, "%s %d %u\n", ts(drp->dr_life),
        SIGN_PREF(drp->dr_recv_pref), drp->dr_pref);
}

void
trace_upslot(struct rt_entry *rt,
    struct rt_spare *rts,
    struct rt_spare *new)
{
    if (!TRACEACTIONS || ftrace == NULL)
        return;

    if (rts->rts_gate == new->rts_gate &&
        rts->rts_router == new->rts_router &&
        rts->rts_metric == new->rts_metric &&
        rts->rts_tag == new->rts_tag &&
        rts->rts_de_ag == new->rts_de_ag)
        return;

    lastlog();
    if (new->rts_gate == 0) {
        (void) fprintf(ftrace, "Del #%d %-35s ",
            (int)(rts - rt->rt_spares),
            rtname(rt->rt_dst, rt->rt_mask, rts->rts_gate));
        print_rts(rts, 0, 0, 0, 0,
            (rts != rt->rt_spares ||
            AGE_RT(rt->rt_state, rts->rts_origin, new->rts_ifp)));

    } else if (rts->rts_gate != RIP_DEFAULT) {
        (void) fprintf(ftrace, "Chg #%d %-35s ",
            (int)(rts - rt->rt_spares),
            rtname(rt->rt_dst, rt->rt_mask, rts->rts_gate));
        print_rts(rts, 0, 0,
            rts->rts_gate != new->rts_gate,
            rts->rts_tag != new->rts_tag,
            rts != rt->rt_spares ||
            AGE_RT(rt->rt_state, rts->rts_origin, rt->rt_ifp));

        (void) fprintf(ftrace, "\n       %19s%-16s ", "",
            (new->rts_gate != rts->rts_gate ?
            naddr_ntoa(new->rts_gate) : ""));
        print_rts(new,
            ((new->rts_metric == rts->rts_metric) ? -1 : 0),
            ((new->rts_ifp == rts->rts_ifp) ? -1 : 0),
            0,
            rts->rts_tag != new->rts_tag,
            (new->rts_time != rts->rts_time &&
            (rts != rt->rt_spares ||
            AGE_RT(rt->rt_state, new->rts_origin, new->rts_ifp))));

    } else {
        (void) fprintf(ftrace, "Add #%d %-35s ",
            (int)(rts - rt->rt_spares),
            rtname(rt->rt_dst, rt->rt_mask, new->rts_gate));
        print_rts(new, 0, 0, 0, 0,
            (rts != rt->rt_spares ||
            AGE_RT(rt->rt_state, new->rts_origin, new->rts_ifp)));
    }
    (void) fputc('\n', ftrace);
}


/* miscellaneous message checked by the caller */
void
trace_misc(const char *p, ...)
{
    va_list args;

    if (ftrace == NULL)
        return;

    lastlog();
    va_start(args, p);
    (void) vfprintf(ftrace, p, args);
    (void) fputc('\n', ftrace);
    (void) va_end(args);
}


/* display a message if tracing actions */
void
trace_act(const char *p, ...)
{
    va_list args;

    if (!TRACEACTIONS || ftrace == NULL)
        return;

    lastlog();
    va_start(args, p);
    (void) vfprintf(ftrace, p, args);
    (void) fputc('\n', ftrace);
    (void) va_end(args);
}


/* display a message if tracing packets */
void
trace_pkt(const char *p, ...)
{
    va_list args;

    if (!TRACEPACKETS || ftrace == NULL)
        return;

    lastlog();
    va_start(args, p);
    (void) vfprintf(ftrace, p, args);
    (void) fputc('\n', ftrace);
    (void) va_end(args);
}


void
trace_change(struct rt_entry *rt,
    uint16_t    state,
    struct  rt_spare *new,
    const char  *label)
{
    if (ftrace == NULL)
        return;

    if (rt->rt_metric == new->rts_metric &&
        rt->rt_gate == new->rts_gate &&
        rt->rt_router == new->rts_router &&
        rt->rt_state == state &&
        rt->rt_tag == new->rts_tag &&
        rt->rt_de_ag == new->rts_de_ag)
        return;

    lastlog();
    (void) fprintf(ftrace, "%s %-35s ",
        label,
        rtname(rt->rt_dst, rt->rt_mask, rt->rt_gate));
    print_rts(rt->rt_spares,
        0, 0, 0, 0, AGE_RT(rt->rt_state, rt->rt_spares->rts_origin,
        rt->rt_ifp));
    print_rtsorigin(origin_bits, rt->rt_spares->rts_origin);
    trace_bits(rs_bits, rt->rt_state, rt->rt_state != state);

    (void) fprintf(ftrace, "\n%*s %19s%-16s ",
        strlen(label), "", "",
        (rt->rt_gate != new->rts_gate ?
        naddr_ntoa(new->rts_gate) : ""));
    print_rts(new,
        ((new->rts_metric == rt->rt_metric) ? -1 : 0),
        ((new->rts_ifp == rt->rt_ifp) ? -1 : 0),
        0,
        rt->rt_tag != new->rts_tag,
        (rt->rt_time != new->rts_time &&
        AGE_RT(rt->rt_state, new->rts_origin, new->rts_ifp)));
    if (rt->rt_state != state) {
        print_rtsorigin(origin_bits, new->rts_origin);
        trace_bits(rs_bits, state, _B_TRUE);
    }
    (void) fputc('\n', ftrace);
}


void
trace_add_del(const char *action, struct rt_entry *rt)
{
    if (ftrace == NULL)
        return;

    lastlog();
    (void) fprintf(ftrace, "%s    %-35s ",
        action,
        rtname(rt->rt_dst, rt->rt_mask, rt->rt_gate));
    print_rts(rt->rt_spares, 0, 0, 0, 0, AGE_RT(rt->rt_state,
        rt->rt_spares->rts_origin, rt->rt_ifp));
    print_rtsorigin(origin_bits, rt->rt_spares->rts_origin);
    trace_bits(rs_bits, rt->rt_state, _B_FALSE);
    (void) fputc('\n', ftrace);
}


/* ARGSUSED */
static int
walk_trace(struct radix_node *rn,
    void *w)
{
#define RT ((struct rt_entry *)rn)
    struct rt_spare *rts;
    int i;

    (void) fprintf(ftrace, "  %-35s ",
        rtname(RT->rt_dst, RT->rt_mask, RT->rt_gate));
    print_rts(&RT->rt_spares[0], 0, 0, 0, 0,
        AGE_RT(RT->rt_state, RT->rt_spares[0].rts_origin, RT->rt_ifp));
    print_rtsorigin(origin_bits, RT->rt_spares[0].rts_origin);
    trace_bits(rs_bits, RT->rt_state, _B_FALSE);
    if (RT->rt_poison_time >= now_garbage &&
        RT->rt_poison_metric < RT->rt_metric)
        (void) fprintf(ftrace, "pm=%d@%s",
            RT->rt_poison_metric, ts(RT->rt_poison_time));
    (void) fprintf(ftrace, "%d spare slots", RT->rt_num_spares);

    rts = &RT->rt_spares[1];
    for (i = 1; i < RT->rt_num_spares; i++, rts++) {
        if (rts->rts_gate != RIP_DEFAULT) {
            (void) fprintf(ftrace, "\n    #%d%15s%-16s ",
                i, "", naddr_ntoa(rts->rts_gate));
            print_rts(rts, 0, 0, 0, 0, 1);
            print_rtsorigin(origin_bits, rts->rts_origin);
        }
    }
    (void) fputc('\n', ftrace);

    return (0);
}


void
trace_dump(void)
{
    struct interface *ifp;

    if (ftrace == NULL)
        return;
    lastlog();

    /*
     * Warning: the rtquery.trace.* family of STC tests depend on
     * the log file format here.  If you need to change this next
     * message, make sure that you change the TRACE_DUMP variable
     * as well.
     */
    (void) fputs("current daemon state:\n", ftrace);
    for (ifp = ifnet; ifp != NULL; ifp = ifp->int_next)
        trace_if("", ifp);
    (void) fputs("Routes:\n", ftrace);
    (void) rn_walktree(rhead, walk_trace, NULL);
    (void) fputs("Kernel routes:\n", ftrace);
    kern_dump();
    (void) fputs("Discovered routers:\n", ftrace);
    rdisc_dump();
}


void
trace_rip(const char *dir1, const char *dir2,
    struct sockaddr_in *who,
    struct interface *ifp,
    struct rip *msg,
    int size)           /* total size of message */
{
    struct netinfo *n, *lim;
#define NA ((struct netauth *)n)
    int i, seen_route;
    struct in_addr tmp_mask;

    if (!TRACEPACKETS || ftrace == NULL)
        return;

    lastlog();
    if (msg->rip_cmd >= RIPCMD_MAX || msg->rip_vers == 0) {
        (void) fprintf(ftrace, "%s bad RIPv%d cmd=%d %s"
            " %s.%d size=%d\n",
            dir1, msg->rip_vers, msg->rip_cmd, dir2,
            naddr_ntoa(who->sin_addr.s_addr),
            ntohs(who->sin_port),
            size);
        return;
    }

    (void) fprintf(ftrace, "%s RIPv%d %s %s %s.%d%s%s\n",
        dir1, msg->rip_vers, ripcmds[msg->rip_cmd], dir2,
        naddr_ntoa(who->sin_addr.s_addr), ntohs(who->sin_port),
        ifp ? " via " : "", ifp ? ifp->int_name : "");
    if (!TRACECONTENTS)
        return;

    seen_route = 0;
    switch (msg->rip_cmd) {
    case RIPCMD_REQUEST:
    case RIPCMD_RESPONSE:

        n = msg->rip_nets;
        tmp_mask.s_addr = n->n_mask;
        lim = n + (size - 4) / sizeof (struct netinfo);
        for (; n < lim; n++) {
            if (!seen_route &&
                n->n_family == RIP_AF_UNSPEC &&
                ntohl(n->n_metric) == HOPCNT_INFINITY &&
                msg->rip_cmd == RIPCMD_REQUEST &&
                (n+1 == lim ||
                (n+2 == lim &&
                (n+1)->n_family == RIP_AF_AUTH))) {
                (void) fputs("\tQUERY ", ftrace);
                if (n->n_dst != 0)
                    (void) fprintf(ftrace, "%s ",
                        naddr_ntoa(n->n_dst));
                if (n->n_mask != 0)
                    (void) fprintf(ftrace, "mask=%s ",
                        inet_ntoa(tmp_mask));
                if (n->n_nhop != 0)
                    (void) fprintf(ftrace, "nhop=%s ",
                        naddr_ntoa(n->n_nhop));
                if (n->n_tag != 0)
                    (void) fprintf(ftrace, "tag=%#x ",
                        ntohs(n->n_tag));
                (void) fputc('\n', ftrace);
                continue;
            }

            if (n->n_family == RIP_AF_AUTH) {
                if (NA->a_type == RIP_AUTH_PW &&
                    n == msg->rip_nets) {
                    (void) fprintf(ftrace, "\tPassword"
                        " Authentication: \"%s\"\n",
                        qstring(NA->au.au_pw,
                        RIP_AUTH_PW_LEN));
                    continue;
                }

                if (NA->a_type == RIP_AUTH_MD5 &&
                    n == msg->rip_nets) {
                    (void) fprintf(ftrace,
                        "\tMD5 Auth"
                        " pkt_len=%d KeyID=%u"
                        " auth_len=%d"
                        " seqno=%#x"
                        " rsvd=%#hx,%#hx\n",
                        ntohs(NA->au.a_md5.md5_pkt_len),
                        NA->au.a_md5.md5_keyid,
                        NA->au.a_md5.md5_auth_len,
                        ntohl(NA->au.a_md5.md5_seqno),
                        ntohs(NA->au.a_md5.rsvd[0]),
                        ntohs(NA->au.a_md5.rsvd[1]));
                    continue;
                }
                (void) fprintf(ftrace,
                    "\tAuthentication type %d: ",
                    ntohs(NA->a_type));
                for (i = 0; i < (int)sizeof (NA->au.au_pw);
                    i++)
                    (void) fprintf(ftrace, "%02x ",
                        NA->au.au_pw[i]);
                (void) fputc('\n', ftrace);
                continue;
            }

            seen_route = 1;
            if (n->n_family != RIP_AF_INET) {
                (void) fprintf(ftrace,
                    "\t(af %d) %-18s mask=%s ",
                    ntohs(n->n_family),
                    naddr_ntoa(n->n_dst),
                    inet_ntoa(tmp_mask));
            } else if (msg->rip_vers == RIPv1) {
                (void) fprintf(ftrace, "\t%-18s ",
                    addrname(n->n_dst, ntohl(n->n_mask),
                    n->n_mask == 0 ? 2 : 1));
            } else {
                (void) fprintf(ftrace, "\t%-18s ",
                    addrname(n->n_dst, ntohl(n->n_mask),
                    n->n_mask == 0 ? 2 : 0));
            }
            (void) fprintf(ftrace, "metric=%-2lu ",
                (unsigned long)ntohl(n->n_metric));
            if (n->n_nhop != 0)
                (void) fprintf(ftrace, " nhop=%s ",
                    naddr_ntoa(n->n_nhop));
            if (n->n_tag != 0)
                (void) fprintf(ftrace, "tag=%#x",
                    ntohs(n->n_tag));
            (void) fputc('\n', ftrace);
        }
        if (size != (char *)n - (char *)msg)
            (void) fprintf(ftrace, "truncated record, len %d\n",
                size);
        break;

    case RIPCMD_TRACEON:
        (void) fprintf(ftrace, "\tfile=\"%.*s\"\n", size - 4,
            msg->rip_tracefile);
        break;

    case RIPCMD_TRACEOFF:
        break;
    }
}