Add new files for HARP3

Host ATM Research Platform (HARP), Network Computing Services, Inc.
This software was developed with the support of the Defense Advanced
Research Projects Agency (DARPA).

1 files changed, 1336 insertions, 0 deletions

diff --git a/sys/netatm/spans/spans_if.c b/sys/netatm/spans/spans_if.c
new file mode 100644
index 0000000..4facf73
--- /dev/null
+++ b/sys/netatm/spans/spans_if.c
@@ -0,0 +1,1336 @@
+/*
+ *
+ * ===================================
+ * 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: spans_if.c,v 1.12 1998/08/26 23:29:09 mks Exp $
+ *
+ */
+
+/*
+ * SPANS Signalling Manager
+ * ---------------------------
+ *
+ * External interfaces to SPANS manager.  Includes support for
+ * running as a loadable kernel module.
+ *
+ */
+
+#ifndef lint
+static char *RCSid = "@(#) $Id: spans_if.c,v 1.12 1998/08/26 23:29:09 mks Exp $";
+#endif
+
+#ifndef ATM_SPANS_MODULE
+#include "opt_atm.h"
+#endif
+
+#include <netatm/kern_include.h>
+
+#include "spans_xdr.h"
+#include <netatm/spans/spans_var.h>
+
+/*
+ * Global variables
+ */
+struct sp_info	spans_vcpool = {
+	"spans vcc pool",		/* si_name */
+	sizeof(struct spans_vccb),	/* si_blksiz */
+	10,				/* si_blkcnt */
+	50				/* si_maxallow */
+};
+
+struct sp_info	spans_msgpool = {
+	"spans message pool",		/* si_name */
+	sizeof(spans_msg),		/* si_blksiz */
+	10,				/* si_blkcnt */
+	50				/* si_maxallow */
+};
+
+/*
+ * Local functions
+ */
+static int	spans_start __P((void));
+static int	spans_stop __P((void));
+static int	spans_attach __P((struct sigmgr *, struct atm_pif *));
+static int	spans_detach __P((struct atm_pif *));
+static int	spans_setup __P((Atm_connvc *, int *));
+static int	spans_release __P((struct vccb *, int *));
+static int	spans_accept __P((struct vccb *, int *));
+static int	spans_reject __P((struct vccb *, int *));
+static int	spans_ioctl __P((int, caddr_t, caddr_t));
+
+/*
+ * Local variables
+ */
+static struct sigmgr	*spans_mgr = NULL;
+
+
+/*
+ * Initialize SPANS processing
+ *
+ * This will be called during module loading.  We'll just register
+ * the SPANS protocol descriptor and wait for a SPANS ATM interface
+ * to come online.
+ *
+ * Arguments:
+ *	none
+ *
+ * Returns:
+ *	0	startup was successful
+ *	errno	startup failed - reason indicated
+ *
+ */
+static int
+spans_start()
+{
+	int	err = 0;
+
+	/*
+	 * Verify software version
+	 */
+	if (atm_version != ATM_VERSION) {
+		log(LOG_ERR, "version mismatch: spans=%d.%d kernel=%d.%d\n",
+				ATM_VERS_MAJ(ATM_VERSION),
+				ATM_VERS_MIN(ATM_VERSION),
+				ATM_VERS_MAJ(atm_version),
+				ATM_VERS_MIN(atm_version));
+		return (EINVAL);
+	}
+
+	/*
+	 * Allocate protocol definition structure
+	 */
+	spans_mgr = (struct sigmgr *)KM_ALLOC(sizeof(struct sigmgr),
+			M_DEVBUF, M_NOWAIT);
+	if (spans_mgr == NULL) {
+		err = ENOMEM;
+		goto done;
+	}
+	KM_ZERO(spans_mgr, sizeof(struct sigmgr));
+
+	/*
+	 * Initialize protocol invariant values
+	 */
+	spans_mgr->sm_proto = ATM_SIG_SPANS;
+	spans_mgr->sm_attach = spans_attach;
+	spans_mgr->sm_detach = spans_detach;
+	spans_mgr->sm_setup = spans_setup;
+	spans_mgr->sm_release = spans_release;
+	spans_mgr->sm_accept = spans_accept;
+	spans_mgr->sm_reject = spans_reject;
+	spans_mgr->sm_free = spans_free;
+	spans_mgr->sm_ioctl = spans_ioctl;
+
+	/*
+	 * Register ourselves with system
+	 */
+	err = atm_sigmgr_register(spans_mgr);
+	if (err)
+		goto done;
+
+	/*
+	 * Start up Connectionless Service
+	 */
+	err = spanscls_start();
+	if (err)
+		goto done;
+
+done:
+	return (err);
+}
+
+
+/*
+ * Halt SPANS processing
+ *
+ * This should be called just prior to unloading the module from
+ * memory.  All SPANS interfaces must be deregistered before the
+ * protocol can be shutdown.
+ *
+ * Arguments:
+ *	none
+ *
+ * Returns:
+ *	0	startup was successful
+ *	errno	startup failed - reason indicated
+ *
+ */
+static int
+spans_stop()
+{
+	int	err = 0;
+	int	s = splnet();
+
+	/*
+	 * Is protocol even set up?
+	 */
+	if (spans_mgr) {
+
+		/*
+		 * Any protocol instances still registered?
+		 */
+		if (spans_mgr->sm_prinst) {
+
+			/* Yes, can't stop now */
+			err = EBUSY;
+			goto done;
+		}
+
+		/*
+		 * Stop Connectionless Service
+		 */
+		spanscls_stop();
+
+		/*
+		 * De-register from system
+		 */
+		err = atm_sigmgr_deregister(spans_mgr);
+
+		/*
+		 * Free up protocol block
+		 */
+		KM_FREE(spans_mgr, sizeof(struct sigmgr), M_DEVBUF);
+		spans_mgr = NULL;
+
+		/*
+		 * Free up our storage pools
+		 */
+		atm_release_pool(&spans_vcpool);
+		atm_release_pool(&spans_msgpool);
+	} else
+		err = ENXIO;
+
+done:
+	(void) splx(s);
+	return (err);
+}
+
+
+/*
+ * Attach a SPANS-controlled interface
+ *
+ * Each ATM physical interface must be attached with the signalling
+ * manager for the interface's signalling protocol (via the
+ * atm_sigmgr_attach function).  This function will handle the
+ * attachment for SPANS-controlled interfaces.  A new SPANS protocol
+ * instance will be created and then we'll just sit around waiting for
+ * status or connection requests.
+ *
+ * Function must be called at splnet.
+ *
+ * Arguments:
+ *	smp	pointer to SPANS signalling manager control block
+ *	pip	pointer to ATM physical interface control block
+ *
+ * Returns:
+ *	0	attach successful
+ *	errno	attach failed - reason indicated
+ *
+ */
+static int
+spans_attach(smp, pip)
+	struct sigmgr	*smp;
+	struct atm_pif	*pip;
+{
+	int		err = 0, n = 0, s;
+	struct spans	*spp = NULL;
+	struct atm_nif	*np;
+
+	ATM_DEBUG2("spans_attach: smp=%x, pip=%x\n", smp, pip);
+
+	/*
+	 * Count network interfaces attached to the physical interface.
+	 * If there are more or less than one, we have big problems.
+	 */
+	np = pip->pif_nif;
+	while (np) {
+		n++;
+		np = np->nif_pnext;
+	}
+	if (n != 1) {
+		err = ETOOMANYREFS;
+		goto done;
+	}
+
+	/*
+	 * Allocate SPANS protocol instance control block
+	 */
+	spp = (struct spans *)KM_ALLOC(sizeof(struct spans),
+			M_DEVBUF, M_NOWAIT);
+	if (spp == NULL) {
+		err = ENOMEM;
+		goto done;
+	}
+	KM_ZERO(spp, sizeof(struct spans));
+
+	/*
+	 * Set variables in SPANS protocol instance control block
+	 */
+	spp->sp_state = SPANS_INIT;
+	spp->sp_h_epoch = time_second;
+	spp->sp_s_epoch = 0;
+	spp->sp_addr.address_format = T_ATM_ABSENT;
+	spp->sp_addr.address_length = 0;
+	spp->sp_subaddr.address_format = T_ATM_ABSENT;
+	spp->sp_subaddr.address_length = 0;
+	spp->sp_probe_ct = 0;
+	spp->sp_alloc_vci = SPANS_MIN_VCI;
+	spp->sp_alloc_vpi = SPANS_VPI;
+	spp->sp_min_vci = SPANS_MIN_VCI;
+	spp->sp_max_vci = pip->pif_maxvci;
+
+	/*
+	 * Link instance into manager's chain
+	 */
+	LINK2TAIL((struct siginst *)spp, struct siginst, smp->sm_prinst,
+			si_next);
+
+	/*
+	 * Link in interface
+	 */
+	spp->sp_pif = pip;
+	pip->pif_sigmgr = smp;
+	pip->pif_siginst = (struct siginst *) spp;
+
+	/*
+	 * Kick-start the SPANS protocol
+	 */
+	SPANS_TIMER(spp, 0);
+
+	/*
+	 * Notify Connectionless Service
+	 */
+	err = spanscls_attach(spp);
+
+	/*
+	 * Log the fact that we've attached
+	 */
+	if (!err)
+		log(LOG_INFO, "spans: attached to interface %s%d\n",
+				pip->pif_name, pip->pif_unit);
+
+done:
+	/*
+	 * Reset our work if attach fails
+	 */
+	if (err) {
+		if (spp) {
+			SPANS_CANCEL(spp);
+			UNLINK((struct siginst *)spp, struct siginst,
+					smp->sm_prinst, si_next);
+			KM_FREE(spp, sizeof(struct spans), M_DEVBUF);
+		}
+		s = splimp();
+		pip->pif_sigmgr = NULL;
+		pip->pif_siginst = NULL;
+		(void) splx(s);
+	}
+
+	return (err);
+}
+
+
+/*
+ * Detach a SPANS-controlled interface
+ *
+ * Each ATM physical interface may be detached from its signalling
+ * manager (via the atm_sigmgr_detach function).  This function will
+ * handle the detachment for all SPANS-controlled interfaces.  All
+ * circuits will be immediately terminated.
+ *
+ * Function must be called at splnet.
+ *
+ * Arguments:
+ *	pip	pointer to ATM physical interface control block
+ *
+ * Returns:
+ *	0	detach successful
+ *	errno	detach failed - reason indicated
+ *
+ */
+static int
+spans_detach(pip)
+	struct atm_pif	*pip;
+{
+	struct spans		*spp;
+	struct vccb		*vcp, *vnext;
+	Atm_connection		*cop;
+	int			err;
+
+	ATM_DEBUG1("spans_detach: pip=0x%x\n", pip);
+
+	/*
+	 * Get SPANS protocol instance
+	 */
+	spp = (struct spans *)pip->pif_siginst;
+
+	/*
+	 * Return an error if we're already detaching
+	 */
+	if (spp->sp_state == SPANS_DETACH) {
+		return(EALREADY);
+	}
+
+	/*
+	 * Cancel any outstanding timer
+	 */
+	SPANS_CANCEL(spp);
+
+	/*
+	 * Notify Connectionless Service
+	 */
+	spanscls_detach(spp);
+
+	/*
+	 * Terminate all of our VCCs
+	 */
+	for (vcp = Q_HEAD(spp->sp_vccq, struct vccb); vcp; vcp = vnext) {
+
+		vnext = Q_NEXT(vcp, struct vccb, vc_sigelem);
+
+		/*
+		 * Don't close the signalling VCC yet
+		 */
+		if (vcp->vc_connvc && vcp->vc_connvc->cvc_conn ==
+				spp->sp_conn)
+			continue;
+
+		/*
+		 * Close VCC and notify owner
+		 */
+		err = spans_clear_vcc(spp, (struct spans_vccb *)vcp);
+		if (err) {
+			log(LOG_ERR, "spans: error %d clearing VCCB 0x%x\n",
+					err, vcp);
+		}
+	}
+
+	/*
+	 * Now close the SPANS signalling VCC
+	 */
+	if (cop = spp->sp_conn) {
+		err = atm_cm_release(cop, &spans_cause);
+		if (err)
+			ATM_DEBUG2(
+					"spans_detach: close failed for SPANS signalling channel; cop=0x%x, err=%d\n",
+					cop, err);
+	}
+	
+
+	/*
+	 * Get rid of protocol instance if there are no VCCs queued
+	 */
+	if (Q_HEAD(spp->sp_vccq, struct vccb) == NULL) {
+		struct sigmgr   *smp = pip->pif_sigmgr;
+
+		pip->pif_sigmgr = NULL;
+		pip->pif_siginst = NULL;
+		UNLINK((struct siginst *)spp, struct siginst,
+				smp->sm_prinst, si_next);
+		KM_FREE(spp, sizeof(struct spans), M_DEVBUF);
+	} else {
+		/*
+		 * Otherwise, wait for protocol instance to be freed
+		 * during spans_free processing for the last queued VCC.
+		 */
+		spp->sp_state = SPANS_DETACH;
+	}
+
+	/*
+	 * Log the fact that we've detached
+	 */
+	log(LOG_INFO, "spans: detached from interface %s%d\n",
+			pip->pif_name, pip->pif_unit);
+
+	return (0);
+}
+
+
+/*
+ * Open a SPANS ATM Connection
+ *
+ * All service user requests to open a VC connection (via
+ * atm_open_connection) over an ATM interface attached to the SPANS
+ * signalling manager are handled here.
+ *
+ * Function will be called at splnet.
+ *
+ * Arguments:
+ *	cvp	pointer to user's requested connection parameters
+ *	errp	pointer to an int for extended error information
+ *
+ * Returns:
+ *	CALL_PROCEEDING	connection establishment is in progress
+ *	CALL_FAILED	connection establishment failed
+ *	CALL_CONNECTED	connection has been successfully established
+ *
+ */
+static int
+spans_setup(cvp, errp)
+	Atm_connvc	*cvp;
+	int		*errp;
+{
+	struct atm_pif	*pip = cvp->cvc_attr.nif->nif_pif;
+	struct spans	*spp = (struct spans *)pip->pif_siginst;
+	int		rc = 0;
+
+	ATM_DEBUG1("spans_setup: cvp=0x%x\n", cvp);
+
+	/*
+	 * Intialize the returned error code
+	 */
+	*errp = 0;
+
+	/*
+	 * Open the connection
+	 */
+	switch (cvp->cvc_attr.called.addr.address_format) {
+	case T_ATM_PVC_ADDR:
+		/*
+		 * Create a PVC
+		 */
+		*errp = spans_open_vcc(spp, cvp);
+		rc = (*errp ? CALL_FAILED : CALL_CONNECTED);
+		break;
+
+	case T_ATM_SPANS_ADDR:
+
+		/*
+		 * Create an SVC
+		 */
+		*errp = spans_open_vcc(spp, cvp);
+		rc = (*errp ? CALL_FAILED : CALL_PROCEEDING);
+		break;
+
+	default:
+		*errp = EPROTONOSUPPORT;
+		rc = CALL_FAILED;
+	}
+
+	return (rc);
+}
+
+
+/*
+ * Close a SPANS ATM Connection
+ *
+ * All service user requests to terminate a previously open VC
+ * connection (via the atm_close_connection function), which is running
+ * over an interface attached to the SPANS signalling manager, are
+ * handled here.
+ *
+ * Function will be called at splnet.
+ *
+ * Arguments:
+ *	vcp	pointer to connection's VC control block
+ *	errp	pointer to an int for extended error information
+ *
+ * Returns:
+ *	CALL_PROCEEDING	connection termination is in progress
+ *	CALL_FAILED	connection termination failed
+ *	CALL_CLEARED	connection has been successfully terminated
+ *
+ */
+static int
+spans_release(vcp, errp)
+	struct vccb	*vcp;
+	int		*errp;
+{
+	int		rc = 0;
+	struct atm_pif	*pip = vcp->vc_pif;
+	struct spans	*spp = (struct spans *)pip->pif_siginst;
+
+	ATM_DEBUG1("spans_release: vcp=0x%x\n", vcp);
+
+	/*
+	 * Initialize returned error code
+	 */
+	*errp = 0;
+
+	/*
+	 * Make sure VCC is open
+	 */
+	if ((vcp->vc_sstate == SPANS_VC_NULL) ||
+			(vcp->vc_sstate == SPANS_VC_CLOSE) ||
+			(vcp->vc_sstate == SPANS_VC_FREE) ||
+			(vcp->vc_ustate == VCCU_NULL) ||
+			(vcp->vc_ustate == VCCU_CLOSED)) {
+		*errp = EALREADY;
+		return(CALL_FAILED);
+	}
+
+	/*
+	 * Validate the connection type (PVC or SVC)
+	 */
+	if (!(vcp->vc_type & (VCC_PVC | VCC_SVC))) {
+		*errp = EPROTONOSUPPORT;
+		return(CALL_FAILED);
+	}
+
+	/*
+	 * Close the VCCB
+	 */
+	*errp = spans_close_vcc(spp, (struct spans_vccb *)vcp, FALSE);
+
+	/*
+	 * Set the return code
+	 */
+	if (vcp->vc_type & VCC_PVC) {
+		rc = (*errp ? CALL_FAILED : CALL_CLEARED);
+	} else {
+		rc = (*errp ? CALL_FAILED : CALL_PROCEEDING);
+	}
+
+	return (rc);
+}
+
+
+/*
+ * Accept a SPANS Open from a remote host
+ *
+ * A user calls this routine (via the atm_accept_call function)
+ * after it is notified that an open request was received for it.
+ *
+ * Function will be called at splnet.
+ *
+ * Arguments:
+ *	vcp	pointer to user's VCCB
+ *	errp	pointer to an int for extended error information
+ *
+ * Returns:
+ *	CALL_PROCEEDING	connection establishment is in progress
+ *	CALL_FAILED	connection establishment failed
+ *	CALL_CONNECTED	connection has been successfully established
+ *
+ */
+static int
+spans_accept(vcp, errp)
+	struct vccb	*vcp;
+	int		*errp;
+{
+	struct atm_pif		*pip = vcp->vc_pif;
+	struct spans		*spp = (struct spans *)pip->pif_siginst;
+	struct spans_vccb	*svp = (struct spans_vccb *)vcp;
+
+	ATM_DEBUG1("spans_accept: vcp=0x%x\n", vcp);
+
+	/*
+	 * Initialize the returned error code
+	 */
+	*errp = 0;
+
+	/*
+	 * Return an error if we're detaching
+	 */
+	if (spp->sp_state == SPANS_DETACH) {
+		*errp = ENETDOWN;
+		ATM_DEBUG0("spans_accept: detaching\n");
+		return(CALL_FAILED);
+	}
+
+	/*
+	 * Respond to the open request
+	 */
+	*errp = spans_send_open_rsp(spp, svp, SPANS_OK);
+	if (*errp) {
+		ATM_DEBUG0("spans_accept: spans_send_open_rsp failed\n");
+		goto failed;
+	}
+
+	/*
+	 * Update the VCC states
+	 */
+	svp->sv_sstate = SPANS_VC_OPEN;
+	svp->sv_ustate = VCCU_OPEN;
+
+	return(CALL_CONNECTED);
+
+failed:
+	/*
+	 * On error, free the VCCB and return CALL_FAILED
+	 */
+	svp->sv_sstate = SPANS_VC_FREE;
+	svp->sv_ustate = VCCU_CLOSED;
+	DEQUEUE(svp, struct spans_vccb, sv_sigelem, spp->sp_vccq);
+	spans_free((struct vccb *)svp);
+
+	return(CALL_FAILED);
+}
+
+
+/*
+ * Reject a SPANS Open from a remote host
+ *
+ * A user calls this routine (via the atm_reject_call function)
+ * after it is notified that an open request was received for it.
+ *
+ * Function will be called at splnet.
+ *
+ * Arguments:
+ *	vcp	pointer to user's VCCB
+ *	errp	pointer to an int for extended error information
+ *
+ * Returns:
+ *	CALL_CLEARED	call request rejected
+ *	CALL_FAILED	call rejection failed
+ *
+ */
+static int
+spans_reject(vcp, errp)
+	struct vccb	*vcp;
+	int		*errp;
+{
+	struct atm_pif		*pip = vcp->vc_pif;
+	struct spans		*spp = (struct spans *)pip->pif_siginst;
+	struct spans_vccb	*svp = (struct spans_vccb *)vcp;
+
+	ATM_DEBUG1("spans_reject: vcp=0x%x\n", vcp);
+
+	/*
+	 * Initialize the returned error code
+	 */
+	*errp = 0;
+
+	/*
+	 * Return an error if we're detaching
+	 */
+	if (spp->sp_state == SPANS_DETACH) {
+		*errp = ENETDOWN;
+		ATM_DEBUG0("spans_reject: detaching\n");
+		return(CALL_FAILED);
+	}
+
+	ATM_DEBUG1("spans_reject: cause code is %d\n",
+			vcp->vc_connvc->cvc_attr.cause.v.cause_value);
+
+	/*
+	 * Clean up the VCCB--the connection manager will free it
+	 * spans_close_vcc will send a SPANS open response
+	 */
+	if (*errp = spans_close_vcc(spp, svp, TRUE)) {
+		ATM_DEBUG0("spans_reject: spans_close_vcc failed\n");
+		return(CALL_FAILED);
+	}
+
+	return(CALL_CLEARED);
+}
+
+
+/*
+ * Abort a SPANS ATM Connection
+ *
+ * All (non-user) requests to abort a previously open VC connection (via
+ * the atm_abort_connection function), which is running over an
+ * interface attached to the SPANS signalling manager, are handled here.
+ * The VCC owner will be notified of the request, in order to initiate
+ * termination of the connection.
+ *
+ * Function will be called at splnet.
+ *
+ * Arguments:
+ *	vcp	pointer to connection's VC control block
+ *
+ * Returns:
+ *	0	connection release was succesful
+ *	errno	connection release failed - reason indicated
+ *
+ */
+int
+spans_abort(vcp)
+	struct vccb	*vcp;
+{
+
+	/*
+	 * Make sure VCC is available
+	 */
+	if ((vcp->vc_sstate == SPANS_VC_NULL) ||
+			(vcp->vc_sstate == SPANS_VC_CLOSE) ||
+			(vcp->vc_sstate == SPANS_VC_FREE) ||
+			(vcp->vc_ustate == VCCU_NULL) ||
+			(vcp->vc_ustate == VCCU_CLOSED)) {
+		return(EALREADY);
+	}
+
+	/*
+	 * Only abort once
+	 */
+	if (vcp->vc_sstate == SPANS_VC_ABORT) {
+		return (EALREADY);
+	}
+
+	/*
+	 * Cancel any timer that might be running
+	 */
+	SPANS_VC_CANCEL(vcp);
+
+	/*
+	 * Set immediate timer to schedule connection termination
+	 */
+	vcp->vc_sstate = SPANS_VC_ABORT;
+	SPANS_VC_TIMER(vcp, 0);
+
+	return (0);
+}
+
+
+/*
+ * Free SPANS ATM connection resources
+ *
+ * All service user requests to free the resources of a closed
+ * VCC connection (via the atm_free_connection function), which
+ * is running over an interface attached to the SigPVC signalling
+ * manager, are handled here.
+ *
+ * Function will be called at splnet.
+ *
+ * Arguments:
+ *	vcp	pointer to connection's VC control block
+ *
+ * Returns:
+ *	0	connection free was successful
+ *	errno	connection free failed - reason indicated
+ *
+ */
+int
+spans_free(vcp)
+	struct vccb	*vcp;
+{
+	struct atm_pif *pip = vcp->vc_pif;
+	struct spans *spp = (struct spans *)pip->pif_siginst;
+
+	ATM_DEBUG1("spans_free: vcp = 0x%x\n", vcp);
+
+	/*
+	 * Make sure VCC has been closed
+	 */
+	if ((vcp->vc_ustate != VCCU_CLOSED) ||
+			(vcp->vc_sstate != SPANS_VC_FREE)) {
+		ATM_DEBUG2("spans_free: bad state, sstate=%d, ustate=%d\n",
+				vcp->vc_sstate, vcp->vc_ustate);
+		return(EEXIST);
+	}
+
+	/*
+	 * Remove VCCB from protocol queue
+	 */
+	DEQUEUE(vcp, struct vccb, vc_sigelem, spp->sp_vccq);
+
+	/*
+	 * Free VCCB storage
+	 */
+	vcp->vc_ustate = VCCU_NULL;
+	vcp->vc_sstate = SPANS_VC_NULL;
+	atm_free((caddr_t)vcp);
+
+	/*
+	 * If we're detaching and this was the last VCC queued,
+	 * get rid of the protocol instance
+	 */
+	if ((spp->sp_state == SPANS_DETACH) &&
+			(Q_HEAD(spp->sp_vccq, struct vccb) == NULL)) {
+		struct sigmgr   *smp = pip->pif_sigmgr;
+
+		pip->pif_sigmgr = NULL;
+		pip->pif_siginst = NULL;
+		UNLINK((struct siginst *)spp, struct siginst, smp->sm_prinst,
+				si_next);
+		KM_FREE(spp, sizeof(struct spans), M_DEVBUF);
+	}
+
+	return (0);
+}
+
+
+/*
+ * SPANS IOCTL support
+ *
+ * Function will be called at splnet.
+ *
+ * Arguments:
+ *	code	PF_ATM sub-operation code
+ *      data    pointer to code specific parameter data area
+ *      arg1    pointer to code specific argument
+ *
+ * Returns:
+ *	0	request procesed
+ *	errno	error processing request - reason indicated
+ *
+ */
+static int
+spans_ioctl(code, data, arg1)
+        int		code;
+        caddr_t		data;
+        caddr_t		arg1;
+{
+	struct atmdelreq	*adp;
+	struct atminfreq	*aip;
+	struct spans		*spp;
+	struct spans_vccb	*svp;
+	struct air_vcc_rsp	rsp;
+	Atm_connection		*cop;
+	int			buf_len, err = 0, i, vpi, vci;
+	caddr_t			buf_addr;
+
+
+	switch (code) {
+
+	case AIOCS_DEL_PVC:
+	case AIOCS_DEL_SVC:
+		/*
+		 * Delete a VCC
+		 */
+		adp = (struct atmdelreq *)data;
+		spp = (struct spans *)arg1;
+
+		/*
+		 * Don't let a user close the SPANS signalling VC or
+		 * the SPANS CLS VC
+		 */
+		vpi = adp->adr_pvc_vpi;
+		vci = adp->adr_pvc_vci;
+		if ((vpi == SPANS_SIG_VPI && vci == SPANS_SIG_VCI) ||
+				(vpi == SPANS_CLS_VPI &&
+				vci == SPANS_CLS_VCI))
+			return(EINVAL);
+
+		/*
+		 * Find requested VCC
+		 */
+		for (svp = Q_HEAD(spp->sp_vccq, struct spans_vccb); svp;
+				svp = Q_NEXT(svp, struct spans_vccb, sv_sigelem)) {
+			if ((svp->sv_vpi == vpi) && (svp->sv_vci == vci))
+				break;
+		}
+		if (svp == NULL)
+			return (ENOENT);
+
+		/*
+		 * Check VCC type
+		 */
+		switch (code) {
+		case AIOCS_DEL_PVC:
+			if (!(svp->sv_type & VCC_PVC)) {
+				return(EINVAL);
+			}
+			break;
+		case AIOCS_DEL_SVC:
+			if (!(svp->sv_type & VCC_SVC)) {
+				return(EINVAL);
+			}
+			break;
+		}
+
+		/*
+		 * Schedule VCC termination
+		 */
+		err = spans_abort((struct vccb *)svp);
+		break;
+
+	case AIOCS_INF_VCC:
+		/*
+		 * Return VCC information
+		 */
+		aip = (struct atminfreq *)data;
+		spp = (struct spans *)arg1;
+
+		buf_addr = aip->air_buf_addr;
+		buf_len = aip->air_buf_len;
+
+		/*
+		 * Loop through the VCC queue
+		 */
+		for (svp = Q_HEAD(spp->sp_vccq, struct spans_vccb); svp;
+				svp = Q_NEXT(svp, struct spans_vccb, sv_sigelem)) {
+			/*
+			 * Make sure there's room in the user's buffer
+			 */
+			if (buf_len < sizeof(rsp)) {
+				err = ENOSPC;
+				break;
+			}
+
+			/*
+			 * Fill out the response struct for the VCC
+			 */
+			(void) sprintf(rsp.avp_intf, "%s%d",
+					spp->sp_pif->pif_name,
+					spp->sp_pif->pif_unit);
+			rsp.avp_vpi = svp->sv_vpi;
+			rsp.avp_vci = svp->sv_vci;
+			rsp.avp_type = svp->sv_type;
+			rsp.avp_aal = svp->sv_connvc->cvc_attr.aal.type;
+			rsp.avp_sig_proto = svp->sv_proto;
+			cop = svp->sv_connvc->cvc_conn;
+			if (cop)
+				rsp.avp_encaps = cop->co_mpx;
+			else
+				rsp.avp_encaps = 0;
+			rsp.avp_state = svp->sv_sstate;
+			KM_ZERO(rsp.avp_owners, sizeof(rsp.avp_owners));
+			for (i = 0; cop && i < sizeof(rsp.avp_owners);
+					cop = cop->co_next,
+					i += T_ATM_APP_NAME_LEN+1) {
+				strncpy(&rsp.avp_owners[i],
+					cop->co_endpt->ep_getname(cop->co_toku),
+					T_ATM_APP_NAME_LEN);
+			}
+			rsp.avp_daddr.address_format = T_ATM_SPANS_ADDR;
+			rsp.avp_daddr.address_length = 
+					sizeof(Atm_addr_spans);
+			if (svp->sv_type & VCC_OUT) {
+				spans_addr_copy(&svp->sv_conn.con_dst,
+						rsp.avp_daddr.address);
+			} else {
+				spans_addr_copy(&svp->sv_conn.con_src,
+						rsp.avp_daddr.address);
+			}
+			rsp.avp_dsubaddr.address_format = T_ATM_ABSENT;
+			rsp.avp_dsubaddr.address_length = 0;
+			rsp.avp_ipdus = svp->sv_ipdus;
+			rsp.avp_opdus = svp->sv_opdus;
+			rsp.avp_ibytes = svp->sv_ibytes;
+			rsp.avp_obytes = svp->sv_obytes;
+			rsp.avp_ierrors = svp->sv_ierrors;
+			rsp.avp_oerrors = svp->sv_oerrors;
+			rsp.avp_tstamp = svp->sv_tstamp;
+
+			/*
+			 * Copy the response into the user's buffer
+			 */
+			if (err = copyout((caddr_t)&rsp, buf_addr,
+					sizeof(rsp)))
+				break;
+			buf_addr += sizeof(rsp);
+			buf_len -= sizeof(rsp);
+		}
+
+		/*
+		 * Update the buffer pointer and length
+		 */
+		aip->air_buf_addr = buf_addr;
+		aip->air_buf_len = buf_len;
+		break;
+
+	case AIOCS_ADD_ARP:
+	case AIOCS_DEL_ARP:
+	case AIOCS_INF_ARP:
+	case AIOCS_INF_ASV:
+		/*
+		 * ARP specific ioctl's
+		 */
+		err = spansarp_ioctl(code, data, arg1);
+		break;
+
+	default:
+		err = EOPNOTSUPP;
+	}
+
+	return (err);
+}
+
+
+#ifdef ATM_SPANS_MODULE
+/*
+ *******************************************************************
+ *
+ * Loadable Module Support
+ *
+ *******************************************************************
+ */
+static int	spans_doload __P((void));
+static int	spans_dounload __P((void));
+
+/*
+ * Generic module load processing
+ * 
+ * This function is called by an OS-specific function when this
+ * module is being loaded.
+ *
+ * Arguments:
+ *	none
+ *
+ * Returns:
+ *	0 	load was successful 
+ *	errno	load failed - reason indicated
+ *
+ */
+static int
+spans_doload()
+{
+	int	err = 0;
+
+	/*
+	 * Start us up
+	 */
+	err = spans_start();
+	if (err)
+		/* Problems, clean up */
+		(void)spans_stop();
+
+	return (err);
+}
+
+
+/*
+ * Generic module unload processing
+ * 
+ * This function is called by an OS-specific function when this
+ * module is being unloaded.
+ *
+ * Arguments:
+ *	none
+ *
+ * Returns:
+ *	0 	unload was successful 
+ *	errno	unload failed - reason indicated
+ *
+ */
+static int
+spans_dounload()
+{
+	int	err = 0;
+
+	/*
+	 * OK, try to clean up our mess
+	 */
+	err = spans_stop();
+
+	return (err);
+}
+
+
+#ifdef sun
+/*
+ * Loadable driver description
+ */
+struct vdldrv spans_drv = {
+	VDMAGIC_PSEUDO,	/* Pseudo Driver */
+	"spans_mod",	/* name */
+	NULL,		/* dev_ops */
+	NULL,		/* bdevsw */
+	NULL,		/* cdevsw */
+	0,		/* blockmajor */
+	0		/* charmajor */
+};
+
+
+/*
+ * Loadable module support entry point
+ * 
+ * This is the routine called by the vd driver for all loadable module
+ * functions for this pseudo driver.  This routine name must be specified
+ * on the modload(1) command.  This routine will be called whenever the
+ * modload(1), modunload(1) or modstat(1) commands are issued for this
+ * module.
+ *
+ * Arguments:
+ *	cmd	vd command code
+ *	vdp	pointer to vd driver's structure
+ *	vdi	pointer to command-specific vdioctl_* structure
+ *	vds	pointer to status structure (VDSTAT only)
+ *
+ * Returns:
+ *	0 	command was successful 
+ *	errno	command failed - reason indicated
+ *
+ */
+int
+spans_mod(cmd, vdp, vdi, vds)
+	int		cmd;
+	struct vddrv	*vdp;
+	caddr_t		vdi;
+	struct vdstat	*vds;
+{
+	int	err = 0;
+
+	switch (cmd) {
+
+	case VDLOAD:
+		/*
+		 * Module Load
+		 *
+		 * We dont support any user configuration
+		 */
+		err = spans_doload();
+		if (err == 0)
+			/* Let vd driver know about us */
+			vdp->vdd_vdtab = (struct vdlinkage *)&spans_drv;
+		break;
+
+	case VDUNLOAD:
+		/*
+		 * Module Unload
+		 */
+		err = spans_dounload();
+		break;
+
+	case VDSTAT:
+		/*
+		 * Module Status
+		 */
+
+		/* Not much to say at the moment */
+
+		break;
+
+	default:
+		log(LOG_ERR, "spans_mod: Unknown vd command 0x%x\n", cmd);
+		err = EINVAL;
+	}
+
+	return (err);
+}
+#endif	/* sun */
+
+#ifdef __FreeBSD__
+
+#include <sys/exec.h>
+#include <sys/sysent.h>
+#include <sys/lkm.h>
+
+/*
+ * Loadable miscellaneous module description
+ */
+MOD_MISC(spans);
+
+
+/*
+ * Loadable module support "load" entry point
+ * 
+ * This is the routine called by the lkm driver whenever the
+ * modload(1) command is issued for this module.
+ *
+ * Arguments:
+ *	lkmtp	pointer to lkm drivers's structure
+ *	cmd	lkm command code
+ *
+ * Returns:
+ *	0 	command was successful 
+ *	errno	command failed - reason indicated
+ *
+ */
+static int
+spans_load(lkmtp, cmd)
+	struct lkm_table	*lkmtp;
+	int		cmd;
+{
+	return(spans_doload());
+}
+
+
+/*
+ * Loadable module support "unload" entry point
+ * 
+ * This is the routine called by the lkm driver whenever the
+ * modunload(1) command is issued for this module.
+ *
+ * Arguments:
+ *	lkmtp	pointer to lkm drivers's structure
+ *	cmd	lkm command code
+ *
+ * Returns:
+ *	0 	command was successful 
+ *	errno	command failed - reason indicated
+ *
+ */
+static int
+spans_unload(lkmtp, cmd)
+	struct lkm_table	*lkmtp;
+	int		cmd;
+{
+	return(spans_dounload());
+}
+
+
+/*
+ * Loadable module support entry point
+ * 
+ * This is the routine called by the lkm driver for all loadable module
+ * functions for this driver.  This routine name must be specified
+ * on the modload(1) command.  This routine will be called whenever the
+ * modload(1), modunload(1) or modstat(1) commands are issued for this
+ * module.
+ *
+ * Arguments:
+ *	lkmtp	pointer to lkm drivers's structure
+ *	cmd	lkm command code
+ *	ver	lkm version
+ *
+ * Returns:
+ *	0 	command was successful 
+ *	errno	command failed - reason indicated
+ *
+ */
+int
+spans_mod(lkmtp, cmd, ver)
+	struct lkm_table	*lkmtp;
+	int		cmd;
+	int		ver;
+{
+	MOD_DISPATCH(spans, lkmtp, cmd, ver,
+		spans_load, spans_unload, lkm_nullcmd);
+}
+#endif	/* __FreeBSD__ */
+
+#else	/* !ATM_SPANS_MODULE */
+
+/*
+ *******************************************************************
+ *
+ * Kernel Compiled Module Support
+ *
+ *******************************************************************
+ */
+static void	spans_doload __P((void *));
+
+SYSINIT(atmspans, SI_SUB_PROTO_END, SI_ORDER_ANY, spans_doload, NULL)
+
+/*
+ * Kernel initialization
+ * 
+ * Arguments:
+ *	arg	Not used
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_doload(void *arg)
+{
+	int	err = 0;
+
+	/*
+	 * Start us up
+	 */
+	err = spans_start();
+	if (err) {
+		/* Problems, clean up */
+		(void)spans_stop();
+
+		log(LOG_ERR, "ATM SPANS unable to initialize (%d)!!\n", err);
+	}
+	return;
+}
+#endif	/* ATM_SPANS_MODULE */
+