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, 1633 insertions, 0 deletions

diff --git a/sys/netatm/spans/spans_msg.c b/sys/netatm/spans/spans_msg.c
new file mode 100644
index 0000000..0dc5df9
--- /dev/null
+++ b/sys/netatm/spans/spans_msg.c
@@ -0,0 +1,1633 @@
+/*
+ *
+ * ===================================
+ * 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_msg.c,v 1.8 1998/08/26 23:29:09 mks Exp $
+ *
+ */
+
+/*
+ * SPANS Signalling Manager
+ * ---------------------------
+ *
+ * SPANS signalling message processing.
+ *
+ */
+
+#ifndef lint
+static char *RCSid = "@(#) $Id: spans_msg.c,v 1.8 1998/08/26 23:29:09 mks Exp $";
+#endif
+
+#include <netatm/kern_include.h>
+
+#include <rpc/rpc.h>
+#include "spans_xdr.h"
+#include <netatm/spans/spans_var.h>
+
+/*
+ * External functions
+ */
+void		xdrmbuf_init __P((XDR *, KBuffer *, enum xdr_op));
+
+/*
+ * Local functions
+ */
+static void	spans_host_link __P((struct spans *, long));
+static void	spans_status_ind __P((struct spans *, spans_msg *));
+static void	spans_status_rsp __P((struct spans *, spans_msg *));
+static void	spans_open_req __P((struct spans *, spans_msg *));
+static void	spans_open_rsp __P((struct spans *, spans_msg *));
+static void	spans_close_req __P((struct spans *, spans_msg *));
+static void	spans_close_rsp __P((struct spans *, spans_msg *));
+static void	spans_multi_req __P((struct spans *, spans_msg *));
+static void	spans_add_req __P((struct spans *, spans_msg *));
+static void	spans_join_req __P((struct spans *, spans_msg *));
+static void	spans_leave_req __P((struct spans *, spans_msg *));
+static void	spans_vcir_ind __P((struct spans *, spans_msg *));
+static void	spans_query_req __P((struct spans *, spans_msg *));
+
+
+/*
+ * Called to set status when a status message comes in from a host
+ * connected back-to-back with us.  Check the epoch and, if it has
+ * changed, set the appropriate state and save updated state
+ * information.
+ *
+ * Arguments:
+ *	spp		pointer to SPANS protocol instance block
+ *	host_epoch	epoch of host at far end of link
+ *
+ * Returns:
+ *	0	message sent OK
+ *	errno	error encountered
+ *
+ */
+static void
+spans_host_link(spp, host_epoch)
+	struct spans	*spp;
+	long	host_epoch;
+{
+	struct atm_pif	*pip = spp->sp_pif;
+
+	/*
+	 * There's a host at the other end of the link.  If its
+	 * epoch has changed, clean up our state and save the
+	 * new information.
+	 */
+	if (spp->sp_s_epoch != host_epoch) {
+		spp->sp_s_epoch = host_epoch;
+		spans_switch_reset(spp, SPANS_UNI_UP);
+		spp->sp_addr.address_format = T_ATM_SPANS_ADDR;
+		spp->sp_addr.address_length = sizeof(spans_addr);
+		KM_COPY(&pip->pif_macaddr.ma_data[2],
+				&spp->sp_addr.address[4],
+				4);
+		log(LOG_INFO,
+		"spans: using SPANS address of %s on interface %s%d\n",
+			spans_addr_print((spans_addr *)spp->sp_addr.address),
+			pip->pif_name,
+			pip->pif_unit);
+	}
+}
+
+/*
+ * Send a SPANS signalling message
+ *
+ * Called to send a SPANS message.  This routine gets a buffer, performs
+ * XDR processing, and hands the message to the AAL for transmission.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to status message
+ *
+ * Returns:
+ *	0	message sent OK
+ *	errno	error encountered
+ *
+ */
+int
+spans_send_msg(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	int		err = 0;
+	KBuffer		*m;
+	XDR		xdrs;
+
+#ifdef NOTDEF
+	ATM_DEBUG2("spans_send_msg: msg=0x%x, type=%d\n", msg,
+			msg->sm_type);
+	if (msg->sm_type != SPANS_STAT_REQ &&
+			msg->sm_type != SPANS_STAT_IND &&
+			msg->sm_type != SPANS_STAT_RSP) {
+		printf("spans_send_msg: sending ");
+		spans_print_msg(msg);
+	}
+#endif
+
+	/*
+	 * If the signalling channel has been closed, don't do anything
+	 */
+	if (!spp->sp_conn)
+		return(ECONNABORTED);
+
+	/*
+	 * Get a buffer
+	 */
+	KB_ALLOCPKT(m, sizeof(spans_msg), KB_F_NOWAIT, KB_T_DATA);
+	if (m == NULL) {
+		/* No buffer available */
+		return(ENOBUFS);
+	}
+
+	/*
+	 * Convert message to network order
+	 */
+	KB_LEN(m) = KB_BFRLEN(m);
+	xdrmbuf_init(&xdrs, m, XDR_ENCODE);
+	if (!xdr_spans_msg(&xdrs, msg)) {
+		log(LOG_ERR, "spans_send_msg: XDR encode failed\n");
+		KB_LEN(m) = XDR_GETPOS(&xdrs);
+		spans_dump_buffer(m);
+		KB_FREEALL(m);
+		return(EIO);
+	}
+	KB_LEN(m) = XDR_GETPOS(&xdrs);
+
+	/*
+	 * Send the message
+	 */
+	err = atm_cm_cpcs_data(spp->sp_conn, m);
+	if (err)
+		KB_FREEALL(m);
+
+	return(err);
+}
+
+
+/*
+ * Send an open request
+ *
+ * Build and send an open request.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	svp	pointer to VCCB for which the request is being sent
+ *
+ * Returns:
+ *	none
+ *
+ */
+int
+spans_send_open_req(spp, svp)
+	struct	spans		*spp;
+	struct	spans_vccb	*svp;
+{
+	spans_msg	*req;
+	int		err = 0;
+
+	ATM_DEBUG1("spans_send_open_req: svp=0x%x\n", svp);
+
+	/*
+	 * Get memory for a request message
+	 */
+	req = (spans_msg *)atm_allocate(&spans_msgpool);
+	if (req == NULL) {
+		err = ENOBUFS;
+		goto done;
+	}
+
+	/*
+	 * Fill in the request
+	 */
+	req->sm_vers = SPANS_VERS_1_0;
+	req->sm_type = SPANS_OPEN_REQ;
+	req->sm_open_req.opreq_conn = svp->sv_conn;
+	req->sm_open_req.opreq_aal = svp->sv_spans_aal;
+	req->sm_open_req.opreq_desrsrc = svp->sv_spans_qos;
+	req->sm_open_req.opreq_minrsrc.rsc_peak = 0;
+	req->sm_open_req.opreq_minrsrc.rsc_mean = 0;
+	req->sm_open_req.opreq_minrsrc.rsc_burst = 0;
+	req->sm_open_req.opreq_vpvc.vpf_valid = FALSE;
+
+	/*
+	 * Send the request
+	 */
+	err = spans_send_msg(spp, req);
+	atm_free(req);
+
+done:
+	return(err);
+}
+
+
+/*
+ * Send an open response
+ *
+ * Build and send a response to an open request or open indication.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	svp	pointer to VCCB for which the response is being sent
+ *	result	result code to include in the response
+ *
+ * Returns:
+ *	none
+ *
+ */
+int
+spans_send_open_rsp(spp, svp, result)
+	struct	spans		*spp;
+	struct	spans_vccb	*svp;
+	spans_result		result;
+{
+	spans_msg	*rsp;
+	int		rc;
+
+	ATM_DEBUG2("spans_send_open_rsp: svp=0x%x, result=%d\n", svp,
+			result);
+
+	/*
+	 * Get memory for a response message
+	 */
+	rsp = (spans_msg *)atm_allocate(&spans_msgpool);
+	if (rsp == NULL)
+		return(ENOBUFS);
+
+	/*
+	 * Fill in the response
+	 */
+	rsp->sm_vers = SPANS_VERS_1_0;
+	rsp->sm_type = SPANS_OPEN_RSP;
+	rsp->sm_open_rsp.oprsp_conn = svp->sv_conn;
+	rsp->sm_open_rsp.oprsp_result = result;
+	rsp->sm_open_rsp.oprsp_rsrc = svp->sv_spans_qos;
+	rsp->sm_open_rsp.oprsp_vpvc =
+			SPANS_PACK_VPIVCI(svp->sv_vpi, svp->sv_vci);
+
+	/*
+	 * Send the response
+	 */
+	rc = spans_send_msg(spp, rsp);
+	atm_free(rsp);
+
+	return(rc);
+}
+
+
+/*
+ * Send a close request
+ *
+ * Called to send a close request.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	svp	pointer to VCCB for which the close is being sent
+ *
+ * Returns:
+ *	none
+ *
+ */
+int
+spans_send_close_req(spp, svp)
+	struct spans		*spp;
+	struct	spans_vccb	*svp;
+{
+	spans_msg	*req;
+	int		err = 0;
+
+	ATM_DEBUG1("spans_send_close_req: svp=0x%x\n", svp);
+
+	/*
+	 * Get memory for a close request
+	 */
+	req = (spans_msg *)atm_allocate(&spans_msgpool);
+	if (req == NULL) {
+		err = ENOBUFS;
+		goto done;
+	}
+
+	/*
+	 * Fill in the request
+	 */
+	req->sm_vers = SPANS_VERS_1_0;
+	if (svp->sv_type & VCC_OUT) {
+		req->sm_type = SPANS_CLOSE_REQ;
+	} else if (svp->sv_type & VCC_IN) {
+		req->sm_type = SPANS_RCLOSE_REQ;
+	} else {
+		err = EINVAL;
+		ATM_DEBUG1(
+		"spans_send_close_req: invalid VCCB type 0x%x\n",
+				svp->sv_type);
+		goto done;
+	}
+	req->sm_close_req.clreq_conn = svp->sv_conn;
+
+	/*
+	 * Send the close request
+	 */
+	err = spans_send_msg(spp, req);
+
+done:
+	if (req)
+		atm_free(req);
+
+	return(err);
+}
+
+
+
+/*
+ * Process a status indication or status request
+ *
+ * Called when a status indication or status request is received.
+ * Processing will be based on the current SPANS state.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the status message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_status_ind(spp, msg)
+	struct	spans	*spp;
+	spans_msg	*msg;
+{
+	spans_msg	*rsp_msg;
+	struct atm_pif	*pip = spp->sp_pif;
+
+	/*
+	 * Reset the probe count.
+	 */
+	spp->sp_probe_ct = 0;
+
+	switch (spp->sp_state) {
+	case SPANS_PROBE:
+		/*
+		 * Interface just came up, update signalling state
+		 */
+		spp->sp_state = SPANS_ACTIVE;
+		break;
+
+	case SPANS_ACTIVE:
+		break;
+
+	default:
+		log(LOG_ERR, "spans: received status msg in state %d\n",
+				spp->sp_state);
+	}
+
+	/*
+	 * Process the message
+	 */
+	switch (msg->sm_type) {
+
+	case SPANS_STAT_REQ:
+		/*
+		 * Handle a request from a host at the other end of
+		 * the link.
+		 */
+		spans_host_link(spp, msg->sm_stat_req.streq_es_epoch);
+		break;
+
+	case SPANS_STAT_IND:
+
+		/*
+		 * There's a switch at the other end of the link.  If
+		 * its epoch has changed, reset the SPANS state and save
+		 * the new information.
+		 */
+		if (spp->sp_s_epoch !=
+				msg->sm_stat_ind.stind_sw_epoch) {
+			spans_switch_reset(spp, SPANS_UNI_UP);
+			spp->sp_s_epoch =
+				msg->sm_stat_ind.stind_sw_epoch;
+			spp->sp_addr.address_format = T_ATM_SPANS_ADDR;
+			spp->sp_addr.address_length =
+					sizeof(spans_addr);
+			spans_addr_copy(&msg->sm_stat_ind.stind_es_addr,
+				spp->sp_addr.address);
+			log(LOG_INFO,
+		"spans: received SPANS address %s from switch for interface %s%d\n",
+					spans_addr_print((spans_addr *)spp->sp_addr.address),
+					pip->pif_name,
+					pip->pif_unit);
+		}
+		break;
+
+	default:
+		ATM_DEBUG1("spans_status_ind: Invalid message type %d\n",
+				msg->sm_type);
+		return;
+	}
+
+	/*
+	 * Respond to the status request or indication with a
+	 * status response
+	 */
+	rsp_msg = (spans_msg *)atm_allocate(&spans_msgpool);
+	if (rsp_msg == NULL)
+		return;
+	rsp_msg->sm_vers = SPANS_VERS_1_0;
+	rsp_msg->sm_type = SPANS_STAT_RSP;
+	rsp_msg->sm_stat_rsp.strsp_es_epoch = spp->sp_h_epoch;
+	spans_addr_copy(spp->sp_addr.address,
+			&rsp_msg->sm_stat_rsp.strsp_es_addr);
+	spans_send_msg(spp, rsp_msg);
+	atm_free(rsp_msg);
+}
+
+
+
+/*
+ * Process a status response
+ *
+ * Called when a status response is received.
+ * Processing will be based on the current SPANS state.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the status response message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_status_rsp(spp, msg)
+	struct	spans	*spp;
+	spans_msg	*msg;
+{
+
+	/*
+	 * Reset the probe count.
+	 */
+	spp->sp_probe_ct = 0;
+
+	switch (spp->sp_state) {
+	case SPANS_PROBE:
+		/*
+		 * Interface just came up, update signalling state
+		 */
+		spp->sp_state = SPANS_ACTIVE;
+		break;
+
+	case SPANS_ACTIVE:
+		break;
+
+	default:
+		log(LOG_ERR, "spans: received status msg in state %d\n",
+				spp->sp_state);
+	}
+
+	/*
+	 * Process the message
+	 */
+	spans_host_link(spp, msg->sm_stat_req.streq_es_epoch);
+}
+
+
+/*
+ * Process an open indication or open request
+ *
+ * Called when an open indication or open request is received.
+ * Processing will be based on the state of the requested connection.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the open message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_open_req(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	spans_result		result = SPANS_OK;
+	spans_msg		*rsp_msg;
+	struct spans_vccb	*svp = NULL;
+	struct atm_pif		*pip;
+	spans_vpvc		vpvc;
+	int			err = 0, vpi, vci;
+	Aal_t			aal;
+	Atm_attributes		call_attrs;
+
+	ATM_DEBUG2("spans_open_req: spp=0x%x, msg=0x%x\n", spp, msg);
+
+	/*
+	 * See if the connection is new
+	 */
+	if (svp = spans_find_conn(spp, &msg->sm_open_req.opreq_conn)) {
+		/*
+		 * We already have a VCCB that matches the connection in
+		 * the request
+		 */
+		vpi = SPANS_EXTRACT_VPI(msg->sm_open_req.opreq_vpvc.vpf_vpvc);
+		vci = SPANS_EXTRACT_VCI(msg->sm_open_req.opreq_vpvc.vpf_vpvc);
+		if (msg->sm_open_req.opreq_aal == svp->sv_spans_aal &&
+				(!msg->sm_open_req.opreq_vpvc.vpf_valid ||
+					(vpi == svp->sv_vpi &&
+					vci == svp->sv_vci))) {
+			/*
+			 * VCCB already exists, process depending on
+			 * state
+			 */
+			switch (svp->sv_sstate) {
+			case SPANS_VC_R_POPEN:
+				/* I'm still thinking about it */
+				return;
+			case SPANS_VC_OPEN:
+				/* Retransmit the open_rsp */
+				break;
+			case SPANS_VC_POPEN:
+			case SPANS_VC_CLOSE:
+			case SPANS_VC_ABORT:
+				ATM_DEBUG0("spans_open_req: bad VCCB state\n");
+				result = SPANS_FAIL;
+				break;
+			}
+		} else {
+			/*
+			 * VCCB is for same connection, but other
+			 * parameters don't match
+			 */
+			ATM_DEBUG0("spans_open_req: VCCB confusion\n");
+			result = SPANS_FAIL;
+		}
+		svp = NULL;
+		goto response;
+	}
+
+	/*
+	 * Verify that the request is for our ATM addres
+	 */
+	if (spans_addr_cmp(spp->sp_addr.address,
+			&msg->sm_open_req.opreq_conn.con_dst)) {
+		ATM_DEBUG0("spans_open_req: bad destination\n");
+		result = SPANS_BADDEST;
+		goto response;
+	}
+
+	/*
+	 * See if we recognize the specified AAL
+	 */
+	if (!spans_get_local_aal(msg->sm_open_req.opreq_aal, &aal)) {
+		ATM_DEBUG0("spans_open_req: bad AAL\n");
+		result = SPANS_FAIL;
+		goto response;
+	}
+
+	/*
+	 * Should verify that we can handle requested connection QOS
+	 */
+
+	/*
+	 * Select a VPI/VCI for the new connection
+	 */
+	if (msg->sm_open_req.opreq_vpvc.vpf_valid) {
+		/*
+		 * Requestor asked for a certain VPI/VCI.  Make sure we
+		 * aren't already using the pair that was asked for.
+		 */
+		vpi = SPANS_EXTRACT_VPI(msg->sm_open_req.opreq_vpvc.vpf_vpvc);
+		vci = SPANS_EXTRACT_VCI(msg->sm_open_req.opreq_vpvc.vpf_vpvc);
+		if (spans_find_vpvc(spp, vci, vpi, VCC_IN)) {
+			ATM_DEBUG0("spans_open_req: VPI, VCI busy\n");
+			result = SPANS_NOVPVC;
+			goto response;
+		}
+		vpvc = msg->sm_open_req.opreq_vpvc.vpf_vpvc;
+	} else {
+		/*
+		 * Allocate a VPI/VCI for this end of the VCC
+		 */
+		vpvc = spans_alloc_vpvc(spp);
+		if (vpvc == 0) {
+			ATM_DEBUG0("spans_open_req: no VPI, VCI available\n");
+			result = SPANS_NOVPVC;
+			goto response;
+		}
+	}
+
+	/*
+	 * Get a new VCCB for the connection
+	 */
+	svp = (struct spans_vccb *)atm_allocate(&spans_vcpool);
+	if (svp == NULL) {
+		ATM_DEBUG0("spans_open_req: VCCB pool empty\n");
+		result = SPANS_NORSC;
+		goto response;
+	}
+
+	/*
+	 * Find the physical interface structure
+	 */
+	pip = spp->sp_pif;
+
+	/*
+	 * Fill in the VCCB fields that we can at this point
+	 */
+	svp->sv_type = VCC_SVC | VCC_IN;
+	svp->sv_proto = ATM_SIG_SPANS;
+	svp->sv_sstate = SPANS_VC_R_POPEN;
+	svp->sv_ustate = VCCU_POPEN;
+	svp->sv_pif = pip;
+	svp->sv_nif = pip->pif_nif;
+	svp->sv_conn = msg->sm_open_req.opreq_conn;
+	svp->sv_spans_qos = msg->sm_open_req.opreq_desrsrc;
+	svp->sv_spans_aal = msg->sm_open_req.opreq_aal;
+	svp->sv_tstamp = time_second;
+
+	svp->sv_vpi = SPANS_EXTRACT_VPI(vpvc);
+	svp->sv_vci = SPANS_EXTRACT_VCI(vpvc);
+
+	/*
+	 * Put the VCCB on the SPANS queue
+	 */
+	ENQUEUE(svp, struct spans_vccb, sv_sigelem, spp->sp_vccq);
+
+	/*
+	 * Set up the ATM attributes block
+	 */
+	KM_ZERO(&call_attrs, sizeof(call_attrs));
+	call_attrs.nif = svp->sv_nif;
+	call_attrs.api = CMAPI_CPCS;
+
+	call_attrs.aal.tag = T_ATM_PRESENT;
+	call_attrs.aal.type = aal;
+	switch(aal) {
+	case ATM_AAL3_4:
+		call_attrs.aal.v.aal4.forward_max_SDU_size =
+				ATM_NIF_MTU;
+		call_attrs.aal.v.aal4.backward_max_SDU_size =
+				ATM_NIF_MTU;
+		call_attrs.aal.v.aal4.SSCS_type =
+				T_ATM_NULL;
+		call_attrs.aal.v.aal4.mid_low = 0;
+		call_attrs.aal.v.aal4.mid_high = 1023;
+		break;
+	case ATM_AAL5:
+		call_attrs.aal.v.aal5.forward_max_SDU_size =
+				ATM_NIF_MTU;
+		call_attrs.aal.v.aal5.backward_max_SDU_size =
+				ATM_NIF_MTU;
+		call_attrs.aal.v.aal5.SSCS_type =
+				T_ATM_NULL;
+		break;
+	}
+
+	call_attrs.traffic.tag = T_ATM_PRESENT;
+	call_attrs.traffic.v.forward.PCR_high_priority = T_ATM_ABSENT;
+	call_attrs.traffic.v.forward.PCR_all_traffic = 
+			msg->sm_open_req.opreq_desrsrc.rsc_peak *
+			1000 / 53;
+	call_attrs.traffic.v.forward.SCR_high_priority = T_ATM_ABSENT;
+	call_attrs.traffic.v.forward.SCR_all_traffic = T_ATM_ABSENT;
+	call_attrs.traffic.v.forward.MBS_high_priority = T_ATM_ABSENT;
+	call_attrs.traffic.v.forward.MBS_all_traffic = T_ATM_ABSENT;
+	call_attrs.traffic.v.forward.tagging = T_NO;
+	call_attrs.traffic.v.backward.PCR_high_priority = T_ATM_ABSENT;
+	call_attrs.traffic.v.backward.PCR_all_traffic = 
+			call_attrs.traffic.v.forward.PCR_all_traffic;
+	call_attrs.traffic.v.backward.SCR_high_priority = T_ATM_ABSENT;
+	call_attrs.traffic.v.backward.SCR_all_traffic = T_ATM_ABSENT;
+	call_attrs.traffic.v.backward.MBS_high_priority = T_ATM_ABSENT;
+	call_attrs.traffic.v.backward.MBS_all_traffic = T_ATM_ABSENT;
+	call_attrs.traffic.v.backward.tagging = T_NO;
+	call_attrs.traffic.v.best_effort = T_YES;
+
+	call_attrs.bearer.tag = T_ATM_PRESENT;
+	call_attrs.bearer.v.bearer_class = T_ATM_CLASS_X;
+	call_attrs.bearer.v.traffic_type = T_ATM_NULL;
+	call_attrs.bearer.v.timing_requirements = T_ATM_NULL;
+	call_attrs.bearer.v.clipping_susceptibility = T_NO;
+	call_attrs.bearer.v.connection_configuration = T_ATM_1_TO_1;
+
+
+	call_attrs.bhli.tag = T_ATM_ABSENT;
+	call_attrs.blli.tag_l2 = T_ATM_ABSENT;
+	call_attrs.blli.tag_l3 = T_ATM_ABSENT;
+	call_attrs.llc.tag = T_ATM_ABSENT;
+
+	call_attrs.called.tag = T_ATM_PRESENT;
+	spans_addr_copy(&msg->sm_open_req.opreq_conn.con_dst,
+		call_attrs.called.addr.address);
+	call_attrs.called.addr.address_format = T_ATM_SPANS_ADDR;
+	call_attrs.called.addr.address_length = sizeof(spans_addr);
+	call_attrs.called.subaddr.address_format = T_ATM_ABSENT;
+	call_attrs.called.subaddr.address_length = 0;
+
+	call_attrs.calling.tag = T_ATM_PRESENT;
+	spans_addr_copy(&msg->sm_open_req.opreq_conn.con_src,
+		call_attrs.calling.addr.address);
+	call_attrs.calling.addr.address_format = T_ATM_SPANS_ADDR;
+	call_attrs.calling.addr.address_length = sizeof(spans_addr);
+	call_attrs.calling.subaddr.address_format = T_ATM_ABSENT;
+	call_attrs.calling.subaddr.address_length = 0;
+
+	call_attrs.qos.tag = T_ATM_PRESENT;
+	call_attrs.qos.v.coding_standard = T_ATM_NETWORK_CODING;
+	call_attrs.qos.v.forward.qos_class = T_ATM_QOS_CLASS_0;
+	call_attrs.qos.v.backward.qos_class = T_ATM_QOS_CLASS_0;
+
+	call_attrs.transit.tag = T_ATM_ABSENT;
+	call_attrs.cause.tag = T_ATM_ABSENT;
+
+	/*
+	 * Notify the connection manager that it has a new channel
+	 */
+	err = atm_cm_incoming((struct vccb *)svp, &call_attrs);
+	if (err) {
+		ATM_DEBUG0("spans_open_req: atm_cm_incoming returned error\n");
+		result = SPANS_FAIL;
+		goto response;
+	}
+
+	/*
+	 * Wait for the connection recipient to issue an accept
+	 */
+	return;
+
+response:
+	/*
+	 * Clean up the VCCB and the atm_conn block if we got them
+	 */
+	if (svp) {
+		DEQUEUE(svp, struct spans_vccb, sv_sigelem,
+				spp->sp_vccq);
+		atm_free(svp);
+	}
+
+	/*
+	 * Some problem was detected with the request.  Send a SPANS
+	 * message rejecting the connection.
+	 */
+	rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
+	if (rsp_msg == NULL)
+		return;
+
+	/*
+	 * Fill out the response
+	 */
+	rsp_msg->sm_vers = SPANS_VERS_1_0;
+	rsp_msg->sm_type = SPANS_OPEN_RSP;
+	rsp_msg->sm_open_rsp.oprsp_conn = msg->sm_open_req.opreq_conn;
+	rsp_msg->sm_open_rsp.oprsp_result = result;
+	rsp_msg->sm_open_rsp.oprsp_vpvc = 0;
+
+	/*
+	 * Send the Open Response
+	 */
+	spans_send_msg(spp, rsp_msg);
+	atm_free(rsp_msg);
+}
+
+
+/*
+ * Process an open response or open confirmation
+ *
+ * Called when an open response or open confirmation is received.
+ * Processing will be based on the state of the requested connection and
+ * the status returned.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the open response or confirmation message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_open_rsp(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	struct spans_vccb	*svp;
+
+	ATM_DEBUG2("spans_open_rsp: spp=0x%x, msg=0x%x\n", spp, msg);
+
+	/*
+	 * Locate the VCCB for the connection
+	 */
+	svp = spans_find_conn(spp, &msg->sm_open_rsp.oprsp_conn);
+	if (svp == NULL)
+		return;
+
+	/*
+	 * Check the connection state
+	 */
+	if ((svp->sv_sstate != SPANS_VC_POPEN &&
+			svp->sv_sstate != SPANS_VC_R_POPEN) ||
+			svp->sv_ustate != VCCU_POPEN) {
+		ATM_DEBUG2(
+	"spans_open_rsp: invalid VCCB state, sstate=%d, ustate=%d\n",
+				svp->sv_sstate, svp->sv_ustate);
+		return;
+	}
+
+	/*
+	 * Cancel the retransmission timer
+	 */
+	SPANS_VC_CANCEL((struct vccb *) svp);
+
+	/*
+	 * Check the result
+	 */
+	switch (msg->sm_open_rsp.oprsp_result) {
+
+	case SPANS_OK:
+		/*
+		 * Save the assigned VPI and VCI
+		 */
+		svp->sv_vpi = SPANS_EXTRACT_VPI(msg->sm_open_rsp.oprsp_vpvc);
+		svp->sv_vci = SPANS_EXTRACT_VCI(msg->sm_open_rsp.oprsp_vpvc);
+
+		/*
+		 * Update the VCC state and notify the VCC owner
+		 */
+		svp->sv_sstate = SPANS_VC_OPEN;
+		svp->sv_ustate = VCCU_OPEN;
+		svp->sv_tstamp = time_second;
+		atm_cm_connected(svp->sv_connvc);
+		break;
+
+	case SPANS_FAIL:
+	case SPANS_NOVPVC:
+	case SPANS_NORSC:
+	case SPANS_BADDEST:
+		/*
+		 * Close out the VCCB and notify the user
+		 */
+		svp->sv_sstate = SPANS_VC_FREE;
+		svp->sv_ustate = VCCU_CLOSED;
+		svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
+		svp->sv_connvc->cvc_attr.cause.v.coding_standard =
+				T_ATM_ITU_CODING;
+		svp->sv_connvc->cvc_attr.cause.v.location =
+				T_ATM_LOC_USER;
+		svp->sv_connvc->cvc_attr.cause.v.cause_value =
+				T_ATM_CAUSE_CALL_REJECTED;
+		KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
+				sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
+		atm_cm_cleared(svp->sv_connvc);
+		break;
+
+	default:
+		log(LOG_ERR, "spans: unknown result %d in open rsp\n",
+				msg->sm_open_rsp.oprsp_result);
+		break;
+	}
+}
+
+
+/*
+ * Process a close request from the network
+ *
+ * Called when a close request, close indication, rclose request, or
+ * rclose indication is received.  Processing will be based on the
+ * state of the connection.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the close request message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_close_req(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	struct spans_vccb	*svp;
+	spans_result		result;
+	spans_msg		*rsp_msg;
+	u_char			outstate;
+	Atm_connvc		*cvp;
+
+	ATM_DEBUG2("spans_close_req: spp=0x%x, msg=0x%x\n", spp, msg);
+
+	/*
+	 * Locate the VCCB for the connection
+	 */
+	svp = spans_find_conn(spp, &msg->sm_close_req.clreq_conn);
+	if (svp == NULL) {
+		result = SPANS_BADDEST;
+		goto response;
+	}
+
+	/*
+	 * Check the connection type
+	 */
+	if (!(svp->sv_type & VCC_SVC)) {
+		result = SPANS_FAIL;
+		goto response;
+	}
+
+	/*
+	 * Check the connection state
+	 */
+	switch (svp->sv_sstate) {
+	case SPANS_VC_OPEN:
+	case SPANS_VC_R_POPEN:
+	case SPANS_VC_POPEN:
+		/*
+		 * VCC is open or opening--continue
+		 */
+		break;
+	case SPANS_VC_CLOSE:
+	case SPANS_VC_FREE:
+	case SPANS_VC_ABORT:
+		/*
+		 * We're already closing--give a response, since this
+		 * is probably a retransmission
+		 */
+		result = SPANS_OK;
+		goto response;
+	case SPANS_VC_NULL:
+		result = SPANS_FAIL;
+		goto response;
+	}
+
+	/*
+	 * Cancel the retransmission timer
+	 */
+	SPANS_VC_CANCEL((struct vccb *) svp);
+
+	/*
+	 * Close out the VCCB and notify the user
+	 */
+	outstate = svp->sv_sstate;
+	svp->sv_ustate = VCCU_CLOSED;
+	svp->sv_sstate = SPANS_VC_FREE;
+	cvp = svp->sv_connvc;
+	switch (outstate) {
+	case SPANS_VC_R_POPEN:
+		spans_free((struct vccb *)svp);
+		/* FALLTHRU */
+
+	case SPANS_VC_POPEN:
+	case SPANS_VC_OPEN:
+		cvp->cvc_attr.cause.tag = T_ATM_PRESENT;
+		cvp->cvc_attr.cause.v.coding_standard =
+				T_ATM_ITU_CODING;
+		cvp->cvc_attr.cause.v.location = T_ATM_LOC_USER;
+		cvp->cvc_attr.cause.v.cause_value =
+				T_ATM_CAUSE_NORMAL_CALL_CLEARING;
+		KM_ZERO(cvp->cvc_attr.cause.v.diagnostics,
+				sizeof(cvp->cvc_attr.cause.v.diagnostics));
+		atm_cm_cleared(svp->sv_connvc);
+		break;
+	}
+
+	result = SPANS_OK;
+
+response:
+	/*
+	 * Respond to the SPANS_CLOSE_IND with a SPANS_CLOSE_RSP
+	 */
+	rsp_msg = (spans_msg *)atm_allocate(&spans_msgpool);
+	if (rsp_msg == NULL)
+		return;
+	rsp_msg->sm_vers = SPANS_VERS_1_0;
+	if (msg->sm_type == SPANS_RCLOSE_REQ ||
+			msg->sm_type == SPANS_RCLOSE_IND) {
+		rsp_msg->sm_type = SPANS_RCLOSE_RSP;
+	} else {
+		rsp_msg->sm_type = SPANS_CLOSE_RSP;
+	}
+	rsp_msg->sm_close_rsp.clrsp_conn = msg->sm_close_req.clreq_conn;
+	rsp_msg->sm_close_rsp.clrsp_result = result;
+	spans_send_msg(spp, rsp_msg);
+	atm_free(rsp_msg);
+}
+
+
+/*
+ * Process a close response or close confirmation
+ *
+ * Called when an close response or close confirmation is received.
+ * Processing will be based on the state of the requested connection and
+ * the returned status.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the close response or confirmation message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_close_rsp(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	struct spans_vccb	*svp;
+
+	ATM_DEBUG2("spans_close_rsp: spp=0x%x, msg=0x%x\n", spp, msg);
+
+	/*
+	 * Locate the VCCB for the connection
+	 */
+	svp = spans_find_conn(spp, &msg->sm_close_rsp.clrsp_conn);
+	if (svp == NULL) {
+		return;
+	}
+
+	/*
+	 * Check the VCCB state
+	 */
+	if (svp->sv_sstate != SPANS_VC_CLOSE) {
+		return;
+	}
+
+	/*
+	 * Cancel the retransmission timer
+	 */
+	SPANS_VC_CANCEL((struct vccb *) svp);
+
+	/*
+	 * Check the response from the remote end
+	 */
+	switch (msg->sm_close_rsp.clrsp_result) {
+
+	case SPANS_OK:
+		/*
+		 * Mark the VCCB as closed and notify the owner
+		 */
+		svp->sv_sstate = SPANS_VC_FREE;
+		svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
+		svp->sv_connvc->cvc_attr.cause.v.coding_standard =
+				T_ATM_ITU_CODING;
+		svp->sv_connvc->cvc_attr.cause.v.location =
+				T_ATM_LOC_USER;
+		svp->sv_connvc->cvc_attr.cause.v.cause_value =
+				T_ATM_CAUSE_NORMAL_CALL_CLEARING;
+		KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
+				sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
+		atm_cm_cleared(svp->sv_connvc);
+		break;
+
+	case SPANS_NOVPVC:
+	case SPANS_BADDEST:
+	case SPANS_FAIL:
+	case SPANS_NORSC:
+		/*
+		 * Mark the VCCB as closed and notify the owner
+		 */
+		svp->sv_sstate = SPANS_VC_FREE;
+		svp->sv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
+		svp->sv_connvc->cvc_attr.cause.v.coding_standard =
+				T_ATM_ITU_CODING;
+		svp->sv_connvc->cvc_attr.cause.v.location =
+				T_ATM_LOC_USER;
+		svp->sv_connvc->cvc_attr.cause.v.cause_value =
+				T_ATM_CAUSE_UNSPECIFIED_NORMAL;
+		KM_ZERO(svp->sv_connvc->cvc_attr.cause.v.diagnostics,
+				sizeof(svp->sv_connvc->cvc_attr.cause.v.diagnostics));
+		atm_cm_cleared(svp->sv_connvc);
+		break;
+
+	default:
+		log(LOG_ERR, "spans: unknown result %d in close rsp\n",
+				msg->sm_close_rsp.clrsp_result);
+		break;
+	}
+}
+
+
+/*
+ * Process a multi request or multi indication
+ *
+ * Called when a multi response or multi confirmation is received.  We
+ * don't support multicast channels, so we just reject the request.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the multi request or indication message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_multi_req(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	spans_msg	*rsp_msg;
+
+	/*
+	 * Get memory for a SPANS_MULTI_RSP message.
+	 */
+	rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
+	if (rsp_msg == NULL)
+		return;
+
+	/*
+	 * Fill out the response.
+	 */
+	rsp_msg->sm_vers = SPANS_VERS_1_0;
+	rsp_msg->sm_type = SPANS_MULTI_RSP;
+	rsp_msg->sm_multi_rsp.mursp_conn = msg->sm_multi_req.mureq_conn;
+	rsp_msg->sm_multi_rsp.mursp_result = SPANS_FAIL;
+	rsp_msg->sm_multi_rsp.mursp_rsrc = msg->sm_multi_req.mureq_desrsrc;
+	rsp_msg->sm_multi_rsp.mursp_vpvc = 0;
+
+	/*
+	 * Send the response and free the message.
+	 */
+	(void) spans_send_msg(spp, rsp_msg);
+	atm_free(rsp_msg);
+}
+
+
+/*
+ * Process an add request or add indication
+ *
+ * Called when an add response or add confirmation is received.  We
+ * don't support multicast channels, so we just reject the request.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the add request or indication message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_add_req(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	spans_msg	*rsp_msg;
+
+	/*
+	 * Get memory for a SPANS_ADD_RSP message.
+	 */
+	rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
+	if (rsp_msg == NULL)
+		return;
+
+	/*
+	 * Fill out the response.
+	 */
+	rsp_msg->sm_vers = SPANS_VERS_1_0;
+	rsp_msg->sm_type = SPANS_ADD_RSP;
+	rsp_msg->sm_add_rsp.adrsp_conn = msg->sm_add_req.adreq_desconn;
+	rsp_msg->sm_add_rsp.adrsp_result = SPANS_FAIL;
+	rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_peak = 0;
+	rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_mean = 0;
+	rsp_msg->sm_add_rsp.adrsp_rsrc.rsc_burst = 0;
+
+	/*
+	 * Send the response and free the message.
+	 */
+	(void) spans_send_msg(spp, rsp_msg);
+	atm_free(rsp_msg);
+}
+
+
+/*
+ * Process a join request
+ *
+ * Called when an join request is received.  We don't support group
+ * addresses, so we just reject the request.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the join request message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_join_req(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	spans_msg	*rsp_msg;
+
+	/*
+	 * Get memory for a SPANS_JOIN_CNF message.
+	 */
+	rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
+	if (rsp_msg == NULL)
+		return;
+
+	/*
+	 * Fill out the response.
+	 */
+	rsp_msg->sm_vers = SPANS_VERS_1_0;
+	rsp_msg->sm_type = SPANS_JOIN_CNF;
+	spans_addr_copy(&msg->sm_join_req.jnreq_addr,
+			&rsp_msg->sm_join_cnf.jncnf_addr);
+	rsp_msg->sm_join_cnf.jncnf_result = SPANS_FAIL;
+
+	/*
+	 * Send the response and free the message.
+	 */
+	(void) spans_send_msg(spp, rsp_msg);
+	atm_free(rsp_msg);
+}
+
+
+/*
+ * Process a leave request
+ *
+ * Called when an leave request is received.  We don't support group
+ * addresses, so we just reject the request.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the leave request message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_leave_req(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	spans_msg	*rsp_msg;
+
+	/*
+	 * Get memory for a SPANS_LEAVE_CNF message.
+	 */
+	rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
+	if (rsp_msg == NULL)
+		return;
+
+	/*
+	 * Fill out the response.
+	 */
+	rsp_msg->sm_vers = SPANS_VERS_1_0;
+	rsp_msg->sm_type = SPANS_LEAVE_CNF;
+	spans_addr_copy(&msg->sm_leave_req.lvreq_addr,
+			&rsp_msg->sm_leave_cnf.lvcnf_addr);
+	rsp_msg->sm_leave_cnf.lvcnf_result = SPANS_FAIL;
+
+	/*
+	 * Send the response and free the message.
+	 */
+	(void) spans_send_msg(spp, rsp_msg);
+	atm_free(rsp_msg);
+}
+
+
+/*
+ * Process a VCI range indication
+ *
+ * Called when a VCI range indication is received.  Adjust the VCI
+ * bounds if they have changed.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the VCI range indication message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_vcir_ind(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	/*
+	 * Adjust the limits if they have changed
+	 */
+	if (msg->sm_vcir_ind.vrind_min != spp->sp_min_vci) {
+		spp->sp_min_vci =
+				(msg->sm_vcir_ind.vrind_min <
+				SPANS_MIN_VCI ?
+				SPANS_MIN_VCI :
+				msg->sm_vcir_ind.vrind_min);
+	}
+	if (msg->sm_vcir_ind.vrind_max != spp->sp_max_vci) {
+		spp->sp_max_vci =
+				(msg->sm_vcir_ind.vrind_max >
+				SPANS_MAX_VCI ?
+				SPANS_MAX_VCI :
+				msg->sm_vcir_ind.vrind_max);
+	}
+}
+
+
+/*
+ * Process a query request
+ *
+ * Called when a query request is received.  Respond with the
+ * appropriate query response.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	msg	pointer to the VCI range indication message
+ *
+ * Returns:
+ *	none
+ *
+ */
+static void
+spans_query_req(spp, msg)
+	struct spans	*spp;
+	spans_msg	*msg;
+{
+	struct spans_vccb	*svp = NULL;
+	spans_msg		*rsp_msg;
+
+	ATM_DEBUG1("spans_query_req: msg=0x%x\n", msg);
+
+	/*
+	 * Ignore an end-to-end query
+	 */
+	if (msg->sm_query_req.qyreq_type == SPANS_QUERY_END_TO_END) {
+		return;
+	}
+
+	/*
+	 * Get memory for a SPANS_QUERY_RSP message.
+	 */
+	rsp_msg = (spans_msg *) atm_allocate(&spans_msgpool);
+	if (rsp_msg == NULL)
+		return;
+
+	/*
+	 * Fill out the response.
+	 */
+	rsp_msg->sm_vers = SPANS_VERS_1_0;
+	rsp_msg->sm_type = SPANS_QUERY_RSP;
+	rsp_msg->sm_query_rsp.qyrsp_conn = msg->sm_query_req.qyreq_conn;
+	rsp_msg->sm_query_rsp.qyrsp_type = msg->sm_query_req.qyreq_type;
+	rsp_msg->sm_query_rsp.qyrsp_data = 0;
+
+	/*
+	 * Get the state of the requested connection
+	 */
+	svp = spans_find_conn(spp, &msg->sm_query_req.qyreq_conn);
+	if (svp) {
+		switch(svp->sv_sstate) {
+		case SPANS_VC_NULL:
+		case SPANS_VC_FREE:
+			rsp_msg->sm_query_rsp.qyrsp_state =
+				SPANS_CONN_CLOSED;
+			break;
+		case SPANS_VC_OPEN:
+			rsp_msg->sm_query_rsp.qyrsp_state =
+				SPANS_CONN_OPEN;
+			break;
+		case SPANS_VC_POPEN:
+		case SPANS_VC_R_POPEN:
+			rsp_msg->sm_query_rsp.qyrsp_state =
+				SPANS_CONN_OPEN_PEND;
+			break;
+		case SPANS_VC_CLOSE:
+		case SPANS_VC_ABORT:
+			rsp_msg->sm_query_rsp.qyrsp_state =
+				SPANS_CONN_CLOSE_PEND;
+			break;
+		case SPANS_VC_ACTIVE:
+		case SPANS_VC_ACT_DOWN:
+			/*
+			 * VCCB is for a PVC (shouldn't happen)
+			 */
+			atm_free(rsp_msg);
+			return;
+		}
+	} else {
+		/*
+		 * No VCCB found--connection doesn't exist
+		 */
+		rsp_msg->sm_query_rsp.qyrsp_state = SPANS_CONN_CLOSED;
+	}
+
+	/*
+	 * Send the response and free the message.
+	 */
+	(void) spans_send_msg(spp, rsp_msg);
+	atm_free(rsp_msg);
+}
+
+
+/*
+ * Process a SPANS signalling message
+ *
+ * Called when a SPANS message is received.  The message is converted
+ * into internal format with XDR and decoded by calling the appropriate
+ * mesage handling routine.  Unrecognized and unexpected messages are
+ * logged.
+ *
+ * Arguments:
+ *	spp	pointer to SPANS protocol instance block
+ *	m	pointer to a buffer chain containing the SPANS message
+ *
+ * Returns:
+ *	none
+ *
+ */
+void
+spans_rcv_msg(spp, m)
+	struct spans	*spp;
+	KBuffer		*m;
+{
+	XDR		xdrs;
+	spans_msg	*msg;
+
+	/*
+	 * Get storage for the message
+	 */
+	msg = (spans_msg *)atm_allocate(&spans_msgpool);
+	if (msg == NULL) {
+		return;
+	}
+
+	/*
+	 * Convert the message from network order to internal format
+	 */
+	xdrmbuf_init(&xdrs, m, XDR_DECODE);
+	if (!xdr_spans_msg(&xdrs, msg)) {
+		log(LOG_ERR, "spans_rcv_msg: XDR decode failed\n");
+		spans_dump_buffer(m);
+		goto done;
+	}
+
+#ifdef NOTDEF
+	/*
+	 * Debug--print some information about the message
+	 */
+	if (msg->sm_type != SPANS_STAT_REQ &&
+			msg->sm_type != SPANS_STAT_IND &&
+			msg->sm_type != SPANS_STAT_RSP) {
+		printf("spans_rcv_msg: got ");
+		spans_print_msg(msg);
+	}
+#endif
+
+	/*
+	 * Verify the message sm_vers
+	 */
+	if (msg->sm_vers != SPANS_VERS_1_0) {
+		log(LOG_ERR, "spans: invalid message version 0x%x\n",
+				msg->sm_vers);
+	}
+
+	/*
+	 * Ignore the message if SPANS isn't up yet
+	 */
+	if (spp->sp_state != SPANS_ACTIVE &&
+			(spp->sp_state != SPANS_PROBE ||
+			(msg->sm_type != SPANS_STAT_REQ &&
+			msg->sm_type != SPANS_STAT_RSP &&
+			msg->sm_type != SPANS_STAT_IND))) {
+		goto done;
+	}
+
+	/*
+	 * Process the message based on its type
+	 */
+	switch(msg->sm_type) {
+	case SPANS_STAT_REQ:
+		spans_status_ind(spp, msg);
+		break;
+	case SPANS_STAT_IND:
+		spans_status_ind(spp, msg);
+		break;
+	case SPANS_STAT_RSP:
+		spans_status_rsp(spp, msg);
+		break;
+	case SPANS_OPEN_REQ:
+		spans_open_req(spp, msg);
+		break;
+	case SPANS_OPEN_IND:
+		spans_open_req(spp, msg);
+		break;
+	case SPANS_OPEN_RSP:
+		spans_open_rsp(spp, msg);
+		break;
+	case SPANS_OPEN_CNF:
+		spans_open_rsp(spp, msg);
+		break;
+	case SPANS_CLOSE_REQ:
+		spans_close_req(spp, msg);
+		break;
+	case SPANS_CLOSE_IND:
+		spans_close_req(spp, msg);
+		break;
+	case SPANS_CLOSE_RSP:
+		spans_close_rsp(spp, msg);
+		break;
+	case SPANS_CLOSE_CNF:
+		spans_close_rsp(spp, msg);
+		break;
+	case SPANS_RCLOSE_REQ:
+		spans_close_req(spp, msg);
+		break;
+	case SPANS_RCLOSE_IND:
+		spans_close_req(spp, msg);
+		break;
+	case SPANS_RCLOSE_RSP:
+		spans_close_rsp(spp, msg);
+		break;
+	case SPANS_RCLOSE_CNF:
+		spans_close_rsp(spp, msg);
+		break;
+	case SPANS_MULTI_REQ:
+		spans_multi_req(spp, msg);
+		break;
+	case SPANS_MULTI_IND:
+		spans_multi_req(spp, msg);
+		break;
+	case SPANS_MULTI_RSP:
+		log(LOG_ERR,
+			"spans: unexpected message (multi_rsp)\n");
+		break;
+	case SPANS_MULTI_CNF:
+		log(LOG_ERR,
+			"spans: unexpected message (multi_conf)\n");
+		break;
+	case SPANS_ADD_REQ:
+		spans_add_req(spp, msg);
+		break;
+	case SPANS_ADD_IND:
+		spans_add_req(spp, msg);
+		break;
+	case SPANS_ADD_RSP:
+		log(LOG_ERR,
+			"spans: unexpected message (add_rsp)\n");
+		break;
+	case SPANS_ADD_CNF:
+		log(LOG_ERR, "spans: unexpected message (add_conf)\n");
+		break;
+	case SPANS_JOIN_REQ:
+		spans_join_req(spp, msg);
+		break;
+	case SPANS_JOIN_CNF:
+		log(LOG_ERR, "spans: unexpected message (join_conf)\n");
+		break;
+	case SPANS_LEAVE_REQ:
+		spans_leave_req(spp, msg);
+		break;
+	case SPANS_LEAVE_CNF:
+		log(LOG_ERR,
+			"spans: unexpected message (leave_conf)\n");
+		break;
+	case SPANS_VCIR_IND:
+		spans_vcir_ind(spp, msg);
+		break;
+	case SPANS_QUERY_REQ:
+		spans_query_req(spp, msg);
+		break;
+	case SPANS_QUERY_RSP:
+		log(LOG_ERR,
+			"spans: unexpected message (query_rsp)\n");
+		break;
+	default:
+		log(LOG_ERR, "spans: unknown SPANS message type %d\n",
+				msg->sm_type);
+	}
+
+done:
+	/*
+	 * Free the incoming message (both buffer and internal format) if
+	 * necessary.
+	 */
+	if (msg)
+		atm_free(msg);
+	if (m)
+		KB_FREEALL(m);
+}