2237 lines
46 KiB
C
2237 lines
46 KiB
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.
|
|
*
|
|
* @(#) $FreeBSD$
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* ATM Forum UNI 3.0/3.1 Signalling Manager
|
|
* ----------------------------------------
|
|
*
|
|
* VC state machine
|
|
*
|
|
*/
|
|
|
|
#include <netatm/kern_include.h>
|
|
|
|
#include <netatm/uni/unisig.h>
|
|
#include <netatm/uni/unisig_var.h>
|
|
#include <netatm/uni/unisig_msg.h>
|
|
#include <netatm/uni/unisig_mbuf.h>
|
|
#include <netatm/uni/unisig_decode.h>
|
|
|
|
#ifndef lint
|
|
__RCSID("@(#) $FreeBSD$");
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Local functions
|
|
*/
|
|
static int unisig_vc_invalid __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act01 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act02 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act03 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act04 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act05 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act06 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act07 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act08 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act09 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act10 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act11 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act12 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act13 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act14 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act15 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act16 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act17 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act18 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act19 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act20 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act21 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act22 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act23 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act24 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act25 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act26 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act27 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act28 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act29 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act30 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_act31 __P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *));
|
|
static int unisig_vc_clear_call __P((struct unisig *,
|
|
struct unisig_vccb *,
|
|
struct unisig_msg *,
|
|
int));
|
|
|
|
|
|
/*
|
|
* State table
|
|
*/
|
|
static int unisig_vc_states[21][17] = {
|
|
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 */
|
|
{ 0, 2, 99, 5, 99, 99, 0, 99, 12, 99, 0, 14, 0, 3, 0, 0, 0 },
|
|
{ 29, 4, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 },
|
|
{ 29, 6, 99, 6, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 },
|
|
{ 29, 17, 99, 17, 99, 99, 17, 99, 10, 99, 17, 17, 17, 0, 0, 0, 0 },
|
|
{ 8, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 },
|
|
{ 29, 7, 99, 15, 99, 99, 15, 99, 15, 99, 15, 16, 17, 0, 0, 0, 0 },
|
|
{ 19, 3, 99, 3, 99, 99, 3, 99, 3, 99, 3, 13, 3, 0, 0, 0, 0 },
|
|
{ 21, 21, 99, 21, 99, 99, 21, 99, 21, 99, 21, 21, 21, 0, 0, 0, 0 },
|
|
{ 22, 22, 99, 22, 99, 99, 22, 99, 22, 99, 22, 22, 22, 0, 0, 0, 0 },
|
|
{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 23, 17, 17, 0, 0, 0, 0 },
|
|
{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 },
|
|
{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 },
|
|
{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 },
|
|
{ 29, 17, 99, 17, 99, 99, 17, 99, 17, 99, 17, 17, 17, 0, 0, 0, 0 },
|
|
{ 1, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99 },
|
|
{ 99, 25, 99, 25, 99, 99, 9, 99, 25, 99, 25, 25, 25, 25, 31, 25, 25 },
|
|
{ 99, 25, 99, 25, 99, 99, 11, 99, 25, 99, 25, 25, 25, 25, 19, 25, 25 },
|
|
{ 99, 12, 99, 12, 99, 99, 25, 99, 12, 99, 12, 19, 19, 30, 19, 99, 99 },
|
|
{ 99, 12, 99, 12, 99, 99, 12, 99, 12, 99, 12, 3, 3, 3, 24, 26, 26 },
|
|
{ 99, 3, 99, 3, 99, 99, 30, 99, 3, 99, 18, 3, 3, 0, 19, 27, 19 },
|
|
{ 99, 7, 99, 7, 99, 99, 30, 99, 7, 99, 19, 19, 19, 20, 19, 19, 28 }
|
|
};
|
|
|
|
|
|
/*
|
|
* Action vector
|
|
*
|
|
* A given state, action pair selects an action number from the
|
|
* state table. This vector holds the address of the action routine
|
|
* for each action number.
|
|
*/
|
|
#define MAX_ACTION 32
|
|
static int (*unisig_vc_act_vec[MAX_ACTION])
|
|
__P((struct unisig *, struct unisig_vccb *,
|
|
struct unisig_msg *)) = {
|
|
unisig_vc_invalid,
|
|
unisig_vc_act01,
|
|
unisig_vc_act02,
|
|
unisig_vc_act03,
|
|
unisig_vc_act04,
|
|
unisig_vc_act05,
|
|
unisig_vc_act06,
|
|
unisig_vc_act07,
|
|
unisig_vc_act08,
|
|
unisig_vc_act09,
|
|
unisig_vc_act10,
|
|
unisig_vc_act11,
|
|
unisig_vc_act12,
|
|
unisig_vc_act13,
|
|
unisig_vc_act14,
|
|
unisig_vc_act15,
|
|
unisig_vc_act16,
|
|
unisig_vc_act17,
|
|
unisig_vc_act18,
|
|
unisig_vc_act19,
|
|
unisig_vc_act20,
|
|
unisig_vc_act21,
|
|
unisig_vc_act22,
|
|
unisig_vc_act23,
|
|
unisig_vc_act24,
|
|
unisig_vc_act25,
|
|
unisig_vc_act26,
|
|
unisig_vc_act27,
|
|
unisig_vc_act28,
|
|
unisig_vc_act29,
|
|
unisig_vc_act30,
|
|
unisig_vc_act31
|
|
};
|
|
|
|
|
|
/*
|
|
* Process an event on a VC
|
|
*
|
|
* Arguments:
|
|
* usp pointer to the UNISIG instance
|
|
* uvp pointer to the VCCB for the affected VCC
|
|
* event a numeric indication of which event has occured
|
|
* msg pointer to a signalling message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
int
|
|
unisig_vc_state(usp, uvp, event, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
int event;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int action, rc, state;
|
|
|
|
/*
|
|
* Select an action from the state table
|
|
*/
|
|
if (uvp)
|
|
state = uvp->uv_sstate;
|
|
else
|
|
state = UNI_NULL;
|
|
action = unisig_vc_states[event][state];
|
|
if (action >= MAX_ACTION || action < 0)
|
|
panic("unisig_vc_state: invalid action\n");
|
|
|
|
/*
|
|
* Perform the requested action
|
|
*/
|
|
ATM_DEBUG4("unisig_vc_state: uvp=%p, state=%d, event=%d, action=%d\n",
|
|
uvp, state, event, action);
|
|
rc = unisig_vc_act_vec[action](usp, uvp, msg);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 0
|
|
* Unexpected action - log an error message
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection (may
|
|
be null)
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_invalid(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
log(LOG_ERR, "unisig_vc_state: unexpected action\n");
|
|
return(EINVAL);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 1
|
|
* Setup handler called
|
|
*
|
|
* Send SETUP, start timer T303, go to UNI_CALL_INITIATED state
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act01(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
|
|
/*
|
|
* Send the setup message
|
|
*/
|
|
rc = unisig_send_setup(usp, uvp);
|
|
if (rc)
|
|
return(rc);
|
|
|
|
/*
|
|
* Set timer T303
|
|
*/
|
|
uvp->uv_retry = 0;
|
|
UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T303);
|
|
|
|
/*
|
|
* Set the new state
|
|
*/
|
|
uvp->uv_sstate = UNI_CALL_INITIATED;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 2
|
|
* Timeout while waiting for CALL PROCEEDING or CONNECT
|
|
*
|
|
* If this is the second expiration, clear the call. Otherwise,
|
|
* retransmit the SETUP message and restart T303.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act02(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc = 0;
|
|
|
|
if (uvp->uv_retry) {
|
|
/*
|
|
* Clear the call
|
|
*/
|
|
rc = unisig_clear_vcc(usp, uvp,
|
|
T_ATM_CAUSE_NO_ROUTE_TO_DESTINATION);
|
|
} else {
|
|
uvp->uv_retry++;
|
|
(void) unisig_send_setup(usp, uvp);
|
|
UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T303);
|
|
}
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 3
|
|
*
|
|
* Clear the call internally
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act03(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc, cause;
|
|
|
|
/*
|
|
* Set cause code
|
|
*/
|
|
if ((msg != NULL) && (msg->msg_ie_caus != NULL)) {
|
|
unisig_cause_attr_from_ie(&uvp->uv_connvc->cvc_attr,
|
|
msg->msg_ie_caus);
|
|
cause = T_ATM_ABSENT;
|
|
} else
|
|
cause = T_ATM_CAUSE_DESTINATION_OUT_OF_ORDER;
|
|
|
|
/*
|
|
* Clear the VCCB
|
|
*/
|
|
rc = unisig_clear_vcc(usp, uvp, cause);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 4
|
|
* Received CALL PROCEEDING
|
|
*
|
|
* Start timer T310, go to UNI_CALL_OUT_PROC
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act04(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int cause, rc, vpi, vci;
|
|
struct atm_pif *pip = usp->us_pif;
|
|
struct ie_generic *iep;
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Make sure a Connection ID is part of the message
|
|
*/
|
|
if (msg->msg_ie_cnid) {
|
|
vpi = msg->msg_ie_cnid->ie_cnid_vpci;
|
|
vci = msg->msg_ie_cnid->ie_cnid_vci;
|
|
} else {
|
|
iep = (struct ie_generic *)atm_allocate(&unisig_iepool);
|
|
if (!iep)
|
|
return(ENOMEM);
|
|
iep->ie_ident = UNI_IE_CNID;
|
|
iep->ie_err_cause = UNI_IE_CAUS_MISSING;
|
|
MSG_IE_ADD(msg, iep, UNI_MSG_IE_ERR);
|
|
cause = UNI_IE_CAUS_MISSING;
|
|
ATM_DEBUG0("unisig_vc_act04: no CNID in Call Proc\n");
|
|
goto response04;
|
|
}
|
|
|
|
/*
|
|
* Make sure we can handle the specified VPI and VCI
|
|
*/
|
|
if (vpi > pip->pif_maxvpi || vci > pip->pif_maxvci ||
|
|
vci < UNI_IE_CNID_MIN_VCI) {
|
|
cause = UNI_IE_CAUS_BAD_VCC;
|
|
ATM_DEBUG0("unisig_vc_act04: VPI/VCI invalid\n");
|
|
goto response04;
|
|
}
|
|
|
|
/*
|
|
* Make sure the specified VPI and VCI are not in use
|
|
*/
|
|
if (unisig_find_vpvc(usp, vpi, vci, VCC_OUT)) {
|
|
cause = UNI_IE_CAUS_NA_VCC;
|
|
ATM_DEBUG0("unisig_vc_act04: VPI/VCI in use\n");
|
|
goto response04;
|
|
}
|
|
|
|
/*
|
|
* Start timer T310
|
|
*/
|
|
UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T310);
|
|
|
|
/*
|
|
* Save the specified VPI and VCI
|
|
*/
|
|
uvp->uv_vpi = vpi;
|
|
uvp->uv_vci = vci;
|
|
|
|
/*
|
|
* Set the state
|
|
*/
|
|
uvp->uv_sstate = UNI_CALL_OUT_PROC;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(0);
|
|
|
|
response04:
|
|
/*
|
|
* Initiate call clearing
|
|
*/
|
|
rc = unisig_vc_clear_call(usp, uvp, msg, cause);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 5
|
|
* Timeout in UNI_CALL_OUT_PROC
|
|
*
|
|
* Clear call towards network
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act05(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
struct unisig_msg *rls_msg;
|
|
struct ie_generic *cause_ie;
|
|
|
|
/*
|
|
* Send a RELEASE message
|
|
*/
|
|
rls_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
|
|
if (rls_msg == NULL)
|
|
return(ENOMEM);
|
|
cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool);
|
|
if (cause_ie == NULL) {
|
|
atm_free(rls_msg);
|
|
return(ENOMEM);
|
|
}
|
|
|
|
/*
|
|
* Fill out the RELEASE message
|
|
*/
|
|
rls_msg->msg_call_ref = uvp->uv_call_ref;
|
|
rls_msg->msg_type = UNI_MSG_RLSE;
|
|
rls_msg->msg_type_flag = 0;
|
|
rls_msg->msg_type_action = 0;
|
|
rls_msg->msg_ie_caus = cause_ie;
|
|
|
|
/*
|
|
* Fill out the cause IE
|
|
*/
|
|
cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER;
|
|
cause_ie->ie_caus_cause = UNI_IE_CAUS_TIMER;
|
|
KM_COPY("310", cause_ie->ie_caus_diagnostic, 3);
|
|
|
|
/*
|
|
* Send the RELEASE message.
|
|
*/
|
|
rc = unisig_send_msg(usp, rls_msg);
|
|
unisig_free_msg(rls_msg);
|
|
|
|
/*
|
|
* Start timer T308
|
|
*/
|
|
UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T308);
|
|
|
|
/*
|
|
* Set the new state
|
|
*/
|
|
uvp->uv_sstate = UNI_RELEASE_REQUEST;
|
|
uvp->uv_ustate = VCCU_CLOSED;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 6
|
|
* Received CONNECT
|
|
*
|
|
* Send CONNECT ACK, go to UNI_ACTIVE state
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act06(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int cause, rc, vci, vpi;
|
|
struct atm_pif *pip = usp->us_pif;
|
|
struct unisig_msg *cack_msg;
|
|
struct ie_generic *iep;
|
|
Atm_attributes *ap;
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
ap = &uvp->uv_connvc->cvc_attr;
|
|
|
|
/*
|
|
* See if a VPI/VCI is specified
|
|
*/
|
|
if (msg->msg_ie_cnid) {
|
|
/*
|
|
* Yes--VPI/VCI must be the first specification or must
|
|
* match what was specified before
|
|
*/
|
|
vpi = msg->msg_ie_cnid->ie_cnid_vpci;
|
|
vci = msg->msg_ie_cnid->ie_cnid_vci;
|
|
if ((uvp->uv_vpi || uvp->uv_vci) &&
|
|
(vpi != uvp->uv_vpi ||
|
|
vci != uvp->uv_vci)) {
|
|
cause = UNI_IE_CAUS_BAD_VCC;
|
|
ATM_DEBUG0("unisig_vc_act06: VPI/VCI invalid\n");
|
|
goto response06;
|
|
}
|
|
|
|
/*
|
|
* Specified VPI/VCI must be within range
|
|
*/
|
|
if (vpi > pip->pif_maxvpi || vci > pip->pif_maxvci ||
|
|
vci < UNI_IE_CNID_MIN_VCI) {
|
|
cause = UNI_IE_CAUS_BAD_VCC;
|
|
ATM_DEBUG0("unisig_vc_act06: VPI/VCI invalid\n");
|
|
goto response06;
|
|
}
|
|
uvp->uv_vpi = vpi;
|
|
uvp->uv_vci = vci;
|
|
} else {
|
|
/*
|
|
* No--VPI/VCI must have been specified earlier
|
|
*/
|
|
if (!uvp->uv_vpi || !uvp->uv_vci) {
|
|
iep = (struct ie_generic *)atm_allocate(
|
|
&unisig_iepool);
|
|
if (!iep)
|
|
return(ENOMEM);
|
|
iep->ie_ident = UNI_IE_CNID;
|
|
iep->ie_err_cause = UNI_IE_CAUS_MISSING;
|
|
MSG_IE_ADD(msg, iep, UNI_MSG_IE_ERR);
|
|
cause = UNI_IE_CAUS_MISSING;
|
|
ATM_DEBUG0("unisig_vc_act06: CNID missing\n");
|
|
goto response06;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Handle AAL parameters negotiation
|
|
*/
|
|
if (msg->msg_ie_aalp) {
|
|
struct ie_generic *aalp = msg->msg_ie_aalp;
|
|
|
|
/*
|
|
* AAL parameters must have been sent in SETUP
|
|
*/
|
|
if ((ap->aal.tag != T_ATM_PRESENT) ||
|
|
(ap->aal.type != aalp->ie_aalp_aal_type)) {
|
|
cause = UNI_IE_CAUS_IECONTENT;
|
|
goto response06;
|
|
}
|
|
|
|
switch (aalp->ie_aalp_aal_type) {
|
|
|
|
case UNI_IE_AALP_AT_AAL3:
|
|
/*
|
|
* Maximum SDU size negotiation
|
|
*/
|
|
if (aalp->ie_aalp_4_fwd_max_sdu == T_ATM_ABSENT)
|
|
break;
|
|
if ((ap->aal.v.aal4.forward_max_SDU_size <
|
|
aalp->ie_aalp_4_fwd_max_sdu) ||
|
|
(ap->aal.v.aal4.backward_max_SDU_size <
|
|
aalp->ie_aalp_4_bkwd_max_sdu)) {
|
|
cause = UNI_IE_CAUS_IECONTENT;
|
|
goto response06;
|
|
} else {
|
|
ap->aal.v.aal4.forward_max_SDU_size =
|
|
aalp->ie_aalp_4_fwd_max_sdu;
|
|
ap->aal.v.aal4.backward_max_SDU_size =
|
|
aalp->ie_aalp_4_bkwd_max_sdu;
|
|
}
|
|
break;
|
|
|
|
case UNI_IE_AALP_AT_AAL5:
|
|
/*
|
|
* Maximum SDU size negotiation
|
|
*/
|
|
if (aalp->ie_aalp_5_fwd_max_sdu == T_ATM_ABSENT)
|
|
break;
|
|
if ((ap->aal.v.aal5.forward_max_SDU_size <
|
|
aalp->ie_aalp_5_fwd_max_sdu) ||
|
|
(ap->aal.v.aal5.backward_max_SDU_size <
|
|
aalp->ie_aalp_5_bkwd_max_sdu)) {
|
|
cause = UNI_IE_CAUS_IECONTENT;
|
|
goto response06;
|
|
} else {
|
|
ap->aal.v.aal5.forward_max_SDU_size =
|
|
aalp->ie_aalp_5_fwd_max_sdu;
|
|
ap->aal.v.aal5.backward_max_SDU_size =
|
|
aalp->ie_aalp_5_bkwd_max_sdu;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Get memory for a CONNECT ACK message
|
|
*/
|
|
cack_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
|
|
if (cack_msg == NULL)
|
|
return(ENOMEM);
|
|
|
|
/*
|
|
* Fill out the CONNECT ACK message
|
|
*/
|
|
cack_msg->msg_call_ref = uvp->uv_call_ref;
|
|
cack_msg->msg_type = UNI_MSG_CACK;
|
|
cack_msg->msg_type_flag = 0;
|
|
cack_msg->msg_type_action = 0;
|
|
|
|
/*
|
|
* Send the CONNECT ACK message
|
|
*/
|
|
rc = unisig_send_msg(usp, cack_msg);
|
|
unisig_free_msg(cack_msg);
|
|
|
|
/*
|
|
* Set the new state
|
|
*/
|
|
uvp->uv_sstate = UNI_ACTIVE;
|
|
uvp->uv_ustate = VCCU_OPEN;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
/*
|
|
* Notify the user that the connection is now active
|
|
*/
|
|
atm_cm_connected(uvp->uv_connvc);
|
|
|
|
return(0);
|
|
|
|
response06:
|
|
/*
|
|
* Initiate call clearing
|
|
*/
|
|
rc = unisig_vc_clear_call(usp, uvp, msg, cause);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 7
|
|
* Abort routine called or signalling SAAL session reset while in
|
|
* one of the call setup states
|
|
*
|
|
* Clear the call, send RELEASE COMPLETE, notify the user.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act07(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Send a RELEASE COMPLETE message rejecting the connection
|
|
*/
|
|
rc = unisig_send_release_complete(usp, uvp, msg,
|
|
UNI_IE_CAUS_TEMP);
|
|
|
|
/*
|
|
* Clear the call VCCB
|
|
*/
|
|
uvp->uv_sstate = UNI_FREE;
|
|
uvp->uv_ustate = VCCU_CLOSED;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
/*
|
|
* Notify the user
|
|
*/
|
|
if ((msg != NULL) && (msg->msg_ie_caus != NULL))
|
|
unisig_cause_attr_from_ie(&uvp->uv_connvc->cvc_attr,
|
|
msg->msg_ie_caus);
|
|
else
|
|
unisig_cause_attr_from_user(&uvp->uv_connvc->cvc_attr,
|
|
T_ATM_CAUSE_NORMAL_CALL_CLEARING);
|
|
atm_cm_cleared(uvp->uv_connvc);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 8
|
|
* Received SETUP
|
|
*
|
|
* Check call paramaters, notify user that a call has been received,
|
|
* set UNI_CALL_PRESENT state
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act08(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int cause = 0, rc, vpi, vci;
|
|
struct atm_pif *pip = usp->us_pif;
|
|
struct atm_nif *nip;
|
|
Atm_addr_nsap *nap;
|
|
Atm_attributes attr;
|
|
|
|
ATM_DEBUG3("unisig_vc_act08: usp=%p, uvp=%p, msg=%p\n",
|
|
usp, uvp, msg);
|
|
|
|
/*
|
|
* Make sure that the called address is the right format
|
|
*/
|
|
if (msg->msg_ie_cdad->ie_cdad_plan != UNI_IE_CDAD_PLAN_NSAP) {
|
|
cause = UNI_IE_CAUS_IECONTENT;
|
|
ATM_DEBUG0("unisig_vc_act08: bad address format\n");
|
|
goto response08;
|
|
}
|
|
|
|
/*
|
|
* Make sure that the called address is ours
|
|
*/
|
|
nap = (Atm_addr_nsap *) msg->msg_ie_cdad->ie_cdad_addr.address;
|
|
if (bcmp(usp->us_addr.address, nap, /* XXX */
|
|
sizeof(Atm_addr_nsap)-1)) {
|
|
cause = UNI_IE_CAUS_IECONTENT;
|
|
ATM_DEBUG0("unisig_vc_act08: address not mine\n");
|
|
goto response08;
|
|
}
|
|
|
|
/*
|
|
* Find the right NIF for the given selector byte
|
|
*/
|
|
nip = pip->pif_nif;
|
|
while (nip && nip->nif_sel != nap->aan_sel) {
|
|
nip = nip->nif_pnext;
|
|
}
|
|
if (!nip) {
|
|
cause = UNI_IE_CAUS_IECONTENT;
|
|
ATM_DEBUG0("unisig_vc_act08: bad selector byte\n");
|
|
goto response08;
|
|
}
|
|
|
|
/*
|
|
* See if we recognize the specified AAL
|
|
*/
|
|
if (msg->msg_ie_aalp->ie_aalp_aal_type != UNI_IE_AALP_AT_AAL3 &&
|
|
msg->msg_ie_aalp->ie_aalp_aal_type !=
|
|
UNI_IE_AALP_AT_AAL5) {
|
|
cause = UNI_IE_CAUS_UAAL;
|
|
ATM_DEBUG0("unisig_vc_act08: bad AAL\n");
|
|
goto response08;
|
|
}
|
|
|
|
/*
|
|
* Should verify that we can handle requested
|
|
* connection QOS
|
|
*/
|
|
|
|
/*
|
|
* Make sure the specified VPI/VCI is valid
|
|
*/
|
|
vpi = msg->msg_ie_cnid->ie_cnid_vpci;
|
|
vci = msg->msg_ie_cnid->ie_cnid_vci;
|
|
if (vpi > pip->pif_maxvpi ||
|
|
vci > pip->pif_maxvci ||
|
|
vci < UNI_IE_CNID_MIN_VCI) {
|
|
cause = UNI_IE_CAUS_BAD_VCC;
|
|
ATM_DEBUG0("unisig_vc_act08: VPI/VCI invalid\n");
|
|
goto response08;
|
|
}
|
|
|
|
/*
|
|
* Make sure the specified VPI/VCI isn't in use already
|
|
*/
|
|
if (unisig_find_vpvc(usp, vpi, vci, VCC_IN)) {
|
|
cause = UNI_IE_CAUS_NA_VCC;
|
|
ATM_DEBUG0("unisig_vc_act08: VPI/VCI in use\n");
|
|
goto response08;
|
|
}
|
|
|
|
/*
|
|
* Make sure it's a point-to-point connection
|
|
*/
|
|
if (msg->msg_ie_bbcp->ie_bbcp_conn_config !=
|
|
UNI_IE_BBCP_CC_PP) {
|
|
cause = UNI_IE_CAUS_NI_BC;
|
|
ATM_DEBUG0("unisig_vc_act08: conn not pt-pt\n");
|
|
goto response08;
|
|
}
|
|
|
|
/*
|
|
* Fill in the VCCB fields that we can at this point
|
|
*/
|
|
uvp->uv_type = VCC_SVC | VCC_IN | VCC_OUT;
|
|
uvp->uv_proto = pip->pif_sigmgr->sm_proto;
|
|
uvp->uv_sstate = UNI_CALL_PRESENT;
|
|
uvp->uv_ustate = VCCU_POPEN;
|
|
uvp->uv_pif = pip;
|
|
uvp->uv_nif = nip;
|
|
uvp->uv_vpi = msg->msg_ie_cnid->ie_cnid_vpci;
|
|
uvp->uv_vci = msg->msg_ie_cnid->ie_cnid_vci;
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
/*
|
|
* Copy the connection attributes from the SETUP message
|
|
* to an attribute block
|
|
*/
|
|
KM_ZERO(&attr, sizeof(attr));
|
|
attr.nif = nip;
|
|
attr.aal.tag = T_ATM_ABSENT;
|
|
attr.traffic.tag = T_ATM_ABSENT;
|
|
attr.bearer.tag = T_ATM_ABSENT;
|
|
attr.bhli.tag = T_ATM_ABSENT;
|
|
attr.blli.tag_l2 = T_ATM_ABSENT;
|
|
attr.blli.tag_l3 = T_ATM_ABSENT;
|
|
attr.llc.tag = T_ATM_ABSENT;
|
|
attr.called.tag = T_ATM_ABSENT;
|
|
attr.calling.tag = T_ATM_ABSENT;
|
|
attr.qos.tag = T_ATM_ABSENT;
|
|
attr.transit.tag = T_ATM_ABSENT;
|
|
attr.cause.tag = T_ATM_ABSENT;
|
|
unisig_save_attrs(usp, msg, &attr);
|
|
|
|
/*
|
|
* Notify the connection manager of the new VCC
|
|
*/
|
|
ATM_DEBUG0("unisig_vc_act08: notifying user of connection\n");
|
|
rc = atm_cm_incoming((struct vccb *)uvp, &attr);
|
|
if (rc)
|
|
goto response08;
|
|
|
|
/*
|
|
* Wait for the connection recipient to issue an accept
|
|
* or reject
|
|
*/
|
|
return(0);
|
|
|
|
response08:
|
|
ATM_DEBUG1("unisig_vc_act08: reject with cause=%d\n", cause);
|
|
|
|
/*
|
|
* Clear the VCCB state
|
|
*/
|
|
uvp->uv_sstate = UNI_NULL;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
/*
|
|
* Some problem was detected with the request. Send a Q.2931
|
|
* message rejecting the connection.
|
|
*/
|
|
rc = unisig_send_release_complete(usp, uvp, msg, cause);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 9
|
|
* Accept routine called by user
|
|
*
|
|
* Send CONNECT, start timer T313, go to UNI_CONNECT_REQUEST state
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act09(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
struct unisig_msg *conn_msg;
|
|
|
|
conn_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
|
|
if (conn_msg == NULL)
|
|
return(ENOMEM);
|
|
|
|
/*
|
|
* Fill out the response
|
|
*/
|
|
conn_msg->msg_call_ref = uvp->uv_call_ref;
|
|
conn_msg->msg_type = UNI_MSG_CONN;
|
|
conn_msg->msg_type_flag = 0;
|
|
conn_msg->msg_type_action = 0;
|
|
|
|
/*
|
|
* Send the CONNECT message. If the send fails, the other
|
|
* side will eventually time out and close the connection.
|
|
*/
|
|
rc = unisig_send_msg(usp, conn_msg);
|
|
unisig_free_msg(conn_msg);
|
|
if (rc) {
|
|
return(rc);
|
|
}
|
|
|
|
/*
|
|
* Start timer T313
|
|
*/
|
|
UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T313);
|
|
|
|
/*
|
|
* Set the new state
|
|
*/
|
|
uvp->uv_sstate = UNI_CONNECT_REQUEST;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 10
|
|
* Received CONNECT ACK
|
|
*
|
|
* Go to UNI_ACTIVE state
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act10(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Set the state
|
|
*/
|
|
uvp->uv_sstate = UNI_ACTIVE;
|
|
uvp->uv_ustate = VCCU_OPEN;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
/*
|
|
* Notify the user that the call is up
|
|
*/
|
|
atm_cm_connected(uvp->uv_connvc);
|
|
|
|
return (0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 11
|
|
* Reject handler called
|
|
*
|
|
* Send RELEASE COMPLETE, clear the call
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act11(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc, cause;
|
|
|
|
/*
|
|
* Send generic cause code if one is not already set
|
|
*/
|
|
if (uvp->uv_connvc->cvc_attr.cause.tag == T_ATM_PRESENT)
|
|
cause = T_ATM_ABSENT;
|
|
else
|
|
cause = T_ATM_CAUSE_CALL_REJECTED;
|
|
|
|
/*
|
|
* Send a RELEASE COMPLETE message
|
|
*/
|
|
rc = unisig_send_release_complete(usp, uvp, msg, cause);
|
|
|
|
/*
|
|
* Clear the call VCCB
|
|
*/
|
|
uvp->uv_sstate = UNI_FREE;
|
|
uvp->uv_ustate = VCCU_CLOSED;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 12
|
|
* Release or abort routine called
|
|
*
|
|
* Send RELEASE, start timer T308, go to UNI_RELEASE_REQUEST state
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act12(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Send the RELEASE message
|
|
*/
|
|
rc = unisig_vc_clear_call(usp, uvp, (struct unisig_msg *)NULL,
|
|
T_ATM_ABSENT);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 13
|
|
* RELEASE COMPLETE received
|
|
*
|
|
* Clear the call
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act13(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Set the state
|
|
*/
|
|
uvp->uv_sstate = UNI_FREE;
|
|
if (uvp->uv_ustate != VCCU_ABORT)
|
|
uvp->uv_ustate = VCCU_CLOSED;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
/*
|
|
* Notify the user that the call is now closed
|
|
*/
|
|
if (msg->msg_ie_caus != NULL)
|
|
unisig_cause_attr_from_ie(&uvp->uv_connvc->cvc_attr,
|
|
msg->msg_ie_caus);
|
|
atm_cm_cleared(uvp->uv_connvc);
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 14
|
|
* Timer expired while waiting for RELEASE COMPLETE
|
|
*
|
|
* If this is the second expiration, just clear the call. Otherwise,
|
|
* retransmit the RELEASE message and restart timer T308.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act14(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
|
|
/*
|
|
* Check the retry count
|
|
*/
|
|
if (uvp->uv_retry) {
|
|
/*
|
|
* Clear the connection
|
|
*/
|
|
rc = unisig_clear_vcc(usp, uvp,
|
|
T_ATM_CAUSE_NORMAL_CALL_CLEARING);
|
|
} else {
|
|
/*
|
|
* Increment the retry count
|
|
*/
|
|
uvp->uv_retry++;
|
|
|
|
/*
|
|
* Resend the RELEASE message
|
|
*/
|
|
rc = unisig_send_release(usp, uvp,
|
|
(struct unisig_msg *)0, T_ATM_ABSENT);
|
|
if (rc)
|
|
return(rc);
|
|
|
|
/*
|
|
* Restart timer T308
|
|
*/
|
|
UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T308);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 15
|
|
* RELEASE received in UNI_ACTIVE state
|
|
*
|
|
* Send RELEASE COMPLETE, go to UNI_FREE, notify the user
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act15(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int cause, rc;
|
|
struct ie_generic *iep;
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* If there was no Cause IE, flag an error
|
|
*/
|
|
if (!msg->msg_ie_caus) {
|
|
cause = UNI_IE_CAUS_MISSING;
|
|
for (iep=msg->msg_ie_err; iep; iep=iep->ie_next) {
|
|
if (iep->ie_ident == UNI_IE_CAUS &&
|
|
iep->ie_err_cause ==
|
|
UNI_IE_CAUS_IECONTENT) {
|
|
cause = UNI_IE_CAUS_IECONTENT;
|
|
}
|
|
}
|
|
if (cause == UNI_IE_CAUS_MISSING) {
|
|
iep = (struct ie_generic *)atm_allocate(
|
|
&unisig_iepool);
|
|
if (!iep)
|
|
return(ENOMEM);
|
|
iep->ie_ident = UNI_IE_CNID;
|
|
iep->ie_err_cause = UNI_IE_CAUS_MISSING;
|
|
MSG_IE_ADD(msg, iep, UNI_MSG_IE_ERR);
|
|
}
|
|
} else {
|
|
cause = UNI_IE_CAUS_NORM_UNSP;
|
|
}
|
|
|
|
/*
|
|
* Send a RELEASE COMPLETE message
|
|
*/
|
|
rc = unisig_send_release_complete(usp, uvp, msg, cause);
|
|
|
|
/*
|
|
* Set the state
|
|
*/
|
|
uvp->uv_sstate = UNI_FREE;
|
|
uvp->uv_ustate = VCCU_CLOSED;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
/*
|
|
* Notify the user that the call is cleared
|
|
*/
|
|
if (msg->msg_ie_caus != NULL)
|
|
unisig_cause_attr_from_ie(&uvp->uv_connvc->cvc_attr,
|
|
msg->msg_ie_caus);
|
|
else
|
|
unisig_cause_attr_from_user(&uvp->uv_connvc->cvc_attr,
|
|
T_ATM_CAUSE_UNSPECIFIED_NORMAL);
|
|
atm_cm_cleared(uvp->uv_connvc);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 16
|
|
* RELEASE received in UNI_RELEASE_REQUEST state
|
|
*
|
|
* Clear the call
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act16(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Clear the VCCB
|
|
*/
|
|
rc = unisig_clear_vcc(usp, uvp, T_ATM_ABSENT);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 17
|
|
* Protocol error
|
|
*
|
|
* Send a STATUS message with cause 101, "message not compatible with
|
|
* call state"
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act17(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
|
|
ATM_DEBUG3("unisig_vc_perror: usp=%p, uvp=%p, msg=%p\n",
|
|
usp, uvp, msg);
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Send a STATUS message
|
|
*/
|
|
rc = unisig_send_status(usp, uvp, msg, UNI_IE_CAUS_STATE);
|
|
|
|
return(rc ? rc : EINVAL);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 18
|
|
* Signalling AAL connection has been lost
|
|
*
|
|
* Start timer T309. If the timer expires before the SAAL connection
|
|
* comes back, the VCC will be cleared.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act18(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Start timer T309
|
|
*/
|
|
UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T309);
|
|
|
|
/*
|
|
* Set new state
|
|
*/
|
|
uvp->uv_sstate = UNI_SSCF_RECOV;
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 19
|
|
* Ignore the event
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act19(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 20
|
|
* SSCF establish indication in UNI_SSCF_RECOV state -- signalling
|
|
* AAL has come up after an outage
|
|
*
|
|
* Send STATUS ENQ to make sure we're in compatible state with other end
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act20(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
struct unisig_msg *stat_msg;
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Get memory for a STATUS ENQUIRY message
|
|
*/
|
|
stat_msg = (struct unisig_msg *)atm_allocate(&unisig_msgpool);
|
|
if (stat_msg == NULL)
|
|
return(ENOMEM);
|
|
|
|
/*
|
|
* Fill out the message
|
|
*/
|
|
stat_msg->msg_call_ref = uvp->uv_call_ref;
|
|
stat_msg->msg_type = UNI_MSG_SENQ;
|
|
stat_msg->msg_type_flag = 0;
|
|
stat_msg->msg_type_action = 0;
|
|
|
|
/*
|
|
* Send the STATUS ENQUIRY message
|
|
*/
|
|
rc = unisig_send_msg(usp, stat_msg);
|
|
unisig_free_msg(stat_msg);
|
|
|
|
/*
|
|
* Return to active state
|
|
*/
|
|
uvp->uv_sstate = UNI_ACTIVE;
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 21
|
|
* STATUS received
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection (may
|
|
* be NULL)
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act21(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int cause, rc;
|
|
|
|
/*
|
|
* Ignore a STATUS message with the global call reference
|
|
*/
|
|
if (GLOBAL_CREF(msg->msg_call_ref)) {
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
* If the network thinks we're in NULL state, clear the VCC
|
|
*/
|
|
if (msg->msg_ie_clst->ie_clst_state == UNI_NULL) {
|
|
if (uvp) {
|
|
(void)unisig_clear_vcc(usp, uvp,
|
|
T_ATM_CAUSE_DESTINATION_OUT_OF_ORDER);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
* If we are in NULL state, send a RELEASE COMPLETE
|
|
*/
|
|
if (!uvp || (uvp->uv_sstate == UNI_FREE) ||
|
|
(uvp->uv_sstate == UNI_NULL)) {
|
|
rc = unisig_send_release_complete(usp,
|
|
uvp, msg, UNI_IE_CAUS_STATE);
|
|
return(rc);
|
|
}
|
|
|
|
/*
|
|
* If the reported state doesn't match our state, close the VCC
|
|
* unless we're in UNI_RELEASE_REQUEST or UNI_RELEASE_IND
|
|
*/
|
|
if (msg->msg_ie_clst->ie_clst_state != uvp->uv_sstate) {
|
|
if (uvp->uv_sstate == UNI_RELEASE_REQUEST ||
|
|
uvp->uv_sstate == UNI_RELEASE_IND) {
|
|
return(0);
|
|
}
|
|
rc = unisig_clear_vcc(usp, uvp,
|
|
T_ATM_CAUSE_MESSAGE_INCOMPATIBLE_WITH_CALL_STATE);
|
|
}
|
|
|
|
/*
|
|
* States match, check for an error on one of our messages
|
|
*/
|
|
cause = msg->msg_ie_caus->ie_caus_cause;
|
|
if (cause == UNI_IE_CAUS_MISSING ||
|
|
cause == UNI_IE_CAUS_MTEXIST ||
|
|
cause == UNI_IE_CAUS_IEEXIST ||
|
|
cause == UNI_IE_CAUS_IECONTENT ||
|
|
cause == UNI_IE_CAUS_STATE) {
|
|
ATM_DEBUG2("unisig_vc_act21: error %d on message 0x%x\n",
|
|
cause,
|
|
msg->msg_ie_caus->ie_caus_diagnostic[0]);
|
|
if (uvp) {
|
|
(void)unisig_clear_vcc(usp, uvp, cause);
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 22
|
|
* Received STATUS ENQ
|
|
*
|
|
* Send STATUS with cause 30 "response to STATUS ENQUIRY" and
|
|
* current state
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection (may
|
|
* be NULL)
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act22(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
struct unisig_msg *status;
|
|
struct ie_generic *callst_ie, *cause_ie;
|
|
|
|
ATM_DEBUG3("unisig_vc_perror: usp=%p, uvp=%p, msg=%p\n",
|
|
usp, uvp, msg);
|
|
|
|
/*
|
|
* Get memory for a STATUS message
|
|
*/
|
|
status = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
|
|
if (status == NULL)
|
|
return(ENOMEM);
|
|
callst_ie = (struct ie_generic *) atm_allocate(&unisig_iepool);
|
|
if (callst_ie == NULL) {
|
|
atm_free(status);
|
|
return(ENOMEM);
|
|
}
|
|
cause_ie = (struct ie_generic *) atm_allocate(&unisig_iepool);
|
|
if (cause_ie == NULL) {
|
|
atm_free(status);
|
|
atm_free(callst_ie);
|
|
return(ENOMEM);
|
|
}
|
|
|
|
/*
|
|
* Fill out the response
|
|
*/
|
|
if (uvp) {
|
|
status->msg_call_ref = uvp->uv_call_ref;
|
|
} else if (msg) {
|
|
if (msg->msg_call_ref & UNI_MSG_CALL_REF_RMT)
|
|
status->msg_call_ref = msg->msg_call_ref &
|
|
UNI_MSG_CALL_REF_MASK;
|
|
else
|
|
status->msg_call_ref = msg->msg_call_ref |
|
|
UNI_MSG_CALL_REF_RMT;
|
|
} else {
|
|
status->msg_call_ref = UNI_MSG_CALL_REF_GLOBAL;
|
|
}
|
|
status->msg_type = UNI_MSG_STAT;
|
|
status->msg_type_flag = 0;
|
|
status->msg_type_action = 0;
|
|
status->msg_ie_clst = callst_ie;
|
|
status->msg_ie_caus = cause_ie;
|
|
|
|
/*
|
|
* Fill out the call state IE
|
|
*/
|
|
callst_ie->ie_ident = UNI_IE_CLST;
|
|
callst_ie->ie_coding = 0;
|
|
callst_ie->ie_flag = 0;
|
|
callst_ie->ie_action = 0;
|
|
if (uvp) {
|
|
switch(uvp->uv_sstate) {
|
|
case UNI_FREE:
|
|
callst_ie->ie_clst_state = UNI_NULL;
|
|
break;
|
|
default:
|
|
callst_ie->ie_clst_state = uvp->uv_sstate;
|
|
}
|
|
} else {
|
|
callst_ie->ie_clst_state = UNI_NULL;
|
|
}
|
|
|
|
/*
|
|
* Fill out the cause IE
|
|
*/
|
|
cause_ie->ie_ident = UNI_IE_CAUS;
|
|
cause_ie->ie_coding = 0;
|
|
cause_ie->ie_flag = 0;
|
|
cause_ie->ie_action = 0;
|
|
cause_ie->ie_caus_loc = UNI_IE_CAUS_LOC_USER;
|
|
cause_ie->ie_caus_cause = UNI_IE_CAUS_SENQ;
|
|
|
|
/*
|
|
* Send the STATUS message
|
|
*/
|
|
rc = unisig_send_msg(usp, status);
|
|
unisig_free_msg(status);
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 23
|
|
* Received ADD PARTY
|
|
*
|
|
* We don't support multipoint connections, so send an ADD PARTY REJECT
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act23(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
struct unisig_msg *apr_msg;
|
|
|
|
/*
|
|
* Get memory for the ADD PARTY REJECT message
|
|
*/
|
|
apr_msg = (struct unisig_msg *) atm_allocate(&unisig_msgpool);
|
|
if (apr_msg == NULL)
|
|
return(ENOMEM);
|
|
|
|
/*
|
|
* Fill out the message
|
|
*/
|
|
if (msg->msg_call_ref & UNI_MSG_CALL_REF_RMT)
|
|
apr_msg->msg_call_ref = msg->msg_call_ref &
|
|
UNI_MSG_CALL_REF_MASK;
|
|
else
|
|
apr_msg->msg_call_ref = msg->msg_call_ref |
|
|
UNI_MSG_CALL_REF_RMT;
|
|
apr_msg->msg_type = UNI_MSG_ADPR;
|
|
apr_msg->msg_type_flag = 0;
|
|
apr_msg->msg_type_action = 0;
|
|
|
|
/*
|
|
* Use the endpoint reference IE from the received message
|
|
*/
|
|
apr_msg->msg_ie_eprf = msg->msg_ie_eprf;
|
|
|
|
/*
|
|
* Send the ADD PARTY REJECT message
|
|
*/
|
|
rc = unisig_send_msg(usp, apr_msg);
|
|
apr_msg->msg_ie_eprf = NULL;
|
|
unisig_free_msg(apr_msg);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 24
|
|
* User error
|
|
*
|
|
* Return EALREADY
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act24(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
return(EALREADY);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 25
|
|
* User error
|
|
*
|
|
* Return EINVAL
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act25(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
return(EINVAL);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 26
|
|
* PVC abort
|
|
*
|
|
* The abort handler was called to abort a PVC. Clear the VCCB and
|
|
* notify the user.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act26(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Close the VCCB
|
|
*/
|
|
rc = unisig_close_vcc(usp, uvp);
|
|
if (rc)
|
|
return(rc);
|
|
|
|
/*
|
|
* Notify the user
|
|
*/
|
|
if (uvp->uv_connvc->cvc_attr.cause.tag != T_ATM_PRESENT)
|
|
unisig_cause_attr_from_user(&uvp->uv_connvc->cvc_attr,
|
|
T_ATM_CAUSE_NORMAL_CALL_CLEARING);
|
|
|
|
atm_cm_cleared(uvp->uv_connvc);
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 27
|
|
* Signalling AAL failure
|
|
*
|
|
* Change PVC state to UNI_PVC_ACT_DOWN.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act27(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
/*
|
|
* Set the state
|
|
*/
|
|
uvp->uv_sstate = UNI_PVC_ACT_DOWN;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 28
|
|
* Signalling AAL established
|
|
*
|
|
* Set PVC state to UNI_PVC_ACTIVE.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act28(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
/*
|
|
* Set the state
|
|
*/
|
|
uvp->uv_sstate = UNI_PVC_ACTIVE;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 29
|
|
* Protocol error
|
|
*
|
|
* Send a RELEASE COMPLETE message with cause 81, "invalid call
|
|
* reference value"
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection (may
|
|
* be NULL)
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act29(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
int rc;
|
|
|
|
/*
|
|
* Send a RELEASE COMPLETE message
|
|
*/
|
|
rc = unisig_send_release_complete(usp, uvp, msg,
|
|
UNI_IE_CAUS_CREF);
|
|
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 30
|
|
* Release routine called while SSCF session down, or SSCF session
|
|
* reset or lost while in UNI_CALL_PRESENT
|
|
*
|
|
* Go to UNI_FREE state
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act30(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
/*
|
|
* Clear any running timer
|
|
*/
|
|
UNISIG_VC_CANCEL((struct vccb *) uvp);
|
|
|
|
/*
|
|
* Clear the call state
|
|
*/
|
|
uvp->uv_sstate = UNI_FREE;
|
|
uvp->uv_ustate = VCCU_CLOSED;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* VC state machine action 31
|
|
* Accept handler called in UNI_FREE state.
|
|
*
|
|
* The call was in UNI_CALL_PRESENT state when it was closed because
|
|
* of an SSCF failure. Return an error indication. The accept
|
|
* handler will free the VCCB and return the proper code to the
|
|
* caller.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to a UNISIG message structure
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_act31(usp, uvp, msg)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
{
|
|
return(ENETDOWN);
|
|
}
|
|
|
|
|
|
/*
|
|
* Initiate clearing a call by sending a RELEASE message.
|
|
*
|
|
* Arguments:
|
|
* usp pointer to protocol instance block
|
|
* uvp pointer to the VCCB for the affected connection
|
|
* msg pointer to UNI signalling message that the RELEASE
|
|
* responds to (may be NULL)
|
|
* cause the reason for clearing the call; a value of
|
|
* T_ATM_ABSENT indicates that the cause code is
|
|
* in the VCC's ATM attributes block
|
|
*
|
|
* Returns:
|
|
* 0 success
|
|
* errno error encountered
|
|
*
|
|
*/
|
|
static int
|
|
unisig_vc_clear_call(usp, uvp, msg, cause)
|
|
struct unisig *usp;
|
|
struct unisig_vccb *uvp;
|
|
struct unisig_msg *msg;
|
|
int cause;
|
|
{
|
|
int rc;
|
|
|
|
/*
|
|
* Clear the retry count
|
|
*/
|
|
uvp->uv_retry = 0;
|
|
|
|
/*
|
|
* Make sure the ATM attributes block has a valid cause code,
|
|
* if needed
|
|
*/
|
|
if (cause == T_ATM_ABSENT &&
|
|
uvp->uv_connvc->cvc_attr.cause.tag !=
|
|
T_ATM_PRESENT) {
|
|
uvp->uv_connvc->cvc_attr.cause.tag = T_ATM_PRESENT;
|
|
uvp->uv_connvc->cvc_attr.cause.v.coding_standard =
|
|
T_ATM_ITU_CODING;
|
|
uvp->uv_connvc->cvc_attr.cause.v.location =
|
|
T_ATM_LOC_USER;
|
|
uvp->uv_connvc->cvc_attr.cause.v.cause_value =
|
|
usp->us_proto == ATM_SIG_UNI30 ?
|
|
T_ATM_CAUSE_UNSPECIFIED_NORMAL :
|
|
T_ATM_CAUSE_NORMAL_CALL_CLEARING;
|
|
}
|
|
|
|
/*
|
|
* Send a RELEASE message
|
|
*/
|
|
rc = unisig_send_release(usp, uvp, msg, cause);
|
|
if (rc)
|
|
return(rc);
|
|
|
|
/*
|
|
* Start timer T308
|
|
*/
|
|
UNISIG_VC_TIMER((struct vccb *) uvp, UNI_T308);
|
|
|
|
/*
|
|
* Set the VCCB state
|
|
*/
|
|
uvp->uv_sstate = UNI_RELEASE_REQUEST;
|
|
if (uvp->uv_ustate != VCCU_ABORT)
|
|
uvp->uv_ustate = VCCU_CLOSED;
|
|
|
|
/*
|
|
* Mark the time
|
|
*/
|
|
uvp->uv_tstamp = time_second;
|
|
|
|
return(0);
|
|
}
|