FreeBSD-5.3/sys/netatm/spans/spans_if.c
/*
* ===================================
* HARP | Host ATM Research Platform
* ===================================
*
*
* This Host ATM Research Platform ("HARP") file (the "Software") is
* made available by Network Computing Services, Inc. ("NetworkCS")
* "AS IS". NetworkCS does not provide maintenance, improvements or
* support of any kind.
*
* NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
* INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
* SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
* In no event shall NetworkCS be responsible for any damages, including
* but not limited to consequential damages, arising from or relating to
* any use of the Software or related support.
*
* Copyright 1994-1998 Network Computing Services, Inc.
*
* Copies of this Software may be made, however, the above copyright
* notice must be reproduced on all copies.
*/
/*
* SPANS Signalling Manager
* ---------------------------
*
* External interfaces to SPANS manager. Includes support for
* running as a loadable kernel module.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/sys/netatm/spans/spans_if.c,v 1.15 2003/07/29 13:32:10 harti Exp $");
#ifndef ATM_SPANS_MODULE
#include "opt_atm.h"
#endif
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/malloc.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/syslog.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netatm/port.h>
#include <netatm/queue.h>
#include <netatm/atm.h>
#include <netatm/atm_sys.h>
#include <netatm/atm_sap.h>
#include <netatm/atm_cm.h>
#include <netatm/atm_if.h>
#include <netatm/atm_vc.h>
#include <netatm/atm_ioctl.h>
#include <netatm/atm_sigmgr.h>
#include <netatm/atm_stack.h>
#include <netatm/atm_pcb.h>
#include <netatm/atm_var.h>
#include "spans_xdr.h"
#include <netatm/spans/spans_var.h>
/*
* Global variables
*/
uma_zone_t spans_vc_zone;
uma_zone_t spans_msg_zone;
/*
* Local functions
*/
static int spans_start(void);
static int spans_stop(void);
static int spans_attach(struct sigmgr *, struct atm_pif *);
static int spans_detach(struct atm_pif *);
static int spans_setup(Atm_connvc *, int *);
static int spans_release(struct vccb *, int *);
static int spans_accept(struct vccb *, int *);
static int spans_reject(struct vccb *, int *);
static int spans_ioctl(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);
}
spans_vc_zone = uma_zcreate("spans vc", sizeof(struct spans_vccb),
NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
if (spans_vc_zone == NULL)
panic("spans_vc_zone");
spans_msg_zone = uma_zcreate("spans msg", sizeof(spans_msg), NULL,
NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
if (spans_msg_zone == NULL)
panic("spans_msg_zone");
/*
* Allocate protocol definition structure
*/
spans_mgr = malloc(sizeof(struct sigmgr), M_DEVBUF, M_NOWAIT|M_ZERO);
if (spans_mgr == NULL) {
err = ENOMEM;
goto done;
}
/*
* 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 the arp service
*/
spansarp_start();
/*
* 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
*/
free(spans_mgr, M_DEVBUF);
spans_mgr = NULL;
/*
* Free up our storage pools
*/
uma_zdestroy(spans_vc_zone);
uma_zdestroy(spans_msg_zone);
} 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=%p, pip=%p\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 = malloc(sizeof(struct spans), M_DEVBUF, M_NOWAIT|M_ZERO);
if (spp == NULL) {
err = ENOMEM;
goto done;
}
/*
* 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);
free(spp, 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=%p\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 %p\n",
err, vcp);
}
}
/*
* Now close the SPANS signalling VCC
*/
if ((cop = spp->sp_conn) != NULL) {
err = atm_cm_release(cop, &spans_cause);
if (err)
ATM_DEBUG2(
"spans_detach: close failed for SPANS signalling channel; cop=%p, 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);
free(spp, 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=%p\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=%p\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=%p\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=%p\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)) != 0) {
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 = %p\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;
uma_zfree(spans_vc_zone, 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);
free(spp, 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 err = 0, i, vpi, vci;
size_t buf_len;
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) snprintf(rsp.avp_intf,
sizeof(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;
bzero(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))) != 0)
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(void);
static int spans_dounload(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);
}
#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);
}
#else /* !ATM_SPANS_MODULE */
/*
*******************************************************************
*
* Kernel Compiled Module Support
*
*******************************************************************
*/
static void spans_doload(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 */