freebsd/usr.sbin/atm/scspd/scsp_print.c

/*
 *
 * ===================================
 * HARP  |  Host ATM Research Platform
 * ===================================
 *
 *
 * This Host ATM Research Platform ("HARP") file (the "Software") is
 * made available by Network Computing Services, Inc. ("NetworkCS")
 * "AS IS".  NetworkCS does not provide maintenance, improvements or
 * support of any kind.
 *
 * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
 * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
 * In no event shall NetworkCS be responsible for any damages, including
 * but not limited to consequential damages, arising from or relating to
 * any use of the Software or related support.
 *
 * Copyright 1994-1998 Network Computing Services, Inc.
 *
 * Copies of this Software may be made, however, the above copyright
 * notice must be reproduced on all copies.
 *
 *	@(#) $Id: scsp_print.c,v 1.5 1998/08/13 20:11:16 johnc Exp $
 *
 */


/*
 * Server Cache Synchronization Protocol (SCSP) Support
 * ----------------------------------------------------
 *
 * Print routines
 *
 */


#ifndef lint
static char *RCSid = "@(#) $Id: scsp_print.c,v 1.5 1998/08/13 20:11:16 johnc Exp $";
#endif

#include <sys/types.h>
#include <sys/param.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netatm/port.h> 
#include <netatm/queue.h> 
#include <netatm/atm.h>
#include <netatm/atm_if.h>
#include <netatm/atm_sap.h>
#include <netatm/atm_sys.h>
#include <netatm/atm_ioctl.h>
  
#include <libatm.h>
#include "scsp_msg.h"
#include "scsp_if.h"
#include "scsp_var.h"


/*
 * Indent string
 */
#define	MIN_INDENT	2
#define	MAX_INDENT	64
static char	indent[MAX_INDENT + 1];


/*
 * Value-name translation table entry
 */
struct type_name {
	char	*name;
	u_char	type;
};
typedef	struct type_name	Type_name;


/*
 * SCSP name-type tables
 */
static Type_name if_msg_types[] = {
	{ "Config Request",		SCSP_CFG_REQ },
	{ "Config Response",		SCSP_CFG_RSP },
	{ "Cache Indication",		SCSP_CACHE_IND },
	{ "Cache Response",		SCSP_CACHE_RSP },
	{ "Solicit Indication",		SCSP_SOLICIT_IND },
	{ "Solicit Response",		SCSP_SOLICIT_RSP },
	{ "Cache Update Indication",	SCSP_UPDATE_IND },
	{ "Cache Update Request",	SCSP_UPDATE_REQ },
	{ "Cache Update Response",	SCSP_UPDATE_RSP },
	{ (char *)0,	0 }
};

static Type_name msg_types[] = {
	{ "Cache Alignment",	SCSP_CA_MSG },
	{ "CSU Request",	SCSP_CSU_REQ_MSG },
	{ "CSU Reply",		SCSP_CSU_REPLY_MSG },
	{ "CSU Solicit",	SCSP_CSUS_MSG },
	{ "Hello",		SCSP_HELLO_MSG },
	{ (char *)0,		0 }
};

static Type_name proto_types[] = {
	{ "ATMARP",	SCSP_PROTO_ATMARP },
	{ "NHRP",	SCSP_PROTO_NHRP },
	{ "MARS",	SCSP_PROTO_MARS },
	{ "DHCP",	SCSP_PROTO_DHCP },
	{ "LNNI",	SCSP_PROTO_LNNI },
	{ (char *)0,	0 }
};

static Type_name ext_types[] = {
	{ "End of Extensions",	SCSP_EXT_END },
	{ "Authentication",	SCSP_EXT_AUTH },
	{ "Vendor Private",	SCSP_EXT_VENDOR },
	{ (char *)0,		0 }
};

static Type_name hfsm_state_names[] = {
	{ "Down",		SCSP_HFSM_DOWN },
	{ "Waiting",		SCSP_HFSM_WAITING },
	{ "Unidirectional",	SCSP_HFSM_UNI_DIR },
	{ "Bidirectional",	SCSP_HFSM_BI_DIR },
	{ (char *)0,		0 }
};

static Type_name hfsm_event_names[] = {
	{ "VC open",		SCSP_HFSM_VC_ESTAB },
	{ "VC closed",		SCSP_HFSM_VC_CLOSED },
	{ "Hello timer",	SCSP_HFSM_HELLO_T },
	{ "Receive timer",	SCSP_HFSM_RCV_T },
	{ "Msg received",	SCSP_HFSM_RCVD },
	{ (char *)0,		0 }
};

static Type_name cafsm_state_names[] = {
	{ "Down",			SCSP_CAFSM_DOWN },
	{ "Master/Slave negotiation",	SCSP_CAFSM_NEG },
	{ "Master",			SCSP_CAFSM_MASTER },
	{ "Slave",			SCSP_CAFSM_SLAVE },
	{ "Update cache",		SCSP_CAFSM_UPDATE },
	{ "Aligned",			SCSP_CAFSM_ALIGNED },
	{ (char *)0,			0 }
};

static Type_name cafsm_event_names[] = {
	{ "Hello FSM up",		SCSP_CAFSM_HELLO_UP },
	{ "Hello FSM down",		SCSP_CAFSM_HELLO_DOWN },
	{ "CA received",		SCSP_CAFSM_CA_MSG },
	{ "CSU Solicit received",	SCSP_CAFSM_CSUS_MSG },
	{ "CSU Request received",	SCSP_CAFSM_CSU_REQ },
	{ "CSU Reply received",		SCSP_CAFSM_CSU_REPLY },
	{ "CA timer",			SCSP_CAFSM_CA_T },
	{ "CSUS timer",			SCSP_CAFSM_CSUS_T },
	{ "CSU timer",			SCSP_CAFSM_CSU_T },
	{ "Cache Update",		SCSP_CAFSM_CACHE_UPD },
	{ "Cache Response",		SCSP_CAFSM_CACHE_RSP },
	{ (char *)0,			0 }
};

static Type_name cifsm_state_names[] = {
	{ "Null",	SCSP_CIFSM_NULL },
	{ "Summarize",	SCSP_CIFSM_SUM },
	{ "Update",	SCSP_CIFSM_UPD },
	{ "Aligned",	SCSP_CIFSM_ALIGN },
	{ (char *)0,			0 }
};

static Type_name cifsm_event_names[] = {
	{ "CA FSM down",	SCSP_CIFSM_CA_DOWN },
	{ "CA FSM to Summarize",SCSP_CIFSM_CA_SUMM },
	{ "CA FSM to Update",	SCSP_CIFSM_CA_UPD },
	{ "CA FSM to Aligned",	SCSP_CIFSM_CA_ALIGN },
	{ "Solicit Rsp",	SCSP_CIFSM_SOL_RSP },
	{ "Update Req",		SCSP_CIFSM_UPD_REQ },
	{ "Update Rsp",		SCSP_CIFSM_UPD_RSP },
	{ "CSU Request",	SCSP_CIFSM_CSU_REQ },
	{ "CSU Reply",		SCSP_CIFSM_CSU_REPLY },
	{ "CSU Solicit",	SCSP_CIFSM_CSU_SOL },
	{ (char *)0,			0 }
};

static Type_name atmarp_state_names[] = {
	{ "New",	SCSP_ASTATE_NEW },
	{ "Updated",	SCSP_ASTATE_UPD },
	{ "Deleted",	SCSP_ASTATE_DEL },
	{ (char *)0,	0 }
};


/*
 * Initialize the indent string
 *
 * Arguments:
 *	none
 *
 * Returns:
 *	none
 *
 */
static void
init_indent()
{
	indent[0] = '\0';
}


/*
 * Increment the indent string
 *
 * Arguments:
 *	none
 *
 * Returns:
 *	none
 *
 */
static void
inc_indent()
{
	if (strlen(indent) >= MAX_INDENT)
		return;
	strcat(indent, "  ");
}


/*
 * Decrement the indent string
 *
 * Arguments:
 *	none
 *
 * Returns:
 *	none
 *
 */
static void
dec_indent()
{
	if (strlen(indent) < MIN_INDENT)
		return;
	indent[strlen(indent) - 2] = '\0';
}



/*
 * Search for a type in a name-type table
 *
 * Arguments:
 *	type	the value being searched for
 *	tbl	pointer to the table to search
 *
 * Returns:
 *	pointer to a string identifying the type
 *
 */
static char *
scsp_type_name(type, tbl)
	u_char	type;
	Type_name	*tbl;
{
	int	i;

	/*
	 * Search the table
	 */
	for (i = 0; tbl[i].name != (char *)0 && tbl[i].type != type;
			i++)
		;

	/*
	 * Check the result and return the appropriate value
	 */
	if (tbl[i].name)
		return(tbl[i].name);
	else
		return("-");
}


/*
 * Format a Hello FSM state name
 *
 * Arguments:
 *	state	the state
 *
 * Returns:
 *	pointer to a string identifying the state
 *
 */
char *
format_hfsm_state(state)
	int	state;
{
	return(scsp_type_name((u_char)state, hfsm_state_names));
}


/*
 * Format a Hello FSM event name
 *
 * Arguments:
 *	event	the event
 *
 * Returns:
 *	pointer to a string identifying the event
 *
 */
char *
format_hfsm_event(event)
	int	event;
{
	char	*cp;

	cp = scsp_type_name((u_char)event, hfsm_event_names);
	return(cp);
}


/*
 * Format a CA FSM state name
 *
 * Arguments:
 *	state	the state
 *
 * Returns:
 *	pointer to a string identifying the state
 *
 */
char *
format_cafsm_state(state)
	int	state;
{
	return(scsp_type_name((u_char)state, cafsm_state_names));
}


/*
 * Format a CA FSM event name
 *
 * Arguments:
 *	event	the event
 *
 * Returns:
 *	pointer to a string identifying the event
 *
 */
char *
format_cafsm_event(event)
	int	event;
{
	return(scsp_type_name((u_char)event, cafsm_event_names));
}


/*
 * Format a client interface FSM state name
 *
 * Arguments:
 *	state	the state
 *
 * Returns:
 *	pointer to a string identifying the state
 *
 */
char *
format_cifsm_state(state)
	int	state;
{
	return(scsp_type_name((u_char)state, cifsm_state_names));
}


/*
 * Format a client interface FSM event name
 *
 * Arguments:
 *	event	the event
 *
 * Returns:
 *	pointer to a string identifying the event
 *
 */
char *
format_cifsm_event(event)
	int	event;
{
	return(scsp_type_name((u_char)event, cifsm_event_names));
}


/*
 * Print a Sender or Receiver ID structure
 *
 * Arguments:
 *	fp	file to print message to
 *	idp	pointer to ID to be printed
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_id(fp, idp)
	FILE	*fp;
	Scsp_id	*idp;
{
	int	i;

	inc_indent();
	fprintf(fp, "%sNext:                 0x%x\n", indent,
			(u_long)idp->next);
	fprintf(fp, "%sLength:               %d\n", indent,
			idp->id_len);
	fprintf(fp, "%sID:                   0x", indent);
	for (i = 0; i < idp->id_len; i++)
		fprintf(fp, "%02x ", idp->id[i]);
	fprintf(fp, "\n");
	dec_indent();
}


/*
 * Print a Cache Key structure
 *
 * Arguments:
 *	fp	file to print message to
 *	ckp	pointer to cache key structure
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_cache_key(fp, ckp)
	FILE		*fp;
	Scsp_ckey	*ckp;
{
	int	i;

	inc_indent();
	fprintf(fp, "%sLength:               %d\n", indent,
			ckp->key_len);
	fprintf(fp, "%sKey:                  0x", indent);
	for (i = 0; i < ckp->key_len; i++)
		fprintf(fp, "%02x ", ckp->key[i]);
	fprintf(fp, "\n");
	dec_indent();
}


/*
 * Print the mandatory common part of a message
 *
 * Arguments:
 *	fp	file to print message to
 *	mcp	pointer to mandatory common part structure
 *
 * Returns:
 *	none
 *
 */
static void
print_scsp_mcp(fp, mcp)
	FILE		*fp;
	Scsp_mcp	*mcp;
{
	inc_indent();
	fprintf(fp, "%sProtocol ID:          %s (0x%02x)\n", indent,
			scsp_type_name(mcp->pid, proto_types),
			mcp->pid);
	fprintf(fp, "%sServer Group ID:      %d\n", indent, mcp->sgid);
	fprintf(fp, "%sFlags:                0x%04x\n", indent,
			mcp->flags);
	fprintf(fp, "%sRecord Count:         %d\n", indent,
			mcp->rec_cnt);
	fprintf(fp, "%sSender ID:\n", indent);
	print_scsp_id(fp, &mcp->sid);
	fprintf(fp, "%sReceiver ID:\n", indent);
	print_scsp_id(fp, &mcp->rid);
	dec_indent();
}


/*
 * Print an extension
 *
 * Arguments:
 *	fp	file to print message to
 *	exp	pointer to extension
 *
 * Returns:
 *	none
 *
 */
static void
print_scsp_ext(fp, exp)
	FILE		*fp;
	Scsp_ext	*exp;
{
	int	i;
	u_char	*cp;

	inc_indent();
	fprintf(fp, "%sNext:                 0x%x\n", indent,
			exp->next);
	fprintf(fp, "%sType:                 %s (0x%02x)\n", indent,
			scsp_type_name(exp->type, ext_types),
			exp->type);
	fprintf(fp, "%sLength:               %d\n", indent, exp->len);
	if (exp->len) {
		fprintf(fp, "%sValue:                0x", indent);
		cp = (u_char *)((caddr_t)exp + sizeof(Scsp_ext));
		for (i = 0; i < exp->len; i++)
			fprintf(fp, "%02x ", *cp++);
		fprintf(fp, "\n");
	}
	dec_indent();
}


/*
 * Print an ATMARP Cache State Advertisement record
 *
 * Arguments:
 *	fp	file to print message to
 *	acsp	pointer to extension
 *
 * Returns:
 *	none
 *
 */
static void
print_scsp_atmarp_csa(fp, acsp)
	FILE		*fp;
	Scsp_atmarp_csa	*acsp;
{
	inc_indent();
	fprintf(fp, "%sState:                 %s (%d)\n", indent,
			scsp_type_name(acsp->sa_state,
				atmarp_state_names),
			acsp->sa_state);
	fprintf(fp, "%sSource ATM addr:       %s\n", indent,
			format_atm_addr(&acsp->sa_sha));
	fprintf(fp, "%sSource ATM subaddr:    %s\n", indent,
			format_atm_addr(&acsp->sa_ssa));
	fprintf(fp, "%sSource IP addr:        %s\n", indent,
			format_ip_addr(&acsp->sa_spa));
	fprintf(fp, "%sTarget ATM addr:       %s\n", indent,
			format_atm_addr(&acsp->sa_tha));
	fprintf(fp, "%sTarget ATM subaddr:    %s\n", indent,
			format_atm_addr(&acsp->sa_tsa));
	fprintf(fp, "%sTarget IP addr:        %s\n", indent,
			format_ip_addr(&acsp->sa_tpa));
	dec_indent();
}


/*
 * Print a Cache State Advertisement record or
 * Cache State Advertisement Summary record
 *
 * Arguments:
 *	fp	file to print message to
 *	csap	pointer to CSA or CSAS
 *
 * Returns:
 *	none
 *
 */
static void
print_scsp_csa(fp, csap)
	FILE		*fp;
	Scsp_csa	*csap;
{
	inc_indent();
	fprintf(fp, "%sNext:                 0x%x\n", indent,
			(u_long)csap->next);
	fprintf(fp, "%sHops:                 %d\n", indent, csap->hops);
	fprintf(fp, "%sNull Flag:            %s\n", indent,
			csap->null ? "True" : "False");
	fprintf(fp, "%sSequence no.:         %d (0x%x)\n",
			indent, csap->seq, csap->seq);
	fprintf(fp, "%sCache Key:\n", indent);
	print_scsp_cache_key(fp, &csap->key);
	fprintf(fp, "%sOriginator ID:\n", indent);
	print_scsp_id(fp, &csap->oid);
	if (csap->atmarp_data) {
		fprintf(fp, "%sATMARP data:\n", indent);
		print_scsp_atmarp_csa(fp, csap->atmarp_data);
	}
	dec_indent();
}


/*
 * Print a Cache Alignment message
 *
 * Arguments:
 *	fp	file to print message to
 *	cap	pointer to extension
 *
 * Returns:
 *	none
 *
 */
static void
print_scsp_ca(fp, cap)
	FILE	*fp;
	Scsp_ca	*cap;
{
	int		n;
	Scsp_csa	*csap;

	inc_indent();
	fprintf(fp, "%sCA Seq. No.:          %d\n", indent,
			cap->ca_seq);
	fprintf(fp, "%sM bit:                %s\n", indent,
			cap->ca_m ? "True" : "False");
	fprintf(fp, "%sI bit:                %s\n", indent,
			cap->ca_i ? "True" : "False");
	fprintf(fp, "%sO bit:                %s\n", indent,
			cap->ca_o ? "True" : "False");
	fprintf(fp, "%sMandatory Common Part:\n", indent);
	print_scsp_mcp(fp, &cap->ca_mcp);
	for (csap = cap->ca_csa_rec, n = 1; csap;
			csap = csap->next, n++) {
		fprintf(fp, "%sCSA Record %d (0x%x):\n", indent, n,
				(u_long)csap);
		print_scsp_csa(fp, csap);
	}
	dec_indent();
}


/*
 * Print a Cache State Update Request, Cache State Update Reply, or
 * Cache State Update Solicit message
 *
 * Arguments:
 *	fp	file to print message to
 *	csup	pointer to CSU message
 *
 * Returns:
 *	none
 *
 */
static void
print_scsp_csu(fp, csup)
	FILE		*fp;
	Scsp_csu_msg	*csup;
{
	int		i;
	Scsp_csa	*csap;

	inc_indent();
	fprintf(fp, "%sMandatory Common Part:\n", indent);
	print_scsp_mcp(fp, &csup->csu_mcp);
	for (csap = csup->csu_csa_rec, i = 1; csap;
			csap = csap->next, i++) {
		fprintf(fp, "%sCSA Record %d:\n", indent, i);
		print_scsp_csa(fp, csap);
	}
	dec_indent();
}


/*
 * Print a Hello message
 *
 * Arguments:
 *	fp	file to print message to
 *	hp	pointer to hello message
 *
 * Returns:
 *	none
 *
 */
static void
print_scsp_hello(fp, hp)
	FILE		*fp;
	Scsp_hello	*hp;
{
	Scsp_id	*ridp;

	inc_indent();
	fprintf(fp, "%sHello Interval:       %d\n", indent,
			hp->hello_int);
	fprintf(fp, "%sDead Factor:          %d\n", indent,
			hp->dead_factor);
	fprintf(fp, "%sFamily ID:            %d\n", indent,
			hp->family_id);
	fprintf(fp, "%sMandatory Common Part:\n", indent);
	print_scsp_mcp(fp, &hp->hello_mcp);
	ridp = hp->hello_mcp.rid.next;
	if (ridp) {
		fprintf(fp, "%sAdditional Receiver IDs:\n", indent);
		for (; ridp; ridp = ridp->next)
			print_scsp_id(fp, ridp);
	}
	dec_indent();
}


#ifdef NOTDEF
/*
 * NHRP-specific Cache State Advertisement record
 */
struct scsp_nhrp_csa {
	u_char	req_id;			/* Request ID */
	u_char	state;			/* State */
	u_char	pref_len;		/* Prefix length */
	u_short	flags;			/* See below */
	u_short	mtu;			/* Maximim transmission unit */
	u_short	hold_time;		/* Entry holding time */
	u_char	caddr_tlen;		/* Client addr type/length */
	u_char	csaddr_tlen;		/* Client subaddr type/length */
	u_char	cproto_len;		/* Client proto addr length */
	u_char	pref;			/* Preference */
	Atm_addr	caddr;		/* Client address */
	Atm_addr	csaddr;		/* Client subaddress */
	struct in_addr	cproto_addr;	/* Client protocol address */
};
typedef	struct scsp_nhrp	Scsp_nhrp;

#define	SCSP_NHRP_UNIQ	0x8000
#define	SCSP_NHRP_ARP	0x4000

#endif


/*
 * Print an SCSP message
 *
 * Arguments:
 *	fp	file to print message to
 *	msg	pointer to message to be printed
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_msg(fp, msg)
	FILE		*fp;
	Scsp_msg	*msg;
{
	int		n;
	Scsp_ext	*exp;

	/*
	 * Initialize
	 */
	init_indent();

	/*
	 * Print the message type
	 */
	inc_indent();
	fprintf(fp, "%sMessage type:         %s (0x%02x)\n", indent,
			scsp_type_name(msg->sc_msg_type, msg_types),
			msg->sc_msg_type);

	/*
	 * Print the body of the message
	 */
	switch(msg->sc_msg_type) {
	case SCSP_CA_MSG:
		print_scsp_ca(fp, msg->sc_ca);
		break;
	case SCSP_CSU_REQ_MSG:
	case SCSP_CSU_REPLY_MSG:
	case SCSP_CSUS_MSG:
		print_scsp_csu(fp, msg->sc_csu_msg);
		break;
	case SCSP_HELLO_MSG:
		print_scsp_hello(fp, msg->sc_hello);
		break;
	}

	/*
	 * Print any extensions
	 */
	for (exp = msg->sc_ext, n = 1; exp; exp = exp->next, n++) {
		fprintf(fp, "%sExtension %d:\n", indent, n);
		print_scsp_ext(fp, exp);
	}
	dec_indent();

	(void)fflush(fp);
}


/*
 * Print an SCSP ATMARP message
 *
 * Arguments:
 *	fp	file to print message to
 *	acp	pointer to ATMARP message
 *
 * Returns:
 *	none
 *
 */
static void
print_scsp_if_atmarp(fp, amp)
	FILE		*fp;
	Scsp_atmarp_msg	*amp;
{
	inc_indent();
	fprintf(fp, "%sState:                %s (%d)\n", indent,
			scsp_type_name(amp->sa_state,
				atmarp_state_names),
			amp->sa_state);
	fprintf(fp, "%sCached protocol addr: %s\n", indent,
			format_ip_addr(&amp->sa_cpa));
	fprintf(fp, "%sCached ATM addr:      %s\n", indent,
			format_atm_addr(&amp->sa_cha));
	fprintf(fp, "%sCached ATM subaddr:      %s\n", indent,
			format_atm_addr(&amp->sa_csa));
	fprintf(fp, "%sCache key:\n", indent);
	print_scsp_cache_key(fp, &amp->sa_key);
	fprintf(fp, "%sOriginator ID:\n", indent);
	print_scsp_id(fp, &amp->sa_oid);
	fprintf(fp, "%sSequence number:         %d (0x%08x)\n", indent,
			amp->sa_seq, (u_long)amp->sa_seq);
	dec_indent();
}


/*
 * Print an SCSP client interface message
 *
 * Arguments:
 *	fp	file to print message to
 *	imsg	pointer to message to be printed
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_if_msg(fp, imsg)
	FILE		*fp;
	Scsp_if_msg	*imsg;
{
	int		len;
	Scsp_atmarp_msg	*ap;

	/*
	 * Initialize
	 */
	init_indent();
	fprintf(fp, "SCSP Client Interface Message at 0x%x\n",
			(u_long)imsg);

	/*
	 * Print the message header
	 */
	inc_indent();
	fprintf(fp, "%sMessage type:         %s (0x%02x)\n", indent,
			scsp_type_name(imsg->si_type, if_msg_types),
			imsg->si_type);
	fprintf(fp, "%sResponse code:        %d\n", indent,
			imsg->si_rc);
	fprintf(fp, "%sProtocol type:        %s (%d)\n", indent,
			scsp_type_name(imsg->si_proto, proto_types),
			imsg->si_proto);
	fprintf(fp, "%sLength:               %d\n", indent,
			imsg->si_len);
	fprintf(fp, "%sToken:                0x%x\n", indent,
			imsg->si_tok);

	/*
	 * Print the body of the message
	 */
	switch(imsg->si_type) {
	case SCSP_CFG_REQ:
		fprintf(fp, "%sInterface:            %s\n", indent,
				imsg->si_cfg.atmarp_netif);
		break;
	case SCSP_CACHE_RSP:
	case SCSP_UPDATE_IND:
	case SCSP_UPDATE_REQ:
		len = imsg->si_len - sizeof(Scsp_if_msg_hdr);
		ap = &imsg->si_atmarp;
		while (len) {
			switch(imsg->si_proto) {
			case SCSP_PROTO_ATMARP:
				fprintf(fp, "%sATMARP CSA:\n", indent);
				print_scsp_if_atmarp(fp, ap);
				len -= sizeof(Scsp_atmarp_msg);
				ap++;
				break;
			case SCSP_PROTO_NHRP:
			case SCSP_PROTO_MARS:
			case SCSP_PROTO_DHCP:
			case SCSP_PROTO_LNNI:
			default:
				fprintf(fp, "Protocol type not implemented\n");
				break;
			}
		}
		break;
	}
	dec_indent();

	(void)fflush(fp);
}


/*
 * Print an SCSP pending connection block
 *
 * Arguments:
 *	fp	file to print message to
 *	pp	pointer to pending control block
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_pending(fp, pp)
	FILE		*fp;
	Scsp_pending	*pp;
{
	/*
	 * Initialize
	 */
	init_indent();

	/*
	 * Print a header
	 */
	fprintf(fp, "Pending control block at 0x%x\n", (u_long)pp);

	/*
	 * Print the fields of the control block
	 */
	inc_indent();
	fprintf(fp, "%sNext:                 0x%x\n", indent,
			(u_long)pp->sp_next);
	fprintf(fp, "%sSocket:               %d\n", indent,
			pp->sp_sock);

	dec_indent();
}


/*
 * Print an SCSP server control block
 *
 * Arguments:
 *	fp	file to print message to
 *	ssp	pointer to server control block
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_server(fp, ssp)
	FILE		*fp;
	Scsp_server	*ssp;
{
	/*
	 * Initialize
	 */
	init_indent();

	/*
	 * Print a header
	 */
	fprintf(fp, "Server control block at 0x%x\n", (u_long)ssp);

	/*
	 * Print the fields of the client control block
	 */
	inc_indent();
	fprintf(fp, "%sNext:                 0x%x\n", indent,
			ssp->ss_next);
	fprintf(fp, "%sName:                 %s\n", indent,
			ssp->ss_name);
	fprintf(fp, "%sNetwork Interface:    %s\n", indent,
			ssp->ss_intf);
	fprintf(fp, "%sState:                %d\n", indent,
			ssp->ss_state);
	fprintf(fp, "%sProtocol ID:          0x%x\n", indent,
			ssp->ss_pid);
	fprintf(fp, "%sID length:            %d\n", indent,
			ssp->ss_id_len);
	fprintf(fp, "%sCache key length:     %d\n", indent,
			ssp->ss_ckey_len);
	fprintf(fp, "%sServer Group ID:      0x%x\n", indent,
			ssp->ss_sgid);
	fprintf(fp, "%sFamily ID:            0x%x\n", indent,
			ssp->ss_fid);
	fprintf(fp, "%sSocket:               %d\n", indent,
			ssp->ss_sock);
	fprintf(fp, "%sDCS Listen Socket:    %d\n", indent,
			ssp->ss_dcs_lsock);
	fprintf(fp, "%sLocal Server ID:\n", indent);
	print_scsp_id(fp, &ssp->ss_lsid);
	fprintf(fp, "%sATM address:          %s\n", indent,
			format_atm_addr(&ssp->ss_addr));
	fprintf(fp, "%sATM subaddress:       %s\n", indent,
			format_atm_addr(&ssp->ss_subaddr));
	fprintf(fp, "%sInterface MTU:        %d\n", indent,
			ssp->ss_mtu);
	fprintf(fp, "%sMark:                 %d\n", indent,
			ssp->ss_mark);
	dec_indent();
}


/*
 * Print an SCSP client cache summary entry control block
 *
 * Arguments:
 *	fp	file to print message to
 *	csep	pointer to summary entry
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_cse(fp, csep)
	FILE		*fp;
	Scsp_cse	*csep;
{
	/*
	 * Print the fields of the cache summary entry
	 */
	inc_indent();
	fprintf(fp, "%sNext CSE:             0x%x\n", indent,
			(u_long)csep->sc_next);
	fprintf(fp, "%sCSA sequence no.:     %d (0x%x)\n", indent,
			csep->sc_seq, csep->sc_seq);
	fprintf(fp, "%sCache key:\n", indent);
	print_scsp_cache_key(fp, &csep->sc_key);
	fprintf(fp, "%sOrigin ID:\n", indent);
	print_scsp_id(fp, &csep->sc_oid);
	dec_indent();
}


/*
 * Print an SCSP CSU Request retransmission control block
 *
 * Arguments:
 *	fp	file to print message to
 *	csurp	pointer to retransmission entry
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_csu_rexmt(fp, rxp)
	FILE		*fp;
	Scsp_csu_rexmt	*rxp;
{
	int		i;
	Scsp_csa	*csap;

	inc_indent();
	fprintf(fp, "%sNext CSU Req rexmt:   0x%x\n", indent,
			(u_long)rxp->sr_next);
	fprintf(fp, "%sDCS address:          0x%x\n", indent,
			(u_long)rxp->sr_dcs);
	for (csap = rxp->sr_csa, i = 1; csap;
			csap = csap->next, i++) {
		fprintf(fp, "%sCSA %d:\n", indent, i);
		print_scsp_csa(fp, csap);
	}
	dec_indent();
}


/*
 * Print an SCSP DCS control block
 *
 * Arguments:
 *	fp	file to print message to
 *	dcsp	pointer to DCS control block
 *
 * Returns:
 *	none
 *
 */
void
print_scsp_dcs(fp, dcsp)
	FILE		*fp;
	Scsp_dcs	*dcsp;
{
	Scsp_csa	*csap;
	Scsp_cse	*csep;
	Scsp_csu_rexmt	*rxp;

	/*
	 * Initialize
	 */
	init_indent();

	/*
	 * Print a header
	 */
	fprintf(fp, "DCS control block at 0x%x\n", (u_long)dcsp);

	/*
	 * Print the fields of the DCS control block
	 */
	inc_indent();
	fprintf(fp, "%sNext DCS block:       0x%x\n", indent,
			(u_long)dcsp->sd_next);
	fprintf(fp, "%sServer control block: 0x%x\n", indent,
			(u_long)dcsp->sd_server);
	fprintf(fp, "%sDCS ID:\n", indent);
	print_scsp_id(fp, &dcsp->sd_dcsid);
	fprintf(fp, "%sDCS address:          %s\n", indent,
			format_atm_addr(&dcsp->sd_addr));
	fprintf(fp, "%sDCS subaddress        %s\n", indent,
			format_atm_addr(&dcsp->sd_subaddr));
	fprintf(fp, "%sSocket:               %d\n", indent,
			dcsp->sd_sock);
	fprintf(fp, "%sOpen VCC Retry Timer:\n", indent);
	fprintf(fp, "%sHello FSM State:      %s\n", indent,
			format_hfsm_state(dcsp->sd_hello_state));
	fprintf(fp, "%sHello Interval:       %d\n", indent,
			dcsp->sd_hello_int);
	fprintf(fp, "%sHello Dead Factor:    %d\n", indent,
			dcsp->sd_hello_df);
	fprintf(fp, "%sHello Rcvd:           %d\n", indent,
			dcsp->sd_hello_rcvd);
	fprintf(fp, "%sCA FSM State:         %s\n", indent,
			format_cafsm_state(dcsp->sd_ca_state));
	fprintf(fp, "%sCA Seq. No.:          0x%x\n", indent,
			dcsp->sd_ca_seq);
	fprintf(fp, "%sCA Rexmit Int:        %d\n", indent,
			dcsp->sd_ca_rexmt_int);
	fprintf(fp, "%sCA Retransmit Msg:    0x%x\n", indent,
			(u_long)dcsp->sd_ca_rexmt_msg);
	fprintf(fp, "%sCSASs to send:        ", indent);
	if (dcsp->sd_ca_csas == (Scsp_cse *)0) {
		fprintf(fp, "Empty\n");
	} else {
		fprintf(fp, "0x%x\n", (u_long) dcsp->sd_ca_csas);
	}
	fprintf(fp, "%sCSUS Rexmit Int:      %d\n", indent,
			dcsp->sd_csus_rexmt_int);
	fprintf(fp, "%sCache Request List:   ", indent);
	if (dcsp->sd_crl == (Scsp_csa *)0) {
		fprintf(fp, "Empty\n");
	} else {
		fprintf(fp, "0x%x\n", dcsp->sd_crl);
	}
	fprintf(fp, "%sCSUS Rexmit Msg:      0x%x\n", indent,
			(u_long)dcsp->sd_csus_rexmt_msg);
	fprintf(fp, "%sCSA Hop count:        %d\n", indent,
			dcsp->sd_hops);
	fprintf(fp, "%sCSAs Pending ACK:     0x%x\n", indent,
			(u_long)dcsp->sd_csu_ack_pend);
	fprintf(fp, "%sCSAs ACKed:           0x%x\n", indent,
			(u_long)dcsp->sd_csu_ack);
	fprintf(fp, "%sCSU Req Rexmit Int:   %d\n", indent,
			dcsp->sd_csu_rexmt_int);
	fprintf(fp, "%sCSU Req Rexmit Max:   %d\n", indent,
			dcsp->sd_csu_rexmt_max);
	fprintf(fp, "%sCSU Req Rexmit Queue  ", indent);
	if (!dcsp->sd_csu_rexmt) {
		fprintf(fp, "Empty\n");
	} else {
		fprintf(fp, "0x%x\n", (u_long)dcsp->sd_csu_rexmt);
	}
	fprintf(fp, "%sClient I/F state:     %d\n", indent,
			dcsp->sd_client_state);

	/*
	 * Print the list of CSASs waiting to be sent
	 */
	if (dcsp->sd_ca_csas) {
		fprintf(fp, "\n%sCSASs to send:", indent);
		inc_indent();
		for (csep = dcsp->sd_ca_csas; csep;
				csep = csep->sc_next) {
			fprintf(fp, "%sCache summary entry at 0x%x\n",
					indent,
					(u_long)csep);
			print_scsp_cse(fp, csep);
		}
		dec_indent();
	}

	/*
	 * Print the Cache Request List
	 */
	if (dcsp->sd_crl) {
		fprintf(fp, "\n%sCache Request List:\n", indent);
		inc_indent();
		for (csap = dcsp->sd_crl; csap; csap = csap->next) {
			fprintf(fp, "%sCSA at 0x%x\n", indent,
					(u_long)csap);
			print_scsp_csa(fp, csap);
		}
		dec_indent();
	}

	/*
	 * Print the CSU retransmit queue
	 */
	if (dcsp->sd_csu_rexmt) {
		fprintf(fp, "\n%sCSU Req Rexmit Queue:\n", indent);
		inc_indent();
		for (rxp = dcsp->sd_csu_rexmt; rxp;
				rxp = rxp->sr_next) {
			fprintf(fp, "%sCSU Rexmit Block at 0x%x\n",
					indent, (u_long)csap);
			print_scsp_csu_rexmt(fp, rxp);
		}
		dec_indent();
	}

	dec_indent();
}


/*
 * Print SCSP's control blocks
 *
 * Arguments:
 *	none
 *
 * Returns:
 *	None
 *
 */
void
print_scsp_dump()
{
	int		i;
	Scsp_server	*ssp;
	Scsp_dcs	*dcsp;
	Scsp_cse	*scp;
	Scsp_csu_rexmt	*rxp;
	Scsp_pending	*pp;
	FILE		*df;
	char		fname[64];
	static int	dump_no = 0;

	/*
	 * Build a file name
	 */
	UM_ZERO(fname, sizeof(fname));
	sprintf(fname, "/tmp/scspd.%d.%03d.out", getpid(), dump_no++);

	/*
	 * Open the output file
	 */
	df = fopen(fname, "w");
	if (df == (FILE *)0)
		return;

	/*
	 * Dump the server control blocks
	 */
	for (ssp = scsp_server_head; ssp; ssp = ssp->ss_next) {
		print_scsp_server(df, ssp);
		fprintf(df, "\n");

		/*
		 * Print the client's cache summary
		 */
		for (i = 0; i < SCSP_HASHSZ; i++) {
			for (scp = ssp->ss_cache[i]; scp;
					scp = scp->sc_next) {
				print_scsp_cse(df, scp);
				fprintf(df, "\n");
			}
		}

		/*
		 * Print the client's DCS control blocks
		 */
		for (dcsp = ssp->ss_dcs; dcsp; dcsp = dcsp->sd_next) {
			print_scsp_dcs(df, dcsp);
			fprintf(df, "\n\n");
		}
		fprintf(df, "\n\n");
	}

	/*
	 * Print the pending connection blocks
	 */
	for (pp = scsp_pending_head; pp; pp = pp->sp_next) {
		print_scsp_pending(df, pp);
		fprintf(df, "\n");
	}

	/*
	 * Close the output file
	 */
	(void)fclose(df);
}