mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-21 11:13:30 +00:00
1560 lines
30 KiB
C
1560 lines
30 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 Support
|
|
* ---------------------
|
|
*
|
|
* ITU-T Q.SAAL1 - Process CPCS-signals (SSCOP PDUs)
|
|
*
|
|
*/
|
|
|
|
#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>
|
|
|
|
#ifndef lint
|
|
__RCSID("@(#) $FreeBSD$");
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Local functions
|
|
*/
|
|
static void sscop_bgn_outconn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_end_outresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_end_conresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_end_ready(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_endak_outresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_rs_outresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_rs_ready(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_rsak_conresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_sd_inresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_sd_conresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_sd_process(struct sscop *, KBuffer *, caddr_t, int);
|
|
static void sscop_sd_ready(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_sdp_ready(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_poll_inresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_poll_conresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_poll_ready(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_stat_conresyn(struct sscop *, KBuffer *, caddr_t);
|
|
static void sscop_ustat_conresyn(struct sscop *, KBuffer *, caddr_t);
|
|
|
|
|
|
/*
|
|
* PDU type state lookup tables
|
|
*/
|
|
/* BGN PDU */
|
|
static void (*sscop_bgn_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_bgn_idle, /* SOS_IDLE */
|
|
sscop_bgn_outconn, /* SOS_OUTCONN */
|
|
sscop_noop, /* SOS_INCONN */
|
|
sscop_bgn_outdisc, /* SOS_OUTDISC */
|
|
sscop_bgn_outresyn, /* SOS_OUTRESYN */
|
|
sscop_bgn_inresyn, /* SOS_INRESYN */
|
|
sscop_bgn_outresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_bgn_inresyn, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* BGAK PDU */
|
|
static void (*sscop_bgak_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_bgak_idle, /* SOS_IDLE */
|
|
sscop_bgak_outconn, /* SOS_OUTCONN */
|
|
sscop_bgak_error, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_bgak_error, /* SOS_OUTRESYN */
|
|
sscop_bgak_error, /* SOS_INRESYN */
|
|
sscop_bgak_error, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_noop, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* BGREJ PDU */
|
|
static void (*sscop_bgrej_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_bgrej_error, /* SOS_IDLE */
|
|
sscop_bgrej_outconn, /* SOS_OUTCONN */
|
|
sscop_bgrej_inconn, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_bgrej_outresyn, /* SOS_OUTRESYN */
|
|
sscop_bgrej_ready, /* SOS_INRESYN */
|
|
sscop_bgrej_outresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_bgrej_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* END PDU */
|
|
static void (*sscop_end_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_end_idle, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_end_inconn, /* SOS_INCONN */
|
|
sscop_end_outdisc, /* SOS_OUTDISC */
|
|
sscop_end_outresyn, /* SOS_OUTRESYN */
|
|
sscop_end_ready, /* SOS_INRESYN */
|
|
sscop_end_conresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_end_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* ENDAK PDU */
|
|
static void (*sscop_endak_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_noop, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_endak_inconn, /* SOS_INCONN */
|
|
sscop_endak_outdisc, /* SOS_OUTDISC */
|
|
sscop_endak_outresyn, /* SOS_OUTRESYN */
|
|
sscop_endak_ready, /* SOS_INRESYN */
|
|
sscop_endak_outresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_endak_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* RS PDU */
|
|
static void (*sscop_rs_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_rs_idle, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_rs_error, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_rs_outresyn, /* SOS_OUTRESYN */
|
|
sscop_noop, /* SOS_INRESYN */
|
|
sscop_noop, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_rs_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* RSAK PDU */
|
|
static void (*sscop_rsak_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_rsak_idle, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_rsak_error, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_rsak_outresyn, /* SOS_OUTRESYN */
|
|
sscop_rsak_error, /* SOS_INRESYN */
|
|
sscop_rsak_conresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_rsak_error, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* SD PDU */
|
|
static void (*sscop_sd_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_sd_idle, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_sd_inconn, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_sd_ready, /* SOS_OUTRESYN */
|
|
sscop_sd_inresyn, /* SOS_INRESYN */
|
|
sscop_sd_conresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_sd_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* SDP PDU */
|
|
static void (*sscop_sdp_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_sd_idle, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_sd_inconn, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_sdp_ready, /* SOS_OUTRESYN */
|
|
sscop_sd_inresyn, /* SOS_INRESYN */
|
|
sscop_sd_conresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_sdp_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* POLL PDU */
|
|
static void (*sscop_poll_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_poll_idle, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_poll_inconn, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_poll_ready, /* SOS_OUTRESYN */
|
|
sscop_poll_inresyn, /* SOS_INRESYN */
|
|
sscop_poll_conresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_poll_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* STAT PDU */
|
|
static void (*sscop_stat_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_stat_idle, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_stat_inconn, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_noop, /* SOS_OUTRESYN */
|
|
sscop_stat_ready, /* SOS_INRESYN */
|
|
sscop_stat_conresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_stat_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* USTAT PDU */
|
|
static void (*sscop_ustat_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_ustat_idle, /* SOS_IDLE */
|
|
sscop_noop, /* SOS_OUTCONN */
|
|
sscop_ustat_inconn, /* SOS_INCONN */
|
|
sscop_noop, /* SOS_OUTDISC */
|
|
sscop_noop, /* SOS_OUTRESYN */
|
|
sscop_ustat_ready, /* SOS_INRESYN */
|
|
sscop_ustat_conresyn, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_ustat_ready, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* UD PDU */
|
|
static void (*sscop_ud_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_ud_all, /* SOS_IDLE */
|
|
sscop_ud_all, /* SOS_OUTCONN */
|
|
sscop_ud_all, /* SOS_INCONN */
|
|
sscop_ud_all, /* SOS_OUTDISC */
|
|
sscop_ud_all, /* SOS_OUTRESYN */
|
|
sscop_ud_all, /* SOS_INRESYN */
|
|
sscop_ud_all, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_ud_all, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
/* MD PDU */
|
|
static void (*sscop_md_tab[SOS_NUMSTATES])
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL, /* SOS_INST */
|
|
sscop_md_all, /* SOS_IDLE */
|
|
sscop_md_all, /* SOS_OUTCONN */
|
|
sscop_md_all, /* SOS_INCONN */
|
|
sscop_md_all, /* SOS_OUTDISC */
|
|
sscop_md_all, /* SOS_OUTRESYN */
|
|
sscop_md_all, /* SOS_INRESYN */
|
|
sscop_md_all, /* SOS_CONRESYN */
|
|
NULL, /* invalid */
|
|
NULL, /* invalid */
|
|
sscop_md_all, /* SOS_READY */
|
|
sscop_noop /* SOS_TERM */
|
|
};
|
|
|
|
|
|
/*
|
|
* PDU type lookup table
|
|
*/
|
|
void (*(*sscop_qsaal_pdutab[]))
|
|
(struct sscop *, KBuffer *, caddr_t) = {
|
|
NULL,
|
|
sscop_bgn_tab,
|
|
sscop_bgak_tab,
|
|
sscop_end_tab,
|
|
sscop_endak_tab,
|
|
sscop_rs_tab,
|
|
sscop_rsak_tab,
|
|
sscop_bgrej_tab,
|
|
sscop_sd_tab,
|
|
sscop_sdp_tab,
|
|
sscop_poll_tab,
|
|
sscop_stat_tab,
|
|
sscop_ustat_tab,
|
|
sscop_ud_tab,
|
|
sscop_md_tab,
|
|
NULL
|
|
};
|
|
|
|
|
|
/*
|
|
* BGN 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_bgn_outconn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
struct bgn_pdu *bp = (struct bgn_pdu *)trlr;
|
|
int err;
|
|
|
|
/*
|
|
* Initialize transmit window
|
|
*/
|
|
SEQ_SET(sop->so_sendmax, ntohl(bp->bgn_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, "sscop_bgn_outconn: 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, "sscop_bgn_outconn: stack memory\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Return an ACK to peer
|
|
*/
|
|
(void) sscop_send_bgak(sop);
|
|
|
|
/*
|
|
* Stop retransmit timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_CC] = 0;
|
|
|
|
/*
|
|
* 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;
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
|
|
|
|
/*
|
|
* END 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_end_outresyn(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, "sscop_end_outresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* END PDU / SOS_CONRESYN Processor
|
|
*
|
|
* Arguments:
|
|
* sop pointer to sscop connection block
|
|
* m pointer to PDU buffer (without trailer)
|
|
* trlr pointer to PDU trailer
|
|
*
|
|
* Returns:
|
|
* none
|
|
*
|
|
*/
|
|
static void
|
|
sscop_end_conresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Stop retransmit timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_CC] = 0;
|
|
|
|
/*
|
|
* Free up buffers
|
|
*/
|
|
KB_FREEALL(m);
|
|
|
|
/*
|
|
* Acknowledge END
|
|
*/
|
|
(void) sscop_send_endak(sop);
|
|
|
|
/*
|
|
* 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, "sscop_end_conresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* END 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_end_ready(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
struct end_pdu *ep = (struct end_pdu *)trlr;
|
|
int err, source;
|
|
|
|
/*
|
|
* Stop poll timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_POLL] = 0;
|
|
sop->so_flags &= ~SOF_KEEPALIVE;
|
|
|
|
/*
|
|
* Stop lost poll/stat timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_NORESP] = 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, "sscop_end_ready: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* ENDAK 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_endak_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_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, "sscop_endak_outresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* RS 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_rs_outresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Notify user of resynchronization
|
|
*/
|
|
STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku,
|
|
sop->so_connvc, (intptr_t)m, 0, err);
|
|
if (err) {
|
|
KB_FREEALL(m);
|
|
sscop_abort(sop, "sscop_rs_outresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Reset receiver state variables
|
|
*/
|
|
qsaal1_reset_rcvr(sop);
|
|
|
|
/*
|
|
* Wait for both peer and user responses
|
|
*/
|
|
sop->so_state = SOS_CONRESYN;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* RS 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_rs_ready(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Notify user of resynchronization
|
|
*/
|
|
STACK_CALL(SSCOP_RESYNC_IND, sop->so_upper, sop->so_toku,
|
|
sop->so_connvc, (intptr_t)m, 0, err);
|
|
if (err) {
|
|
KB_FREEALL(m);
|
|
sscop_abort(sop, "sscop_rs_ready: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Reset receiver state variables
|
|
*/
|
|
qsaal1_reset_rcvr(sop);
|
|
|
|
/*
|
|
* Wait for user response
|
|
*/
|
|
sop->so_state = SOS_INRESYN;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* RSAK PDU / SOS_CONRESYN Processor
|
|
*
|
|
* Arguments:
|
|
* sop pointer to sscop connection block
|
|
* m pointer to PDU buffer (without trailer)
|
|
* trlr pointer to PDU trailer
|
|
*
|
|
* Returns:
|
|
* none
|
|
*
|
|
*/
|
|
static void
|
|
sscop_rsak_conresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Stop retransmit timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_CC] = 0;
|
|
|
|
/*
|
|
* Free buffers
|
|
*/
|
|
KB_FREEALL(m);
|
|
|
|
/*
|
|
* Notify user of resynchronization completion
|
|
*/
|
|
STACK_CALL(SSCOP_RESYNC_CNF, sop->so_upper, sop->so_toku,
|
|
sop->so_connvc, 0, 0, err);
|
|
if (err) {
|
|
sscop_abort(sop, "sscop_rsak_conresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Start the polling timer
|
|
*/
|
|
sscop_set_poll(sop);
|
|
|
|
/*
|
|
* Start lost poll/stat timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
|
|
|
|
/*
|
|
* Continue waiting for user response
|
|
*/
|
|
sop->so_state = SOS_INRESYN;
|
|
|
|
/*
|
|
* See if transmit queues need servicing
|
|
*/
|
|
if (sop->so_flags & SOF_XMITSRVC)
|
|
sscop_service_xmit(sop);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* SD 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_sd_inresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Stop poll timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_POLL] = 0;
|
|
sop->so_flags &= ~SOF_KEEPALIVE;
|
|
|
|
/*
|
|
* Stop lost poll/stat timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_NORESP] = 0;
|
|
|
|
/*
|
|
* 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, "sscop_sd_inresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Go back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* SD PDU / SOS_CONRESYN Processor
|
|
*
|
|
* Arguments:
|
|
* sop pointer to sscop connection block
|
|
* m pointer to PDU buffer (without trailer)
|
|
* trlr pointer to PDU trailer
|
|
*
|
|
* Returns:
|
|
* none
|
|
*
|
|
*/
|
|
static void
|
|
sscop_sd_conresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Stop retransmit timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_CC] = 0;
|
|
|
|
/*
|
|
* 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, "sscop_sd_conresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Go back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* SD/SDP PDU Common Processor
|
|
*
|
|
* Arguments:
|
|
* sop pointer to sscop connection block
|
|
* m pointer to PDU user data buffer chain
|
|
* trlr pointer to PDU trailer
|
|
* type PDU type (SD or SDP)
|
|
*
|
|
* Returns:
|
|
* none
|
|
*
|
|
*/
|
|
static void
|
|
sscop_sd_process(sop, m, trlr, type)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
int type;
|
|
{
|
|
struct sd_pdu *sp;
|
|
struct sdp_pdu *spp;
|
|
struct poll_pdu poll;
|
|
struct pdu_hdr *php;
|
|
KBuffer *n;
|
|
sscop_seq ns, nps;
|
|
int err, space;
|
|
|
|
/*
|
|
* Get PDU sequence number(s)
|
|
*/
|
|
if (type == PT_SD) {
|
|
sp = (struct sd_pdu *)trlr;
|
|
SEQ_SET(ns, ntohl(sp->sd_ns));
|
|
SEQ_SET(nps, 0);
|
|
} else {
|
|
spp = (struct sdp_pdu *)trlr;
|
|
SEQ_SET(ns, ntohl(spp->sdp_ns));
|
|
SEQ_SET(nps, ntohl(spp->sdp_nps));
|
|
}
|
|
|
|
/*
|
|
* Ensure that the sequence number fits within the window
|
|
*/
|
|
if (SEQ_GEQ(ns, sop->so_rcvmax, sop->so_rcvnext)) {
|
|
KB_FREEALL(m);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If this is the next in-sequence PDU, hand it to user
|
|
*/
|
|
if (ns == sop->so_rcvnext) {
|
|
STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku,
|
|
sop->so_connvc, (intptr_t)m, ns, err);
|
|
if (err) {
|
|
KB_FREEALL(m);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Bump next expected sequence number
|
|
*/
|
|
SEQ_INCR(sop->so_rcvnext, 1);
|
|
|
|
/*
|
|
* Slide receive window down
|
|
*/
|
|
SEQ_INCR(sop->so_rcvmax, 1);
|
|
|
|
/*
|
|
* Is this the highest sequence PDU we've received??
|
|
*/
|
|
if (ns == sop->so_rcvhigh) {
|
|
/*
|
|
* Yes, bump the limit and exit
|
|
*/
|
|
sop->so_rcvhigh = sop->so_rcvnext;
|
|
if (type == PT_SDP)
|
|
goto dopoll;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* This is a retransmitted PDU, so see if we have
|
|
* more in-sequence PDUs already queued up
|
|
*/
|
|
while ((php = sop->so_recv_hd) &&
|
|
(php->ph_ns == sop->so_rcvnext)) {
|
|
|
|
/*
|
|
* Yup we do, so remove next PDU from queue and
|
|
* pass it up to the user as well
|
|
*/
|
|
sop->so_recv_hd = php->ph_recv_lk;
|
|
if (sop->so_recv_hd == NULL)
|
|
sop->so_recv_tl = NULL;
|
|
STACK_CALL(SSCOP_DATA_IND, sop->so_upper, sop->so_toku,
|
|
sop->so_connvc, (intptr_t)php->ph_buf,
|
|
php->ph_ns, err);
|
|
if (err) {
|
|
/*
|
|
* Should never happen, but...
|
|
*/
|
|
KB_FREEALL(php->ph_buf);
|
|
sscop_abort(sop,
|
|
"sscop_sd_process: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Bump next expected sequence number
|
|
*/
|
|
SEQ_INCR(sop->so_rcvnext, 1);
|
|
|
|
/*
|
|
* Slide receive window down
|
|
*/
|
|
SEQ_INCR(sop->so_rcvmax, 1);
|
|
}
|
|
|
|
/*
|
|
* Finished with data...see if we need to poll
|
|
*/
|
|
if (type == PT_SDP)
|
|
goto dopoll;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* We're gonna have to queue this PDU, so find space
|
|
* for the PDU header
|
|
*/
|
|
KB_HEADROOM(m, space);
|
|
|
|
/*
|
|
* If there's not enough room in the received buffer,
|
|
* allocate & link a new buffer for the header
|
|
*/
|
|
if (space < sizeof(struct pdu_hdr)) {
|
|
|
|
KB_ALLOC(n, sizeof(struct pdu_hdr), KB_F_NOWAIT, KB_T_HEADER);
|
|
if (n == NULL) {
|
|
KB_FREEALL(m);
|
|
return;
|
|
}
|
|
KB_HEADSET(n, sizeof(struct pdu_hdr));
|
|
KB_LEN(n) = 0;
|
|
KB_LINKHEAD(n, m);
|
|
m = n;
|
|
}
|
|
|
|
/*
|
|
* Build PDU header
|
|
*
|
|
* We can at least assume/require that the start of
|
|
* the user data is aligned. Also note that we don't
|
|
* include this header in the buffer len/offset fields.
|
|
*/
|
|
KB_DATASTART(m, php, struct pdu_hdr *);
|
|
php--;
|
|
php->ph_ns = ns;
|
|
php->ph_buf = m;
|
|
|
|
/*
|
|
* Insert PDU into the receive queue
|
|
*/
|
|
if (sscop_recv_insert(sop, php)) {
|
|
/*
|
|
* Oops, a duplicate sequence number PDU is already on
|
|
* the queue, somethings wrong here.
|
|
*/
|
|
sscop_maa_error(sop, 'Q');
|
|
|
|
/*
|
|
* Free buffers
|
|
*/
|
|
KB_FREEALL(m);
|
|
|
|
/*
|
|
* Reestablish a new connection
|
|
*/
|
|
qsaal1_reestablish(sop);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Are we at the high-water mark??
|
|
*/
|
|
if (ns == sop->so_rcvhigh) {
|
|
/*
|
|
* Yes, just bump the mark
|
|
*/
|
|
SEQ_INCR(sop->so_rcvhigh, 1);
|
|
|
|
if (type == PT_SDP)
|
|
goto dopoll;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Are we beyond the high-water mark??
|
|
*/
|
|
if (SEQ_GT(ns, sop->so_rcvhigh, sop->so_rcvnext)) {
|
|
/*
|
|
* Yes, then there's a missing PDU, so inform the transmitter
|
|
*/
|
|
if (type == PT_SD)
|
|
(void) sscop_send_ustat(sop, ns);
|
|
|
|
/*
|
|
* Update high-water mark
|
|
*/
|
|
sop->so_rcvhigh = SEQ_ADD(ns, 1);
|
|
}
|
|
|
|
if (type == PT_SD)
|
|
return;
|
|
|
|
dopoll:
|
|
/*
|
|
* Do the "poll" part of an SDP PDU
|
|
*/
|
|
poll.poll_nps = htonl(nps);
|
|
poll.poll_ns = htonl((PT_POLL << PT_TYPE_SHIFT) | ns);
|
|
sscop_poll_ready(sop, NULL, (caddr_t)&poll);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* SD 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_sd_ready(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
/*
|
|
* Just call common SD/SDP processor
|
|
*/
|
|
sscop_sd_process(sop, m, trlr, PT_SD);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* SDP 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_sdp_ready(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
/*
|
|
* Just call common SD/SDP processor
|
|
*/
|
|
sscop_sd_process(sop, m, trlr, PT_SDP);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* POLL 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_poll_inresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Stop poll timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_POLL] = 0;
|
|
sop->so_flags &= ~SOF_KEEPALIVE;
|
|
|
|
/*
|
|
* Stop lost poll/stat timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_NORESP] = 0;
|
|
|
|
/*
|
|
* Report protocol error
|
|
*/
|
|
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, "sscop_poll_inresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* POLL PDU / SOS_CONRESYN Processor
|
|
*
|
|
* Arguments:
|
|
* sop pointer to sscop connection block
|
|
* m pointer to PDU buffer (without trailer)
|
|
* trlr pointer to PDU trailer
|
|
*
|
|
* Returns:
|
|
* none
|
|
*
|
|
*/
|
|
static void
|
|
sscop_poll_conresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Stop retransmit timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_CC] = 0;
|
|
|
|
/*
|
|
* 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, "sscop_poll_conresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Go back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* POLL 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
|
|
*
|
|
*/
|
|
static void
|
|
sscop_poll_ready(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
struct poll_pdu *pp = (struct poll_pdu *)trlr;
|
|
sscop_seq nps;
|
|
|
|
pp->poll_ns = ntohl(pp->poll_ns);
|
|
|
|
/*
|
|
* If the poll sequence number is less than highest number
|
|
* we've already seen, something's wrong - so attempt to
|
|
* reestablish a new connection.
|
|
*/
|
|
if (SEQ_LT(pp->poll_ns, sop->so_rcvhigh, sop->so_rcvnext)) {
|
|
/*
|
|
* Record error condition
|
|
*/
|
|
sscop_maa_error(sop, 'Q');
|
|
|
|
/*
|
|
* Free buffers
|
|
*/
|
|
KB_FREEALL(m);
|
|
|
|
/*
|
|
* Reestablish a new connection
|
|
*/
|
|
qsaal1_reestablish(sop);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Set a new "next highest" sequence number expected
|
|
*/
|
|
if (SEQ_LT(pp->poll_ns, sop->so_rcvmax, sop->so_rcvnext))
|
|
SEQ_SET(sop->so_rcvhigh, pp->poll_ns);
|
|
else
|
|
sop->so_rcvhigh = sop->so_rcvmax;
|
|
|
|
/*
|
|
* Return a STAT PDU to peer
|
|
*/
|
|
SEQ_SET(nps, ntohl(pp->poll_nps));
|
|
KB_FREEALL(m);
|
|
(void) sscop_send_stat(sop, nps);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* STAT PDU / SOS_CONRESYN Processor
|
|
*
|
|
* Arguments:
|
|
* sop pointer to sscop connection block
|
|
* m pointer to PDU buffer (without trailer)
|
|
* trlr pointer to PDU trailer
|
|
*
|
|
* Returns:
|
|
* none
|
|
*
|
|
*/
|
|
static void
|
|
sscop_stat_conresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Stop retransmit timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_CC] = 0;
|
|
|
|
/*
|
|
* 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, "sscop_stat_conresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Go back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* USTAT PDU / SOS_CONRESYN Processor
|
|
*
|
|
* Arguments:
|
|
* sop pointer to sscop connection block
|
|
* m pointer to PDU buffer (without trailer)
|
|
* trlr pointer to PDU trailer
|
|
*
|
|
* Returns:
|
|
* none
|
|
*
|
|
*/
|
|
static void
|
|
sscop_ustat_conresyn(sop, m, trlr)
|
|
struct sscop *sop;
|
|
KBuffer *m;
|
|
caddr_t trlr;
|
|
{
|
|
int err;
|
|
|
|
/*
|
|
* Stop retransmit timer
|
|
*/
|
|
sop->so_timer[SSCOP_T_CC] = 0;
|
|
|
|
/*
|
|
* 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, "sscop_ustat_conresyn: stack memory\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Clear connection data
|
|
*/
|
|
qsaal1_clear_connection(sop);
|
|
|
|
/*
|
|
* Go back to idle state
|
|
*/
|
|
sop->so_state = SOS_IDLE;
|
|
|
|
return;
|
|
}
|
|
|