NetBSD/sys/netccitt/llc_subr.c

/*	$NetBSD: llc_subr.c,v 1.4 1996/02/13 22:04:51 christos Exp $	*/

/* 
 * Copyright (C) Dirk Husemann, Computer Science Department IV, 
 * 		 University of Erlangen-Nuremberg, Germany, 1990, 1991, 1992
 * Copyright (c) 1992, 1993
 *	The Regents of the University of California.  All rights reserved.
 * 
 * This code is derived from software contributed to Berkeley by
 * Dirk Husemann and the Computer Science Department (IV) of
 * the University of Erlangen-Nuremberg, Germany.
 *
 * 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 acknowledgement:
 *	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.
 *
 *	@(#)llc_subr.c	8.1 (Berkeley) 6/10/93
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/domain.h>
#include <sys/socket.h>
#include <sys/protosw.h>
#include <sys/socketvar.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/kernel.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_llc.h>
#include <net/route.h>

#include <netccitt/dll.h>
#include <netccitt/llc_var.h>

/*
 * Frame names for diagnostic messages
 */
char *frame_names[] = {
	"INFO", "RR", "RNR", "REJ", "DM", "SABME", "DISC",
	"UA", "FRMR", "UI", "XID", "TEST", "ILLEGAL", "TIMER", "N2xT1"
};


/*
 * Trace level
 */
int llc_tracelevel = LLCTR_URGENT;

/*
 * Values for accessing various bitfields
 */
struct bitslice llc_bitslice[] = {
	/* mask, shift value */
	{0x1, 0x0},
	{0xfe, 0x1},
	{0x3, 0x0},
	{0xc, 0x2},
	{0x10, 0x4},
	{0xe0, 0x5},
	{0x1f, 0x0}
};

/*
 * We keep the link control blocks on a doubly linked list -
 * primarily for checking in llc_time()
 */
struct llccb_q  llccb_q = {&llccb_q, &llccb_q};

/*
 * Flag for signalling wether route tree for AF_LINK has been
 * initialized yet.
 */

int af_link_rts_init_done = 0;


/*
 * Functions dealing with struct sockaddr_dl */

/* Compare sdl_a w/ sdl_b */
int
sdl_cmp(sdl_a, sdl_b)
	struct sockaddr_dl *sdl_a;
	struct sockaddr_dl *sdl_b;
{
	if (LLADDRLEN(sdl_a) != LLADDRLEN(sdl_b))
		return (1);
	return (bcmp((caddr_t) sdl_a->sdl_data, (caddr_t) sdl_b->sdl_data,
		     LLADDRLEN(sdl_a)));
}

/* Copy sdl_f to sdl_t */
void
sdl_copy(sdl_f, sdl_t)
	struct sockaddr_dl *sdl_f;
	struct sockaddr_dl *sdl_t;
{
	bcopy((caddr_t) sdl_f, (caddr_t) sdl_t, sdl_f->sdl_len);
}

/* Swap sdl_a w/ sdl_b */
void
sdl_swapaddr(sdl_a, sdl_b)
	struct sockaddr_dl *sdl_a;
	struct sockaddr_dl *sdl_b;
{
	struct sockaddr_dl sdl_tmp;

	sdl_copy(sdl_a, &sdl_tmp);
	sdl_copy(sdl_b, sdl_a);
	sdl_copy(&sdl_tmp, sdl_b);
}

/* Fetch the sdl of the associated if */
struct sockaddr_dl *
sdl_getaddrif(ifp)
	struct ifnet *ifp;
{
	register struct ifaddr *ifa;

	for (ifa = ifp->if_addrlist.tqh_first; ifa != 0;
	     ifa = ifa->ifa_list.tqe_next)
		if (ifa->ifa_addr->sa_family == AF_LINK)
			return ((struct sockaddr_dl *) (ifa->ifa_addr));

	return ((struct sockaddr_dl *) 0);
}

/* Check addr of interface with the one given */
int
sdl_checkaddrif(ifp, sdl_c)
	struct ifnet *ifp;
	struct sockaddr_dl *sdl_c;
{
	register struct ifaddr *ifa;

	for (ifa = ifp->if_addrlist.tqh_first; ifa != 0;
	     ifa = ifa->ifa_list.tqe_next)
		if (ifa->ifa_addr->sa_family == AF_LINK &&
		    !sdl_cmp((struct sockaddr_dl *) (ifa->ifa_addr), sdl_c))
			return (1);

	return (0);
}

/* Build an sdl from MAC addr, DLSAP addr, and interface */
int
sdl_setaddrif(ifp, mac_addr, dlsap_addr, mac_len, sdl_to)
	struct ifnet *ifp;
	u_char *mac_addr;
	u_char dlsap_addr;
        u_char mac_len;
	struct sockaddr_dl *sdl_to;
{
	register struct sockaddr_dl *sdl_tmp;

	if ((sdl_tmp = sdl_getaddrif(ifp))) {
		sdl_copy(sdl_tmp, sdl_to);
		bcopy((caddr_t) mac_addr, (caddr_t) LLADDR(sdl_to), mac_len);
		*(LLADDR(sdl_to) + mac_len) = dlsap_addr;
		sdl_to->sdl_alen = mac_len + 1;
		return (1);
	} else
		return (0);
}

/* Fill out the sdl header aggregate */
int
sdl_sethdrif(ifp, mac_src, dlsap_src, mac_dst, dlsap_dst, mac_len, sdlhdr_to)
	struct ifnet *ifp;
	u_char *mac_src;
	u_char dlsap_src;
	u_char *mac_dst;
	u_char dlsap_dst;
	u_char mac_len;
	struct sdl_hdr *sdlhdr_to;
{
	if (!sdl_setaddrif(ifp, mac_src, dlsap_src, mac_len,
			   &sdlhdr_to->sdlhdr_src) ||
	    !sdl_setaddrif(ifp, mac_dst, dlsap_dst, mac_len,
			   &sdlhdr_to->sdlhdr_dst))
		return (0);
	else
		return (1);
}

static struct sockaddr_dl sap_saddr;
static struct sockaddr_dl sap_sgate = {
	sizeof(struct sockaddr_dl),	/* _len */
	AF_LINK				/* _af */
};

/*
 * Set sapinfo for SAP address, llcconfig, af, and interface
 */
struct npaidbentry *
llc_setsapinfo(ifp, af, sap, llconf)
	struct ifnet *ifp;
	u_char af;
	u_char sap;
	struct dllconfig* llconf;
{
	struct protosw *pp;
	struct sockaddr_dl *ifdl_addr;
	struct rtentry *sirt = (struct rtentry *) 0;
	struct npaidbentry *sapinfo;
	u_char          saploc;
	int             size = sizeof(struct npaidbentry);

	USES_AF_LINK_RTS;

	/*
	 * We rely/assume that only STREAM protocols will make use of
	 * connection oriented LLC2. If this will one day not be the case
	 * this will obviously fail.
	 */
	pp = pffindtype(af, SOCK_STREAM);
	if (pp == 0 || pp->pr_input == 0 || pp->pr_ctlinput == 0) {
		printf("network	level protosw error");
		return 0;
	}
	/*
	 * We need a way to jot down the LLC2 configuration for
	 * a certain LSAP address. To do this we enter
	 * a "route" for the SAP.
	 */
	ifdl_addr = sdl_getaddrif(ifp);
	sdl_copy(ifdl_addr, &sap_saddr);
	sdl_copy(ifdl_addr, &sap_sgate);
	saploc = LLSAPLOC(&sap_saddr, ifp);
	sap_saddr.sdl_data[saploc] = sap;
	sap_saddr.sdl_alen++;

	/* now enter it */
	rtrequest(RTM_ADD, (struct sockaddr *) & sap_saddr,
		  (struct sockaddr *) & sap_sgate, 0, 0, &sirt);
	if (sirt == 0)
		return 0;

	/* Plug in config information in rt->rt_llinfo */

	sirt->rt_llinfo = malloc(size, M_PCB, M_WAITOK);
	sapinfo = (struct npaidbentry *) sirt->rt_llinfo;
	if (sapinfo) {
		bzero((caddr_t) sapinfo, size);
		/*
		 * For the time being we support LLC CLASS II here 	 only
		 */
		sapinfo->si_class = LLC_CLASS_II;
		sapinfo->si_window = llconf->dllcfg_window;
		sapinfo->si_trace = llconf->dllcfg_trace;
		if (sapinfo->si_trace)
			llc_tracelevel--;
		else
			llc_tracelevel++;
		sapinfo->si_input = pp->pr_input;
		sapinfo->si_ctlinput = pp->pr_ctlinput;

		return (sapinfo);
	}
	return 0;
}

/*
 * Get sapinfo for SAP address and interface
 */
struct npaidbentry *
llc_getsapinfo(sap, ifp)
	u_char sap;
	struct ifnet *ifp;
{
	struct sockaddr_dl *ifdl_addr;
	struct sockaddr_dl si_addr;
	struct rtentry *sirt;
	u_char          saploc;

	USES_AF_LINK_RTS;

	ifdl_addr = sdl_getaddrif(ifp);
	sdl_copy(ifdl_addr, &si_addr);
	saploc = LLSAPLOC(&si_addr, ifp);
	si_addr.sdl_data[saploc] = sap;
	si_addr.sdl_alen++;

	if ((sirt = rtalloc1((struct sockaddr *) & si_addr, 0)))
		sirt->rt_refcnt--;
	else
		return (0);

	return ((struct npaidbentry *) sirt->rt_llinfo);
}

/*
 * llc_seq2slot() --- We only allocate enough memory to hold the window. This
 * introduces the necessity to keep track of two ``pointers''
 *
 *        o llcl_freeslot     the next free slot to be used
 *                            this one advances modulo llcl_window
 *        o llcl_projvs       the V(S) associated with the next frame
 *                            to be set via llcl_freeslot
 *                            this one advances modulo LLC_MAX_SEQUENCE
 *
 * A new frame is inserted at llcl_output_buffers[llcl_freeslot], after
 * which both llcl_freeslot and llcl_projvs are incremented.
 *
 * The slot sl(sn) for any given sequence number sn is given by
 *
 *        sl(sn) = (llcl_freeslot + llcl_window - 1 - (llcl_projvs +
 *                  LLC_MAX_SEQUENCE- sn) % LLC_MAX_SEQUENCE) %
 *                  llcl_window
 *
 * i.e. we first calculate the number of frames we need to ``go back''
 * from the current one (really the next one, but that doesn't matter as
 * llcl_projvs is likewise of by plus one) and subtract that from the
 * pointer to the most recently taken frame (llcl_freeslot - 1).
 */

short
llc_seq2slot(linkp, seqn)
	struct llc_linkcb *linkp;
	short seqn;
{
	register        sn = 0;

	sn = (linkp->llcl_freeslot + linkp->llcl_window -
	      (linkp->llcl_projvs + LLC_MAX_SEQUENCE - seqn) %
	      LLC_MAX_SEQUENCE) % linkp->llcl_window;

	return sn;
}

/*
 * LLC2 link state handler
 *
 * There is in most cases one function per LLC2 state. The LLC2 standard
 * ISO 8802-2 allows in some cases for ambiguities, i.e. we have the choice
 * to do one thing or the other. Right now I have just chosen one but have also
 * indicated the spot by "multiple possibilities". One could make the behavior
 * in those cases configurable, allowing the superuser to enter a profile word
 * (32/64 bits, whatever is needed) that would suit her needs [I quite like
 * that idea, perhaps I'll get around to it].
 *
 * [Preceeding each state handler function is the description as taken from
 * ISO 8802-2, section 7.9.2.1]
 */

/*
 * ADM --- The connection component is in the asynchronous disconnected mode.
 *         It can accept an SABME PDU from a remote LLC SSAP or, at the request
 *         of the service access point user, can initiate an SABME PDU
 *         transmission to a remote LLC DSAP, to establish a data link
 *         connection. It also responds to a DISC command PDU and to any
 *         command PDU with the P bit set to ``1''.
 */
int
llc_state_ADM(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case NL_CONNECT_REQUEST:
		llc_send(linkp, LLCFT_SABME, LLC_CMD, pollfinal);
		LLC_SETFLAG(linkp,P,pollfinal);
		LLC_SETFLAG(linkp,S,0);
		linkp->llcl_retry = 0;
		LLC_NEWSTATE(linkp,SETUP);
		break;
	case LLCFT_SABME + LLC_CMD:
		/*
		 * ISO 8802-2, table 7-1, ADM state says to set the P flag,
		 * yet this will cause an SABME [P] to be answered with an UA
		 * only, not an UA [F], all other `disconnected' states set
		 * the F flag, so ...
		 */
		LLC_SETFLAG(linkp,F,pollfinal);
		LLC_NEWSTATE(linkp,CONN);
		action = LLC_CONNECT_INDICATION;
		break;
	case LLCFT_DISC + LLC_CMD:
		llc_send(linkp, LLCFT_DM, LLC_RSP, pollfinal);
		break;
	default:
		if (cmdrsp == LLC_CMD && pollfinal == 1)
			llc_send(linkp, LLCFT_DM, LLC_RSP, 1);
		/* remain in ADM state */
	}

	return action;
}

/*
 * CONN --- The local connection component has received an SABME PDU from a
 *          remote LLC SSAP, and it is waiting for the local user to accept or
 *          refuse the connection.
 */
int
llc_state_CONN(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
        int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case NL_CONNECT_RESPONSE:
		llc_send(linkp, LLCFT_UA, LLC_RSP, LLC_GETFLAG(linkp,F));
		LLC_RESETCOUNTER(linkp);
		LLC_SETFLAG(linkp,P,0);
		LLC_SETFLAG(linkp,REMOTE_BUSY, 0);
		LLC_NEWSTATE(linkp,NORMAL);
		break;
	case NL_DISCONNECT_REQUEST:
		llc_send(linkp, LLCFT_DM, LLC_RSP, LLC_GETFLAG(linkp,F));
		LLC_NEWSTATE(linkp,ADM);
		break;
	case LLCFT_SABME + LLC_CMD:
		LLC_SETFLAG(linkp,F,pollfinal);
		break;
	case LLCFT_DM + LLC_RSP:
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
		/* all other frames effect nothing here */
	}

	return action;
}

/*
 * RESET_WAIT --- The local connection component is waiting for the local user
 *                 to indicate a RESET_REQUEST or a DISCONNECT_REQUEST.
 */
int
llc_state_RESET_WAIT(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case NL_RESET_REQUEST:
		if (LLC_GETFLAG(linkp,S) == 0) {
			llc_send(linkp, LLCFT_SABME, LLC_CMD, pollfinal);
			LLC_SETFLAG(linkp,P,pollfinal);
			LLC_START_ACK_TIMER(linkp);
			linkp->llcl_retry = 0;
			LLC_NEWSTATE(linkp,RESET);
		} else {
			llc_send(linkp, LLCFT_UA, LLC_RSP,
				 LLC_GETFLAG(linkp,F));
			LLC_RESETCOUNTER(linkp);
			LLC_SETFLAG(linkp,P,0);
			LLC_SETFLAG(linkp,REMOTE_BUSY,0);
			LLC_NEWSTATE(linkp,NORMAL);
			action = LLC_RESET_CONFIRM;
		}
		break;
	case NL_DISCONNECT_REQUEST:
		if (LLC_GETFLAG(linkp,S) == 0) {
			llc_send(linkp, LLCFT_DISC, LLC_CMD, pollfinal);
			LLC_SETFLAG(linkp,P,pollfinal);
			LLC_START_ACK_TIMER(linkp);
			linkp->llcl_retry = 0;
			LLC_NEWSTATE(linkp,D_CONN);
		} else {
			llc_send(linkp, LLCFT_DM, LLC_RSP,
				 LLC_GETFLAG(linkp,F));
			LLC_NEWSTATE(linkp,ADM);
		}
		break;
	case LLCFT_DM + LLC_RSP:
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	case LLCFT_SABME + LLC_CMD:
		LLC_SETFLAG(linkp,S,1);
		LLC_SETFLAG(linkp,F,pollfinal);
		break;
	case LLCFT_DISC + LLC_CMD:
		llc_send(linkp, LLCFT_DM, LLC_RSP, pollfinal);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	}

	return action;
}

/*
 * RESET_CHECK --- The local connection component is waiting for the local user
 *                 to accept or refuse a remote reset request.
 */
int
llc_state_RESET_CHECK(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case NL_RESET_RESPONSE:
		llc_send(linkp, LLCFT_UA, LLC_RSP, LLC_GETFLAG(linkp,F));
		LLC_RESETCOUNTER(linkp);
		LLC_SETFLAG(linkp,P,0);
		LLC_SETFLAG(linkp,REMOTE_BUSY,0);
		LLC_NEWSTATE(linkp,NORMAL);
		break;
	case NL_DISCONNECT_REQUEST:
		llc_send(linkp, LLCFT_DM, LLC_RSP, LLC_GETFLAG(linkp,F));
		LLC_NEWSTATE(linkp,ADM);
		break;
	case LLCFT_DM + LLC_RSP:
		action = LLC_DISCONNECT_INDICATION;
		break;
	case LLCFT_SABME + LLC_CMD:
		LLC_SETFLAG(linkp,F,pollfinal);
		break;
	case LLCFT_DISC + LLC_CMD:
		llc_send(linkp, LLCFT_DM, LLC_RSP, pollfinal);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	}

	return action;
}

/*
 * SETUP --- The connection component has transmitted an SABME command PDU to a
 *           remote LLC DSAP and is waiting for a reply.
 */
int
llc_state_SETUP(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case LLCFT_SABME + LLC_CMD:
		LLC_RESETCOUNTER(linkp);
		llc_send(linkp, LLCFT_UA, LLC_RSP, pollfinal);
		LLC_SETFLAG(linkp,S,1);
		break;
	case LLCFT_UA + LLC_RSP:
		if (LLC_GETFLAG(linkp,P) == pollfinal) {
			LLC_STOP_ACK_TIMER(linkp);
			LLC_RESETCOUNTER(linkp);
			LLC_UPDATE_P_FLAG(linkp,cmdrsp,pollfinal);
			LLC_SETFLAG(linkp,REMOTE_BUSY,0);
			LLC_NEWSTATE(linkp,NORMAL);
			action = LLC_CONNECT_CONFIRM;
		}
		break;
	case LLC_ACK_TIMER_EXPIRED:
		if (LLC_GETFLAG(linkp,S) == 1) {
			LLC_SETFLAG(linkp,P,0);
			LLC_SETFLAG(linkp,REMOTE_BUSY,0),
				LLC_NEWSTATE(linkp,NORMAL);
			action = LLC_CONNECT_CONFIRM;
		} else if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_SABME, LLC_CMD, pollfinal);
			LLC_SETFLAG(linkp,P,pollfinal);
			LLC_START_ACK_TIMER(linkp);
			linkp->llcl_retry++;
		} else {
			LLC_NEWSTATE(linkp,ADM);
			action = LLC_DISCONNECT_INDICATION;
		}
		break;
	case LLCFT_DISC + LLC_CMD:
		llc_send(linkp, LLCFT_DM, LLC_RSP, pollfinal);
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	case LLCFT_DM + LLC_RSP:
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	}

	return action;
}

/*
 * RESET --- As a result of a service access point user request or the receipt
 *           of a FRMR response PDU, the local connection component has sent an
 *           SABME command PDU to the remote LLC DSAP to reset the data link
 *           connection and is waiting for a reply.
 */
int
llc_state_RESET(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case LLCFT_SABME + LLC_CMD:
		LLC_RESETCOUNTER(linkp);
		LLC_SETFLAG(linkp,S,1);
		llc_send(linkp, LLCFT_UA, LLC_RSP, pollfinal);
		break;
	case LLCFT_UA + LLC_RSP:
		if (LLC_GETFLAG(linkp,P) == pollfinal) {
			LLC_STOP_ACK_TIMER(linkp);
			LLC_RESETCOUNTER(linkp);
			LLC_UPDATE_P_FLAG(linkp,cmdrsp,pollfinal);
			LLC_SETFLAG(linkp,REMOTE_BUSY,0);
			LLC_NEWSTATE(linkp,NORMAL);
			action = LLC_RESET_CONFIRM;
		}
		break;
	case LLC_ACK_TIMER_EXPIRED:
		if (LLC_GETFLAG(linkp,S) == 1) {
			LLC_SETFLAG(linkp,P,0);
			LLC_SETFLAG(linkp,REMOTE_BUSY,0);
			LLC_NEWSTATE(linkp,NORMAL);
			action = LLC_RESET_CONFIRM;
		} else if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_SABME, LLC_CMD, pollfinal);
			LLC_SETFLAG(linkp,P,pollfinal);
			LLC_START_ACK_TIMER(linkp);
			linkp->llcl_retry++;
		} else {
			LLC_NEWSTATE(linkp,ADM);
			action = LLC_DISCONNECT_INDICATION;
		}
		break;
	case LLCFT_DISC + LLC_CMD:
		llc_send(linkp, LLCFT_DM, LLC_RSP, pollfinal);
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	case LLCFT_DM + LLC_RSP:
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	}

	return action;
}

/*
 * D_CONN --- At the request of the service access point user, the local LLC
 *            has sent a DISC command PDU to the remote LLC DSAP and is waiting
 *            for a reply.
 */
int
llc_state_D_CONN(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case LLCFT_SABME + LLC_CMD:
		llc_send(linkp, LLCFT_DM, LLC_RSP, pollfinal);
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,ADM);
		break;
	case LLCFT_UA + LLC_RSP:
		if (LLC_GETFLAG(linkp,P) == pollfinal) {
			LLC_STOP_ACK_TIMER(linkp);
			LLC_NEWSTATE(linkp,ADM);
		}
		break;
	case LLCFT_DISC + LLC_CMD:
		llc_send(linkp, LLCFT_UA, LLC_RSP, pollfinal);
		break;
	case LLCFT_DM + LLC_RSP:
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,ADM);
		break;
	case LLC_ACK_TIMER_EXPIRED:
		if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_DISC, LLC_CMD, pollfinal);
			LLC_SETFLAG(linkp,P,pollfinal);
			LLC_START_ACK_TIMER(linkp);
			linkp->llcl_retry++;
		} else
			LLC_NEWSTATE(linkp,ADM);
		break;
	}

	return action;
}

/*
 * ERROR --- The local connection component has detected an error in a received
 *           PDU and has sent a FRMR response PDU. It is waiting for a reply from
 *           the remote connection component.
 */
int
llc_state_ERROR(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case LLCFT_SABME + LLC_CMD:
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,RESET_CHECK);
		action = LLC_RESET_INDICATION_REMOTE;
		break;
	case LLCFT_DISC + LLC_CMD:
		llc_send(linkp, LLCFT_UA, LLC_RSP, pollfinal);
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	case LLCFT_DM + LLC_RSP:
		LLC_STOP_ACK_TIMER(linkp);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	case LLCFT_FRMR + LLC_RSP:
		LLC_STOP_ACK_TIMER(linkp);
		LLC_SETFLAG(linkp,S,0);
		LLC_NEWSTATE(linkp,RESET_WAIT);
		action = LLC_FRMR_RECEIVED;
		break;
	case LLC_ACK_TIMER_EXPIRED:
		if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_FRMR, LLC_RSP, 0);
			LLC_START_ACK_TIMER(linkp);
			linkp->llcl_retry++;
		} else {
			LLC_SETFLAG(linkp,S,0);
			LLC_NEWSTATE(linkp,RESET_WAIT);
			action = LLC_RESET_INDICATION_LOCAL;
		}
		break;
	default:
		if (cmdrsp == LLC_CMD) {
			llc_send(linkp, LLCFT_FRMR, LLC_RSP, pollfinal);
			LLC_START_ACK_TIMER(linkp);
		}
		break;

	}

	return action;
}

/*
 * NORMAL, BUSY, REJECT, AWAIT, AWAIT_BUSY, and AWAIT_REJECT all share
 * a common core state handler.
 */
int
llc_state_NBRAcore(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = 0;

	switch (frame_kind + cmdrsp) {
	case NL_DISCONNECT_REQUEST:
		llc_send(linkp, LLCFT_DISC, LLC_CMD, pollfinal);
		LLC_SETFLAG(linkp,P,pollfinal);
		LLC_STOP_ALL_TIMERS(linkp);
		LLC_START_ACK_TIMER(linkp);
		linkp->llcl_retry = 0;
		LLC_NEWSTATE(linkp,D_CONN);
		break;
	case NL_RESET_REQUEST:
		llc_send(linkp, LLCFT_SABME, LLC_CMD, pollfinal);
		LLC_SETFLAG(linkp,P,pollfinal);
		LLC_STOP_ALL_TIMERS(linkp);
		LLC_START_ACK_TIMER(linkp);
		linkp->llcl_retry = 0;
		LLC_SETFLAG(linkp,S,0);
		LLC_NEWSTATE(linkp,RESET);
		break;
	case LLCFT_SABME + LLC_CMD:
		LLC_SETFLAG(linkp,F,pollfinal);
		LLC_STOP_ALL_TIMERS(linkp);
		LLC_NEWSTATE(linkp,RESET_CHECK);
		action = LLC_RESET_INDICATION_REMOTE;
		break;
	case LLCFT_DISC + LLC_CMD:
		llc_send(linkp, LLCFT_UA, LLC_RSP, pollfinal);
		LLC_STOP_ALL_TIMERS(linkp);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	case LLCFT_FRMR + LLC_RSP:
		LLC_STOP_ALL_TIMERS(linkp);
		LLC_SETFLAG(linkp,S,0);
		LLC_NEWSTATE(linkp,RESET_WAIT);
		action = LLC_FRMR_RECEIVED;
		break;
	case LLCFT_DM + LLC_RSP:
		LLC_STOP_ALL_TIMERS(linkp);
		LLC_NEWSTATE(linkp,ADM);
		action = LLC_DISCONNECT_INDICATION;
		break;
	case LLC_INVALID_NR + LLC_CMD:
	case LLC_INVALID_NS + LLC_CMD:
		LLC_SETFRMR(linkp, frame, cmdrsp,
			    (frame_kind == LLC_INVALID_NR ? LLC_FRMR_Z :
			     (LLC_FRMR_V | LLC_FRMR_W)));
		llc_send(linkp, LLCFT_FRMR, LLC_RSP, pollfinal);
		LLC_STOP_ALL_TIMERS(linkp);
		LLC_START_ACK_TIMER(linkp);
		linkp->llcl_retry = 0;
		LLC_NEWSTATE(linkp,ERROR);
		action = LLC_FRMR_SENT;
		break;
	case LLC_INVALID_NR + LLC_RSP:
	case LLC_INVALID_NS + LLC_RSP:
	case LLCFT_UA + LLC_RSP:
	case LLC_BAD_PDU:{
			char            frmrcause = 0;

			switch (frame_kind) {
			case LLC_INVALID_NR:
				frmrcause = LLC_FRMR_Z;
				break;
			case LLC_INVALID_NS:
				frmrcause = LLC_FRMR_V | LLC_FRMR_W;
				break;
			default:
				frmrcause = LLC_FRMR_W;
			}
			LLC_SETFRMR(linkp,frame,cmdrsp,frmrcause);
			llc_send(linkp, LLCFT_FRMR, LLC_RSP, 0);
			LLC_STOP_ALL_TIMERS(linkp);
			LLC_START_ACK_TIMER(linkp);
			linkp->llcl_retry = 0;
			LLC_NEWSTATE(linkp,ERROR);
			action = LLC_FRMR_SENT;
			break;
		}
	default:
		if (cmdrsp == LLC_RSP && pollfinal == 1 &&
		    LLC_GETFLAG(linkp,P) == 0) {
			LLC_SETFRMR(linkp,frame,cmdrsp,LLC_FRMR_W);
			LLC_STOP_ALL_TIMERS(linkp);
			LLC_START_ACK_TIMER(linkp);
			linkp->llcl_retry = 0;
			LLC_NEWSTATE(linkp,ERROR);
			action = LLC_FRMR_SENT;
		}
		break;
	case LLC_P_TIMER_EXPIRED:
	case LLC_ACK_TIMER_EXPIRED:
	case LLC_REJ_TIMER_EXPIRED:
	case LLC_BUSY_TIMER_EXPIRED:
		if (linkp->llcl_retry >= llc_n2) {
			LLC_STOP_ALL_TIMERS(linkp);
			LLC_SETFLAG(linkp,S,0);
			LLC_NEWSTATE(linkp,RESET_WAIT);
			action = LLC_RESET_INDICATION_LOCAL;
		}
		break;
	}

	return action;
}

/*
 * NORMAL --- A data link connection exists between the local LLC service access
 *            point and the remote LLC service access point. Sending and
 *            reception of information and supervisory PDUs can be performed.
 */
int
llc_state_NORMAL(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = LLC_PASSITON;

	switch (frame_kind + cmdrsp) {
	case NL_DATA_REQUEST:
		if (LLC_GETFLAG(linkp,REMOTE_BUSY) == 0) {
#ifdef not_now
			if (LLC_GETFLAG(linkp,P) == 0) {
				/* multiple possibilities */
				llc_send(linkp, LLCFT_INFO, LLC_CMD, 1);
				LLC_START_P_TIMER(linkp);
				if (LLC_TIMERXPIRED(linkp,ACK) !=
				    LLC_TIMER_RUNNING)
					LLC_START_ACK_TIMER(linkp);
			} else {
#endif
				/* multiple possibilities */
				llc_send(linkp, LLCFT_INFO, LLC_CMD, 0);
				if (LLC_TIMERXPIRED(linkp,ACK) !=
				    LLC_TIMER_RUNNING)
					LLC_START_ACK_TIMER(linkp);
#ifdef not_now
			}
#endif
			action = 0;
		}
		break;
	case LLC_LOCAL_BUSY_DETECTED:
		if (LLC_GETFLAG(linkp,P) == 0) {
			/* multiple possibilities --- action-wise */
			/* multiple possibilities --- CMD/RSP-wise */
			llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
			LLC_START_P_TIMER(linkp);
			LLC_SETFLAG(linkp,DATA,0);
			LLC_NEWSTATE(linkp,BUSY);
			action = 0;
		} else {
			/* multiple possibilities --- CMD/RSP-wise */
			llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
			LLC_SETFLAG(linkp,DATA,0);
			LLC_NEWSTATE(linkp,BUSY);
			action = 0;
		}
		break;
	case LLC_INVALID_NS + LLC_CMD:
	case LLC_INVALID_NS + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr =
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_REJ, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_START_REJ_TIMER(linkp);
				LLC_NEWSTATE(linkp,REJECT);
				action = 0;
			} else if (pollfinal == 0 && p == 1) {
				llc_send(linkp, LLCFT_REJ, LLC_CMD, 0);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_START_REJ_TIMER(linkp);
				LLC_NEWSTATE(linkp,REJECT);
				action = 0;
			} else if ((pollfinal == 0 && p == 0) ||
			  (pollfinal == 1 && p == 1 && cmdrsp == LLC_RSP)) {
				llc_send(linkp, LLCFT_REJ, LLC_CMD, 1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_START_P_TIMER(linkp);
				LLC_START_REJ_TIMER(linkp);
				if (cmdrsp == LLC_RSP && pollfinal == 1) {
					LLC_CLEAR_REMOTE_BUSY(linkp,action);
				} else
					action = 0;
				LLC_NEWSTATE(linkp,REJECT);
			}
			break;
		}
	case LLCFT_INFO + LLC_CMD:
	case LLCFT_INFO + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr = 
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				LLC_INC(linkp->llcl_vr);
				LLC_SENDACKNOWLEDGE(linkp,LLC_RSP,1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				action = LLC_DATA_INDICATION;
			} else if (pollfinal == 0 && p == 1) {
				LLC_INC(linkp->llcl_vr);
				LLC_SENDACKNOWLEDGE(linkp,LLC_CMD,0);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				action = LLC_DATA_INDICATION;
			} else if ((pollfinal == 0 && p == 0 &&
				    cmdrsp == LLC_CMD) ||
				   (pollfinal == p && cmdrsp == LLC_RSP)) {
				LLC_INC(linkp->llcl_vr);
				LLC_UPDATE_P_FLAG(linkp,cmdrsp,pollfinal);
				LLC_SENDACKNOWLEDGE(linkp,LLC_CMD,0);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (cmdrsp == LLC_RSP && pollfinal == 1)
					LLC_CLEAR_REMOTE_BUSY(linkp,action);
				action = LLC_DATA_INDICATION;
			}
			break;
		}
	case LLCFT_RR + LLC_CMD:
	case LLCFT_RR + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr =
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				LLC_SENDACKNOWLEDGE(linkp,LLC_RSP,1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_CLEAR_REMOTE_BUSY(linkp,action);
			} else if ((pollfinal == 0) ||
			  (cmdrsp == LLC_RSP && pollfinal == 1 && p == 1)) {
				LLC_UPDATE_P_FLAG(linkp,cmdrsp,pollfinal);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_CLEAR_REMOTE_BUSY(linkp,action);
			}
			break;
		}
	case LLCFT_RNR + LLC_CMD:
	case LLCFT_RNR + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr = 
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			} else if ((pollfinal == 0) ||
			  (cmdrsp == LLC_RSP && pollfinal == 1 && p == 1)) {
				LLC_UPDATE_P_FLAG(linkp,cmdrsp,pollfinal);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			}
			break;
		}
	case LLCFT_REJ + LLC_CMD:
	case LLCFT_REJ + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr =
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				llc_resend(linkp,LLC_RSP,1);
				LLC_CLEAR_REMOTE_BUSY(linkp,action);
			} else if (pollfinal == 0 && p == 1) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp,action);
			} else if ((pollfinal == 0 && p == 0 &&
				    cmdrsp == LLC_CMD) ||
				   (pollfinal == p && cmdrsp == LLC_RSP)) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_START_P_TIMER(linkp);
				llc_resend(linkp, LLC_CMD, 1);
				LLC_CLEAR_REMOTE_BUSY(linkp,action);
			}
			break;
		}
	case NL_INITIATE_PF_CYCLE:
		if (LLC_GETFLAG(linkp,P) == 0) {
			llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			action = 0;
		}
		break;
	case LLC_P_TIMER_EXPIRED:
		if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			linkp->llcl_retry++;
			LLC_NEWSTATE(linkp,AWAIT);
			action = 0;
		}
		break;
	case LLC_ACK_TIMER_EXPIRED:
	case LLC_BUSY_TIMER_EXPIRED:
		if ((LLC_GETFLAG(linkp,P) == 0)
		    && (linkp->llcl_retry < llc_n2)) {
			llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			linkp->llcl_retry++;
			LLC_NEWSTATE(linkp,AWAIT);
			action = 0;
		}
		break;
	}
	if (action == LLC_PASSITON)
		action = llc_state_NBRAcore(linkp, frame, frame_kind,
					    cmdrsp, pollfinal);

	return action;
}

/*
 * BUSY --- A data link connection exists between the local LLC service access
 *          point and the remote LLC service access point. I PDUs may be sent.
 *          Local conditions make it likely that the information feld of
 *          received I PDUs will be ignored. Supervisory PDUs may be both sent
 *          and received.
 */
int
llc_state_BUSY(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = LLC_PASSITON;

	switch (frame_kind + cmdrsp) {
	case NL_DATA_REQUEST:
		if (LLC_GETFLAG(linkp,REMOTE_BUSY) == 0)
			if (LLC_GETFLAG(linkp,P) == 0) {
				llc_send(linkp, LLCFT_INFO, LLC_CMD, 1);
				LLC_START_P_TIMER(linkp);
				if (LLC_TIMERXPIRED(linkp,ACK) !=
				    LLC_TIMER_RUNNING)
					LLC_START_ACK_TIMER(linkp);
				action = 0;
			} else {
				llc_send(linkp, LLCFT_INFO, LLC_CMD, 0);
				if (LLC_TIMERXPIRED(linkp,ACK) !=
				    LLC_TIMER_RUNNING)
					LLC_START_ACK_TIMER(linkp);
				action = 0;
			}
		break;
	case LLC_LOCAL_BUSY_CLEARED:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    df = LLC_GETFLAG(linkp,DATA);

			switch (df) {
			case 1:
				if (p == 0) {
					/* multiple possibilities */
					llc_send(linkp, LLCFT_REJ, LLC_CMD, 1);
					LLC_START_REJ_TIMER(linkp);
					LLC_START_P_TIMER(linkp);
					LLC_NEWSTATE(linkp,REJECT);
					action = 0;
				} else {
					llc_send(linkp, LLCFT_REJ, LLC_CMD, 0);
					LLC_START_REJ_TIMER(linkp);
					LLC_NEWSTATE(linkp,REJECT);
					action = 0;
				}
				break;
			case 0:
				if (p == 0) {
					/* multiple possibilities */
					llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
					LLC_START_P_TIMER(linkp);
					LLC_NEWSTATE(linkp,NORMAL);
					action = 0;
				} else {
					llc_send(linkp, LLCFT_RR, LLC_CMD, 0);
					LLC_NEWSTATE(linkp,NORMAL);
					action = 0;
				}
				break;
			case 2:
				if (p == 0) {
					/* multiple possibilities */
					llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
					LLC_START_P_TIMER(linkp);
					LLC_NEWSTATE(linkp,REJECT);
					action = 0;
				} else {
					llc_send(linkp, LLCFT_RR, LLC_CMD, 0);
					LLC_NEWSTATE(linkp,REJECT);
					action = 0;
				}
				break;
			}
			break;
		}
	case LLC_INVALID_NS + LLC_CMD:
	case LLC_INVALID_NS + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr = 
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (LLC_GETFLAG(linkp,DATA) == 0)
					LLC_SETFLAG(linkp,DATA,1);
				action = 0;
			} else if ((cmdrsp == LLC_CMD && pollfinal == 0 &&
				    p == 0) ||
				   (cmdrsp == LLC_RSP && pollfinal == p)) {
				llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
				LLC_UPDATE_P_FLAG(linkp,cmdrsp,pollfinal);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (LLC_GETFLAG(linkp,DATA) == 0)
					LLC_SETFLAG(linkp,DATA,1);
				if (cmdrsp == LLC_RSP && pollfinal == 1) {
					LLC_CLEAR_REMOTE_BUSY(linkp,action);
				} else
					action = 0;
			} else if (pollfinal == 0 && p == 1) {
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (LLC_GETFLAG(linkp,DATA) == 0)
					LLC_SETFLAG(linkp,DATA,1);
				action = 0;
			}
			break;
		}
	case LLCFT_INFO + LLC_CMD:
	case LLCFT_INFO + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr =
				LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				LLC_INC(linkp->llcl_vr);
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (LLC_GETFLAG(linkp,DATA) == 2)
					LLC_STOP_REJ_TIMER(linkp);
				LLC_SETFLAG(linkp,DATA,0);
				action = LLC_DATA_INDICATION;
			} else if ((cmdrsp == LLC_CMD && pollfinal == 0 && p == 0) ||
				   (cmdrsp == LLC_RSP && pollfinal == p)) {
				LLC_INC(linkp->llcl_vr);
				llc_send(linkp, LLCFT_RNR, LLC_CMD, 1);
				LLC_START_P_TIMER(linkp);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (LLC_GETFLAG(linkp,DATA) == 2)
					LLC_STOP_REJ_TIMER(linkp);
				if (cmdrsp == LLC_RSP && pollfinal == 1)
					LLC_CLEAR_REMOTE_BUSY(linkp,action);
				action = LLC_DATA_INDICATION;
			} else if (pollfinal == 0 && p == 1) {
				LLC_INC(linkp->llcl_vr);
				llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (LLC_GETFLAG(linkp,DATA) == 2)
					LLC_STOP_REJ_TIMER(linkp);
				LLC_SETFLAG(linkp,DATA,0);
				action = LLC_DATA_INDICATION;
			}
			break;
		}
	case LLCFT_RR + LLC_CMD:
	case LLCFT_RR + LLC_RSP:
	case LLCFT_RNR + LLC_CMD:
	case LLCFT_RNR + LLC_RSP:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr =
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (frame_kind == LLCFT_RR) {
					LLC_CLEAR_REMOTE_BUSY(linkp,action);
				} else {
					LLC_SET_REMOTE_BUSY(linkp,action);
				}
			} else if (pollfinal == 0 ||
				   (cmdrsp == LLC_RSP && pollfinal == 1)) {
				LLC_UPDATE_P_FLAG(linkp,cmdrsp,pollfinal);
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				if (frame_kind == LLCFT_RR) {
					LLC_CLEAR_REMOTE_BUSY(linkp,action);
				} else {
					LLC_SET_REMOTE_BUSY(linkp,action);
				}
			}
			break;
		}
	case LLCFT_REJ + LLC_CMD:
	case LLCFT_REJ + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr =
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp,action);
			} else if ((cmdrsp == LLC_CMD && pollfinal == 0 &&
				    p == 0) ||
				   (cmdrsp == LLC_RSP && pollfinal == p)) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				LLC_UPDATE_P_FLAG(linkp,cmdrsp,pollfinal);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp,action);
			} else if (pollfinal == 0 && p == 1) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp,nr);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp,action);
			}
			break;
		}
	case NL_INITIATE_PF_CYCLE:
		if (LLC_GETFLAG(linkp,P) == 0) {
			llc_send(linkp, LLCFT_RNR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			action = 0;
		}
		break;
	case LLC_P_TIMER_EXPIRED:
		/* multiple possibilities */
		if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_RNR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			linkp->llcl_retry++;
			LLC_NEWSTATE(linkp,AWAIT_BUSY);
			action = 0;
		}
		break;
	case LLC_ACK_TIMER_EXPIRED:
	case LLC_BUSY_TIMER_EXPIRED:
		if (LLC_GETFLAG(linkp,P) == 0 && linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_RNR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			linkp->llcl_retry++;
			LLC_NEWSTATE(linkp,AWAIT_BUSY);
			action = 0;
		}
		break;
	case LLC_REJ_TIMER_EXPIRED:
		if (linkp->llcl_retry < llc_n2)
			if (LLC_GETFLAG(linkp,P) == 0) {
				/* multiple possibilities */
				llc_send(linkp, LLCFT_RNR, LLC_CMD, 1);
				LLC_START_P_TIMER(linkp);
				linkp->llcl_retry++;
				LLC_SETFLAG(linkp,DATA,1);
				LLC_NEWSTATE(linkp,AWAIT_BUSY);
				action = 0;
			} else {
				LLC_SETFLAG(linkp,DATA,1);
				LLC_NEWSTATE(linkp,BUSY);
				action = 0;
			}

		break;
	}
	if (action == LLC_PASSITON)
		action = llc_state_NBRAcore(linkp, frame, frame_kind,
					    cmdrsp, pollfinal);

	return action;
}

/*
 * REJECT --- A data link connection exists between the local LLC service
 *            access point and the remote LLC service access point. The local
 *            connection component has requested that the remote connection
 *            component resend a specific I PDU that the local connection
 *            componnent has detected as being out of sequence. Both I PDUs and
 *            supervisory PDUs may be sent and received.
 */
int
llc_state_REJECT(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = LLC_PASSITON;

	switch (frame_kind + cmdrsp) {
	case NL_DATA_REQUEST:
		if (LLC_GETFLAG(linkp,P) == 0) {
			llc_send(linkp, LLCFT_INFO, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			if (LLC_TIMERXPIRED(linkp,ACK) != LLC_TIMER_RUNNING)
				LLC_START_ACK_TIMER(linkp);
			LLC_NEWSTATE(linkp,REJECT);
			action = 0;
		} else {
			llc_send(linkp, LLCFT_INFO, LLC_CMD, 0);
			if (LLC_TIMERXPIRED(linkp,ACK) != LLC_TIMER_RUNNING)
				LLC_START_ACK_TIMER(linkp);
			LLC_NEWSTATE(linkp,REJECT);
			action = 0;
		}
		break;
	case NL_LOCAL_BUSY_DETECTED:
		if (LLC_GETFLAG(linkp,P) == 0) {
			llc_send(linkp, LLCFT_RNR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			LLC_SETFLAG(linkp,DATA,2);
			LLC_NEWSTATE(linkp,BUSY);
			action = 0;
		} else {
			llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
			LLC_SETFLAG(linkp,DATA,2);
			LLC_NEWSTATE(linkp,BUSY);
			action = 0;
		}
		break;
	case LLC_INVALID_NS + LLC_CMD:
	case LLC_INVALID_NS + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				action = 0;
			} else if (pollfinal == 0 ||
			  (cmdrsp == LLC_RSP && pollfinal == 1 && p == 1)) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_UPDATE_P_FLAG(linkp, cmdrsp, pollfinal);
				if (cmdrsp == LLC_RSP && pollfinal == 1) {
					LLC_CLEAR_REMOTE_BUSY(linkp, action);
				} else
					action = 0;
			}
			break;
		}
	case LLCFT_INFO + LLC_CMD:
	case LLCFT_INFO + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				LLC_INC(linkp->llcl_vr);
				LLC_SENDACKNOWLEDGE(linkp, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_STOP_REJ_TIMER(linkp);
				LLC_NEWSTATE(linkp,NORMAL);
				action = LLC_DATA_INDICATION;
			} else if ((cmdrsp = LLC_RSP && pollfinal == p) ||
			  (cmdrsp == LLC_CMD && pollfinal == 0 && p == 0)) {
				LLC_INC(linkp->llcl_vr);
				LLC_SENDACKNOWLEDGE(linkp, LLC_CMD, 1);
				LLC_START_P_TIMER(linkp);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				if (cmdrsp == LLC_RSP && pollfinal == 1)
					LLC_CLEAR_REMOTE_BUSY(linkp, action);
				LLC_STOP_REJ_TIMER(linkp);
				LLC_NEWSTATE(linkp,NORMAL);
				action = LLC_DATA_INDICATION;
			} else if (pollfinal == 0 && p == 1) {
				LLC_INC(linkp->llcl_vr);
				LLC_SENDACKNOWLEDGE(linkp, LLC_CMD, 0);
				LLC_STOP_REJ_TIMER(linkp);
				LLC_NEWSTATE(linkp,NORMAL);
				action = LLC_DATA_INDICATION;
			}
			break;
		}
	case LLCFT_RR + LLC_CMD:
	case LLCFT_RR + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				LLC_SENDACKNOWLEDGE(linkp, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			} else if (pollfinal == 0 ||
			  (cmdrsp == LLC_RSP && pollfinal == 1 && p == 1)) {
				LLC_UPDATE_P_FLAG(linkp, cmdrsp, pollfinal);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			}
			break;
		}
	case LLCFT_RNR + LLC_CMD:
	case LLCFT_RNR + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			} else if (pollfinal == 0 ||
			  (cmdrsp == LLC_RSP && pollfinal == 1 && p == 1)) {
				LLC_UPDATE_P_FLAG(linkp, cmdrsp, pollfinal);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				action = 0;
			}
			break;
		}
	case LLCFT_REJ + LLC_CMD:
	case LLCFT_REJ + LLC_RSP:{
			register int    p = LLC_GETFLAG(linkp,P);
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				llc_resend(linkp, LLC_RSP, 1);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			} else if ((cmdrsp == LLC_CMD && pollfinal == 0 && p == 0) ||
				   (cmdrsp == LLC_RSP && pollfinal == p)) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_UPDATE_P_FLAG(linkp, cmdrsp, pollfinal);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			} else if (pollfinal == 0 && p == 1) {
				linkp->llcl_vs = nr;
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			}
			break;
		}
	case NL_INITIATE_PF_CYCLE:
		if (LLC_GETFLAG(linkp,P) == 0) {
			llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			action = 0;
		}
		break;
	case LLC_REJ_TIMER_EXPIRED:
		if (LLC_GETFLAG(linkp,P) == 0 && linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_REJ, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			LLC_START_REJ_TIMER(linkp);
			linkp->llcl_retry++;
			action = 0;
		}
	case LLC_P_TIMER_EXPIRED:
		if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			LLC_START_REJ_TIMER(linkp);
			linkp->llcl_retry++;
			LLC_NEWSTATE(linkp,AWAIT_REJECT);
			action = 0;
		}
		break;
	case LLC_ACK_TIMER_EXPIRED:
	case LLC_BUSY_TIMER_EXPIRED:
		if (LLC_GETFLAG(linkp,P) == 0 && linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			LLC_START_REJ_TIMER(linkp);
			linkp->llcl_retry++;
			/*
			 * I cannot locate the description of RESET_V(S) in
			 * ISO 8802-2, table 7-1, state REJECT, last event,
			 * and  assume they meant to set V(S) to 0 ...
			 */
			linkp->llcl_vs = 0;	/* XXX */
			LLC_NEWSTATE(linkp,AWAIT_REJECT);
			action = 0;
		}
		break;
	}
	if (action == LLC_PASSITON)
		action = llc_state_NBRAcore(linkp, frame, frame_kind,
					    cmdrsp, pollfinal);

	return action;
}

/*
 * AWAIT --- A data link connection exists between the local LLC service access
 *           point and the remote LLC service access point. The local LLC is
 *           performing a timer recovery operation and has sent a command PDU
 *           with the P bit set to ``1'', and is awaiting an acknowledgement
 *           from the remote LLC. I PDUs may be received but not sent.
 *           Supervisory PDUs may be both sent and received.
 */
int
llc_state_AWAIT(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = LLC_PASSITON;

	switch (frame_kind + cmdrsp) {
	case LLC_LOCAL_BUSY_DETECTED:
		llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
		LLC_SETFLAG(linkp,DATA,0);
		LLC_NEWSTATE(linkp,AWAIT_BUSY);
		action = 0;
		break;
	case LLC_INVALID_NS + LLC_CMD:
	case LLC_INVALID_NS + LLC_RSP:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_REJ, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_START_REJ_TIMER(linkp);
				LLC_NEWSTATE(linkp,AWAIT_REJECT);
				action = 0;
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				llc_send(linkp, LLCFT_REJ, LLC_CMD, 0);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_STOP_P_TIMER(linkp);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_START_REJ_TIMER(linkp);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				LLC_NEWSTATE(linkp,REJECT);
			} else if (pollfinal == 0) {
				llc_send(linkp, LLCFT_REJ, LLC_CMD, 0);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_START_REJ_TIMER(linkp);
				LLC_NEWSTATE(linkp,AWAIT_REJECT);
				action = 0;
			}
			break;
		}
	case LLCFT_INFO + LLC_RSP:
	case LLCFT_INFO + LLC_CMD:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			LLC_INC(linkp->llcl_vr);
			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				action = LLC_DATA_INDICATION;
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				llc_resend(linkp, LLC_CMD, 1);
				LLC_START_P_TIMER(linkp);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				LLC_NEWSTATE(linkp,NORMAL);
				action = LLC_DATA_INDICATION;
			} else if (pollfinal == 0) {
				llc_send(linkp, LLCFT_RR, LLC_CMD, 0);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				action = LLC_DATA_INDICATION;
			}
			break;
		}
	case LLCFT_RR + LLC_CMD:
	case LLCFT_RR + LLC_RSP:
	case LLCFT_REJ + LLC_CMD:
	case LLCFT_REJ + LLC_RSP:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_STOP_P_TIMER(linkp);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				LLC_NEWSTATE(linkp,NORMAL);
			} else if (pollfinal == 0) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			}
			break;
		}
	case LLCFT_RNR + LLC_CMD:
	case LLCFT_RNR + LLC_RSP:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (pollfinal == 1 && cmdrsp == LLC_CMD) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			} else if (pollfinal == 1 && cmdrsp == LLC_RSP) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_STOP_P_TIMER(linkp);
				LLC_SET_REMOTE_BUSY(linkp,action);
				LLC_NEWSTATE(linkp,NORMAL);
			} else if (pollfinal == 0) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			}
			break;
		}
	case LLC_P_TIMER_EXPIRED:
		if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_RR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			linkp->llcl_retry++;
			action = 0;
		}
		break;
	}
	if (action == LLC_PASSITON)
		action = llc_state_NBRAcore(linkp, frame, frame_kind,
					    cmdrsp, pollfinal);

	return action;
}

/*
 * AWAIT_BUSY --- A data link connection exists between the local LLC service
 *                access point and the remote LLC service access point. The
 *                local LLC is performing a timer recovery operation and has
 *                sent a command PDU with the P bit set to ``1'', and is
 *                awaiting an acknowledgement from the remote LLC. I PDUs may
 *                not be sent. Local conditions make it likely that the
 *                information feld of receoved I PDUs will be ignored.
 *                Supervisory PDUs may be both sent and received.
 */
int
llc_state_AWAIT_BUSY(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = LLC_PASSITON;

	switch (frame_kind + cmdrsp) {
	case LLC_LOCAL_BUSY_CLEARED:
		switch (LLC_GETFLAG(linkp,DATA)) {
		case 1:
			llc_send(linkp, LLCFT_REJ, LLC_CMD, 0);
			LLC_START_REJ_TIMER(linkp);
			LLC_NEWSTATE(linkp,AWAIT_REJECT);
			action = 0;
			break;
		case 0:
			llc_send(linkp, LLCFT_RR, LLC_CMD, 0);
			LLC_NEWSTATE(linkp,AWAIT);
			action = 0;
			break;
		case 2:
			llc_send(linkp, LLCFT_RR, LLC_CMD, 0);
			LLC_NEWSTATE(linkp,AWAIT_REJECT);
			action = 0;
			break;
		}
		break;
	case LLC_INVALID_NS + LLC_CMD:
	case LLC_INVALID_NS + LLC_RSP:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SETFLAG(linkp,DATA,1);
				action = 0;
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				/* optionally */
				llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_STOP_P_TIMER(linkp);
				LLC_SETFLAG(linkp,DATA,1);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_NEWSTATE(linkp,BUSY);
			} else if (pollfinal == 0) {
				/* optionally */
				llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SETFLAG(linkp,DATA,1);
				action = 0;
			}
		}
	case LLCFT_INFO + LLC_CMD:
	case LLCFT_INFO + LLC_RSP:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				LLC_INC(linkp->llcl_vr);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SETFLAG(linkp,DATA,0);
				action = LLC_DATA_INDICATION;
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				llc_send(linkp, LLCFT_RNR, LLC_CMD, 1);
				LLC_INC(linkp->llcl_vr);
				LLC_START_P_TIMER(linkp);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_SETFLAG(linkp,DATA,0);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_NEWSTATE(linkp,BUSY);
				action = LLC_DATA_INDICATION;
			} else if (pollfinal == 0) {
				llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
				LLC_INC(linkp->llcl_vr);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SETFLAG(linkp,DATA,0);
				action = LLC_DATA_INDICATION;
			}
			break;
		}
	case LLCFT_RR + LLC_CMD:
	case LLCFT_REJ + LLC_CMD:
	case LLCFT_RR + LLC_RSP:
	case LLCFT_REJ + LLC_RSP:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_STOP_P_TIMER(linkp);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				LLC_NEWSTATE(linkp,BUSY);
			} else if (pollfinal == 0) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_STOP_P_TIMER(linkp);
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			}
			break;
		}
	case LLCFT_RNR + LLC_CMD:
	case LLCFT_RNR + LLC_RSP:{
#if 0
			register int    p = LLC_GETFLAG(linkp,P);
#endif
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RNR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_STOP_P_TIMER(linkp);
				LLC_SET_REMOTE_BUSY(linkp,action);
				LLC_NEWSTATE(linkp,BUSY);
			} else if (pollfinal == 0) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			}
			break;
		}
	case LLC_P_TIMER_EXPIRED:
		if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_RNR, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			linkp->llcl_retry++;
			action = 0;
		}
		break;
	}
	if (action == LLC_PASSITON)
		action = llc_state_NBRAcore(linkp, frame, frame_kind,
					    cmdrsp, pollfinal);

	return action;
}

/*
 * AWAIT_REJECT --- A data link connection exists between the local LLC service
 *                  access point and the remote LLC service access point. The
 *                  local connection component has requested that the remote
 *                  connection component re-transmit a specific I PDU that the
 *                  local connection component has detected as being out of
 *                  sequence. Before the local LLC entered this state it was
 *                  performing a timer recovery operation and had sent a
 *                  command PDU with the P bit set to ``1'', and is still
 *                  awaiting an acknowledgment from the remote LLC. I PDUs may
 *                  be received but not transmitted. Supervisory PDUs may be
 *                  both transmitted and received.
 */
int
llc_state_AWAIT_REJECT(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	int             action = LLC_PASSITON;

	switch (frame_kind + cmdrsp) {
	case LLC_LOCAL_BUSY_DETECTED:
		llc_send(linkp, LLCFT_RNR, LLC_CMD, 0);
		LLC_SETFLAG(linkp,DATA,2);
		LLC_NEWSTATE(linkp,AWAIT_BUSY);
		action = 0;
		break;
	case LLC_INVALID_NS + LLC_CMD:
	case LLC_INVALID_NS + LLC_RSP:{
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				action = 0;
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				llc_resend(linkp, LLC_CMD, 1);
				LLC_START_P_TIMER(linkp);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				LLC_NEWSTATE(linkp,REJECT);
			} else if (pollfinal == 0) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				action = 0;
			}
			break;
		}
	case LLCFT_INFO + LLC_CMD:
	case LLCFT_INFO + LLC_RSP:{
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				LLC_INC(linkp->llcl_vr);
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_STOP_REJ_TIMER(linkp);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_NEWSTATE(linkp,AWAIT);
				action = LLC_DATA_INDICATION;
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				LLC_INC(linkp->llcl_vr);
				LLC_STOP_P_TIMER(linkp);
				LLC_STOP_REJ_TIMER(linkp);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				llc_resend(linkp, LLC_CMD, 0);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				LLC_NEWSTATE(linkp,NORMAL);
				action = LLC_DATA_INDICATION;
			} else if (pollfinal == 0) {
				LLC_INC(linkp->llcl_vr);
				llc_send(linkp, LLCFT_RR, LLC_CMD, 0);
				LLC_STOP_REJ_TIMER(linkp);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_NEWSTATE(linkp,AWAIT);
				action = LLC_DATA_INDICATION;
			}
			break;
		}
	case LLCFT_RR + LLC_CMD:
	case LLCFT_REJ + LLC_CMD:
	case LLCFT_RR + LLC_RSP:
	case LLCFT_REJ + LLC_RSP:{
			register int    nr = LLCGBITS(frame->llc_control_ext, s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				llc_resend(linkp, LLC_CMD, 1);
				LLC_START_P_TIMER(linkp);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
				LLC_NEWSTATE(linkp,REJECT);
			} else if (pollfinal == 0) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_CLEAR_REMOTE_BUSY(linkp, action);
			}
			break;
		}
	case LLCFT_RNR + LLC_CMD:
	case LLCFT_RNR + LLC_RSP:{
			register int    nr =
				LLCGBITS(frame->llc_control_ext,s_nr);

			if (cmdrsp == LLC_CMD && pollfinal == 1) {
				llc_send(linkp, LLCFT_RR, LLC_RSP, 1);
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			} else if (cmdrsp == LLC_RSP && pollfinal == 1) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				linkp->llcl_vs = nr;
				LLC_STOP_P_TIMER(linkp);
				LLC_SET_REMOTE_BUSY(linkp,action);
				LLC_NEWSTATE(linkp,REJECT);
			} else if (pollfinal == 0) {
				LLC_UPDATE_NR_RECEIVED(linkp, nr);
				LLC_SET_REMOTE_BUSY(linkp,action);
			}
			break;
		}
	case LLC_P_TIMER_EXPIRED:
		if (linkp->llcl_retry < llc_n2) {
			llc_send(linkp, LLCFT_REJ, LLC_CMD, 1);
			LLC_START_P_TIMER(linkp);
			linkp->llcl_retry++;
			action = 0;
		}
		break;
	}
	if (action == LLC_PASSITON)
		action = llc_state_NBRAcore(linkp, frame, frame_kind,
					    cmdrsp, pollfinal);

	return action;
}


/*
 * llc_statehandler() --- Wrapper for llc_state_*() functions.
 *                         Deals with action codes and checks for
 *                         ``stuck'' links.
 */

int
llc_statehandler(linkp, frame, frame_kind, cmdrsp, pollfinal)
	struct llc_linkcb *linkp;
	struct llc *frame;
	int frame_kind;
	int cmdrsp;
	int pollfinal;
{
	register int    action = 0;

	/*
	 * To check for ``zombie'' links each time llc_statehandler() gets called
	 * the AGE timer of linkp is reset. If it expires llc_timer() will
	 * take care of the link --- i.e. kill it 8=)
	 */
	LLC_STARTTIMER(linkp,AGE);

	/*
	 * Now call the current statehandler function.
	 */
	action = (*linkp->llcl_statehandler) (linkp, frame, frame_kind,
					      cmdrsp, pollfinal);
once_more_and_again:
	switch (action) {
	case LLC_CONNECT_INDICATION:{
			int             naction;

			LLC_TRACE(linkp, LLCTR_INTERESTING, "CONNECT INDICATION");
			linkp->llcl_nlnext =
				(*linkp->llcl_sapinfo->si_ctlinput)
				(PRC_CONNECT_INDICATION,
				 (struct sockaddr *) & linkp->llcl_addr, (caddr_t) linkp);
			if (linkp->llcl_nlnext == 0)
				naction = NL_DISCONNECT_REQUEST;
			else
				naction = NL_CONNECT_RESPONSE;
			action = (*linkp->llcl_statehandler) (linkp, frame, naction, 0, 0);
			goto once_more_and_again;
		}
	case LLC_CONNECT_CONFIRM:
		/* llc_resend(linkp, LLC_CMD, 0); */
		llc_start(linkp);
		break;
	case LLC_DISCONNECT_INDICATION:
		LLC_TRACE(linkp, LLCTR_INTERESTING, "DISCONNECT INDICATION");
		(*linkp->llcl_sapinfo->si_ctlinput)
			(PRC_DISCONNECT_INDICATION,
		(struct sockaddr *) & linkp->llcl_addr, linkp->llcl_nlnext);
		break;
		/* internally visible only */
	case LLC_RESET_CONFIRM:
	case LLC_RESET_INDICATION_LOCAL:
		/*
		 * not much we can do here, the state machine either makes it or
		 * brakes it ...
		 */
		break;
	case LLC_RESET_INDICATION_REMOTE:
		LLC_TRACE(linkp, LLCTR_SHOULDKNOW, "RESET INDICATION (REMOTE)");
		action = (*linkp->llcl_statehandler) (linkp, frame,
						   NL_RESET_RESPONSE, 0, 0);
		goto once_more_and_again;
	case LLC_FRMR_SENT:
		LLC_TRACE(linkp, LLCTR_URGENT, "FRMR SENT");
		break;
	case LLC_FRMR_RECEIVED:
		LLC_TRACE(linkp, LLCTR_URGEN, "FRMR RECEIVED");
		action = (*linkp->llcl_statehandler) (linkp, frame,
						    NL_RESET_REQUEST, 0, 0);

		goto once_more_and_again;
	case LLC_REMOTE_BUSY:
		LLC_TRACE(linkp, LLCTR_SHOULDKNOW, "REMOTE BUSY");
		break;
	case LLC_REMOTE_NOT_BUSY:
		LLC_TRACE(linkp, LLCTR_SHOULDKNOW, "REMOTE BUSY CLEARED");
		/*
		 * try to get queued frames out
		 */
		llc_start(linkp);
		break;
	}

	/*
         * Only LLC_DATA_INDICATION is for the time being
	 * passed up to the network layer entity.
	 * The remaining action codes are for the time
	 * being visible internally only.
         * However, this can/may be changed if necessary.
	 */

	return action;
}


/*
 * Core LLC2 routines
 */

/*
 * The INIT call. This routine is called once after the system is booted.
 */

void
llc_init()
{
	llcintrq.ifq_maxlen = IFQ_MAXLEN;
}


/*
 * In case of a link reset we need to shuffle the frames queued inside the
 * LLC2 window.
 */

void
llc_resetwindow(linkp)
	struct llc_linkcb *linkp;
{
	register struct mbuf *mptr = (struct mbuf *) 0;
	register struct mbuf *anchor = (struct mbuf *) 0;
	register short  i;

	/* Pick up all queued frames and collect them in a linked mbuf list */
	if (linkp->llcl_slotsfree != linkp->llcl_window) {
		i = llc_seq2slot(linkp, linkp->llcl_nr_received);
		anchor = mptr = linkp->llcl_output_buffers[i];
		for (; i != linkp->llcl_freeslot;
		     i = llc_seq2slot(linkp, i + 1)) {
			if (linkp->llcl_output_buffers[i]) {
				mptr->m_nextpkt = linkp->llcl_output_buffers[i];
				mptr = mptr->m_nextpkt;
			} else
				panic("LLC2 window broken");
		}
	}
	/* clean closure */
	if (mptr)
		mptr->m_nextpkt = (struct mbuf *) 0;

	/* Now --- plug 'em in again */
	if (anchor != (struct mbuf *) 0) {
		for (i = 0, mptr = anchor; mptr != (struct mbuf *) 0; i++) {
			linkp->llcl_output_buffers[i] = mptr;
			mptr = mptr->m_nextpkt;
			linkp->llcl_output_buffers[i]->m_nextpkt = (struct mbuf *) 0;
		}
		linkp->llcl_freeslot = i;
	} else
		linkp->llcl_freeslot = 0;

	/* We're resetting the link, the next frame to be acknowledged is 0 */
	linkp->llcl_nr_received = 0;

	/*
	 * set distance between LLC2 sequence number and the top of window to
	 * 0
	 */
	linkp->llcl_projvs = linkp->llcl_freeslot;

	return;
}

/*
 * llc_newlink() --- We allocate enough memory to contain a link control block
 *                   and initialize it properly. We don't intiate the actual
 *		     setup of the LLC2 link here.
 */
struct llc_linkcb *
llc_newlink(dst, ifp, nlrt, nlnext, llrt)
	struct sockaddr_dl *dst;
	struct ifnet *ifp;
	struct rtentry *nlrt;
	caddr_t nlnext;
	struct rtentry *llrt;
{
	struct llc_linkcb *nlinkp;
	u_char          sap = LLSAPADDR(dst);
	short           llcwindow;


	/* allocate memory for link control block */
	MALLOC(nlinkp, struct llc_linkcb *, sizeof(struct llc_linkcb),
	       M_PCB, M_DONTWAIT);
	if (nlinkp == 0)
		return (NULL);
	bzero((caddr_t) nlinkp, sizeof(struct llc_linkcb));

	/* copy link address */
	sdl_copy(dst, &nlinkp->llcl_addr);

	/* hold on to the network layer route entry */
	nlinkp->llcl_nlrt = nlrt;

	/* likewise the network layer control block */
	nlinkp->llcl_nlnext = nlnext;

	/* jot down the link layer route entry */
	nlinkp->llcl_llrt = llrt;

	/* reset writeq */
	nlinkp->llcl_writeqh = nlinkp->llcl_writeqt = NULL;

	/* setup initial state handler function */
	nlinkp->llcl_statehandler = llc_state_ADM;

	/* hold on to interface pointer */
	nlinkp->llcl_if = ifp;

	/* get service access point information */
	nlinkp->llcl_sapinfo = llc_getsapinfo(sap, ifp);

	/* get window size from SAP info block */
	if ((llcwindow = nlinkp->llcl_sapinfo->si_window) == 0)
		llcwindow = LLC_MAX_WINDOW;

	/* allocate memory for window buffer */
	MALLOC(nlinkp->llcl_output_buffers, struct mbuf **,
	       llcwindow * sizeof(struct mbuf *), M_PCB, M_DONTWAIT);
	if (nlinkp->llcl_output_buffers == 0) {
		FREE(nlinkp, M_PCB);
		return (NULL);
	}
	bzero((caddr_t) nlinkp->llcl_output_buffers,
	      llcwindow * sizeof(struct mbuf *));

	/* set window size & slotsfree */
	nlinkp->llcl_slotsfree = nlinkp->llcl_window = llcwindow;

	/* enter into linked listed of link control blocks */
	insque(nlinkp, &llccb_q);

	return (nlinkp);
}

/*
 * llc_dellink() --- farewell to link control block
 */
void
llc_dellink(linkp)
	struct llc_linkcb *linkp;
{
	register struct mbuf *m;
	register struct mbuf *n;
	register struct npaidbentry *sapinfo = linkp->llcl_sapinfo;
	register        i;

	/* notify upper layer of imminent death */
	if (linkp->llcl_nlnext && sapinfo->si_ctlinput)
		(*sapinfo->si_ctlinput)
			(PRC_DISCONNECT_INDICATION,
		(struct sockaddr *) & linkp->llcl_addr, linkp->llcl_nlnext);

	/* pull the plug */
	if (linkp->llcl_llrt)
		((struct npaidbentry *) (linkp->llcl_llrt->rt_llinfo))->np_link
			= (struct llc_linkcb *) 0;

	/* leave link control block queue */
	remque(linkp);

	/* drop queued packets */
	for (m = linkp->llcl_writeqh; m;) {
		n = m->m_act;
		m_freem(m);
		m = n;
	}

	/* drop packets in the window */
	for (i = 0; i < linkp->llcl_window; i++)
		if (linkp->llcl_output_buffers[i])
			m_freem(linkp->llcl_output_buffers[i]);

	/* return the window space */
	FREE((caddr_t) linkp->llcl_output_buffers, M_PCB);

	/* return the control block space --- now it's gone ... */
	FREE((caddr_t) linkp, M_PCB);
}

int
llc_decode(frame, linkp)
	struct llc *frame;
	struct llc_linkcb *linkp;
{
	register int    ft = LLC_BAD_PDU;

	if ((frame->llc_control & 01) == 0) {
		ft = LLCFT_INFO;
		/* S or U frame ? */
	} else
		switch (frame->llc_control) {

			/* U frames */
		case LLC_UI:
		case LLC_UI_P:
			ft = LLC_UI;
			break;
		case LLC_DM:
		case LLC_DM_P:
			ft = LLCFT_DM;
			break;
		case LLC_DISC:
		case LLC_DISC_P:
			ft = LLCFT_DISC;
			break;
		case LLC_UA:
		case LLC_UA_P:
			ft = LLCFT_UA;
			break;
		case LLC_SABME:
		case LLC_SABME_P:
			ft = LLCFT_SABME;
			break;
		case LLC_FRMR:
		case LLC_FRMR_P:
			ft = LLCFT_FRMR;
			break;
		case LLC_XID:
		case LLC_XID_P:
			ft = LLCFT_XID;
			break;
		case LLC_TEST:
		case LLC_TEST_P:
			ft = LLCFT_TEST;
			break;

			/* S frames */
		case LLC_RR:
			ft = LLCFT_RR;
			break;
		case LLC_RNR:
			ft = LLCFT_RNR;
			break;
		case LLC_REJ:
			ft = LLCFT_REJ;
			break;
		}		/* switch */

	if (linkp) {
		switch (ft) {
		case LLCFT_INFO:
			if (LLCGBITS(frame->llc_control,i_ns) !=
			    linkp->llcl_vr) {
				ft = LLC_INVALID_NS;
				break;
			}
			/* fall thru --- yeeeeeee */
		case LLCFT_RR:
		case LLCFT_RNR:
		case LLCFT_REJ:
			/* splash! */
			if (LLC_NR_VALID(linkp,
					 LLCGBITS(frame->llc_control_ext,s_nr))
					 == 0)
				ft = LLC_INVALID_NR;
			break;
		}
	}
	return ft;
}

/*
 * llc_anytimersup() --- Checks if at least one timer is still up and running.
 */
int
llc_anytimersup(linkp)
	struct llc_linkcb *linkp;
{
	register int    i;

	FOR_ALL_LLC_TIMERS(i)
		if (linkp->llcl_timers[i] > 0)
		break;
	if (i == LLC_AGE_SHIFT)
		return 0;
	else
		return 1;
}

/*
 * llc_link_dump() - dump link info
 */

#define SAL(s) ((struct sockaddr_dl *)&(s)->llcl_addr)
#define CHECK(l,s) if (LLC_STATEEQ(l,s)) return __STRING(s)

char *timer_names[] = {"ACK", "P", "BUSY", "REJ", "AGE"};

char *
llc_getstatename(linkp)
	struct llc_linkcb *linkp;
{
	CHECK(linkp,ADM);
	CHECK(linkp,CONN);
	CHECK(linkp,RESET_WAIT);
	CHECK(linkp,RESET_CHECK);
	CHECK(linkp,SETUP);
	CHECK(linkp,RESET);
	CHECK(linkp,D_CONN);
	CHECK(linkp,ERROR);
	CHECK(linkp,NORMAL);
	CHECK(linkp,BUSY);
	CHECK(linkp,REJECT);
	CHECK(linkp,AWAIT);
	CHECK(linkp,AWAIT_BUSY);
	CHECK(linkp,AWAIT_REJECT);

	return "UNKNOWN - eh?";
}

void
llc_link_dump(linkp, message)
	struct llc_linkcb *linkp;
	const char *message;
{
	register int    i;

	/* print interface */
	printf("if %s%d\n", linkp->llcl_if->if_name, linkp->llcl_if->if_unit);

	/* print message */
	printf(">> %s <<\n", message);

	/* print MAC and LSAP */
	printf("llc addr ");
	for (i = 0; i < (SAL(linkp)->sdl_alen) - 2; i++)
		printf("%x:", (char) *(LLADDR(SAL(linkp)) + i) & 0xff);
	printf("%x,", (char) *(LLADDR(SAL(linkp)) + i) & 0xff);
	printf("%x\n", (char) *(LLADDR(SAL(linkp)) + i + 1) & 0xff);

	/* print state we're in and timers */
	printf("state %s, ", llc_getstatename(linkp));
	for (i = LLC_ACK_SHIFT; i < LLC_AGE_SHIFT; i++)
		printf("%s-%c %d/", timer_names[i],
		       (linkp->llcl_timerflags & (1 << i) ? 'R' : 'S'),
		       linkp->llcl_timers[i]);
	printf("%s-%c %d\n", timer_names[i], (linkp->llcl_timerflags & (1 << i) ?
					 'R' : 'S'), linkp->llcl_timers[i]);

	/* print flag values */
	printf("flags P %d/F %d/S %d/DATA %d/REMOTE_BUSY %d\n",
	       LLC_GETFLAG(linkp,P), LLC_GETFLAG(linkp,F),
	       LLC_GETFLAG(linkp,S),
	       LLC_GETFLAG(linkp,DATA), LLC_GETFLAG(linkp,REMOTE_BUSY));

	/* print send and receive state variables, ack, and window */
	printf("V(R) %d/V(S) %d/N(R) received %d/window %d/freeslot %d\n",
	       linkp->llcl_vs, linkp->llcl_vr, linkp->llcl_nr_received,
	       linkp->llcl_window, linkp->llcl_freeslot);

	/* further expansions can follow here */

}

void
llc_trace(linkp, level, message)
	struct llc_linkcb *linkp;
	int level;
	const char *message;
{
	if (linkp->llcl_sapinfo->si_trace && level > llc_tracelevel)
		llc_link_dump(linkp, message);
}