FreeBSD-5.3/sys/netatm/uni/sscop_sigcpcs.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.
*/
/*
* ATM Forum UNI Support
* ---------------------
*
* SSCOP Common - Process CPCS-signals (SSCOP PDUs)
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/sys/netatm/uni/sscop_sigcpcs.c,v 1.10 2003/06/11 07:22:30 obrien Exp $");
#include <sys/param.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <net/if.h>
#include <netatm/port.h>
#include <netatm/queue.h>
#include <netatm/atm.h>
#include <netatm/atm_sys.h>
#include <netatm/atm_sap.h>
#include <netatm/atm_cm.h>
#include <netatm/atm_if.h>
#include <netatm/atm_stack.h>
#include <netatm/atm_pcb.h>
#include <netatm/atm_var.h>
#include <netatm/uni/sscop.h>
#include <netatm/uni/sscop_misc.h>
#include <netatm/uni/sscop_pdu.h>
#include <netatm/uni/sscop_var.h>
/*
* No-op Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_noop(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Just free PDU
*/
KB_FREEALL(m);
return;
}
/*
* BGN PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgn_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct bgn_pdu *bp = (struct bgn_pdu *)trlr;
int err, source;
if (sop->so_vers == SSCOP_VERS_Q2110) {
/*
* "Power-up Robustness" option
*
* Accept BGN regardless of BGN.N(SQ)
*/
sop->so_rcvconn = bp->bgn_nsq;
} else {
/*
* If retransmitted BGN, reject it
*/
if (sscop_is_rexmit(sop, bp->bgn_nsq)) {
KB_FREEALL(m);
(void) sscop_send_bgrej(sop);
return;
}
}
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Get Source value
*/
if (bp->bgn_type & PT_SOURCE_SSCOP)
source = SSCOP_SOURCE_SSCOP;
else
source = SSCOP_SOURCE_USER;
/*
* Reset receiver state variables
*/
qsaal1_reset_rcvr(sop);
} else
source = 0;
/*
* Set initial transmit window
*/
SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr));
/*
* Pass connection request up to user
*/
STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, (intptr_t)m, source, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Wait for user's response
*/
sop->so_state = SOS_INCONN;
return;
}
/*
* BGN PDU / SOS_OUTDISC Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgn_outdisc(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct bgn_pdu *bp = (struct bgn_pdu *)trlr;
int err, source;
/*
* If retransmitted BGN, ACK it and send new END
*/
if (sscop_is_rexmit(sop, bp->bgn_nsq)) {
KB_FREEALL(m);
(void) sscop_send_bgak(sop);
(void) sscop_send_end(sop, SSCOP_SOURCE_LAST);
return;
}
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Initialize transmit window
*/
SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr));
/*
* Notify user of connection termination
*/
STACK_CALL(SSCOP_RELEASE_CNF, sop->so_upper, sop->so_toku,
sop->so_connvc, 0, 0, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Get Source value
*/
if (bp->bgn_type & PT_SOURCE_SSCOP)
source = SSCOP_SOURCE_SSCOP;
else
source = SSCOP_SOURCE_USER;
/*
* Reset receiver variables
*/
qsaal1_reset_rcvr(sop);
} else
source = 0;
/*
* Tell user about incoming connection
*/
STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, (intptr_t)m, source, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Wait for user's response
*/
sop->so_state = SOS_INCONN;
return;
}
/*
* BGN PDU / SOS_OUTRESYN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgn_outresyn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct bgn_pdu *bp = (struct bgn_pdu *)trlr;
int err, source;
/*
* If retransmitted BGN, ACK it and send new RS
*/
if (sscop_is_rexmit(sop, bp->bgn_nsq)) {
KB_FREEALL(m);
(void) sscop_send_bgak(sop);
(void) sscop_send_rs(sop);
return;
}
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Initialize transmit window
*/
SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr));
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Get (possible) Source value
*/
if (bp->bgn_type & PT_SOURCE_SSCOP)
source = SSCOP_SOURCE_SSCOP;
else
source = SSCOP_SOURCE_USER;
/*
* Reset receiver variables
*/
qsaal1_reset_rcvr(sop);
} else
source = SSCOP_SOURCE_USER;
/*
* Notify user of connection termination
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, source, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Now tell user of a "new" incoming connection
*/
STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, (intptr_t)m, source, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Wait for user's response
*/
sop->so_state = SOS_INCONN;
return;
}
/*
* BGN PDU / SOS_INRESYN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgn_inresyn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct bgn_pdu *bp = (struct bgn_pdu *)trlr;
int err, source;
/*
* If retransmitted BGN, oops
*/
if (sscop_is_rexmit(sop, bp->bgn_nsq)) {
KB_FREEALL(m);
sscop_maa_error(sop, 'B');
return;
}
/*
* Stop data transfer timers
*/
sop->so_timer[SSCOP_T_POLL] = 0;
sop->so_timer[SSCOP_T_NORESP] = 0;
sop->so_timer[SSCOP_T_IDLE] = 0;
sop->so_flags &= ~SOF_KEEPALIVE;
/*
* Initialize transmit window
*/
SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_nmr));
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Get (possible) Source value
*/
if (bp->bgn_type & PT_SOURCE_SSCOP)
source = SSCOP_SOURCE_SSCOP;
else
source = SSCOP_SOURCE_USER;
/*
* Reset receiver variables
*/
qsaal1_reset_rcvr(sop);
} else {
/*
* Stop possible retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Drain receiver queues
*/
sscop_rcvr_drain(sop);
/*
* Tell user current connection has been released
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_USER, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
source = 0;
}
/*
* Tell user of incoming connection
*/
STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, (intptr_t)m, source, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Wait for user's response
*/
sop->so_state = SOS_INCONN;
return;
}
/*
* BGAK PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgak_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'C');
KB_FREEALL(m);
return;
}
/*
* BGAK PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgak_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_bgak_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
return;
}
/*
* BGAK PDU / SOS_OUTCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgak_outconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct bgak_pdu *bp = (struct bgak_pdu *)trlr;
int err;
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Initialize transmit window
*/
SEQ_SET(sop->so_sendmax, ntohl(bp->bgak_nmr));
/*
* Notify user of connection establishment
*/
if (sop->so_flags & SOF_REESTAB) {
KB_FREEALL(m);
STACK_CALL(SSCOP_ESTABLISH_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
sop->so_flags &= ~SOF_REESTAB;
} else {
STACK_CALL(SSCOP_ESTABLISH_CNF, sop->so_upper, sop->so_toku,
sop->so_connvc, (intptr_t)m, 0, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
}
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Reset receiver variables
*/
qsaal1_reset_rcvr(sop);
/*
* Start polling timer
*/
sscop_set_poll(sop);
/*
* Start lost poll/stat timer
*/
sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
} else {
/*
* Initialize state variables
*/
q2110_init_state(sop);
/*
* Start data transfer timers
*/
sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll;
sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
}
/*
* OK, we're ready for data
*/
sop->so_state = SOS_READY;
/*
* See if transmit queues need servicing
*/
if (sop->so_flags & SOF_XMITSRVC)
sscop_service_xmit(sop);
return;
}
/*
* BGREJ PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgrej_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'D');
KB_FREEALL(m);
return;
}
/*
* BGREJ PDU / SOS_OUTCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgrej_outconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int source, err;
intptr_t uu;
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Clear reestablishment flag
*/
sop->so_flags &= ~SOF_REESTAB;
KB_FREEALL(m);
m = NULL;
uu = SSCOP_UU_NULL;
source = SSCOP_SOURCE_SSCOP;
} else {
uu = (intptr_t)m;
source = SSCOP_SOURCE_USER;
}
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, uu, source, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* BGREJ PDU / SOS_INCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgrej_inconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Report protocol error
*/
sscop_bgrej_error(sop, m, trlr);
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* BGREJ PDU / SOS_OUTRESYN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgrej_outresyn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Report protocol error
*/
sscop_bgrej_error(sop, m, trlr);
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Clear connection data
*/
qsaal1_clear_connection(sop);
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* BGREJ PDU / SOS_READY Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_bgrej_ready(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Stop data transfer timers
*/
sop->so_timer[SSCOP_T_POLL] = 0;
sop->so_timer[SSCOP_T_NORESP] = 0;
sop->so_timer[SSCOP_T_IDLE] = 0;
sop->so_flags &= ~SOF_KEEPALIVE;
/*
* Report protocol error
*/
sscop_bgrej_error(sop, m, trlr);
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Clear connection data
*/
qsaal1_clear_connection(sop);
} else {
/*
* Clear out appropriate queues
*/
q2110_prep_retrieve(sop);
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* END PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_end_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Free buffers
*/
KB_FREEALL(m);
/*
* Return an ENDAK to peer
*/
(void) sscop_send_endak(sop);
return;
}
/*
* END PDU / SOS_INCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_end_inconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct end_pdu *ep = (struct end_pdu *)trlr;
int err, source;
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Acknowledge END
*/
(void) sscop_send_endak(sop);
/*
* Get Source value
*/
if (ep->end_type & PT_SOURCE_SSCOP)
source = SSCOP_SOURCE_SSCOP;
else
source = SSCOP_SOURCE_USER;
/*
* Notify user of connection termination
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, (intptr_t)m, source, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* END PDU / SOS_OUTDISC Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_end_outdisc(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Release buffers
*/
KB_FREEALL(m);
/*
* Acknowledge END
*/
(void) sscop_send_endak(sop);
/*
* Notify user of connection termination
*/
STACK_CALL(SSCOP_RELEASE_CNF, sop->so_upper, sop->so_toku,
sop->so_connvc, 0, 0, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* ENDAK PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_endak_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'F');
KB_FREEALL(m);
return;
}
/*
* ENDAK PDU / SOS_INCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_endak_inconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Report protocol error
*/
sscop_endak_error(sop, m, trlr);
/*
* Notify user of connection termination
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* ENDAK PDU / SOS_OUTDISC Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_endak_outdisc(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Release buffers
*/
KB_FREEALL(m);
/*
* Notify user of connection termination
*/
STACK_CALL(SSCOP_RELEASE_CNF, sop->so_upper, sop->so_toku,
sop->so_connvc, 0, 0, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* ENDAK PDU / SOS_READY Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_endak_ready(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Stop data transfer timers
*/
sop->so_timer[SSCOP_T_POLL] = 0;
sop->so_timer[SSCOP_T_NORESP] = 0;
sop->so_timer[SSCOP_T_IDLE] = 0;
sop->so_flags &= ~SOF_KEEPALIVE;
/*
* Report protocol error
*/
sscop_endak_error(sop, m, trlr);
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Clear connection data
*/
qsaal1_clear_connection(sop);
} else {
/*
* Clear out appropriate queues
*/
q2110_prep_retrieve(sop);
}
/*
* Back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* RS PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_rs_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'J');
KB_FREEALL(m);
return;
}
/*
* RS PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_rs_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Report error condition
*/
sscop_rs_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
return;
}
/*
* RSAK PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_rsak_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'K');
KB_FREEALL(m);
return;
}
/*
* RSAK PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_rsak_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Report error condition
*/
sscop_rsak_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
return;
}
/*
* RSAK PDU / SOS_OUTRESYN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_rsak_outresyn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct rsak_q2110_pdu *rp = (struct rsak_q2110_pdu *)trlr;
int err;
/*
* Stop retransmit timer
*/
sop->so_timer[SSCOP_T_CC] = 0;
/*
* Notify user of resynchronization completion
*/
STACK_CALL(SSCOP_RESYNC_CNF, sop->so_upper, sop->so_toku,
sop->so_connvc, 0, 0, err);
if (err) {
KB_FREEALL(m);
sscop_abort(sop, "stack memory\n");
return;
}
if (sop->so_vers == SSCOP_VERS_QSAAL) {
/*
* Start the polling timer
*/
sscop_set_poll(sop);
/*
* Start lost poll/stat timer
*/
sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
} else {
/*
* Initialize state variables
*/
SEQ_SET(sop->so_sendmax, ntohl(rp->rsak_nmr));
q2110_init_state(sop);
/*
* Start data transfer timers
*/
sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll;
sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
}
/*
* Free buffers
*/
KB_FREEALL(m);
/*
* Now go back to data transfer state
*/
sop->so_state = SOS_READY;
/*
* See if transmit queues need servicing
*/
if (sop->so_flags & SOF_XMITSRVC)
sscop_service_xmit(sop);
return;
}
/*
* SD PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_sd_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'A');
KB_FREEALL(m);
return;
}
/*
* SD PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_sd_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_sd_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
return;
}
/*
* SD PDU / SOS_INCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_sd_inconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Record error condition
*/
sscop_sd_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Go back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* POLL PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_poll_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'G');
KB_FREEALL(m);
return;
}
/*
* POLL PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_poll_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Report error condition
*/
sscop_poll_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
return;
}
/*
* POLL PDU / SOS_INCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_poll_inconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Record error condition
*/
sscop_poll_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Go back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* STAT PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_stat_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'H');
KB_FREEALL(m);
return;
}
/*
* STAT PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_stat_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Report error condition
*/
sscop_stat_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
return;
}
/*
* STAT PDU / SOS_INCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_stat_inconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Record error condition
*/
sscop_stat_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Go back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* STAT PDU / SOS_READY Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_stat_ready(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct stat_pdu *sp = (struct stat_pdu *)trlr;
struct pdu_hdr *php;
KBuffer *m0 = m;
sscop_seq seq1, seq2, opa;
int cnt = 0;
sp->stat_nps = ntohl(sp->stat_nps);
sp->stat_nmr = ntohl(sp->stat_nmr);
sp->stat_nr = ntohl(sp->stat_nr);
/*
* Validate peer's received poll sequence number
*/
if (SEQ_GT(sop->so_pollack, sp->stat_nps, sop->so_pollack) ||
SEQ_GT(sp->stat_nps, sop->so_pollsend, sop->so_pollack)) {
/*
* Bad poll sequence number
*/
sscop_maa_error(sop, 'R');
goto goterr;
}
/*
* Validate peer's current receive data sequence number
*/
if (SEQ_GT(sop->so_ack, sp->stat_nr, sop->so_ack) ||
SEQ_GT(sp->stat_nr, sop->so_send, sop->so_ack)) {
/*
* Bad data sequence number
*/
sscop_maa_error(sop, 'S');
goto goterr;
}
/*
* Free acknowledged PDUs
*/
for (seq1 = sop->so_ack, SEQ_SET(seq2, sp->stat_nr);
SEQ_LT(seq1, seq2, sop->so_ack);
SEQ_INCR(seq1, 1)) {
sscop_pack_free(sop, seq1);
}
/*
* Update transmit state variables
*/
opa = sop->so_pollack;
sop->so_ack = seq2;
SEQ_SET(sop->so_pollack, sp->stat_nps);
SEQ_SET(sop->so_sendmax, sp->stat_nmr);
/*
* Get first element in STAT list
*/
while (m && (KB_LEN(m) == 0))
m = KB_NEXT(m);
if (m == NULL)
goto done;
m = sscop_stat_getelem(m, &seq1);
/*
* Make sure there's a second element too
*/
if (m == NULL)
goto done;
/*
* Validate first element (start of missing pdus)
*/
if (SEQ_GT(sop->so_ack, seq1, sop->so_ack) ||
SEQ_GEQ(seq1, sop->so_send, sop->so_ack)) {
/*
* Bad element sequence number
*/
sscop_maa_error(sop, 'S');
goto goterr;
}
/*
* Loop thru all STAT elements in list
*/
while (m) {
/*
* Get next even element (start of received pdus)
*/
m = sscop_stat_getelem(m, &seq2);
/*
* Validate seqence number
*/
if (SEQ_GEQ(seq1, seq2, sop->so_ack) ||
SEQ_GT(seq2, sop->so_send, sop->so_ack)) {
/*
* Bad element sequence number
*/
sscop_maa_error(sop, 'S');
goto goterr;
}
/*
* Process each missing sequence number in this gap
*/
while (SEQ_LT(seq1, seq2, sop->so_ack)) {
/*
* Find corresponding SD PDU on pending ack queue
*/
php = sscop_pack_locate(sop, seq1);
if (php == NULL) {
sscop_maa_error(sop, 'S');
goto goterr;
}
/*
* Retransmit this SD PDU only if it was last sent
* during an earlier poll sequence and it's not
* already scheduled for retranmission.
*/
if (SEQ_LT(php->ph_nps, sp->stat_nps, opa) &&
(php->ph_rexmit_lk == NULL) &&
(sop->so_rexmit_tl != php)) {
/*
* Put PDU on retransmit queue and schedule
* transmit servicing
*/
sscop_rexmit_insert(sop, php);
sop->so_flags |= SOF_XMITSRVC;
cnt++;
}
/*
* Bump to next sequence number
*/
SEQ_INCR(seq1, 1);
}
/*
* Now process series of acknowledged PDUs
*
* Get next odd element (start of missing pdus),
* but make sure there is one and that it's valid
*/
if (m == NULL)
goto done;
m = sscop_stat_getelem(m, &seq2);
if (SEQ_GEQ(seq1, seq2, sop->so_ack) ||
SEQ_GT(seq2, sop->so_send, sop->so_ack)) {
/*
* Bad element sequence number
*/
sscop_maa_error(sop, 'S');
goto goterr;
}
/*
* Process each acked sequence number
*/
while (SEQ_LT(seq1, seq2, sop->so_ack)) {
/*
* Can we clear transmit buffers ??
*/
if ((sop->so_flags & SOF_NOCLRBUF) == 0) {
/*
* Yes, free acked buffers
*/
sscop_pack_free(sop, seq1);
}
/*
* Bump to next sequence number
*/
SEQ_INCR(seq1, 1);
}
}
done:
/*
* Free PDU buffer chain
*/
KB_FREEALL(m0);
/*
* Report retransmitted PDUs
*/
if (cnt)
sscop_maa_error(sop, 'V');
/*
* Record transmit window closed transitions
*/
if (SEQ_LT(sop->so_send, sop->so_sendmax, sop->so_ack)) {
if (sop->so_flags & SOF_NOCREDIT) {
sop->so_flags &= ~SOF_NOCREDIT;
sscop_maa_error(sop, 'X');
}
} else {
if ((sop->so_flags & SOF_NOCREDIT) == 0) {
sop->so_flags |= SOF_NOCREDIT;
sscop_maa_error(sop, 'W');
}
}
if (sop->so_vers == SSCOP_VERS_QSAAL)
/*
* Restart lost poll/stat timer
*/
sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
else {
/*
* Determine new polling phase
*/
if ((sop->so_timer[SSCOP_T_POLL] != 0) &&
((sop->so_flags & SOF_KEEPALIVE) == 0)) {
/*
* Remain in active phase - reset NO-RESPONSE timer
*/
sop->so_timer[SSCOP_T_NORESP] =
sop->so_parm.sp_timeresp;
} else if (sop->so_timer[SSCOP_T_IDLE] == 0) {
/*
* Go from transient to idle phase
*/
sop->so_timer[SSCOP_T_POLL] = 0;
sop->so_flags &= ~SOF_KEEPALIVE;
sop->so_timer[SSCOP_T_NORESP] = 0;
sop->so_timer[SSCOP_T_IDLE] = sop->so_parm.sp_timeidle;
}
}
/*
* See if transmit queues need servicing
*/
if (sop->so_flags & SOF_XMITSRVC)
sscop_service_xmit(sop);
return;
goterr:
/*
* Protocol/parameter error encountered
*/
/*
* Free PDU buffer chain
*/
KB_FREEALL(m0);
if (sop->so_vers == SSCOP_VERS_QSAAL)
/*
* Reestablish a new connection
*/
qsaal1_reestablish(sop);
else
/*
* Initiate error recovery
*/
q2110_error_recovery(sop);
return;
}
/*
* USTAT PDU / Protocol Error
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_ustat_error(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Record error condition
*/
sscop_maa_error(sop, 'I');
KB_FREEALL(m);
return;
}
/*
* USTAT PDU / SOS_IDLE Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_ustat_idle(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* Report error condition
*/
sscop_ustat_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
return;
}
/*
* USTAT PDU / SOS_INCONN Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_ustat_inconn(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Record error condition
*/
sscop_ustat_error(sop, m, trlr);
/*
* Return an END to peer
*/
(void) sscop_send_end(sop, SSCOP_SOURCE_SSCOP);
/*
* Notify user of connection failure
*/
STACK_CALL(SSCOP_RELEASE_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, SSCOP_UU_NULL, SSCOP_SOURCE_SSCOP, err);
if (err) {
sscop_abort(sop, "stack memory\n");
return;
}
/*
* Go back to idle state
*/
sop->so_state = SOS_IDLE;
return;
}
/*
* USTAT PDU / SOS_READY Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_ustat_ready(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
struct ustat_pdu *up = (struct ustat_pdu *)trlr;
struct pdu_hdr *php;
sscop_seq seq1, seq2;
up->ustat_nmr = ntohl(up->ustat_nmr);
up->ustat_nr = ntohl(up->ustat_nr);
/*
* Validate peer's current receive data sequence number
*/
if (SEQ_GT(sop->so_ack, up->ustat_nr, sop->so_ack) ||
SEQ_GEQ(up->ustat_nr, sop->so_send, sop->so_ack)) {
/*
* Bad data sequence number
*/
goto goterr;
}
/*
* Free acknowledged PDUs
*/
for (seq1 = sop->so_ack, SEQ_SET(seq2, up->ustat_nr);
SEQ_LT(seq1, seq2, sop->so_ack);
SEQ_INCR(seq1, 1)) {
sscop_pack_free(sop, seq1);
}
/*
* Update transmit state variables
*/
sop->so_ack = seq2;
SEQ_SET(sop->so_sendmax, up->ustat_nmr);
/*
* Get USTAT list elements
*/
SEQ_SET(seq1, ntohl(up->ustat_le1));
SEQ_SET(seq2, ntohl(up->ustat_le2));
/*
* Validate elements
*/
if (SEQ_GT(sop->so_ack, seq1, sop->so_ack) ||
SEQ_GEQ(seq1, seq2, sop->so_ack) ||
SEQ_GEQ(seq2, sop->so_send, sop->so_ack)) {
/*
* Bad element sequence number
*/
goto goterr;
}
/*
* Process each missing sequence number in this gap
*/
while (SEQ_LT(seq1, seq2, sop->so_ack)) {
/*
* Find corresponding SD PDU on pending ack queue
*/
php = sscop_pack_locate(sop, seq1);
if (php == NULL) {
goto goterr;
}
/*
* Retransmit this SD PDU if it's not
* already scheduled for retranmission.
*/
if ((php->ph_rexmit_lk == NULL) &&
(sop->so_rexmit_tl != php)) {
/*
* Put PDU on retransmit queue and schedule
* transmit servicing
*/
sscop_rexmit_insert(sop, php);
sop->so_flags |= SOF_XMITSRVC;
}
/*
* Bump to next sequence number
*/
SEQ_INCR(seq1, 1);
}
/*
* Report retransmitted PDUs
*/
sscop_maa_error(sop, 'V');
/*
* Free PDU buffer chain
*/
KB_FREEALL(m);
/*
* See if transmit queues need servicing
*/
if (sop->so_flags & SOF_XMITSRVC)
sscop_service_xmit(sop);
return;
goterr:
/*
* Protocol/parameter error encountered
*/
sscop_maa_error(sop, 'T');
/*
* Free PDU buffer chain
*/
KB_FREEALL(m);
if (sop->so_vers == SSCOP_VERS_QSAAL)
/*
* Reestablish a new connection
*/
qsaal1_reestablish(sop);
else
/*
* Initiate error recovery
*/
q2110_error_recovery(sop);
return;
}
/*
* UD PDU / SOS_* Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_ud_all(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
int err;
/*
* Pass data up to user
*/
STACK_CALL(SSCOP_UNITDATA_IND, sop->so_upper, sop->so_toku,
sop->so_connvc, (intptr_t)m, 0, err);
if (err)
KB_FREEALL(m);
return;
}
/*
* MD PDU / SOS_* Processor
*
* Arguments:
* sop pointer to sscop connection block
* m pointer to PDU buffer (without trailer)
* trlr pointer to PDU trailer
*
* Returns:
* none
*
*/
void
sscop_md_all(sop, m, trlr)
struct sscop *sop;
KBuffer *m;
caddr_t trlr;
{
/*
* We don't support MD PDUs
*/
KB_FREEALL(m);
return;
}