xref: /illumos-gate/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_slp.c (revision d6913e07)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1998,2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <iconv.h>
#include "snoop.h"
#include "slp.h"

#define	MAXSUMLEN 30

/* define VERIFYSLP to enable full message checking in summary mode */
#define	VERIFYSLP

/* Globals -- ugly, yes, but fast and easy in macros */
static int msglength;
static int retlength;
static char *msgend;	/* the end of the summary message buffer */
static char *p;		/* current position in the packet */
static char *msgbuf;	/* message buffer for summary mode */
static boolean_t url_auth	= B_FALSE;
static boolean_t attr_auth	= B_FALSE;
static boolean_t fresh		= B_FALSE;
static boolean_t overflow	= B_FALSE;
static int v1_charset		= 0;	/* character set; only in V1 */

/* Entry points for parsing the protocol */
static int interpret_slp_v1(int, struct slpv1_hdr *, int);
static int interpret_slp_v2(int, struct slpv2_hdr *, int);

/* header parsing */
static int v1_header(int, struct slpv1_hdr *, int);
static int v2_header(int, struct slpv2_hdr *, int *, int);
static int v2_finish(struct slpv2_hdr *, int);

/* V2 auth blocks */
static int slpv2_authblock(int);

/*
 * Functions for parsing each protocol message
 * Each function takes the interpreter's flags argument as its input
 * parameter, and returns 1 on success, or 0 on message corruption.
 * retlength is set as a side-effect in summary mode.
 */
static int v2_srv_rqst(int);
static int v2_srv_rply(int);
static int v2_srv_reg(int);
static int v2_srv_dereg(int);
static int v2_srv_ack(int);
static int v2_attr_rqst(int);
static int v2_attr_rply(int);
static int v2_daadvert(int);
static int v2_srv_type_rqst(int);
static int v2_srv_type_rply(int);
static int v2_saadvert(int);

static int v1_srv_rqst(int);
static int v1_srv_rply(int);
static int v1_srv_reg(int);
static int v1_srv_dereg(int);
static int v1_srv_ack(int);
static int v1_attr_rqst(int);
static int v1_attr_rply(int);
static int v1_daadvert(int);
static int v1_srv_type_rqst(int);
static int v1_srv_type_rply(int);

/*
 * The dispatch tables for handling individual messages, keyed by
 * function number.
 */
typedef int function_handler();

#define	V2_MAX_FUNCTION	11

static function_handler *v2_functions[V2_MAX_FUNCTION + 1] = {
	(function_handler *) NULL,
	(function_handler *) v2_srv_rqst,
	(function_handler *) v2_srv_rply,
	(function_handler *) v2_srv_reg,
	(function_handler *) v2_srv_dereg,
	(function_handler *) v2_srv_ack,
	(function_handler *) v2_attr_rqst,
	(function_handler *) v2_attr_rply,
	(function_handler *) v2_daadvert,
	(function_handler *) v2_srv_type_rqst,
	(function_handler *) v2_srv_type_rply,
	(function_handler *) v2_saadvert };

#define	V1_MAX_FUNCTION	10

static function_handler *v1_functions[V1_MAX_FUNCTION + 1] = {
	(function_handler *) NULL,
	(function_handler *) v1_srv_rqst,
	(function_handler *) v1_srv_rply,
	(function_handler *) v1_srv_reg,
	(function_handler *) v1_srv_dereg,
	(function_handler *) v1_srv_ack,
	(function_handler *) v1_attr_rqst,
	(function_handler *) v1_attr_rply,
	(function_handler *) v1_daadvert,
	(function_handler *) v1_srv_type_rqst,
	(function_handler *) v1_srv_type_rply };

/* TCP continuation handling */
static boolean_t tcp_continuation = B_FALSE;

#define	MAX_TCPCONT	16

static struct tcp_cont {
	int dst_port;
	char *msg;
	int totallen;
	int curr_offset;
} *tcp_cont[MAX_TCPCONT];

static int current_tcp_cont;

static void reg_tcp_cont(char *, int, int, int);
static int add_tcp_cont(struct tcp_cont *, char *, int);
static struct tcp_cont *find_tcp_cont(int);
static void remove_tcp_cont(int);

/* Conversions from numbers to strings */
static char *slpv2_func(int, boolean_t);
static char *slpv2_error(unsigned short);
static char *slpv1_func(int, boolean_t);
static char *slpv1_error(unsigned short);
static char *slpv1_charset(unsigned short);

/*
 * The only external entry point to the SLP interpreter. This function
 * simply dispatches the packet based on the version.
 */
int
interpret_slp(int flags, void *slp, int fraglen)
{
	extern int dst_port, curr_proto;
	struct tcp_cont *tce = NULL;
	char *s;

	msglength = fraglen;
	retlength = 0;
	p = slp;

	/* check if this is a TCP continuation */
	if (flags & F_DTAIL && curr_proto == IPPROTO_TCP) {
		tce = find_tcp_cont(dst_port);
		if (tce) {
			if (add_tcp_cont(tce, slp, fraglen)) {
				slp = tce->msg;
				fraglen = tce->curr_offset;
				tcp_continuation = B_TRUE;
			}
		}
	}
	if (*(char *)slp == 2 || tce)
		interpret_slp_v2(flags, slp, fraglen);
	else
		interpret_slp_v1(flags, slp, fraglen);

	tcp_continuation = B_FALSE;
	return (0);
}

/*
 * Primitives. These are implemented as much as possible as macros for
 * speed.
 */

#define	FIELD_DEFAULT	0
#define	FIELD_PREVRESP	1
#define	FIELD_TYPENA	2

static long long netval = 0;	/* need signed 64 bit quantity */

/* gets two bytes from p and leaves the result in netval */
#define	nbtohs() \
	netval = ((int)(p[0] & 0xff)) << 8; \
	netval += ((int)(p[1] & 0xff))

/* gets four bytes from p and leaves the result in netval */
#define	nbtohl() \
	netval = ((int)(p[0] & 0xff)) << 24; \
	netval += ((int)(p[1] & 0xff)) << 16; \
	netval += ((int)(p[2] & 0xff)) << 8; \
	netval += ((int)(p[3] & 0xff))

#define	get_byte() \
	if (msglength >= 1) { \
		netval = *p; \
		p++; \
		msglength--; \
	} else \
		netval = -1

#define	GETBYTE(x) \
	get_byte(); \
	if ((retlength = netval) < 0) \
		return (0); \
	x = netval

#define	SKIPBYTE \
	get_byte(); \
	if ((retlength = netval) < 0) \
		return (0); \

/*
 * gets two bytes from p, leaves the result in netval, and updates
 * msglength and p.
 */
#define	get_short() \
	if (msglength >= sizeof (unsigned short)) { \
		nbtohs(); \
		p += sizeof (unsigned short); \
		msglength -= sizeof (unsigned short); \
	} else \
		netval = -1

#define	GETSHORT(x) \
	get_short(); \
	if ((retlength = netval) < 0) \
		return (0); \
	x = netval

#define	SKIPSHORT \
	get_short(); \
	if ((retlength = netval) < 0) \
		return (0)

#define	get_int24(pp) \
	netval = ((int)((pp)[0] & 0xff)) << 16; \
	netval += ((int)((pp)[1] & 0xff)) << 8; \
	netval += ((int)((pp)[2] & 0xff))

static void slp_prevresp(char *p) {
	char *p2;

	/* cycle through all entries */
	for (; p != NULL; p = p2) {
	    p2 = strchr(p, ',');
	    if (p2 != NULL)
		*p2++ = '\0';

	    /* print entry at p */
	    sprintf(get_line(0, 0), "  \"%s\"", p);
	}
}

static int skip_field(int type) {
	unsigned short stringlen;

	get_short();
	if (netval < 0) {
	    return (-1);
	}
	stringlen = netval;

	/* special case for NA field in SrvTypeRqst */
	if (type == FIELD_TYPENA && stringlen == 0xffff) {
	    stringlen = 0;
	}

	if (stringlen > msglength) {
	    return (-1);
	}

	msglength -= stringlen;
	p += stringlen;

	return (stringlen);
}

#define	SKIPFIELD(type) \
	if ((retlength = skip_field(type)) < 0) \
		return (0)

#define	GETFIELD \
	get_short(); \
	if ((retlength = netval) < 0) \
		return (0); \
	strncat(msgbuf, p, (retlength > MAXSUMLEN ? MAXSUMLEN : retlength)); \
	p += retlength; \
	msglength -= retlength

/*
 * Determines from the first five bytes of a potential SLP header
 * if the following message is really an SLP message. Returns 1 if
 * it is a real SLP message, 0 if not.
 */
int valid_slp(unsigned char *slphdr, int len) {
	struct slpv1_hdr slp1;
	struct slpv2_hdr slp2;

	len -= (8 /* udp */ + 20 /* IP */ + 14 /* ether */);
	/* a valid version will be 1 or 2 */
	switch (*slphdr) {
	case 1:
	    memcpy(&slp1, slphdr, 5);
	    /* valid function? */
	    if (slp1.function > V1_MAX_FUNCTION) {
		return (0);
	    }
	    /* valid length heuristic */
	    if (slp1.length > len) {
		return (0);
	    }
	    return (1);
	case 2:
	    memcpy(&slp2, slphdr, 5);
	    /* valid function? */
	    if (slp2.function > V2_MAX_FUNCTION) {
		return (0);
	    }
	    /* valid length heuristic */
	    get_int24(&(slp2.l1));
	    if (netval > len) {
		return (0);
	    }
	    return (1);
	default:
	    return (0);
	}
}

/*
 * Converts a V1 char encoding to UTF8. If this fails, returns 0,
 * otherwise, 1. This function is the union of iconv UTF-8
 * modules and character sets registered with IANA.
 */
static int make_utf8(char *outbuf, size_t outlen,
			const char *inbuf, size_t inlen) {
	iconv_t cd;
	size_t converted;

	switch (v1_charset) {
	case 4:
	case 1004:
	    cd = iconv_open("UTF-8", "8859-1");
	    break;
	case 5:
	    cd = iconv_open("UTF-8", "8859-2");
	    break;
	case 6:
	    cd = iconv_open("UTF-8", "8859-3");
	    break;
	case 7:
	    cd = iconv_open("UTF-8", "8859-4");
	    break;
	case 8:
	    cd = iconv_open("UTF-8", "8859-5");
	    break;
	case 9:
	    cd = iconv_open("UTF-8", "8859-6");
	    break;
	case 10:
	    cd = iconv_open("UTF-8", "8859-7");
	    break;
	case 11:
	    cd = iconv_open("UTF-8", "8859-8");
	    break;
	case 12:
	    cd = iconv_open("UTF-8", "8859-9");
	    break;
	case 13:
	    cd = iconv_open("UTF-8", "8859-10");
	    break;
	case 37:
	    cd = iconv_open("UTF-8", "ko_KR-iso2022-7");
	    break;
	case 104:
	    cd = iconv_open("UTF-8", "iso2022");
	    break;
	case 1000:
	    cd = iconv_open("UTF-8", "UCS-2");
	    break;
	case 1001:
	    cd = iconv_open("UTF-8", "UCS-4");
	    break;
	default:
		/*
		 * charset not set, or reserved, or not supported, so
		 * just copy it and hope for the best.
		 */
	    converted = outlen < inlen ? outlen : inlen;
	    memcpy(outbuf, inbuf, converted);
	    outbuf[converted] = 0;
	    return (1);
	}

	if (cd == (iconv_t)-1) {
	    return (0);
	}

	if ((converted = iconv(cd, &inbuf, &inlen, &outbuf, &outlen))
	    == (size_t)-1) {
	    return (0);
	}

	outbuf[converted] = 0;
	iconv_close(cd);

	return (1);
}

static int slp_field(char *tag, int type) {
	int length;

	get_short();
	if (netval < 0) {
	    return (-1);
	}
	length = netval;

	/* special case for NA field in SrvTypeRqst */
	if (type == FIELD_TYPENA && length == 0xffff) {
	    sprintf(get_line(0, 0), "%s: length = -1: Use all NAs", tag);
	    return (0);
	}

	sprintf(get_line(0, 0), "%s: length = %d", tag, length);
	if (length > msglength) {
	    /* framing error: message is not long enough to contain data */
	    sprintf(get_line(0, 0),
		    "  [Framing error: remaining pkt length = %u]",
		    msglength);
	    return (-1);
	}

	if (length > 0) {
	    char *buf = malloc(length + 1);
	    if (buf != NULL) {
		if (v1_charset) {
		    if (!make_utf8(buf, length, p, length)) {
			strcpy(buf, "[Invalid Character Encoding]");
		    }
		} else {
		    memcpy(buf, p, length);
		    buf[length] = '\0';		/* ensure null-terminated */
		}

		switch (type) {
		    case FIELD_PREVRESP:
			slp_prevresp(buf);
			break;

		    default:
			sprintf(get_line(0, 0), "  \"%s\"", buf);
			break;
		}
		free(buf);
	    }

	    p += length;
	    msglength -= length;
	}

	/* return ok */
	return (0);
}

static int slpv2_url(int cnt) {
	time_t exp;
	int lifetime, length, n;

	/* reserved */
	get_byte();
	if (netval < 0)
	    return (-1);

	/* lifetime */
	get_short();
	if ((lifetime = netval) < 0)
	    return (-1);

	/* length */
	get_short();
	if ((length = netval) < 0)
	    return (-1);

	/* time */
	exp = time(0) + lifetime;
	if (cnt == -1)
	    sprintf(get_line(0, 0),
		    "URL: length = %u, lifetime = %d (%24.24s)",
		    length, lifetime, ctime(&exp));
	else
	    /* number the URLs to make it easier to parse them */
	    sprintf(get_line(0, 0),
		    "URL %d: length = %u, lifetime = %d (%24.24s)",
		    cnt, length, lifetime, ctime(&exp));

	if (length > msglength) {
	    if (!tcp_continuation)
		/* framing error: message is not long enough to contain data */
		sprintf(get_line(0, 0),
			"  [Framing error: remaining pkt length = %u]",
			msglength);
	    return (-1);
	}

	if (length > 0) {
	    char *buf = malloc(length + 1);
	    if (buf != NULL) {
		memcpy(buf, p, length);
		buf[length] = '\0';		/* ensure null-terminated */
		sprintf(get_line(0, 0), "  \"%s\"", buf);
		free(buf);
	    }
	}
	msglength -= length;
	p += length;

	get_byte();
	if ((n = netval) < 0)
	    return (-1);

	if (n > 0) {
	    int i;
	    sprintf(get_line(0, 0), "%d Authentication Blocks", n);
	    for (i = 0; i < n; i++)
		if ((length = slpv2_authblock(i)) < 0)
		    return (-1);
	}
	return (0);
}

#define	DOFIELD(tag, type) \
	if (slp_field(tag, type) < 0) \
		return (0)

#define	V2_DOURL(x) \
	if (slpv2_url(x) < 0) \
		return (0)

#define	V2_DOERRCODE \
	if (msglength < sizeof (unsigned short)) \
		return (0); \
	nbtohs(); \
	errcode = netval; \
	sprintf(get_line(0, 0), "Error code = %d, %s", \
				errcode, slpv2_error(errcode)); \
	p += sizeof (unsigned short); \
	msglength -= sizeof (unsigned short); \
	if (errcode != OK) \
		msglength = 0;	/* skip rest of message */ \
	if (errcode != OK) \
		return (0)

#define	V2_DOAUTH(cnt) \
	if (slpv2_authblock(cnt) < 0) \
		return (0)

#define	V2_DOTIMESTAMP \
	if (msglength < 4) \
		return (0); \
	nbtohl(); \
	timestamp = netval; \
	sprintf(get_line(0, 0), "Timestamp = %u, %s", \
		timestamp, (timestamp ? convert_ts(timestamp) : "0")); \
	p += 4; \
	msglength -= 4

/* some V1 macros */
#define	SKIPAUTH(auth) \
	if (auth && ((retlength = skip_v1authblock()) < 0)) \
		return (0)

#define	DOERRCODE \
	if (msglength < sizeof (unsigned short)) \
		return (0); \
	nbtohs(); \
	errcode = netval; \
	sprintf(get_line(0, 0), "Error code = %d, %s", errcode, \
				slpv1_error(errcode)); \
	p += sizeof (unsigned short); \
	msglength -= sizeof (unsigned short); \
	if (errcode != OK) \
		return (0)

#define	DOURL \
	if (slpv1_url(url_auth) < 0) \
		return (0)

#define	DOAUTH(auth) \
	if (auth && slpv1_authblock() < 0) \
		return (0)

/*
 * TCP Continuation handling
 * We keep track of continuations in a fixed size cache, so as to prevent
 * memory leaks if some continuations are never finished. The continuations
 * are indexed by their destination ports.
 */
static void reg_tcp_cont(char *msg, int totallen,
			    int fraglen, int dst_port) {
	struct tcp_cont *tce = malloc(sizeof (*tce));

	/* always overwrite the entry at current_tcp_cont */
	if (tcp_cont[current_tcp_cont]) {
	    free(tcp_cont[current_tcp_cont]->msg);
	    free(tcp_cont[current_tcp_cont]);
	}

	tce->dst_port = dst_port;
	tce->msg = malloc(totallen);
	memcpy(tce->msg, msg, fraglen);
	tce->totallen = totallen;
	tce->curr_offset = fraglen;

	tcp_cont[current_tcp_cont++] = tce;
	if (current_tcp_cont == MAX_TCPCONT)
	    current_tcp_cont = 0;
}

/* returns 0 if there is a mismatch error, 1 on success */
static int add_tcp_cont(struct tcp_cont *tce, char *msg, int fraglen) {
	if ((fraglen + tce->curr_offset) > tce->totallen)
	    return (0);

	memcpy(tce->msg + tce->curr_offset, msg, fraglen);
	tce->curr_offset += fraglen;
	return (1);
}

static struct tcp_cont *find_tcp_cont(int dst_port) {
	int i;
	for (i = current_tcp_cont; i >= 0; i--)
	    if (tcp_cont[i] && tcp_cont[i]->dst_port == dst_port)
		return (tcp_cont[i]);

	for (i = MAX_TCPCONT -1; i > current_tcp_cont; i--)
	    if (tcp_cont[i] && tcp_cont[i]->dst_port == dst_port)
		return (tcp_cont[i]);

	return (NULL);
}

static void remove_tcp_cont(int dst_port) {
	int i;
	for (i = current_tcp_cont; i >= 0; i--)
	    if (tcp_cont[i] && tcp_cont[i]->dst_port == dst_port) {
		free(tcp_cont[i]->msg);
		free(tcp_cont[i]);
		tcp_cont[i] = NULL;
		return;
	    }

	for (i = MAX_TCPCONT -1; i > current_tcp_cont; i--)
	    if (tcp_cont[i] && tcp_cont[i]->dst_port == dst_port) {
		free(tcp_cont[i]->msg);
		free(tcp_cont[i]);
		tcp_cont[i] = NULL;
		return;
	    }
}

/*
 * V2 interpreter
 */

static int interpret_slp_v2(int flags, struct slpv2_hdr *slp, int fraglen) {
	extern int src_port, dst_port, curr_proto;
	char msgbuf_real[256];
	int totallen = 0;

	msgbuf = msgbuf_real;

	/*
	 * Somewhat of a hack to decode traffic from a server that does
	 * not send udp replies from its SLP src port.
	 */

	if (curr_proto == IPPROTO_UDP &&
	    dst_port == 427 &&
	    src_port != 427) {
	    add_transient(src_port, interpret_slp);
	}

	/* parse the header */
	if (v2_header(flags, slp, &totallen, fraglen)) {

	    if (slp->function <= V2_MAX_FUNCTION && slp->function > 0) {

		/* Parse the message body */
		if ((v2_functions[slp->function])(flags)) {

		    /* finish any remaining tasks */
		    v2_finish(slp, flags);

		}

	    }

	}

	/* summary error check */
	if (flags & F_SUM) {
	    if (retlength < 0) {
		if (curr_proto == IPPROTO_TCP)
		    sprintf(get_sum_line(),
			    "%s [partial TCP message]", msgbuf);
		else if (overflow)
		    sprintf(get_sum_line(), "%s [OVERFLOW]", msgbuf);
		else
		    sprintf(get_sum_line(), "%s [CORRUPTED MESSAGE]", msgbuf);
	    }
#ifdef VERIFYSLP
	    else if (msglength > 0)
		sprintf(get_sum_line(), "%s +%d", msgbuf, msglength);
#endif
	    else
		sprintf(get_sum_line(), "%s", msgbuf);
	} else if (flags & F_DTAIL) {
	    /* detailed error check */
	    if (msglength > 0) {
		if (tcp_continuation) {
		    sprintf(get_line(0, 0),
			    "[TCP Continuation, %d bytes remaining]",
			    totallen - fraglen);
		} else
		    sprintf(get_line(0, 0),
			"[%d extra bytes at end of SLP message]", msglength);
	    }

	    show_trailer();

	    if (tcp_continuation && msglength == 0)
		remove_tcp_cont(dst_port);
	}

	return (0);
}

static int v2_header(int flags,
			struct slpv2_hdr *slp,
			int *totallen,
			int fraglen) {
	extern int curr_proto, dst_port;
	char *prototag = (curr_proto == IPPROTO_TCP ? "/tcp" : "");

	if ((slp->flags & V2_OVERFLOW) == V2_OVERFLOW)
	    overflow = B_TRUE;

	/* summary mode header parsing */
	if (flags & F_SUM) {

	    /* make sure we have at least a header */
	    if (msglength < sizeof (*slp)) {
		sprintf(get_sum_line(), "SLP V2 [Incomplete Header]");
		return (0);
	    }

	    sprintf(msgbuf, "SLP V2 %s [%d%s] ",
		    slpv2_func(slp->function, B_TRUE),
		    ntohs(slp->xid), prototag);

	    /* skip to end of header */
	    msgend = msgbuf + strlen(msgbuf);
	    msglength -= sizeof (*slp);
	    p += sizeof (*slp);

	    /* skip language tag */
	    SKIPFIELD(FIELD_DEFAULT);
	} else if (flags & F_DTAIL) {
	    char *lang;
	    int len;

	    /* detailed mode header parsing */
	    show_header("SLP:  ", "Service Location Protocol (v2)", fraglen);
	    show_space();

	    if (msglength < sizeof (*slp)) {
		sprintf(get_line(0, 0), "==> Incomplete SLP header");
		return (0);
	    }

	    sprintf(get_line(0, 0), "Version = %d", slp->vers);
	    sprintf(get_line(0, 0), "Function = %d, %s",
		    slp->function, slpv2_func(slp->function, B_FALSE));
	    get_int24(&(slp->l1));
	    *totallen = netval;
	    sprintf(get_line(0, 0), "Message length = %u", *totallen);
	    /* check for TCP continuation */
	    if (curr_proto == IPPROTO_TCP &&
		*totallen > msglength &&
		!tcp_continuation) {
		tcp_continuation = B_TRUE;
		reg_tcp_cont((char *)slp, *totallen, msglength, dst_port);
	    }

	    if (!tcp_continuation && *totallen != msglength) {
		sprintf(get_line(0, 0),
			"  (Stated and on-the-wire lengths differ)");
	    }
	    /* flags */
	    sprintf(get_line(0, 0), "Flags = 0x%02x", slp->flags);
	    sprintf(get_line(0, 0), "      %s",
		    getflag(slp->flags, V2_OVERFLOW,
			    "overflow", "no overflow"));
	    sprintf(get_line(0, 0), "      %s",
		    getflag(slp->flags, V2_FRESH,
			    "fresh registration", "no fresh registration"));
	    sprintf(get_line(0, 0), "      %s",
		    getflag(slp->flags, V2_MCAST,
			    "request multicast / broadcast", "unicast"));
	    /* check reserved flags that must be zero */
	    if ((slp->flags & 7) != 0) {
		sprintf(get_line(0, 0),
			"      .... .xxx = %d (reserved flags nonzero)",
			slp->flags & 7);
	    }
	    /* end of flags */

	    /* language tag */
	    p = (char *)slp + sizeof (*slp);
	    msglength -= sizeof (*slp);
	    GETSHORT(len);
	    if (len > msglength) {
		sprintf(get_line(0, 0),
			"Language Tag Length = %u [CORRUPT MESSAGE]",
			len);
		return (0);
	    }

	    lang = get_line(0, 0);
	    strcpy(lang, "Language Tag = ");
	    strncat(lang,  p, len);
	    sprintf(get_line(0, 0), "XID = %u", ntohs(slp->xid));

	    /* set msglength to remaining length of SLP message */
	    p += len;
	    msglength -= len;
	}

	return (1);
}

static int v2_finish(struct slpv2_hdr *slp, int flags) {
	unsigned int firstop;

	if (!(flags & F_DTAIL))
	    return (1);

	/* check for options */
	get_int24(&(slp->o1));
	firstop = netval;

	if (firstop) {
	    unsigned short op_id;
	    unsigned short nextop;
	    char *op_class;

	    for (;;) {
		unsigned short real_oplen;

		if (msglength < 4) {
		    sprintf(get_line(0, 0),
			    "Option expected but not present");
		    return (0);
		}

		nbtohs();
		op_id = netval;
		p += sizeof (unsigned short);
		msglength -= sizeof (unsigned short);
		nbtohs();
		nextop = netval;
		p += sizeof (unsigned short);
		msglength -= sizeof (unsigned short);

		real_oplen = nextop ? nextop : msglength;

		/* known options */
		switch (op_id) {
		case 1:
		    sprintf(get_line(0, 0),
			    "Option: Required Attribute Missing");
		    DOFIELD("Template IDVer", FIELD_DEFAULT);
		    DOFIELD("Required Attrs", FIELD_DEFAULT);
		    break;
		default:
		    sprintf(get_line(0, 0), "Option: Unknown");
		    p += (real_oplen - 4);
		    msglength -= (real_oplen - 4);
		    break;
		}

		if (op_id < 0x3fff)
		    op_class = "Standardized, optional";
		else if (op_id < 0x7fff)
		    op_class = "Standardized, mandatory";
		else if (op_id < 0x8fff)
		    op_class = "Not standardized, private";
		else if (op_id < 0xffff)
		    op_class = "Reserved";
		sprintf(get_line(0, 0), "Option ID = 0x%04x, %s",
			op_id, op_class);
		if (nextop &&
		    ((nextop - 4) > msglength) &&
		    !tcp_continuation) {
		    sprintf(get_line(0, 0),
			    "[Framing error: remaining pkt length = %u]",
			    msglength);
		    return (0);
		}

		sprintf(get_line(0, 0), "Option Length = %u", real_oplen);

		if (!nextop)
		    break;
	    }
	}

	return (1);
}

#ifdef VERIFYSLP
static int skip_v2authblock() {
	unsigned short length, slen;

	/* auth header */
	if (msglength < 10)
	    return (-1);

	/* block descriptor: 2 bytes */
	p += sizeof (unsigned short);
	/* length */
	nbtohs();
	length = netval;
	p += sizeof (unsigned short);
	/* timestamp */
	p += 4;
	/* SPI String length */
	nbtohs();
	slen = netval;
	p += sizeof (unsigned short);

	msglength -= 10;
	if (slen > msglength || length > (msglength + 10))
	    return (-1);

	p += slen;
	msglength -= slen;

	/* structured auth block */
	p += (length - 10 - slen);
	msglength -= (length - 10 - slen);
	return (0);
}
#endif

static char *display_bsd(unsigned short bsd) {
	switch (bsd) {
	case 1: return ("MD5 with RSA");
	case 2: return ("DSA with SHA-1");
	case 3: return ("Keyed HMAC with MD5");
	default: return ("Unknown BSD");
	}
}

static char *slpv2_func(int t, boolean_t s) {
	static char buf[128];

	switch (t) {
	case V2_SRVRQST:	return s? "SrvRqst"  : "Service Request";
	case V2_SRVRPLY:	return s? "SrvRply"  : "Service Reply";
	case V2_SRVREG:		return s? "SrvReg"   : "Service Registration";
	case V2_SRVDEREG:
	    return (s ? "SrvDereg" : "Service Deregistration");
	case V2_SRVACK:		return s? "SrvAck"   : "Service Acknowledge";
	case V2_ATTRRQST:	return s? "AttrRqst" : "Attribute Request";
	case V2_ATTRRPLY:	return s? "AttrRply" : "Attribute Reply";
	case V2_DAADVERT:	return s? "DAAdvert" : "DA advertisement";
	case V2_SRVTYPERQST:
	    return (s ? "SrvTypeRqst" : "Service Type Request");
	case V2_SRVTYPERPLY:
	    return (s ? "SrvTypeRply" : "Service Type Reply");
	case V2_SAADVERT:	return s? "SAAdvert" : "SA advertisement";
	}
	sprintf(buf, "(func %d)", t);
	return (s ? buf : "unknown function");
}

static char *slpv2_error(unsigned short code) {
	static char buf[128];

	switch (code) {
	case OK:			return "ok";
	case LANG_NOT_SUPPORTED:	return "language not supported";
	case PROTOCOL_PARSE_ERR:	return "protocol parse error";
	case INVALID_REGISTRATION:	return "invalid registration";
	case SCOPE_NOT_SUPPORTED:	return "scope not supported";
	case AUTHENTICATION_UNKNOWN:	return "authentication unknown";
	case V2_AUTHENTICATION_ABSENT:	return "authentication absent";
	case V2_AUTHENTICATION_FAILED:	return "authentication failed";
	case V2_VER_NOT_SUPPORTED:	return "version not supported";
	case V2_INTERNAL_ERROR:		return "internal error";
	case V2_DA_BUSY_NOW:		return "DA busy";
	case V2_OPTION_NOT_UNDERSTOOD:	return "option not understood";
	case V2_INVALID_UPDATE:		return "invalid update";
	case V2_RQST_NOT_SUPPORTED:	return "request not supported";
	case INVALID_LIFETIME:		return "invalid lifetime";
	}
	sprintf(buf, "error %d", code);
	return (buf);
}

static char *convert_ts(unsigned int timestamp) {
	/* timestamp is in UNIX time */
	static char buff[128];

	strcpy(buff, ctime((time_t *)&timestamp));
	buff[strlen(buff) - 1] = '\0';
	return (buff);
}

static int slpv2_authblock(int cnt) {
	unsigned short bsd, length, slen;
	char *pp, *scopes;
	unsigned int timestamp;

	if (msglength < 10) {
	    sprintf(get_line(0, 0),
		"  [no room for auth block header: remaining msg length = %u]",
		    msglength);
	    return (-1);
	}

	/* bsd */
	nbtohs();
	bsd = netval;
	p += sizeof (unsigned short);

	/* length */
	nbtohs();
	length = netval;
	p += sizeof (unsigned short);

	/* timestamp */
	nbtohl();
	timestamp = netval;
	p += 4;

	/* SPI String length */
	nbtohs();
	slen = netval;
	p += sizeof (unsigned short);

	msglength -= 10;
	if (slen > msglength) {
	    sprintf(get_line(0, 0),
		"  [no room for auth block scopes: remaining msg length = %u]",
		    msglength);
	    return (-1);
	}

	if (length > (msglength + 10)) {
	    if (!tcp_continuation)
		/* framing error: message is not long enough to contain data */
		sprintf(get_line(0, 0),
			"  [Framing error: remaining pkt length = %u]",
			msglength);
	    return (-1);
	}

	scopes = p;
	p += slen;
	msglength -= slen;

	sprintf(get_line(0, 0),
	    "Auth block %d: timestamp = %s", cnt,
	    (timestamp) ? convert_ts(timestamp) : "0");

	pp = get_line(0, 0);
	strcpy(pp, "              SPI = ");
	strncat(pp, scopes, slen);

	sprintf(get_line(0, 0),
	    "              block desc = 0x%04x: %s", bsd, display_bsd(bsd));

	sprintf(get_line(0, 0), "              length = %u", length);

	p += (length - 10 - slen);
	msglength -= (length - 10 - slen);
	return (0);
}

static int v2_srv_rqst(int flags) {
	if (flags & F_SUM) {
		SKIPFIELD(FIELD_DEFAULT);	/* PR list */
		GETFIELD;			/* service type */
		SKIPFIELD(FIELD_DEFAULT);	/* scopes */
		strcat(msgend, " [");
		GETFIELD;			/* predicate */
		strcat(msgend, "]");
		SKIPFIELD(FIELD_DEFAULT);	/* SPI */
	} else if (flags & F_DTAIL) {
		DOFIELD("Previous responders", FIELD_DEFAULT);
		DOFIELD("Service type",  FIELD_DEFAULT);
		DOFIELD("Scopes",  FIELD_DEFAULT);
		DOFIELD("Predicate string",  FIELD_DEFAULT);
		DOFIELD("Requested SPI", FIELD_DEFAULT);
	}

	return (1);
}

static int v2_srv_rply(int flags) {
	unsigned short itemcnt, errcode;
	int n;

	if (flags & F_SUM) {
	    int i, auth_cnt;

	    GETSHORT(errcode);
	    if (errcode != OK) {
		strcat(msgbuf, slpv2_error(errcode));
		msglength = 0;	/* skip rest of message */
		return (0);
	    } else {
		GETSHORT(itemcnt);
		sprintf(msgend, "%d URL entries", itemcnt);
#ifdef VERIFYSLP
		for (n = 0; n < itemcnt; n++) {
		    SKIPBYTE;			/* reserved */
		    SKIPSHORT;			/* lifetime */
		    SKIPFIELD(FIELD_DEFAULT);	/* URL */
		    GETBYTE(auth_cnt);
		    for (i = 0; i < auth_cnt; auth_cnt++)
			if (skip_v2authblock() < 0)
			    return (0);
		}
#endif
	    }
	} else if (flags & F_DTAIL) {
	    V2_DOERRCODE;
	    GETSHORT(itemcnt);
	    sprintf(get_line(0, 0), "URL entry count = %d", itemcnt);
	    for (n = 0; n < itemcnt; n++) {
		V2_DOURL(n);
	    }
	}

	return (1);
}

static int v2_srv_reg(int flags) {
	int i, auth_cnt;

	if (flags & F_SUM) {
	    SKIPBYTE;			/* reserved */
	    SKIPSHORT;			/* lifetime */
	    GETFIELD;			/* URL */
#ifdef VERIFYSLP
	    GETBYTE(auth_cnt);
	    for (i = 0; i < auth_cnt; i++)
		if (skip_v2authblock() < 0)
		    return (0);
	    SKIPFIELD(FIELD_DEFAULT);	/* type */
	    SKIPFIELD(FIELD_DEFAULT);	/* scopes */
	    SKIPFIELD(FIELD_DEFAULT);	/* attrs */
	    GETBYTE(auth_cnt);
	    for (i = 0; i < auth_cnt; i++)
		if (skip_v2authblock() < 0)
		    return (0);
#endif
	} if (flags & F_DTAIL) {
	    V2_DOURL(-1);
	    DOFIELD("Service type", FIELD_DEFAULT);
	    DOFIELD("Scopes", FIELD_DEFAULT);
	    DOFIELD("Attribute list", FIELD_DEFAULT);
	    /* auth */
	    GETBYTE(auth_cnt);
	    for (i = 0; i < auth_cnt; i++)
		V2_DOAUTH(i);
	}

	return (1);
}

static int v2_srv_dereg(int flags) {
	if (flags & F_SUM) {
	    int i, auth_cnt;