mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-14 10:09:48 +00:00
Code Issues Releases Activity
680a2f48d9
freebsd/sys/netatm/atm_cm.c
Poul-Henning Kamp 264b85f3ce Trivial stylish changes, mostly to silence gcc. 
Reviewed by:	Mike Spengler <mks@networkcs.com>
Submitted by:	phk
1998-10-31 20:07:01 +00:00

3465 lines
65 KiB
C
Raw Blame History

/*
*
* ===================================
* 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: atm_cm.c,v 1.2 1998/09/17 09:34:59 phk Exp $
*
*/
/*
* Core ATM Services
* -----------------
*
* ATM Connection Manager
*
*/
#include <netatm/kern_include.h>
#ifndef lint
__RCSID("@(#) $Id: atm_cm.c,v 1.2 1998/09/17 09:34:59 phk Exp $");
#endif
/*
* Global variables
*/
struct atm_cm_stat atm_cm_stat = {0};
/*
* Local functions
*/
static void atm_cm_cpcs_upper __P((int, void *, int, int));
static void atm_cm_saal_upper __P((int, void *, int, int));
static void atm_cm_sscop_upper __P((int, void *, int, int));
static Atm_connvc * atm_cm_share_llc __P((Atm_attributes *));
static void atm_cm_closeconn __P((Atm_connection *,
struct t_atm_cause *));
static void atm_cm_closevc __P((Atm_connvc *));
static void atm_cm_timeout __P((struct atm_time *));
static KTimeout_ret atm_cm_procinq __P((void *));
static void atm_cm_incall __P((Atm_connvc *));
static int atm_cm_accept __P((Atm_connvc *, Atm_connection *));
/*
* Local variables
*/
static Queue_t atm_connection_queue = {NULL};
static Queue_t atm_incoming_queue = {NULL};
static int atm_incoming_qlen = 0;
static Atm_connection *atm_listen_queue = NULL;
static struct attr_cause atm_cause_tmpl =
{T_ATM_PRESENT, {T_ATM_ITU_CODING, T_ATM_LOC_USER, 0, {0, 0, 0, 0}}};
/*
* Stack commands, indexed by API
*/
static struct {
int init;
int term;
} atm_stackcmds[] = {
{CPCS_INIT, CPCS_TERM}, /* CMAPI_CPCS */
{SSCF_UNI_INIT, SSCF_UNI_TERM}, /* CMAPI_SAAL */
{SSCOP_INIT, SSCOP_TERM}, /* CMAPI_SSCOP */
};
static struct sp_info atm_connection_pool = {
"atm connection pool", /* si_name */
sizeof(Atm_connection), /* si_blksiz */
10, /* si_blkcnt */
100 /* si_maxallow */
};
static struct sp_info atm_connvc_pool = {
"atm connection vcc pool", /* si_name */
sizeof(Atm_connvc), /* si_blksiz */
10, /* si_blkcnt */
100 /* si_maxallow */
};
/*
* Initiate Outgoing ATM Call
*
* Called by an endpoint service to create a new Connection Manager API
* instance and to initiate an outbound ATM connection. The endpoint
* provided token will be used in all further CM -> endpoint function
* calls, and the returned connection block pointer must be used in all
* subsequent endpoint -> CM function calls.
*
* If the return indicates that the connection setup has been immediately
* successful (typically only for PVCs and shared SVCs), then the connection
* is ready for data transmission.
*
* If the return indicates that the connection setup is still in progress,
* then the endpoint must wait for notification from the Connection Manager
* indicating the final status of the call setup. If the call setup completes
* successfully, then a "call connected" notification will be sent to the
* endpoint by the Connection Manager. If the call setup fails, then the
* endpoint will receive a "call cleared" notification.
*
* All connection instances must be freed with an atm_cm_release() call.
*
* Arguments:
* epp pointer to endpoint definition structure
* token endpoint's connection instance token
* ap pointer to requested connection attributes
* copp pointer to location to return allocated connection block
*
* Returns:
* 0 connection has been successfully established
* EINPROGRESS connection establishment is in progress
* errno connection failed - reason indicated
*
*/
int
atm_cm_connect(epp, token, ap, copp)
Atm_endpoint *epp;
void *token;
Atm_attributes *ap;
Atm_connection **copp;
{
Atm_connection *cop;
Atm_connvc *cvp;
struct atm_pif *pip;
struct sigmgr *smp;
struct stack_list sl;
void (*upf)__P((int, void *, int, int));
int s, sli, err, err2;
*copp = NULL;
cvp = NULL;
/*
* Get a connection block
*/
cop = (Atm_connection *)atm_allocate(&atm_connection_pool);
if (cop == NULL)
return (ENOMEM);
/*
* Initialize connection info
*/
cop->co_endpt = epp;
cop->co_toku = token;
/*
* Initialize stack list index
*/
sli = 0;
/*
* Validate and extract useful attribute information
*/
/*
* Must specify a network interface (validated below)
*/
if (ap->nif == NULL) {
err = EINVAL;
goto done;
}
/*
* Check out Data API
*/
switch (ap->api) {
case CMAPI_CPCS:
upf = atm_cm_cpcs_upper;
break;
case CMAPI_SAAL:
sl.sl_sap[sli++] = SAP_SSCF_UNI;
sl.sl_sap[sli++] = SAP_SSCOP;
upf = atm_cm_saal_upper;
break;
case CMAPI_SSCOP:
sl.sl_sap[sli++] = SAP_SSCOP;
upf = atm_cm_sscop_upper;
break;
default:
err = EINVAL;
goto done;
}
/*
* AAL Attributes
*/
if (ap->aal.tag != T_ATM_PRESENT) {
err = EINVAL;
goto done;
}
switch (ap->aal.type) {
case ATM_AAL5:
sl.sl_sap[sli++] = SAP_CPCS_AAL5;
sl.sl_sap[sli++] = SAP_SAR_AAL5;
sl.sl_sap[sli++] = SAP_ATM;
break;
case ATM_AAL3_4:
sl.sl_sap[sli++] = SAP_CPCS_AAL3_4;
sl.sl_sap[sli++] = SAP_SAR_AAL3_4;
sl.sl_sap[sli++] = SAP_ATM;
break;
default:
err = EINVAL;
goto done;
}
/*
* Broadband Bearer Attributes
*/
if (ap->bearer.tag != T_ATM_PRESENT) {
err = EINVAL;
goto done;
}
switch (ap->bearer.v.connection_configuration) {
case T_ATM_1_TO_1:
cop->co_flags |= COF_P2P;
break;
case T_ATM_1_TO_MANY:
/* Not supported */
cop->co_flags |= COF_P2MP;
err = EINVAL;
goto done;
default:
err = EINVAL;
goto done;
}
/*
* Logical Link Control Attributes
*/
if (ap->llc.tag == T_ATM_PRESENT) {
if ((ap->blli.tag_l2 != T_ATM_PRESENT) ||
(ap->blli.v.layer_2_protocol.ID_type != T_ATM_SIMPLE_ID) ||
(ap->blli.v.layer_2_protocol.ID.simple_ID !=
T_ATM_BLLI2_I8802) ||
(ap->llc.v.llc_len < T_ATM_LLC_MIN_LEN) ||
(ap->llc.v.llc_len > T_ATM_LLC_MAX_LEN)) {
err = EINVAL;
goto done;
}
cop->co_mpx = ATM_ENC_LLC;
cop->co_llc = ap->llc;
} else
cop->co_mpx = ATM_ENC_NULL;
/*
* Called Party Attributes
*/
if (ap->called.tag != T_ATM_PRESENT) {
err = EINVAL;
goto done;
}
if ((ap->called.addr.address_format == T_ATM_ABSENT) ||
(ap->called.addr.address_length == 0)) {
err = EINVAL;
goto done;
}
/*
* Calling Party Attributes
*/
if (ap->calling.tag != T_ATM_ABSENT) {
err = EINVAL;
goto done;
}
/*
* Quality of Service Attributes
*/
if (ap->qos.tag != T_ATM_PRESENT) {
err = EINVAL;
goto done;
}
/*
* Terminate stack list
*/
sl.sl_sap[sli] = 0;
s = splnet();
/*
* Let multiplexors decide whether we need a new VCC
*/
switch (cop->co_mpx) {
case ATM_ENC_NULL:
/*
* All of these connections require a new VCC
*/
break;
case ATM_ENC_LLC:
/*
* See if we can share an existing LLC connection
*/
cvp = atm_cm_share_llc(ap);
if (cvp == NULL)
break;
/*
* We've got a connection to share
*/
cop->co_connvc = cvp;
if (cvp->cvc_state == CVCS_ACTIVE) {
cop->co_state = COS_ACTIVE;
err = 0;
} else {
cop->co_state = COS_OUTCONN;
err = EINPROGRESS;
}
LINK2TAIL(cop, Atm_connection, cvp->cvc_conn->co_mxh, co_next);
cop->co_mxh = cvp->cvc_conn->co_mxh;
*copp = cop;
(void) splx(s);
return (err);
default:
panic("atm_cm_connect: unknown mpx");
}
/*
* If we get here, it means we need to create
* a new VCC for this connection
*/
/*
* Validate that network interface is registered and that
* a signalling manager is attached
*/
for (pip = atm_interface_head; pip != NULL; pip = pip->pif_next) {
struct atm_nif *nip;
for (nip = pip->pif_nif; nip; nip = nip->nif_pnext) {
if (nip == ap->nif)
break;
}
if (nip)
break;
}
if (pip == NULL) {
err = ENXIO;
goto donex;
}
if ((smp = pip->pif_sigmgr) == NULL) {
err = ENXIO;
goto donex;
}
/*
* Get a connection VCC block
*/
cvp = (Atm_connvc *)atm_allocate(&atm_connvc_pool);
if (cvp == NULL) {
err = ENOMEM;
goto donex;
}
/*
* Save VCC attributes
*/
cvp->cvc_attr = *ap;
cvp->cvc_flags |= CVCF_CALLER;
/*
* Link the control blocks
*/
cop->co_connvc = cvp;
cvp->cvc_conn = cop;
cvp->cvc_sigmgr = smp;
/*
* Create a service stack
*/
err = atm_create_stack(cvp, &sl, upf);
if (err) {
cvp->cvc_state = CVCS_CLEAR;
atm_cm_closevc(cvp);
goto donex;
}
/*
* Let the signalling manager handle the VCC creation
*/
cvp->cvc_state = CVCS_SETUP;
switch ((*smp->sm_setup)(cvp, &err)) {
case CALL_CONNECTED:
/*
* Connection is fully setup - initialize the stack
*/
cvp->cvc_state = CVCS_INIT;
STACK_CALL(atm_stackcmds[ap->api].init, cvp->cvc_lower,
cvp->cvc_tokl, cvp, ap->api_init, 0, err2);
if (err2)
panic("atm_cm_connect: init");
if (cvp->cvc_flags & CVCF_ABORTING) {
/*
* Someone on the stack bailed out...schedule the
* VCC and stack termination
*/
atm_cm_closevc(cvp);
err = EFAULT;
} else {
/*
* Everything looks fine from here
*/
cvp->cvc_state = CVCS_ACTIVE;
cop->co_state = COS_ACTIVE;
}
break;
case CALL_FAILED:
/*
* Terminate stack and clean up before we leave
*/
cvp->cvc_state = CVCS_CLEAR;
atm_cm_closevc(cvp);
break;
case CALL_PROCEEDING:
/*
* We'll just wait for final call status
*/
cop->co_state = COS_OUTCONN;
err = EINPROGRESS;
break;
default:
panic("atm_cm_connect: setup");
}
donex:
(void) splx(s);
done:
if (err && err != EINPROGRESS) {
/*
* Undo any partial setup stuff
*/
if (cop)
atm_free((caddr_t)cop);
} else {
/*
* Finish connection setup
*/
s = splnet();
cvp->cvc_flags |= CVCF_CONNQ;
ENQUEUE(cvp, Atm_connvc, cvc_q, atm_connection_queue);
LINK2TAIL(cop, Atm_connection, cop->co_mxh, co_next);
(void) splx(s);
*copp = cop;
}
return (err);
}
/*
* Listen for Incoming ATM Calls
*
* Called by an endpoint service in order to indicate its willingness to
* accept certain incoming calls. The types of calls which the endpoint
* is prepared to accept are specified in the Atm_attributes parameter.
*
* For each call which meets the criteria specified by the endpoint, the
* endpoint service will receive an incoming call notification via the
* endpoint's ep_incoming() function.
*
* To cancel the listening connection, the endpoint user should invoke
* atm_cm_release().
*
* Arguments:
* epp pointer to endpoint definition structure
* token endpoint's listen instance token
* ap pointer to listening connection attributes
* copp pointer to location to return allocated connection block
*
* Returns:
* 0 listening connection installed
* errno listen failed - reason indicated
*
*/
int
atm_cm_listen(epp, token, ap, copp)
Atm_endpoint *epp;
void *token;
Atm_attributes *ap;
Atm_connection **copp;
{
Atm_connection *cop;
int s, err = 0;
*copp = NULL;
/*
* Get a connection block
*/
cop = (Atm_connection *)atm_allocate(&atm_connection_pool);
if (cop == NULL)
return (ENOMEM);
/*
* Initialize connection info
*/
cop->co_endpt = epp;
cop->co_toku = token;
cop->co_mxh = cop;
/*
* Validate and extract useful attribute information
*/
/*
* Check out Data API
*/
switch (ap->api) {
case CMAPI_CPCS:
case CMAPI_SAAL:
case CMAPI_SSCOP:
break;
default:
err = EINVAL;
goto done;
}
/*
* AAL Attributes
*/
switch (ap->aal.tag) {
case T_ATM_PRESENT:
switch (ap->aal.type) {
case ATM_AAL5:
case ATM_AAL3_4:
break;
default:
err = EINVAL;
goto done;
}
break;
case T_ATM_ABSENT:
case T_ATM_ANY:
break;
default:
err = EINVAL;
goto done;
}
/*
* Broadband High Layer Information Attributes
*/
switch (ap->bhli.tag) {
case T_ATM_PRESENT:
case T_ATM_ABSENT:
case T_ATM_ANY:
break;
default:
err = EINVAL;
goto done;
}
/*
* Broadband Low Layer Information Attributes
*/
switch (ap->blli.tag_l2) {
case T_ATM_PRESENT:
case T_ATM_ABSENT:
case T_ATM_ANY:
break;
default:
err = EINVAL;
goto done;
}
switch (ap->blli.tag_l3) {
case T_ATM_PRESENT:
case T_ATM_ABSENT:
case T_ATM_ANY:
break;
default:
err = EINVAL;
goto done;
}
/*
* Logical Link Control Attributes
*/
switch (ap->llc.tag) {
case T_ATM_PRESENT:
if ((ap->blli.tag_l2 != T_ATM_PRESENT) ||
(ap->blli.v.layer_2_protocol.ID_type != T_ATM_SIMPLE_ID) ||
(ap->blli.v.layer_2_protocol.ID.simple_ID !=
T_ATM_BLLI2_I8802) ||
(ap->llc.v.llc_len < T_ATM_LLC_MIN_LEN) ||
(ap->llc.v.llc_len > T_ATM_LLC_MAX_LEN)) {
err = EINVAL;
goto done;
}
cop->co_mpx = ATM_ENC_LLC;
cop->co_llc = ap->llc;
break;
case T_ATM_ABSENT:
case T_ATM_ANY:
cop->co_mpx = ATM_ENC_NULL;
break;
default:
err = EINVAL;
goto done;
}
/*
* Called Party Attributes
*/
switch (ap->called.tag) {
case T_ATM_PRESENT:
switch (ap->called.addr.address_format) {
case T_ATM_ABSENT:
ap->called.tag = T_ATM_ABSENT;
break;
case T_ATM_PVC_ADDR:
err = EINVAL;
goto done;
}
break;
case T_ATM_ABSENT:
case T_ATM_ANY:
break;
default:
err = EINVAL;
goto done;
}
/*
* Get an attribute block and save listening attributes
*/
cop->co_lattr = (Atm_attributes *)atm_allocate(&atm_attributes_pool);
if (cop->co_lattr == NULL) {
err = ENOMEM;
goto done;
}
*cop->co_lattr = *ap;
/*
* Now try to register the listening connection
*/
s = splnet();
if (atm_cm_match(cop->co_lattr, NULL) != NULL) {
/*
* Can't have matching listeners
*/
err = EADDRINUSE;
goto donex;
}
cop->co_state = COS_LISTEN;
LINK2TAIL(cop, Atm_connection, atm_listen_queue, co_next);
donex:
(void) splx(s);
done:
if (err) {
/*
* Undo any partial setup stuff
*/
if (cop) {
if (cop->co_lattr)
atm_free((caddr_t)cop->co_lattr);
atm_free((caddr_t)cop);
}
} else {
/*
* Finish connection setup
*/
*copp = cop;
}
return (err);
}
/*
* Add to LLC Connection
*
* Called by an endpoint service to create a new Connection Manager API
* instance to be associated with an LLC-multiplexed connection instance
* which has been previously created. The endpoint provided token will
* be used in all further CM -> endpoint function calls, and the returned
* connection block pointer must be used in all subsequent endpoint -> CM
* function calls.
*
* If the return indicates that the connection setup has been immediately
* successful, then the connection is ready for data transmission.
*
* If the return indicates that the connection setup is still in progress,
* then the endpoint must wait for notification from the Connection Manager
* indicating the final status of the call setup. If the call setup completes
* successfully, then a "call connected" notification will be sent to the
* endpoint by the Connection Manager. If the call setup fails, then the
* endpoint will receive a "call cleared" notification.
*
* All connection instances must be freed with an atm_cm_release() call.
*
* Arguments:
* epp pointer to endpoint definition structure
* token endpoint's connection instance token
* llc pointer to llc attributes for new connection
* ecop pointer to existing connection block
* copp pointer to location to return allocated connection block
*
* Returns:
* 0 connection has been successfully established
* EINPROGRESS connection establishment is in progress
* errno addllc failed - reason indicated
*
*/
int
atm_cm_addllc(epp, token, llc, ecop, copp)
Atm_endpoint *epp;
void *token;
struct attr_llc *llc;
Atm_connection *ecop;
Atm_connection **copp;
{
Atm_connection *cop, *cop2;
Atm_connvc *cvp;
int s, err;
*copp = NULL;
/*
* Check out requested LLC attributes
*/
if ((llc->tag != T_ATM_PRESENT) ||
((llc->v.flags & T_ATM_LLC_SHARING) == 0) ||
(llc->v.llc_len < T_ATM_LLC_MIN_LEN) ||
(llc->v.llc_len > T_ATM_LLC_MAX_LEN))
return (EINVAL);
/*
* Get a connection block
*/
cop = (Atm_connection *)atm_allocate(&atm_connection_pool);
if (cop == NULL)
return (ENOMEM);
/*
* Initialize connection info
*/
cop->co_endpt = epp;
cop->co_toku = token;
cop->co_llc = *llc;
s = splnet();
/*
* Ensure that supplied connection is really valid
*/
cop2 = NULL;
for (cvp = Q_HEAD(atm_connection_queue, Atm_connvc); cvp;
cvp = Q_NEXT(cvp, Atm_connvc, cvc_q)) {
for (cop2 = cvp->cvc_conn; cop2; cop2 = cop2->co_next) {
if (ecop == cop2)
break;
}
if (cop2)
break;
}
if (cop2 == NULL) {
err = ENOENT;
goto done;
}
switch (ecop->co_state) {
case COS_OUTCONN:
case COS_INACCEPT:
err = EINPROGRESS;
break;
case COS_ACTIVE:
err = 0;
break;
default:
err = EINVAL;
goto done;
}
/*
* Connection must be LLC multiplexed and shared
*/
if ((ecop->co_mpx != ATM_ENC_LLC) ||
((ecop->co_llc.v.flags & T_ATM_LLC_SHARING) == 0)) {
err = EINVAL;
goto done;
}
/*
* This new LLC header must be unique for this VCC
*/
cop2 = ecop->co_mxh;
while (cop2) {
int i = MIN(llc->v.llc_len, cop2->co_llc.v.llc_len);
if (KM_CMP(llc->v.llc_info, cop2->co_llc.v.llc_info, i) == 0) {
err = EINVAL;
goto done;
}
cop2 = cop2->co_next;
}
/*
* Everything seems to check out
*/
cop->co_flags = ecop->co_flags;
cop->co_state = ecop->co_state;
cop->co_mpx = ecop->co_mpx;
cop->co_connvc = ecop->co_connvc;
LINK2TAIL(cop, Atm_connection, ecop->co_mxh, co_next);
cop->co_mxh = ecop->co_mxh;
done:
(void) splx(s);
if (err && err != EINPROGRESS) {
/*
* Undo any partial setup stuff
*/
if (cop)
atm_free((caddr_t)cop);
} else {
/*
* Pass new connection back to caller
*/
*copp = cop;
}
return (err);
}
/*
* XXX
*
* Arguments:
* cop pointer to connection block
* id identifier for party to be added
* addr address of party to be added
*
* Returns:
* 0 addparty successful
* errno addparty failed - reason indicated
*
*/
int
atm_cm_addparty(cop, id, addr)
Atm_connection *cop;
int id;
struct t_atm_sap *addr;
{
return (0);
}
/*
* XXX
*
* Arguments:
* cop pointer to connection block
* id identifier for party to be added
* cause pointer to cause of drop
*
* Returns:
* 0 dropparty successful
* errno dropparty failed - reason indicated
*
*/
int
atm_cm_dropparty(cop, id, cause)
Atm_connection *cop;
int id;
struct t_atm_cause *cause;
{
return (0);
}
/*
* Release Connection Resources
*
* Called by the endpoint service in order to terminate an ATM connection
* and to release all system resources for the connection. This function
* must be called for every allocated connection instance and must only
* be called by the connection's owner.
*
* Arguments:
* cop pointer to connection block
* cause pointer to cause of release
*
* Returns:
* 0 release successful
* errno release failed - reason indicated
*
*/
int
atm_cm_release(cop, cause)
Atm_connection *cop;
struct t_atm_cause *cause;
{
Atm_connvc *cvp;
int s;
s = splnet();
/*
* First, a quick state validation check
*/
switch (cop->co_state) {
case COS_OUTCONN:
case COS_LISTEN:
case COS_INACCEPT:
case COS_ACTIVE:
case COS_CLEAR:
/*
* Break link to user
*/
cop->co_toku = NULL;
break;
case COS_INCONN:
(void) splx(s);
return (EFAULT);
default:
panic("atm_cm_release: bogus conn state");
}
/*
* Check out the VCC state too
*/
if (cvp = cop->co_connvc) {
switch (cvp->cvc_state) {
case CVCS_SETUP:
case CVCS_INIT:
case CVCS_ACCEPT:
case CVCS_ACTIVE:
break;
case CVCS_INCOMING:
(void) splx(s);
return (EFAULT);
case CVCS_CLEAR:
(void) splx(s);
return (EALREADY);
default:
panic("atm_cm_release: bogus connvc state");
}
/*
* If we're the only connection, terminate the VCC
*/
if ((cop->co_mxh == cop) && (cop->co_next == NULL)) {
cvp->cvc_attr.cause.tag = T_ATM_PRESENT;
cvp->cvc_attr.cause.v = *cause;
atm_cm_closevc(cvp);
}
}
/*
* Now get rid of the connection
*/
atm_cm_closeconn(cop, cause);
return (0);
}
/*
* Abort an ATM Connection VCC
*
* This function allows any non-owner kernel entity to request an
* immediate termination of an ATM VCC. This will normally be called
* when encountering a catastrophic error condition that cannot be
* resolved via the available stack protocols. The connection manager
* will schedule the connection's termination, including notifying the
* connection owner of the termination.
*
* This function should only be called by a stack entity instance. After
* calling the function, the caller should set a protocol state which just
* waits for a <sap>_TERM stack command to be delivered.
*
* Arguments:
* cvp pointer to connection VCC block
* cause pointer to cause of abort
*
* Returns:
* 0 abort successful
* errno abort failed - reason indicated
*
*/
int
atm_cm_abort(cvp, cause)
Atm_connvc *cvp;
struct t_atm_cause *cause;
{
ATM_DEBUG2("atm_cm_abort: cvp=%p cause=%d\n",
cvp, cause->cause_value);
/*
* Note that we're aborting
*/
cvp->cvc_flags |= CVCF_ABORTING;
switch (cvp->cvc_state) {
case CVCS_INIT:
/*
* In-line code will handle this
*/
cvp->cvc_attr.cause.tag = T_ATM_PRESENT;
cvp->cvc_attr.cause.v = *cause;
break;
case CVCS_SETUP:
case CVCS_ACCEPT:
case CVCS_ACTIVE:
/*
* Schedule connection termination, since we want
* to avoid any sequencing interactions
*/
cvp->cvc_attr.cause.tag = T_ATM_PRESENT;
cvp->cvc_attr.cause.v = *cause;
CVC_TIMER(cvp, 0);
break;
case CVCS_REJECT:
case CVCS_RELEASE:
case CVCS_CLEAR:
case CVCS_TERM:
/*
* Ignore abort, as we're already terminating
*/
break;
default:
log(LOG_ERR,
"atm_cm_abort: invalid state: cvp=%p, state=%d\n",
cvp, cvp->cvc_state);
}
return (0);
}
/*
* Incoming ATM Call Received
*
* Called by a signalling manager to indicate that a new call request has
* been received. This function will allocate and initialize the connection
* manager control blocks and queue this call request. The call request
* processing function, atm_cm_procinq(), will be scheduled to perform the
* call processing.
*
* Arguments:
* vcp pointer to incoming call's VCC control block
* ap pointer to incoming call's attributes
*
* Returns:
* 0 call queuing successful
* errno call queuing failed - reason indicated
*
*/
int
atm_cm_incoming(vcp, ap)
struct vccb *vcp;
Atm_attributes *ap;
{
Atm_connvc *cvp;
int s, err;
/*
* Do some minimal attribute validation
*/
/*
* Must specify a network interface
*/
if (ap->nif == NULL)
return (EINVAL);
/*
* AAL Attributes
*/
if ((ap->aal.tag != T_ATM_PRESENT) ||
((ap->aal.type != ATM_AAL5) &&
(ap->aal.type != ATM_AAL3_4)))
return (EINVAL);
/*
* Traffic Descriptor Attributes
*/
if ((ap->traffic.tag != T_ATM_PRESENT) &&
(ap->traffic.tag != T_ATM_ABSENT))
return (EINVAL);
/*
* Broadband Bearer Attributes
*/
if ((ap->bearer.tag != T_ATM_PRESENT) ||
((ap->bearer.v.connection_configuration != T_ATM_1_TO_1) &&
(ap->bearer.v.connection_configuration != T_ATM_1_TO_MANY)))
return (EINVAL);
/*
* Broadband High Layer Attributes
*/
if ((ap->bhli.tag != T_ATM_PRESENT) &&
(ap->bhli.tag != T_ATM_ABSENT))
return (EINVAL);
/*
* Broadband Low Layer Attributes
*/
if ((ap->blli.tag_l2 != T_ATM_PRESENT) &&
(ap->blli.tag_l2 != T_ATM_ABSENT))
return (EINVAL);
if ((ap->blli.tag_l3 != T_ATM_PRESENT) &&
(ap->blli.tag_l3 != T_ATM_ABSENT))
return (EINVAL);
/*
* Logical Link Control Attributes
*/
if (ap->llc.tag == T_ATM_PRESENT)
return (EINVAL);
ap->llc.tag = T_ATM_ANY;
/*
* Called Party Attributes
*/
if ((ap->called.tag != T_ATM_PRESENT) ||
(ap->called.addr.address_format == T_ATM_ABSENT))
return (EINVAL);
if (ap->called.tag == T_ATM_ABSENT) {
ap->called.addr.address_format = T_ATM_ABSENT;
ap->called.addr.address_length = 0;
ap->called.subaddr.address_format = T_ATM_ABSENT;
ap->called.subaddr.address_length = 0;
}
/*
* Calling Party Attributes
*/
if ((ap->calling.tag != T_ATM_PRESENT) &&
(ap->calling.tag != T_ATM_ABSENT))
return (EINVAL);
if (ap->calling.tag == T_ATM_ABSENT) {
ap->calling.addr.address_format = T_ATM_ABSENT;
ap->calling.addr.address_length = 0;
ap->calling.subaddr.address_format = T_ATM_ABSENT;
ap->calling.subaddr.address_length = 0;
}
/*
* Quality of Service Attributes
*/
if (ap->qos.tag != T_ATM_PRESENT)
return (EINVAL);
/*
* Transit Network Attributes
*/
if ((ap->transit.tag != T_ATM_PRESENT) &&
(ap->transit.tag != T_ATM_ABSENT))
return (EINVAL);
/*
* Cause Attributes
*/
if ((ap->cause.tag != T_ATM_PRESENT) &&
(ap->cause.tag != T_ATM_ABSENT))
return (EINVAL);
/*
* Get a connection VCC block
*/
cvp = (Atm_connvc *)atm_allocate(&atm_connvc_pool);
if (cvp == NULL) {
err = ENOMEM;
goto fail;
}
/*
* Initialize the control block
*/
cvp->cvc_vcc = vcp;
cvp->cvc_sigmgr = vcp->vc_pif->pif_sigmgr;
cvp->cvc_attr = *ap;
cvp->cvc_state = CVCS_INCOMING;
/*
* Control queue length
*/
s = splnet();
if (atm_incoming_qlen >= ATM_CALLQ_MAX) {
(void) splx(s);
err = EBUSY;
goto fail;
}
/*
* Queue request and schedule call processing function
*/
cvp->cvc_flags |= CVCF_INCOMQ;
ENQUEUE(cvp, Atm_connvc, cvc_q, atm_incoming_queue);
if (atm_incoming_qlen++ == 0) {
timeout(atm_cm_procinq, (void *)0, 0);
}
/*
* Link for signalling manager
*/
vcp->vc_connvc = cvp;
(void) splx(s);
return (0);
fail:
/*
* Free any resources
*/
if (cvp)
atm_free((caddr_t)cvp);
return (err);
}
/*
* VCC Connected Notification
*
* This function is called by a signalling manager as notification that a
* VCC call setup has been successful.
*
* Arguments:
* cvp pointer to connection VCC block
*
* Returns:
* none
*
*/
void
atm_cm_connected(cvp)
Atm_connvc *cvp;
{
Atm_connection *cop, *cop2;
KBuffer *m;
int s, err;
s = splnet();
/*
* Validate connection vcc
*/
switch (cvp->cvc_state) {
case CVCS_SETUP:
/*
* Initialize the stack
*/
cvp->cvc_state = CVCS_INIT;
STACK_CALL(atm_stackcmds[cvp->cvc_attr.api].init,
cvp->cvc_lower, cvp->cvc_tokl,
cvp, cvp->cvc_attr.api_init, 0, err);
if (err)
panic("atm_cm_connected: init");
if (cvp->cvc_flags & CVCF_ABORTING) {
/*
* Someone on the stack bailed out...notify all of the
* connections and schedule the VCC termination
*/
cop = cvp->cvc_conn;
while (cop) {
cop2 = cop->co_next;
atm_cm_closeconn(cop, &cvp->cvc_attr.cause.v);
cop = cop2;
}
atm_cm_closevc(cvp);
(void) splx(s);
return;
}
break;
case CVCS_ACCEPT:
/*
* Stack already initialized
*/
break;
default:
panic("atm_cm_connected: connvc state");
}
/*
* VCC is ready for action
*/
cvp->cvc_state = CVCS_ACTIVE;
/*
* Notify all connections that the call has completed
*/
cop = cvp->cvc_conn;
while (cop) {
cop2 = cop->co_next;
switch (cop->co_state) {
case COS_OUTCONN:
case COS_INACCEPT:
cop->co_state = COS_ACTIVE;
(*cop->co_endpt->ep_connected)(cop->co_toku);
break;
case COS_ACTIVE:
/*
* May get here if an ep_connected() call (from
* above) results in an atm_cm_addllc() call for
* the just connected connection.
*/
break;
default:
panic("atm_cm_connected: connection state");
}
cop = cop2;
}
(void) splx(s);
/*
* Input any queued packets
*/
while (m = cvp->cvc_rcvq) {
cvp->cvc_rcvq = KB_QNEXT(m);
cvp->cvc_rcvqlen--;
KB_QNEXT(m) = NULL;
/*
* Currently only supported for CPCS API
*/
atm_cm_cpcs_upper(CPCS_UNITDATA_SIG, cvp, (int)m, 0);
}
return;
}
/*
* VCC Cleared Notification
*
* This function is called by a signalling manager as notification that a
* VCC call has been cleared. The cause information describing the reason
* for the call clearing will be contained in the connection VCC attributes.
*
* Arguments:
* cvp pointer to connection VCC block
*
* Returns:
* none
*
*/
void
atm_cm_cleared(cvp)
Atm_connvc *cvp;
{
Atm_connection *cop, *cop2;
int s;
#ifdef DIAGNOSTIC
if ((cvp->cvc_state == CVCS_FREE) ||
(cvp->cvc_state >= CVCS_CLEAR))
panic("atm_cm_cleared");
#endif
cvp->cvc_state = CVCS_CLEAR;
s = splnet();
/*
* Terminate all connections
*/
cop = cvp->cvc_conn;
while (cop) {
cop2 = cop->co_next;
atm_cm_closeconn(cop, &cvp->cvc_attr.cause.v);
cop = cop2;
}
/*
* Clean up connection VCC
*/
atm_cm_closevc(cvp);
(void) splx(s);
return;
}
/*
* Process Incoming Call Queue
*
* This function is scheduled by atm_cm_incoming() in order to process
* all the entries on the incoming call queue.
*
* Arguments:
* arg argument passed on timeout() call
*
* Returns:
* none
*
*/
static KTimeout_ret
atm_cm_procinq(arg)
void *arg;
{
Atm_connvc *cvp;
int cnt = 0, s;
/*
* Only process incoming calls up to our quota
*/
while (cnt++ < ATM_CALLQ_MAX) {
s = splnet();
/*
* Get next awaiting call
*/
cvp = Q_HEAD(atm_incoming_queue, Atm_connvc);
if (cvp == NULL) {
(void) splx(s);
break;
}
DEQUEUE(cvp, Atm_connvc, cvc_q, atm_incoming_queue);
atm_incoming_qlen--;
cvp->cvc_flags &= ~CVCF_INCOMQ;
/*
* Handle the call
*/
atm_cm_incall(cvp);
(void) splx(s);
}
/*
* If we've expended our quota, reschedule ourselves
*/
if (cnt >= ATM_CALLQ_MAX)
timeout(atm_cm_procinq, (void *)0, 0);
}
/*
* Process Incoming Call
*
* This function will search through the listening queue and try to find
* matching endpoint(s) for the incoming call. If we find any, we will
* notify the endpoint service(s) of the incoming call and will then
* notify the signalling manager to progress the call to an active status.
*
* If there are no listeners for the call, the signalling manager will be
* notified of a call rejection.
*
* Called at splnet.
*
* Arguments:
* cvp pointer to connection VCC for incoming call
*
* Returns:
* none
*
*/
static void
atm_cm_incall(cvp)
Atm_connvc *cvp;
{
Atm_connection *cop, *lcop, *hcop;
Atm_attributes attr;
int err;
hcop = NULL;
lcop = NULL;
cop = NULL;
attr = cvp->cvc_attr;
/*
* Look for matching listeners
*/
while (lcop = atm_cm_match(&attr, lcop)) {
if (cop == NULL) {
/*
* Need a new connection block
*/
cop = (Atm_connection *)
atm_allocate(&atm_connection_pool);
if (cop == NULL) {
cvp->cvc_attr.cause = atm_cause_tmpl;
cvp->cvc_attr.cause.v.cause_value =
T_ATM_CAUSE_TEMPORARY_FAILURE;
goto fail;
}
}
/*
* Initialize connection from listener and incoming call
*/
cop->co_mxh = NULL;
cop->co_state = COS_INCONN;
cop->co_mpx = lcop->co_mpx;
cop->co_endpt = lcop->co_endpt;
cop->co_llc = lcop->co_llc;
switch (attr.bearer.v.connection_configuration) {
case T_ATM_1_TO_1:
cop->co_flags |= COF_P2P;
break;
case T_ATM_1_TO_MANY:
/* Not supported */
cop->co_flags |= COF_P2MP;
cvp->cvc_attr.cause = atm_cause_tmpl;
cvp->cvc_attr.cause.v.cause_value =
T_ATM_CAUSE_BEARER_CAPABILITY_NOT_IMPLEMENTED;
goto fail;
}
/*
* Notify endpoint of incoming call
*/
err = (*cop->co_endpt->ep_incoming)
(lcop->co_toku, cop, &cvp->cvc_attr, &cop->co_toku);
if (err == 0) {
/*
* Endpoint has accepted the call
*
* Setup call attributes
*/
if (hcop == NULL) {
cvp->cvc_attr.api = lcop->co_lattr->api;
cvp->cvc_attr.api_init =
lcop->co_lattr->api_init;
cvp->cvc_attr.llc = lcop->co_lattr->llc;
}
cvp->cvc_attr.headin = MAX(cvp->cvc_attr.headin,
lcop->co_lattr->headin);
/*
* Setup connection info and queueing
*/
cop->co_state = COS_INACCEPT;
cop->co_connvc = cvp;
LINK2TAIL(cop, Atm_connection, hcop, co_next);
cop->co_mxh = hcop;
/*
* Need a new connection block next time around
*/
cop = NULL;
} else {
/*
* Endpoint refuses call
*/
goto fail;
}
}
/*
* We're done looking for listeners
*/
if (hcop) {
/*
* Someone actually wants the call, so notify
* the signalling manager to continue
*/
cvp->cvc_flags |= CVCF_CONNQ;
ENQUEUE(cvp, Atm_connvc, cvc_q, atm_connection_queue);
if (atm_cm_accept(cvp, hcop))
goto fail;
} else {
/*
* Nobody around to take the call
*/
cvp->cvc_attr.cause = atm_cause_tmpl;
cvp->cvc_attr.cause.v.cause_value =
T_ATM_CAUSE_INCOMPATIBLE_DESTINATION;
goto fail;
}
/*
* Clean up loose ends
*/
if (cop)
atm_free((caddr_t)cop);
/*
* Call has been accepted
*/
return;
fail:
/*
* Call failed - notify any endpoints of the call failure
*/
/*
* Clean up loose ends
*/
if (cop)
atm_free((caddr_t)cop);
if (cvp->cvc_attr.cause.tag != T_ATM_PRESENT) {
cvp->cvc_attr.cause = atm_cause_tmpl;
cvp->cvc_attr.cause.v.cause_value =
T_ATM_CAUSE_UNSPECIFIED_NORMAL;
}
cop = hcop;
while (cop) {
Atm_connection *cop2 = cop->co_next;
atm_cm_closeconn(cop, &cvp->cvc_attr.cause.v);
cop = cop2;
}
/*
* Tell the signalling manager to reject the call
*/
atm_cm_closevc(cvp);
return;
}
/*
* Accept an Incoming ATM Call
*
* Some endpoint service(s) wants to accept an incoming call, so the
* signalling manager will be notified to attempt to progress the call
* to an active status.
*
* If the signalling manager indicates that connection activation has
* been immediately successful, then all of the endpoints will be notified
* that the connection is ready for data transmission.
*
* If the return indicates that connection activation is still in progress,
* then the endpoints must wait for notification from the Connection Manager
* indicating the final status of the call setup. If the call setup completes
* successfully, then a "call connected" notification will be sent to the
* endpoints by the Connection Manager. If the call setup fails, then the
* endpoints will receive a "call cleared" notification.
*
* Called at splnet.
*
* Arguments:
* cvp pointer to connection VCC for incoming call
* cop pointer to head of accepted connections
*
* Returns:
* 0 connection has been successfully activated
* errno accept failed - reason indicated
*
*/
static int
atm_cm_accept(cvp, cop)
Atm_connvc *cvp;
Atm_connection *cop;
{
struct stack_list sl;
void (*upf)__P((int, void *, int, int));
int sli, err, err2;
/*
* Link vcc to connections
*/
cvp->cvc_conn = cop;
/*
* Initialize stack list index
*/
sli = 0;
/*
* Check out Data API
*/
switch (cvp->cvc_attr.api) {
case CMAPI_CPCS:
upf = atm_cm_cpcs_upper;
break;
case CMAPI_SAAL:
sl.sl_sap[sli++] = SAP_SSCF_UNI;
sl.sl_sap[sli++] = SAP_SSCOP;
upf = atm_cm_saal_upper;
break;
case CMAPI_SSCOP:
sl.sl_sap[sli++] = SAP_SSCOP;
upf = atm_cm_sscop_upper;
break;
default:
upf = NULL;
}
/*
* AAL Attributes
*/
switch (cvp->cvc_attr.aal.type) {
case ATM_AAL5:
sl.sl_sap[sli++] = SAP_CPCS_AAL5;
sl.sl_sap[sli++] = SAP_SAR_AAL5;
sl.sl_sap[sli++] = SAP_ATM;
break;
case ATM_AAL3_4:
sl.sl_sap[sli++] = SAP_CPCS_AAL3_4;
sl.sl_sap[sli++] = SAP_SAR_AAL3_4;
sl.sl_sap[sli++] = SAP_ATM;
break;
}
/*
* Terminate stack list
*/
sl.sl_sap[sli] = 0;
/*
* Create a service stack
*/
err = atm_create_stack(cvp, &sl, upf);
if (err) {
goto done;
}
/*
* Let the signalling manager finish the VCC activation
*/
switch ((*cvp->cvc_sigmgr->sm_accept)(cvp->cvc_vcc, &err)) {
case CALL_PROCEEDING:
/*
* Note that we're not finished yet
*/
err = EINPROGRESS;
/* FALLTHRU */
case CALL_CONNECTED:
/*
* Initialize the stack now, even if the call isn't totally
* active yet. We want to avoid the delay between getting
* the "call connected" event and actually notifying the
* adapter to accept cells on the new VCC - if the delay is
* too long, then we end up dropping the first pdus sent by
* the caller.
*/
cvp->cvc_state = CVCS_INIT;
STACK_CALL(atm_stackcmds[cvp->cvc_attr.api].init,
cvp->cvc_lower, cvp->cvc_tokl, cvp,
cvp->cvc_attr.api_init, 0, err2);
if (err2)
panic("atm_cm_accept: init");
if (cvp->cvc_flags & CVCF_ABORTING) {
/*
* Someone on the stack bailed out...schedule the
* VCC and stack termination
*/
err = ECONNABORTED;
} else {
/*
* Everything looks fine from here
*/
if (err)
cvp->cvc_state = CVCS_ACCEPT;
else
cvp->cvc_state = CVCS_ACTIVE;
}
break;
case CALL_FAILED:
/*
* Terminate stack and clean up before we leave
*/
cvp->cvc_state = CVCS_CLEAR;
break;
default:
panic("atm_cm_accept: accept");
}
done:
if (err == 0) {
/*
* Call has been connected, notify endpoints
*/
while (cop) {
Atm_connection *cop2 = cop->co_next;
cop->co_state = COS_ACTIVE;
(*cop->co_endpt->ep_connected)(cop->co_toku);
cop = cop2;
}
} else if (err == EINPROGRESS) {
/*
* Call is still in progress, endpoint must wait
*/
err = 0;
} else {
/*
* Let caller know we failed
*/
cvp->cvc_attr.cause = atm_cause_tmpl;
cvp->cvc_attr.cause.v.cause_value =
T_ATM_CAUSE_UNSPECIFIED_RESOURCE_UNAVAILABLE;
}
return (err);
}
/*
* Match Attributes on Listening Queue
*
* This function will attempt to match the supplied connection attributes
* with one of the registered attributes in the listening queue. The pcop
* argument may be supplied in order to allow multiple listeners to share
* an incoming call (if supported by the listeners).
*
* Called at splnet.
*
* Arguments:
* ap pointer to attributes to be matched
* pcop pointer to the previously matched connection
*
* Returns:
* addr connection with which a match was found
* 0 no match found
*
*/
Atm_connection *
atm_cm_match(ap, pcop)
Atm_attributes *ap;
Atm_connection *pcop;
{
Atm_connection *cop;
Atm_attributes *lap;
/*
* If we've already matched a listener...
*/
if (pcop) {
/*
* Make sure already matched listener supports sharing
*/
if ((pcop->co_mpx != ATM_ENC_LLC) ||
((pcop->co_llc.v.flags & T_ATM_LLC_SHARING) == 0))
return (NULL);
/*
* Position ourselves after the matched entry
*/
for (cop = atm_listen_queue; cop; cop = cop->co_next) {
if (cop == pcop) {
cop = pcop->co_next;
break;
}
}
} else {
/*
* Start search at top of listening queue
*/
cop = atm_listen_queue;
}
/*
* Search through listening queue
*/
for (; cop; cop = cop->co_next) {
lap = cop->co_lattr;
/*
* If we're trying to share, check that this entry allows it
*/
if (pcop) {
if ((cop->co_mpx != ATM_ENC_LLC) ||
((cop->co_llc.v.flags & T_ATM_LLC_SHARING) == 0))
continue;
}
/*
* ALL "matchable" attributes must match
*/
/*
* BHLI
*/
if (lap->bhli.tag == T_ATM_ABSENT) {
if (ap->bhli.tag == T_ATM_PRESENT)
continue;
} else if (lap->bhli.tag == T_ATM_PRESENT) {
if (ap->bhli.tag == T_ATM_ABSENT)
continue;
if (ap->bhli.tag == T_ATM_PRESENT)
if (KM_CMP(&lap->bhli.v, &ap->bhli.v,
sizeof(struct t_atm_bhli)))
continue;
}
/*
* BLLI Layer 2
*/
if (lap->blli.tag_l2 == T_ATM_ABSENT) {
if (ap->blli.tag_l2 == T_ATM_PRESENT)
continue;
} else if (lap->blli.tag_l2 == T_ATM_PRESENT) {
if (ap->blli.tag_l2 == T_ATM_ABSENT)
continue;
if (ap->blli.tag_l2 == T_ATM_PRESENT) {
if (KM_CMP(&lap->blli.v.layer_2_protocol.ID,
&ap->blli.v.layer_2_protocol.ID,
sizeof(
ap->blli.v.layer_2_protocol.ID)))
continue;
}
}
/*
* BLLI Layer 3
*/
if (lap->blli.tag_l3 == T_ATM_ABSENT) {
if (ap->blli.tag_l3 == T_ATM_PRESENT)
continue;
} else if (lap->blli.tag_l3 == T_ATM_PRESENT) {
if (ap->blli.tag_l3 == T_ATM_ABSENT)
continue;
if (ap->blli.tag_l3 == T_ATM_PRESENT) {
if (KM_CMP(&lap->blli.v.layer_3_protocol.ID,
&ap->blli.v.layer_3_protocol.ID,
sizeof(
ap->blli.v.layer_3_protocol.ID)))
continue;
}
}
/*
* LLC
*/
if (lap->llc.tag == T_ATM_ABSENT) {
if (ap->llc.tag == T_ATM_PRESENT)
continue;
} else if (lap->llc.tag == T_ATM_PRESENT) {
if (ap->llc.tag == T_ATM_ABSENT)
continue;
if (ap->llc.tag == T_ATM_PRESENT) {
int i = MIN(lap->llc.v.llc_len,
ap->llc.v.llc_len);
if (KM_CMP(lap->llc.v.llc_info,
ap->llc.v.llc_info, i))
continue;
}
}
/*
* AAL
*/
if (lap->aal.tag == T_ATM_ABSENT) {
if (ap->aal.tag == T_ATM_PRESENT)
continue;
} else if (lap->aal.tag == T_ATM_PRESENT) {
if (ap->aal.tag == T_ATM_ABSENT)
continue;
if (ap->aal.tag == T_ATM_PRESENT) {
if (lap->aal.type != ap->aal.type)
continue;
if (lap->aal.type == ATM_AAL5) {
if (lap->aal.v.aal5.SSCS_type !=
ap->aal.v.aal5.SSCS_type)
continue;
} else {
if (lap->aal.v.aal4.SSCS_type !=
ap->aal.v.aal4.SSCS_type)
continue;
}
}
}
/*
* Called Party
*/
if (lap->called.tag == T_ATM_ABSENT) {
if (ap->called.tag == T_ATM_PRESENT)
continue;
} else if (lap->called.tag == T_ATM_PRESENT) {
if (ap->called.tag == T_ATM_ABSENT)
continue;
if (ap->called.tag == T_ATM_PRESENT) {
if ((!ATM_ADDR_EQUAL(&lap->called.addr,
&ap->called.addr)) ||
(!ATM_ADDR_EQUAL(&lap->called.subaddr,
&ap->called.subaddr)))
continue;
}
}
/*
* Found a full match - return it
*/
break;
}
return (cop);
}
/*
* Find Shareable LLC VCC
*
* Given a endpoint-supplied connection attribute using LLC multiplexing,
* this function will attempt to locate an existing connection which meets
* the requirements of the supplied attributes.
*
* Called at splnet.
*
* Arguments:
* ap pointer to requested attributes
*
* Returns:
* addr shareable LLC connection VCC
* 0 no shareable VCC available
*
*/
static Atm_connvc *
atm_cm_share_llc(ap)
Atm_attributes *ap;
{
Atm_connection *cop;
Atm_connvc *cvp;
/*
* Is requestor willing to share?
*/
if ((ap->llc.v.flags & T_ATM_LLC_SHARING) == 0)
return (NULL);
/*
* Try to find a shareable connection
*/
for (cvp = Q_HEAD(atm_connection_queue, Atm_connvc); cvp;
cvp = Q_NEXT(cvp, Atm_connvc, cvc_q)) {
/*
* Dont use terminating connections
*/
switch (cvp->cvc_state) {
case CVCS_SETUP:
case CVCS_ACCEPT:
case CVCS_ACTIVE:
break;
default:
continue;
}
/*
* Is connection LLC and shareable?
*/
if ((cvp->cvc_attr.llc.tag != T_ATM_PRESENT) ||
((cvp->cvc_attr.llc.v.flags & T_ATM_LLC_SHARING) == 0))
continue;
/*
* Match requested attributes with existing connection
*/
if (ap->nif != cvp->cvc_attr.nif)
continue;
if ((ap->api != cvp->cvc_attr.api) ||
(ap->api_init != cvp->cvc_attr.api_init))
continue;
/*
* Remote Party
*/
if (cvp->cvc_flags & CVCF_CALLER) {
if ((!ATM_ADDR_EQUAL(&ap->called.addr,
&cvp->cvc_attr.called.addr)) ||
(!ATM_ADDR_EQUAL(&ap->called.subaddr,
&cvp->cvc_attr.called.subaddr)))
continue;
} else {
if (cvp->cvc_attr.calling.tag != T_ATM_PRESENT)
continue;
if ((!ATM_ADDR_EQUAL(&ap->called.addr,
&cvp->cvc_attr.calling.addr)) ||
(!ATM_ADDR_EQUAL(&ap->called.subaddr,
&cvp->cvc_attr.calling.subaddr)))
continue;
}
/*
* AAL
*/
if (ap->aal.type = ATM_AAL5) {
struct t_atm_aal5 *ap5, *cv5;
ap5 = &ap->aal.v.aal5;
cv5 = &cvp->cvc_attr.aal.v.aal5;
if ((cvp->cvc_attr.aal.type != ATM_AAL5) ||
(ap5->SSCS_type != cv5->SSCS_type))
continue;
if (cvp->cvc_flags & CVCF_CALLER) {
if (ap5->forward_max_SDU_size >
cv5->forward_max_SDU_size)
continue;
} else {
if (ap5->forward_max_SDU_size >
cv5->backward_max_SDU_size)
continue;
}
} else {
struct t_atm_aal4 *ap4, *cv4;
ap4 = &ap->aal.v.aal4;
cv4 = &cvp->cvc_attr.aal.v.aal4;
if ((cvp->cvc_attr.aal.type != ATM_AAL3_4) ||
(ap4->SSCS_type != cv4->SSCS_type))
continue;
if (cvp->cvc_flags & CVCF_CALLER) {
if (ap4->forward_max_SDU_size >
cv4->forward_max_SDU_size)
continue;
} else {
if (ap4->forward_max_SDU_size >
cv4->backward_max_SDU_size)
continue;
}
}
/*
* Traffic Descriptor
*/
if ((ap->traffic.tag != T_ATM_PRESENT) ||
(cvp->cvc_attr.traffic.tag != T_ATM_PRESENT) ||
(ap->traffic.v.best_effort != T_YES) ||
(cvp->cvc_attr.traffic.v.best_effort != T_YES))
continue;
/*
* Broadband Bearer
*/
if (ap->bearer.v.connection_configuration !=
cvp->cvc_attr.bearer.v.connection_configuration)
continue;
/*
* QOS
*/
if (cvp->cvc_flags & CVCF_CALLER) {
if ((ap->qos.v.forward.qos_class !=
cvp->cvc_attr.qos.v.forward.qos_class) ||
(ap->qos.v.backward.qos_class !=
cvp->cvc_attr.qos.v.backward.qos_class))
continue;
} else {
if ((ap->qos.v.forward.qos_class !=
cvp->cvc_attr.qos.v.backward.qos_class) ||
(ap->qos.v.backward.qos_class !=
cvp->cvc_attr.qos.v.forward.qos_class))
continue;
}
/*
* The new LLC header must also be unique for this VCC
*/
for (cop = cvp->cvc_conn; cop; cop = cop->co_next) {
int i = MIN(ap->llc.v.llc_len,
cop->co_llc.v.llc_len);
if (KM_CMP(ap->llc.v.llc_info,
cop->co_llc.v.llc_info, i) == 0)
break;
}
/*
* If no header overlaps, then we're done
*/
if (cop == NULL)
break;
}
return (cvp);
}
/*
* Close Connection
*
* This function will terminate a connection, including notifying the
* user, if necessary, and freeing up control block memory. The caller
* is responsible for managing the connection VCC.
*
* Called at splnet.
*
* Arguments:
* cop pointer to connection block
* cause pointer to cause of close
*
* Returns:
* none
*
*/
static void
atm_cm_closeconn(cop, cause)
Atm_connection *cop;
struct t_atm_cause *cause;
{
/*
* Decide whether user needs notification
*/
switch (cop->co_state) {
case COS_OUTCONN:
case COS_LISTEN:
case COS_INCONN:
case COS_INACCEPT:
case COS_ACTIVE:
/*
* Yup, let 'em know connection is gone
*/
if (cop->co_toku)
(*cop->co_endpt->ep_cleared)(cop->co_toku, cause);
break;
case COS_CLEAR:
/*
* Nope,they should know already
*/
break;
default:
panic("atm_cm_closeconn: bogus state");
}
/*
* Unlink connection from its queues
*/
switch (cop->co_state) {
case COS_LISTEN:
atm_free((caddr_t)cop->co_lattr);
UNLINK(cop, Atm_connection, atm_listen_queue, co_next);
break;
default:
/*
* Remove connection from multiplexor queue
*/
if (cop->co_mxh != cop) {
/*
* Connection is down the chain, just unlink it
*/
UNLINK(cop, Atm_connection, cop->co_mxh, co_next);
} else if (cop->co_next != NULL) {
/*
* Connection is at the head of a non-singleton chain,
* so unlink and reset the chain head
*/
Atm_connection *t, *nhd;
t = nhd = cop->co_next;
while (t) {
t->co_mxh = nhd;
t = t->co_next;
}
if (nhd->co_connvc)
nhd->co_connvc->cvc_conn = nhd;
}
}
/*
* Free the connection block
*/
cop->co_state = COS_FREE;
atm_free((caddr_t)cop);
return;
}
/*
* Close Connection VCC
*
* This function will terminate a connection VCC, including releasing the
* the call to the signalling manager, terminating the VCC protocol stack,
* and freeing up control block memory.
*
* Called at splnet.
*
* Arguments:
* cvp pointer to connection VCC block
*
* Returns:
* none
*
*/
static void
atm_cm_closevc(cvp)
Atm_connvc *cvp;
{
int err;
/*
* Break links with the connection block
*/
cvp->cvc_conn = NULL;
/*
* Cancel any running timer
*/
CVC_CANCEL(cvp);
/*
* Free queued packets
*/
while (cvp->cvc_rcvq) {
KBuffer *m;
m = cvp->cvc_rcvq;
cvp->cvc_rcvq = KB_QNEXT(m);
KB_QNEXT(m) = NULL;
KB_FREEALL(m);
}
/*
* Unlink from any queues
*/
if (cvp->cvc_flags & CVCF_INCOMQ) {
DEQUEUE(cvp, Atm_connvc, cvc_q, atm_incoming_queue);
atm_incoming_qlen--;
cvp->cvc_flags &= ~CVCF_INCOMQ;
} else if (cvp->cvc_flags & CVCF_CONNQ) {
DEQUEUE(cvp, Atm_connvc, cvc_q, atm_connection_queue);
cvp->cvc_flags &= ~CVCF_CONNQ;
}
/*
* Release the signalling call
*/
switch (cvp->cvc_state) {
case CVCS_SETUP:
case CVCS_INIT:
case CVCS_ACCEPT:
case CVCS_ACTIVE:
case CVCS_RELEASE:
if (cvp->cvc_vcc) {
cvp->cvc_state = CVCS_RELEASE;
switch ((*cvp->cvc_sigmgr->sm_release)
(cvp->cvc_vcc, &err)) {
case CALL_CLEARED:
/*
* Looks good so far...
*/
break;
case CALL_PROCEEDING:
/*
* We'll have to wait for the call to clear
*/
return;
case CALL_FAILED:
/*
* If there's a memory shortage, retry later.
* Otherwise who knows what's going on....
*/
if ((err == ENOMEM) || (err == ENOBUFS)) {
CVC_TIMER(cvp, 1 * ATM_HZ);
return;
}
log(LOG_ERR,
"atm_cm_closevc: release %d\n", err);
break;
}
}
break;
case CVCS_INCOMING:
case CVCS_REJECT:
if (cvp->cvc_vcc) {
cvp->cvc_state = CVCS_REJECT;
switch ((*cvp->cvc_sigmgr->sm_reject)
(cvp->cvc_vcc, &err)) {
case CALL_CLEARED:
/*
* Looks good so far...
*/
break;
case CALL_FAILED:
/*
* If there's a memory shortage, retry later.
* Otherwise who knows what's going on....
*/
if ((err == ENOMEM) || (err == ENOBUFS)) {
CVC_TIMER(cvp, 1 * ATM_HZ);
return;
}
log(LOG_ERR,
"atm_cm_closevc: reject %d\n", err);
break;
}
}
break;
case CVCS_CLEAR:
case CVCS_TERM:
/*
* No need for anything here
*/
break;
default:
panic("atm_cm_closevc: bogus state");
}
/*
* Now terminate the stack
*/
if (cvp->cvc_tokl) {
cvp->cvc_state = CVCS_TERM;
/*
* Wait until stack is unwound before terminating
*/
if ((cvp->cvc_downcnt > 0) || (cvp->cvc_upcnt > 0)) {
CVC_TIMER(cvp, 0);
return;
}
STACK_CALL(atm_stackcmds[cvp->cvc_attr.api].term,
cvp->cvc_lower, cvp->cvc_tokl, cvp, 0, 0, err);
cvp->cvc_tokl = NULL;
}
/*
* Let signalling manager finish up
*/
cvp->cvc_state = CVCS_FREE;
if (cvp->cvc_vcc) {
(void) (*cvp->cvc_sigmgr->sm_free)(cvp->cvc_vcc);
}
/*
* Finally, free our own control blocks
*/
atm_free((caddr_t)cvp);
return;
}
/*
* Process a Connection VCC timeout
*
* Called when a previously scheduled cvc control block timer expires.
* Processing will be based on the current cvc state.
*
* Called at splnet.
*
* Arguments:
* tip pointer to cvc timer control block
*
* Returns:
* none
*
*/
static void
atm_cm_timeout(tip)
struct atm_time *tip;
{
Atm_connection *cop, *cop2;
Atm_connvc *cvp;
/*
* Back-off to cvc control block
*/
cvp = (Atm_connvc *)
((caddr_t)tip - (int)(&((Atm_connvc *)0)->cvc_time));
/*
* Process timeout based on protocol state
*/
switch (cvp->cvc_state) {
case CVCS_SETUP:
case CVCS_ACCEPT:
case CVCS_ACTIVE:
/*
* Handle VCC abort
*/
if ((cvp->cvc_flags & CVCF_ABORTING) == 0)
goto logerr;
/*
* Terminate all connections
*/
cop = cvp->cvc_conn;
while (cop) {
cop2 = cop->co_next;
atm_cm_closeconn(cop, &cvp->cvc_attr.cause.v);
cop = cop2;
}
/*
* Terminate VCC
*/
atm_cm_closevc(cvp);
break;
case CVCS_REJECT:
case CVCS_RELEASE:
case CVCS_TERM:
/*
* Retry failed operation
*/
atm_cm_closevc(cvp);
break;
default:
logerr:
log(LOG_ERR,
"atm_cm_timeout: invalid state: cvp=%p, state=%d\n",
cvp, cvp->cvc_state);
}
}
/*
* CPCS User Control Commands
*
* This function is called by an endpoint user to pass a control command
* across a CPCS data API. Mostly we just send these down the stack.
*
* Arguments:
* cmd stack command code
* cop pointer to connection block
* arg argument
*
* Returns:
* 0 command output successful
* errno output failed - reason indicated
*
*/
int
atm_cm_cpcs_ctl(cmd, cop, arg)
int cmd;
Atm_connection *cop;
void *arg;
{
Atm_connvc *cvp;
int err = 0;
/*
* Validate connection state
*/
if (cop->co_state != COS_ACTIVE) {
err = EFAULT;
goto done;
}
cvp = cop->co_connvc;
if (cvp->cvc_state != CVCS_ACTIVE) {
err = EFAULT;
goto done;
}
if (cvp->cvc_attr.api != CMAPI_CPCS) {
err = EFAULT;
goto done;
}
switch (cmd) {
default:
err = EINVAL;
}
done:
return (err);
}
/*
* CPCS Data Output
*
* This function is called by an endpoint user to output a data packet
* across a CPCS data API. After we've validated the connection state, the
* packet will be encapsulated (if necessary) and sent down the data stack.
*
* Arguments:
* cop pointer to connection block
* m pointer to packet buffer chain to be output
*
* Returns:
* 0 packet output successful
* errno output failed - reason indicated
*
*/
int
atm_cm_cpcs_data(cop, m)
Atm_connection *cop;
KBuffer *m;
{
Atm_connvc *cvp;
struct attr_llc *llcp;
int err, space;
void *bp;
/*
* Validate connection state
*/
if (cop->co_state != COS_ACTIVE) {
err = EFAULT;
goto done;
}
cvp = cop->co_connvc;
if (cvp->cvc_state != CVCS_ACTIVE) {
err = EFAULT;
goto done;
}
if (cvp->cvc_attr.api != CMAPI_CPCS) {
err = EFAULT;
goto done;
}
/*
* Add any packet encapsulation
*/
switch (cop->co_mpx) {
case ATM_ENC_NULL:
/*
* None needed...
*/
break;
case ATM_ENC_LLC:
/*
* Need to add an LLC header
*/
llcp = &cop->co_llc;
/*
* See if there's room to add LLC header to front of packet.
*/
KB_HEADROOM(m, space);
if (space < llcp->v.llc_len) {
KBuffer *n;
/*
* We have to allocate another buffer and tack it
* onto the front of the packet
*/
KB_ALLOCPKT(n, llcp->v.llc_len, KB_F_NOWAIT,
KB_T_HEADER);
if (n == 0) {
err = ENOMEM;
goto done;
}
KB_TAILALIGN(n, llcp->v.llc_len);
KB_LINKHEAD(n, m);
m = n;
} else {
/*
* Header fits, just adjust buffer controls
*/
KB_HEADADJ(m, llcp->v.llc_len);
}
/*
* Add the LLC header
*/
KB_DATASTART(m, bp, void *);
KM_COPY(llcp->v.llc_info, bp, llcp->v.llc_len);
KB_PLENADJ(m, llcp->v.llc_len);
break;
default:
panic("atm_cm_cpcs_data: mpx");
}
/*
* Finally, we can send the packet on its way
*/
STACK_CALL(CPCS_UNITDATA_INV, cvp->cvc_lower, cvp->cvc_tokl,
cvp, (int)m, 0, err);
done:
return (err);
}
/*
* Process CPCS Stack Commands
*
* This is the top of the CPCS API data stack. All upward stack commands
* for the CPCS data API will be received and processed here.
*
* Arguments:
* cmd stack command code
* tok session token (pointer to connection VCC control block)
* arg1 argument 1
* arg2 argument 2
*
* Returns:
* none
*
*/
static void
atm_cm_cpcs_upper(cmd, tok, arg1, arg2)
int cmd;
void *tok;
int arg1;
int arg2;
{
Atm_connection *cop;
Atm_connvc *cvp = tok;
KBuffer *m;
void *bp;
int s;
switch (cmd) {
case CPCS_UNITDATA_SIG:
/*
* Input data packet
*/
m = (KBuffer *)arg1;
if (cvp->cvc_state != CVCS_ACTIVE) {
if (cvp->cvc_state == CVCS_ACCEPT) {
KBuffer *n;
/*
* Queue up any packets received before sigmgr
* notifies us of incoming call completion
*/
if (cvp->cvc_rcvqlen >= CVC_RCVQ_MAX) {
KB_FREEALL(m);
atm_cm_stat.cms_rcvconnvc++;
return;
}
KB_QNEXT(m) = NULL;
if (cvp->cvc_rcvq == NULL) {
cvp->cvc_rcvq = m;
} else {
for (n = cvp->cvc_rcvq;
KB_QNEXT(n) != NULL;
n = KB_QNEXT(n))
;
KB_QNEXT(n) = m;
}
cvp->cvc_rcvqlen++;
return;
} else {
KB_FREEALL(m);
atm_cm_stat.cms_rcvconnvc++;
return;
}
}
/*
* Locate packet's connection
*/
cop = cvp->cvc_conn;
switch (cop->co_mpx) {
case ATM_ENC_NULL:
/*
* We're already there...
*/
break;
case ATM_ENC_LLC:
/*
* Find connection with matching LLC header
*/
if (KB_LEN(m) < T_ATM_LLC_MAX_LEN) {
KB_PULLUP(m, T_ATM_LLC_MAX_LEN, m);
if (m == 0) {
atm_cm_stat.cms_llcdrop++;
return;
}
}
KB_DATASTART(m, bp, void *);
s = splnet();
while (cop) {
if (KM_CMP(bp, cop->co_llc.v.llc_info,
cop->co_llc.v.llc_len) == 0)
break;
cop = cop->co_next;
}
(void) splx(s);
if (cop == NULL) {
/*
* No connected user for this LLC
*/
KB_FREEALL(m);
atm_cm_stat.cms_llcid++;
return;
}
/*
* Strip off the LLC header
*/
KB_HEADADJ(m, -cop->co_llc.v.llc_len);
KB_PLENADJ(m, -cop->co_llc.v.llc_len);
break;
default:
panic("atm_cm_cpcs_upper: mpx");
}
/*
* We've found our connection, so hand the packet off
*/
if (cop->co_state != COS_ACTIVE) {
KB_FREEALL(m);
atm_cm_stat.cms_rcvconn++;
return;
}
(*cop->co_endpt->ep_cpcs_data)(cop->co_toku, m);
break;
case CPCS_UABORT_SIG:
case CPCS_PABORT_SIG:
/*
* We don't support these (yet), so just fall thru...
*/
default:
log(LOG_ERR, "atm_cm_cpcs_upper: unknown cmd 0x%x\n", cmd);
}
}
/*
* SAAL User Control Commands
*
* This function is called by an endpoint user to pass a control command
* across a SAAL data API. Mostly we just send these down the stack.
*
* Arguments:
* cmd stack command code
* cop pointer to connection block
* arg argument
*
* Returns:
* 0 command output successful
* errno output failed - reason indicated
*
*/
int
atm_cm_saal_ctl(cmd, cop, arg)
int cmd;
Atm_connection *cop;
void *arg;
{
Atm_connvc *cvp;
int err = 0;
/*
* Validate connection state
*/
if (cop->co_state != COS_ACTIVE) {
err = EFAULT;
goto done;
}
cvp = cop->co_connvc;
if (cvp->cvc_state != CVCS_ACTIVE) {
err = EFAULT;
goto done;
}
if (cvp->cvc_attr.api != CMAPI_SAAL) {
err = EFAULT;
goto done;
}
switch (cmd) {
case SSCF_UNI_ESTABLISH_REQ:
case SSCF_UNI_RELEASE_REQ:
/*
* Pass command down the stack
*/
STACK_CALL(cmd, cvp->cvc_lower, cvp->cvc_tokl, cvp,
(int)arg, 0, err);
break;
default:
err = EINVAL;
}
done:
return (err);
}
/*
* SAAL Data Output
*
* This function is called by an endpoint user to output a data packet
* across a SAAL data API. After we've validated the connection state,
* the packet will be sent down the data stack.
*
* Arguments:
* cop pointer to connection block
* m pointer to packet buffer chain to be output
*
* Returns:
* 0 packet output successful
* errno output failed - reason indicated
*
*/
int
atm_cm_saal_data(cop, m)
Atm_connection *cop;
KBuffer *m;
{
Atm_connvc *cvp;
int err;
/*
* Validate connection state
*/
if (cop->co_state != COS_ACTIVE) {
err = EFAULT;
goto done;
}
cvp = cop->co_connvc;
if (cvp->cvc_state != CVCS_ACTIVE) {
err = EFAULT;
goto done;
}
if (cvp->cvc_attr.api != CMAPI_SAAL) {
err = EFAULT;
goto done;
}
/*
* Finally, we can send the packet on its way
*/
STACK_CALL(SSCF_UNI_DATA_REQ, cvp->cvc_lower, cvp->cvc_tokl,
cvp, (int)m, 0, err);
done:
return (err);
}
/*
* Process SAAL Stack Commands
*
* This is the top of the SAAL API data stack. All upward stack commands
* for the SAAL data API will be received and processed here.
*
* Arguments:
* cmd stack command code
* tok session token (pointer to connection VCC control block)
* arg1 argument 1
* arg2 argument 2
*
* Returns:
* none
*
*/
static void
atm_cm_saal_upper(cmd, tok, arg1, arg2)
int cmd;
void *tok;
int arg1;
int arg2;
{
Atm_connection *cop;
Atm_connvc *cvp = tok;
switch (cmd) {
case SSCF_UNI_ESTABLISH_IND:
case SSCF_UNI_ESTABLISH_CNF:
case SSCF_UNI_RELEASE_IND:
case SSCF_UNI_RELEASE_CNF:
/*
* Control commands
*/
cop = cvp->cvc_conn;
if (cvp->cvc_state != CVCS_ACTIVE)
break;
if (cop->co_state != COS_ACTIVE)
break;
(*cop->co_endpt->ep_saal_ctl)(cmd, cop->co_toku, (void *)arg1);
break;
case SSCF_UNI_DATA_IND:
/*
* User data
*/
cop = cvp->cvc_conn;
if (cvp->cvc_state != CVCS_ACTIVE) {
atm_cm_stat.cms_rcvconnvc++;
KB_FREEALL((KBuffer *)arg1);
break;
}
if (cop->co_state != COS_ACTIVE) {
atm_cm_stat.cms_rcvconn++;
KB_FREEALL((KBuffer *)arg1);
break;
}
(*cop->co_endpt->ep_saal_data)(cop->co_toku, (KBuffer *)arg1);
break;
case SSCF_UNI_UNITDATA_IND:
/*
* Not supported
*/
KB_FREEALL((KBuffer *)arg1);
/* FALLTHRU */
default:
log(LOG_ERR, "atm_cm_saal_upper: unknown cmd 0x%x\n", cmd);
}
}
/*
* SSCOP User Control Commands
*
* This function is called by an endpoint user to pass a control command
* across a SSCOP data API. Mostly we just send these down the stack.
*
* Arguments:
* cmd stack command code
* cop pointer to connection block
* arg1 argument
* arg2 argument
*
* Returns:
* 0 command output successful
* errno output failed - reason indicated
*
*/
int
atm_cm_sscop_ctl(cmd, cop, arg1, arg2)
int cmd;
Atm_connection *cop;
void *arg1;
void *arg2;
{
Atm_connvc *cvp;
int err = 0;
/*
* Validate connection state
*/
if (cop->co_state != COS_ACTIVE) {
err = EFAULT;
goto done;
}
cvp = cop->co_connvc;
if (cvp->cvc_state != CVCS_ACTIVE) {
err = EFAULT;
goto done;
}
if (cvp->cvc_attr.api != CMAPI_SSCOP) {
err = EFAULT;
goto done;
}
switch (cmd) {
case SSCOP_ESTABLISH_REQ:
case SSCOP_ESTABLISH_RSP:
case SSCOP_RELEASE_REQ:
case SSCOP_RESYNC_REQ:
case SSCOP_RESYNC_RSP:
case SSCOP_RECOVER_RSP:
case SSCOP_RETRIEVE_REQ:
/*
* Pass command down the stack
*/
STACK_CALL(cmd, cvp->cvc_lower, cvp->cvc_tokl, cvp,
(int)arg1, (int)arg2, err);
break;
default:
err = EINVAL;
}
done:
return (err);
}
/*
* SSCOP Data Output
*
* This function is called by an endpoint user to output a data packet
* across a SSCOP data API. After we've validated the connection state,
* the packet will be encapsulated and sent down the data stack.
*
* Arguments:
* cop pointer to connection block
* m pointer to packet buffer chain to be output
*
* Returns:
* 0 packet output successful
* errno output failed - reason indicated
*
*/
int
atm_cm_sscop_data(cop, m)
Atm_connection *cop;
KBuffer *m;
{
Atm_connvc *cvp;
int err;
/*
* Validate connection state
*/
if (cop->co_state != COS_ACTIVE) {
err = EFAULT;
goto done;
}
cvp = cop->co_connvc;
if (cvp->cvc_state != CVCS_ACTIVE) {
err = EFAULT;
goto done;
}
if (cvp->cvc_attr.api != CMAPI_SSCOP) {
err = EFAULT;
goto done;
}
/*
* Finally, we can send the packet on its way
*/
STACK_CALL(SSCOP_DATA_REQ, cvp->cvc_lower, cvp->cvc_tokl,
cvp, (int)m, 0, err);
done:
return (err);
}
/*
* Process SSCOP Stack Commands
*
* This is the top of the SSCOP API data stack. All upward stack commands
* for the SSCOP data API will be received and processed here.
*
* Arguments:
* cmd stack command code
* tok session token (pointer to connection VCC control block)
* arg1 argument 1
* arg2 argument 2
*
* Returns:
* none
*
*/
static void
atm_cm_sscop_upper(cmd, tok, arg1, arg2)
int cmd;
void *tok;
int arg1;
int arg2;
{
Atm_connection *cop;
Atm_connvc *cvp = tok;
switch (cmd) {
case SSCOP_ESTABLISH_IND:
case SSCOP_ESTABLISH_CNF:
case SSCOP_RELEASE_IND:
case SSCOP_RESYNC_IND:
/*
* Control commands
*/
cop = cvp->cvc_conn;
if ((cvp->cvc_state != CVCS_ACTIVE) ||
(cop->co_state != COS_ACTIVE)) {
KB_FREEALL((KBuffer *)arg1);
break;
}
(*cop->co_endpt->ep_sscop_ctl)
(cmd, cop->co_toku, (void *)arg1, (void *)arg2);
break;
case SSCOP_RELEASE_CNF:
case SSCOP_RESYNC_CNF:
case SSCOP_RECOVER_IND:
case SSCOP_RETRIEVE_IND:
case SSCOP_RETRIEVECMP_IND:
/*
* Control commands
*/
cop = cvp->cvc_conn;
if ((cvp->cvc_state != CVCS_ACTIVE) ||
(cop->co_state != COS_ACTIVE))
break;
(*cop->co_endpt->ep_sscop_ctl)
(cmd, cop->co_toku, (void *)arg1, (void *)arg2);
break;
case SSCOP_DATA_IND:
/*
* User data
*/
cop = cvp->cvc_conn;
if (cvp->cvc_state != CVCS_ACTIVE) {
atm_cm_stat.cms_rcvconnvc++;
KB_FREEALL((KBuffer *)arg1);
break;
}
if (cop->co_state != COS_ACTIVE) {
atm_cm_stat.cms_rcvconn++;
KB_FREEALL((KBuffer *)arg1);
break;
}
(*cop->co_endpt->ep_sscop_data)
(cop->co_toku, (KBuffer *)arg1, arg2);
break;
case SSCOP_UNITDATA_IND:
/*
* Not supported
*/
KB_FREEALL((KBuffer *)arg1);
/* FALLTHRU */
default:
log(LOG_ERR, "atm_cm_sscop_upper: unknown cmd 0x%x\n", cmd);
}
}
/*
* Register an ATM Endpoint Service
*
* Every ATM endpoint service must register itself here before it can
* issue or receive any connection requests.
*
* Arguments:
* epp pointer to endpoint definition structure
*
* Returns:
* 0 registration successful
* errno registration failed - reason indicated
*
*/
int
atm_endpoint_register(epp)
Atm_endpoint *epp;
{
int s = splnet();
/*
* See if we need to be initialized
*/
if (!atm_init)
atm_initialize();
/*
* Validate endpoint
*/
if (epp->ep_id > ENDPT_MAX) {
(void) splx(s);
return (EINVAL);
}
if (atm_endpoints[epp->ep_id] != NULL) {
(void) splx(s);
return (EEXIST);
}
/*
* Add endpoint to list
*/
atm_endpoints[epp->ep_id] = epp;
(void) splx(s);
return (0);
}
/*
* De-register an ATM Endpoint Service
*
* Each ATM endpoint service provider must de-register its registered
* endpoint(s) before terminating. Specifically, loaded kernel modules
* must de-register their services before unloading themselves.
*
* Arguments:
* epp pointer to endpoint definition structure
*
* Returns:
* 0 de-registration successful
* errno de-registration failed - reason indicated
*
*/
int
atm_endpoint_deregister(epp)
Atm_endpoint *epp;
{
int s = splnet();
/*
* Validate endpoint
*/
if (epp->ep_id > ENDPT_MAX) {
(void) splx(s);
return (EINVAL);
}
if (atm_endpoints[epp->ep_id] != epp) {
(void) splx(s);
return (ENOENT);
}
/*
* Remove endpoint from list
*/
atm_endpoints[epp->ep_id] = NULL;
(void) splx(s);
return (0);
}
Reference in New Issue View Git Blame Copy Permalink